SQLGlot

https://sqlglot.com
Admin
SQLGlot is a no-dependency SQL parser, transpiler, optimizer, and engine that can translate between...
Tokens:940,425
Snippets:4,206
Trust Score:7.4
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install SQLGlot from local checkout

Source: https://sqlglot.com/

Use the Makefile to install the package from a local repository clone.

```bash
# Optionally prefix with UV=1 to use uv for the installation
make install
```

--------------------------------

### Install SQLGlot with Mypyc

Source: https://sqlglot.com/

Install the compiled version of SQLGlot for improved performance.

```bash
pip3 install "sqlglot[c]"
```

--------------------------------

### Install SQLGlot via PyPI

Source: https://sqlglot.com/

Install the library using pip. The 'c' extra provides C extensions for improved performance.

```bash
# Pure python version
pip3 install sqlglot

# C extensions compiled with mypyc
# prebuilt wheel if available for your platform, otherwise builds from source
pip3 install "sqlglot[c]"
```

--------------------------------

### Databricks Parser Configuration Example

Source: https://sqlglot.com/sqlglot/parsers/databricks.html

Example configuration settings and function mappings for the Databricks parser.

```python
LOG_DEFAULTS_TO_LN = True
STRICT_CAST = True
COLON_IS_VARIANT_EXTRACT = True
COLON_CHAIN_IS_SINGLE_EXTRACT = False
FUNCTIONS =  {'AI_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AIAgg'>>, 'AI_CLASSIFY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIClassify'>>, 'AI_EMBED': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIEmbed'>>, 'A_I_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIForecast'>>, 'AI_GENERATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIGenerate'>>, 'AI_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AISimilarity'>>, 'AI_SUMMARIZE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AISummarizeAgg'>>, 'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Abs'>>, 'ACOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acos'>>, 'ACOSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acosh'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.AddMonths'>>, 'AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.And'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.AnonymousAggFunc'>>, 'ANY_VALUE': <function build_with_ignore_nulls.<locals>._parse>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Apply'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>,
```

--------------------------------

### Install SQLGlot development requirements

Source: https://sqlglot.com/

Install dependencies required for local development.

```bash
# Optionally prefix with UV=1 to use uv for the installation
make install-dev
```

--------------------------------

### SQLGlot Diff Example

Source: https://sqlglot.com/sqlglot/diff.html

This example demonstrates how to use the `diff` function in SQLGlot to compare two SQL queries and visualize the resulting edit script, showing removals, insertions, and kept elements.

```python
>>> from sqlglot import parse_one, diff
>>> diff(parse_one("SELECT a + b + c, d, e"), parse_one("SELECT a - b + c, e, f"))

Remove(Add)
Remove(Column(d))
Remove(Identifier(d))
Insert(Sub)
Insert(Column(f))
Insert(Identifier(f))
Keep(Select, Select)
Keep(Add, Add)
Keep(Column(a), Column(a))
Keep(Identifier(a), Identifier(a))
Keep(Column(b), Column(b))
Keep(Identifier(b), Identifier(b))
Keep(Column(c), Column(c))
Keep(Identifier(c), Identifier(c))
Keep(Column(e), Column(e))
Keep(Identifier(e), Identifier(e))
```

--------------------------------

### Python Protocol Class Examples

Source: https://sqlglot.com/sqlglot/transforms.html

Examples demonstrating the definition and usage of Protocol classes for structural subtyping.

```python
class Proto(Protocol):
    def meth(self) -> int:
        ...
```

```python
class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check
```

```python
class GenProto(Protocol[T]):
    def meth(self) -> T:
        ...
```

--------------------------------

### Pushdown Predicates Example

Source: https://sqlglot.com/sqlglot/executor.html

Illustrates the `pushdown_predicates` rule, which moves filters into the innermost subqueries for optimization.

```sql
SELECT *
FROM (
  SELECT * 
  FROM x AS x
) AS y
WHERE y.a = 1;

SELECT *
FROM (
  SELECT * 
  FROM x AS x
) AS y WHERE TRUE

```

--------------------------------

### Boolean and Math Simplification Example

Source: https://sqlglot.com/sqlglot/executor.html

Illustrates the `simplify` rule for simplifying boolean expressions and mathematical operations.

```sql
((NOT FALSE) AND (x = x)) AND (TRUE OR 1 <> 3);
x = x;

1 + 1;
2;

```

--------------------------------

### Define Get Expression

Source: https://sqlglot.com/sqlglot/expressions/query.html

Defines the Get expression class structure.

```python
940class Get(Expression):
941    arg_types = {"this": True, "target": True, "properties": False}
```

--------------------------------

### Serve documentation locally

Source: https://sqlglot.com/

Command to build and serve the API documentation locally using pdoc.

```bash
make docs-serve
```

--------------------------------

### Oracle (+) Operator Examples

Source: https://sqlglot.com/sqlglot/transforms.html

Examples of the Oracle outer join (+) operator usage.

```sql
-- example with WHERE SELECT d.department_name, sum(e.salary) as total_salary FROM departments d, employees e WHERE e.department_id(+) = d.department_id group by department_name
-- example of left correlation in select SELECT d.department_name, ( SELECT SUM(e.salary) FROM employees e WHERE e.department_id(+) = d.department_id) AS total_salary FROM departments d;
-- example of left correlation in from SELECT d.department_name, t.total_salary FROM departments d, ( SELECT SUM(e.salary) AS total_salary FROM employees e WHERE e.department_id(+) = d.department_id ) t
```

--------------------------------

### Show Tables and Databases SQL Generation

Source: https://sqlglot.com/sqlglot/generators/exasol.html

Handles SHOW TABLES and SHOW DATABASES by querying system tables in Exasol.

```python
910    def show_sql(self, expression: exp.Show) -> str:
911        if expression.name == "TABLES":
912            db_name = expression.text("db")
913            schema_filter: exp.Expression = (
914                exp.Literal.string(db_name.upper()) if db_name else exp.CurrentSchema()
915            )
916            select = (
917                exp.select(exp.column("TABLE_NAME"))
918                .from_(exp.table_("EXA_ALL_TABLES", db="SYS"))
919                .where(exp.column("TABLE_SCHEMA").eq(schema_filter))
920            )
921            return self.sql(select)
922
923        if expression.name == "DATABASES":
924            select = exp.select(exp.column("SCHEMA_NAME")).from_(
925                exp.table_("EXA_SCHEMAS", db="SYS")
926            )
927            return self.sql(select)
928
929        return super().show_sql(expression)
```

--------------------------------

### Define Install Expression

Source: https://sqlglot.com/sqlglot/expressions/ddl.html

Defines the Install expression class with its required and optional arguments.

```python
150class Install(Expression):
151    arg_types = {"this": True, "from_": False, "force": False}
```

--------------------------------

### Qualify Tables and Columns Example

Source: https://sqlglot.com/sqlglot/executor.html

Demonstrates how `qualify_tables` and `qualify_columns` rules add database/catalog qualifiers to tables and ensure column unambiguity.

```sql
SELECT * FROM x;

SELECT "db"."x" AS "x";

```

--------------------------------

### Example SQL Query for Execution

Source: https://sqlglot.com/sqlglot/executor.html

This is a sample SQL query that will be used to demonstrate the execution steps within the SQLGlot engine.

```sql
SELECT
  bar.a,
  b + 1 AS b
FROM bar
JOIN baz
  ON bar.a = baz.a
WHERE bar.a > 1

```

--------------------------------

### Parse Get Command

Source: https://sqlglot.com/sqlglot/parsers/snowflake.html

Parses the GET command, handling potential function calls or file paths.

```python
def _parse_get(self) -> exp.Expr | None:
    start = self._prev

    # If we detect GET( then we need to parse a function, not a statement
    if self._match(TokenType.L_PAREN):
        self._retreat(self._index - 2)
        return self._parse_expression()

    target = self._parse_location_path()

    # Parse as command if unquoted file path
    if self._curr.token_type == TokenType.URI_START:
        return self._parse_as_command(start)

    return self.expression(
        exp.Get(this=self._parse_string(), target=target, properties=self._parse_properties())
    )
```

--------------------------------

### Initialize Protocol-like Classes

Source: https://sqlglot.com/sqlglot/transforms.html

Handles dynamic initialization for protocol-like classes by searching the MRO for a valid __init__ method.

```python
1431def _no_init_or_replace_init(self, *args, **kwargs):
1432    cls = type(self)
1433
1434    if cls._is_protocol:
1435        raise TypeError('Protocols cannot be instantiated')
1436
1437    # Already using a custom `__init__`. No need to calculate correct
1438    # `__init__` to call. This can lead to RecursionError. See bpo-45121.
1439    if cls.__init__ is not _no_init_or_replace_init:
1440        return
1441
1442    # Initially, `__init__` of a protocol subclass is set to `_no_init_or_replace_init`.
1443    # The first instantiation of the subclass will call `_no_init_or_replace_init` which
1444    # searches for a proper new `__init__` in the MRO. The new `__init__`
1445    # replaces the subclass' old `__init__` (ie `_no_init_or_replace_init`). Subsequent
1446    # instantiation of the protocol subclass will thus use the new
1447    # `__init__` and no longer call `_no_init_or_replace_init`.
1448    for base in cls.__mro__:
1449        init = base.__dict__.get('__init__', _no_init_or_replace_init)
1450        if init is not _no_init_or_replace_init:
1451            cls.__init__ = init
1452            break
1453    else:
1454        # should not happen
1455        cls.__init__ = object.__init__
1456
1457    cls.__init__(self, *args, **kwargs)
```

--------------------------------

### Sort by method definition and example

Source: https://sqlglot.com/sqlglot/expressions/query.html

Defines the sort_by method for Select expressions and provides a usage example for Hive dialect.

```python
def sort_by(
    self,
    *expressions: ExpOrStr | None,
    append: bool = True,
    dialect: DialectType = None,
    copy: bool = True,
    **opts: Unpack[ParserNoDialectArgs],
) -> Select:
    """
    Set the SORT BY expression.

    Example:
        >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
        'SELECT x FROM tbl SORT BY x DESC'

    Args:
        *expressions: the SQL code strings to parse.
            If a `Group` instance is passed, this is used as-is.
            If another `Expr` instance is passed, it will be wrapped in a `SORT`.
        append: if `True`, add to any existing expressions.
            Otherwise, this flattens all the `Order` expression into a single expression.
        dialect: the dialect used to parse the input expression.
        copy: if `False`, modify this expression instance in-place.
        opts: other options to use to parse the input expressions.

    Returns:
        The modified Select expression.
    """
    return _apply_child_list_builder(
        *expressions,
        instance=self,
        arg="sort",
        append=append,
        copy=copy,
        prefix="SORT BY",
        into=Sort,
        dialect=dialect,
        **opts,
    )
```

```python
>>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
'SELECT x FROM tbl SORT BY x DESC'
```

--------------------------------

### Registering a Dialect Plugin

Source: https://sqlglot.com/

Configuration for a custom dialect package using setuptools entry points.

```python
from setuptools import setup

setup(
    name="mydb-sqlglot-dialect",
    entry_points={
        "sqlglot.dialects": [
            "mydb = my_package.dialect:MyDB",
        ],
    },
)
```

--------------------------------

### Plan Initialization

Source: https://sqlglot.com/sqlglot/planner.html

Initializes a Plan object with a SQL expression.

```python
    def __init__(self, expression: exp.Expr) -> None:
        self.expression: exp.Expr = expression.copy()
        self.root: Step = Step.from_expression(self.expression)
        self._dag: dict[Step, set[Step]] = {}
```

--------------------------------

### MappingSchema.__init__

Source: https://sqlglot.com/sqlglot/schema.html

Initializes a new MappingSchema instance with optional schema definitions, visibility settings, and dialect configurations.

```APIDOC
## MappingSchema(schema=None, visible=None, dialect=None, normalize=True, udf_mapping=None)

### Description
Initializes the schema mapping object. The schema can be provided as a nested dictionary mapping catalogs, databases, and tables to their columns.

### Parameters
- **schema** (dict[str, object] | None) - Optional - Mapping of database structure (catalog -> db -> table -> col).
- **visible** (dict[str, object] | None) - Optional - Mapping of visible columns mirroring the schema structure.
- **dialect** (str | Dialect | type[Dialect] | None) - Optional - The dialect used for type mappings and parsing.
- **normalize** (bool) - Optional - Whether to normalize identifier names.
- **udf_mapping** (dict[str, object] | None) - Optional - Mapping for user-defined functions.
```

--------------------------------

### GraphHTML.__init__

Source: https://sqlglot.com/sqlglot/lineage.html

Initializes a new GraphHTML instance to generate a vis.js network visualization.

```APIDOC
## Class: GraphHTML

### Description
Initializes the generator for a vis.js network graph. This class prepares the nodes, edges, and configuration options required to render the lineage visualization.

### Constructor
`GraphHTML(nodes: dict, edges: list, imports: bool = True, options: Mapping[str, object] | None = None)`

### Parameters
- **nodes** (dict) - Required - A dictionary of nodes to be displayed in the graph.
- **edges** (list) - Required - A list of edges defining the relationships between nodes.
- **imports** (bool) - Optional - Whether to include the necessary vis.js script and stylesheet imports. Defaults to True.
- **options** (Mapping[str, object]) - Optional - Custom configuration options to override the default vis.js network settings.
```

--------------------------------

### size property

Source: https://sqlglot.com/sqlglot/tokens.html

Get the length of the SQL string.

```APIDOC
### size

Length of the SQL string.

#### Returns
- **int** - The length of the string.
```

--------------------------------

### Get Expression Depth

Source: https://sqlglot.com/sqlglot/expressions/core.html

Calculates the depth of the expression in the tree.

```python
1143    @property
1144    def depth(self) -> int:
1145        if self.parent:
1146            return self.parent.depth + 1
1147        return 0
```

--------------------------------

### Run Benchmarking Commands

Source: https://sqlglot.com/

Execute these commands to run parsing and optimization benchmarks.

```makefile
make bench            # Run parsing benchmark
make bench-optimize   # Run optimization benchmark
```

--------------------------------

### Get SQL string length

Source: https://sqlglot.com/sqlglot/tokens.html

Length of the SQL string.

```python
585    @property
586    def size(self) -> int:
587        """Length of the SQL string."""
588        return self._core.size
```

--------------------------------

### Get Table Width

Source: https://sqlglot.com/sqlglot/executor/table.html

Retrieve the number of columns in the table.

```python
table.width
```

--------------------------------

### Get Root Expression

Source: https://sqlglot.com/sqlglot/expressions/core.html

Returns the root node of the expression tree.

```python
    def root(self) -> Expr:
        """
        Returns the root expression of this tree.
        """
        raise NotImplementedError
```

--------------------------------

### Context Initialization

Source: https://sqlglot.com/sqlglot/executor/context.html

Initializes the execution context with data tables and an optional environment dictionary.

```APIDOC
## __init__

### Description
Initializes the execution context with data tables and an optional environment dictionary.

### Parameters
#### Arguments
- **tables** (dict[str, sqlglot.executor.table.Table]) - representing the scope of the current execution context.
- **env** (dict | None) - dictionary of functions within the execution context.
```

--------------------------------

### Get Type Name

Source: https://sqlglot.com/sqlglot/planner.html

Returns the class name of the step instance.

```python
291    @property
292    def type_name(self) -> str:
293        return self.__class__.__name__
```

--------------------------------

### Define Tokenizer configuration and initialization

Source: https://sqlglot.com/sqlglot/tokens.html

The Tokenizer class uses a dictionary of keywords and command sets to configure how SQL strings are parsed. The __init__ method initializes the core tokenizer based on the provided dialect.

```python
486        "INT4RANGE": TokenType.INT4RANGE,
487        "INT4MULTIRANGE": TokenType.INT4MULTIRANGE,
488        "INT8RANGE": TokenType.INT8RANGE,
489        "INT8MULTIRANGE": TokenType.INT8MULTIRANGE,
490        "NUMRANGE": TokenType.NUMRANGE,
491        "NUMMULTIRANGE": TokenType.NUMMULTIRANGE,
492        "TSRANGE": TokenType.TSRANGE,
493        "TSMULTIRANGE": TokenType.TSMULTIRANGE,
494        "TSTZRANGE": TokenType.TSTZRANGE,
495        "TSTZMULTIRANGE": TokenType.TSTZMULTIRANGE,
496        "DATERANGE": TokenType.DATERANGE,
497        "DATEMULTIRANGE": TokenType.DATEMULTIRANGE,
498        "UNIQUE": TokenType.UNIQUE,
499        "VECTOR": TokenType.VECTOR,
500        "STRUCT": TokenType.STRUCT,
501        "SEQUENCE": TokenType.SEQUENCE,
502        "VARIANT": TokenType.VARIANT,
503        "ALTER": TokenType.ALTER,
504        "ANALYZE": TokenType.ANALYZE,
505        "CALL": TokenType.COMMAND,
506        "COMMENT": TokenType.COMMENT,
507        "EXPLAIN": TokenType.COMMAND,
508        "GRANT": TokenType.GRANT,
509        "REVOKE": TokenType.REVOKE,
510        "OPTIMIZE": TokenType.COMMAND,
511        "PREPARE": TokenType.COMMAND,
512        "VACUUM": TokenType.COMMAND,
513        "USER-DEFINED": TokenType.USERDEFINED,
514    }
515
516    COMMANDS = {
517        TokenType.COMMAND,
518        TokenType.EXECUTE,
519        TokenType.FETCH,
520        TokenType.SHOW,
521        TokenType.RENAME,
522    }
523
524    COMMAND_PREFIX_TOKENS = {TokenType.SEMICOLON, TokenType.BEGIN}
525
526    # Handle numeric literals like in hive (3L = BIGINT)
527    NUMERIC_LITERALS: t.ClassVar[dict[str, str]] = {}
528
529    # In tokenizers like JSONPath, dots are always key separators, never decimal points
530    NUMBERS_CAN_HAVE_DECIMALS: t.ClassVar[bool] = True
531
532    COMMENTS = ["--", ("/*", "*/")]
```

```python
539    def __init__(self, dialect: DialectType = None) -> None:
540        from sqlglot.dialects.dialect import Dialect
541
542        self.dialect = Dialect.get_or_raise(dialect)
543        self._core = self._init_core()
```

--------------------------------

### Define ColumnConstraintKind Expression

Source: https://sqlglot.com/sqlglot/expressions/core.html

Example definition of the ColumnConstraintKind expression class.

```python
1606@trait
1607class ColumnConstraintKind(Expr):
1608    pass
```

--------------------------------

### Tokenizer Initialization

Source: https://sqlglot.com/sqlglot/tokenizer_core.html

The constructor initializes the tokenizer with configuration dictionaries and sets, defining how specific SQL syntax elements should be parsed.

```python
def __init__(
        self,
        single_tokens: dict[str, TokenType],
        keywords: dict[str, TokenType],
        quotes: dict[str, str],
        format_strings: dict[str, tuple[str, TokenType]],
        identifiers: dict[str, str],
        comments: dict[str, str | None],
        string_escapes: set[str],
        byte_string_escapes: set[str],
        identifier_escapes: set[str],
        escape_follow_chars: set[str],
        commands: set[TokenType],
        command_prefix_tokens: set[TokenType],
        nested_comments: bool,
        hint_start: str,
        tokens_preceding_hint: set[TokenType],
        has_bit_strings: bool,
        has_hex_strings: bool,
        numeric_literals: dict[str, str],
        var_single_tokens: set[str],
        string_escapes_allowed_in_raw_strings: bool,
        heredoc_tag_is_identifier: bool,
        heredoc_string_alternative: TokenType,
        keyword_trie: dict,
        numbers_can_be_underscore_separated: bool,
        numbers_can_have_decimals: bool,
        identifiers_can_start_with_digit: bool,
        unescaped_sequences: dict[str, str],
    ) -> None:
        self.single_tokens = single_tokens
        self.keywords = keywords
        self.quotes = quotes
        self.format_strings = format_strings
        self.identifiers = identifiers
        self.comments = comments
        self.string_escapes = string_escapes
        self.byte_string_escapes = byte_string_escapes
        self.identifier_escapes = identifier_escapes
        self.escape_follow_chars = escape_follow_chars
        self.commands = commands
        self.command_prefix_tokens = command_prefix_tokens
        self.nested_comments = nested_comments
        self.hint_start = hint_start
        self.tokens_preceding_hint = tokens_preceding_hint
        self.has_bit_strings = has_bit_strings
        self.has_hex_strings = has_hex_strings
        self.numeric_literals = numeric_literals
        self.var_single_tokens = var_single_tokens
        self.string_escapes_allowed_in_raw_strings = string_escapes_allowed_in_raw_strings
        self.heredoc_tag_is_identifier = heredoc_tag_is_identifier
        self.heredoc_string_alternative = heredoc_string_alternative
        self.keyword_trie = keyword_trie
        self.numbers_can_be_underscore_separated = numbers_can_be_underscore_separated
        self.numbers_can_have_decimals = numbers_can_have_decimals
        self.identifiers_can_start_with_digit = identifiers_can_start_with_digit
        self.unescaped_sequences = unescaped_sequences
        self.sql = ""
        self.size = 0
        self.tokens: list[Token] = []
        self._start = 0
        self._current = 0
        self._line = 1
        self._col = 0
        self._comments: list[str] = []
        self._char = ""
        self._end = False
        self._peek = ""
        self._prev_token_line = -1
```

--------------------------------

### Define LockingStatement Expression

Source: https://sqlglot.com/sqlglot/expressions/core.html

Example definition of the LockingStatement expression class.

```python
1602class LockingStatement(Expression):
1603    arg_types = {"this": True, "expression": True}
```

```python

arg_types = {'this': True, 'expression': True}
key: ClassVar[str] = 'lockingstatement'
required_args: 't.ClassVar[set[str]]' = {'this', 'expression'}
```

--------------------------------

### Define Refresh Expression

Source: https://sqlglot.com/sqlglot/expressions/core.html

Example definition of the Refresh expression class.

```python
1598class Refresh(Expression):
1599    arg_types = {"this": True, "kind": True}
```

```python

arg_types = {'this': True, 'kind': True}
key: ClassVar[str] = 'refresh'
required_args: 't.ClassVar[set[str]]' = {'this', 'kind'}
```

--------------------------------

### Exasol Tokenizer Configuration

Source: https://sqlglot.com/sqlglot/dialects/exasol.html

Mapping of SQL keywords and data types to their respective token types for the Exasol dialect.

```python
<TokenType.INT: 105>, 'INT64': <TokenType.BIGINT: 107>, 'INT128': <TokenType.INT128: 110>, 'INT256': <TokenType.INT256: 112>, 'LONG': <TokenType.BIGINT: 107>, 'BIGINT': <TokenType.BIGINT: 107>, 'INT8': <TokenType.TINYINT: 99>, 'UINT': <TokenType.UINT: 106>, 'UINT128': <TokenType.UINT128: 111>, 'UINT256': <TokenType.UINT256: 113>, 'DEC': <TokenType.DECIMAL: 117>, 'DECIMAL': <TokenType.DECIMAL: 117>, 'DECIMAL32': <TokenType.DECIMAL32: 118>, 'DECIMAL64': <TokenType.DECIMAL64: 119>, 'DECIMAL128': <TokenType.DECIMAL128: 120>, 'DECIMAL256': <TokenType.DECIMAL256: 121>, 'DECFLOAT': <TokenType.DECFLOAT: 122>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 124>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 124>, 'BIGNUM': <TokenType.BIGNUM: 109>, 'LIST': <TokenType.LIST: 320>, 'MAP': <TokenType.MAP: 323>, 'NULLABLE': <TokenType.NULLABLE: 174>, 'NUMBER': <TokenType.DECIMAL: 117>, 'NUMERIC': <TokenType.DECIMAL: 117>, 'FIXED': <TokenType.DECIMAL: 117>, 'REAL': <TokenType.FLOAT: 114>, 'FLOAT': <TokenType.FLOAT: 114>, 'FLOAT4': <TokenType.FLOAT: 114>, 'FLOAT8': <TokenType.DOUBLE: 115>, 'DOUBLE': <TokenType.DOUBLE: 115>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 115>, 'JSON': <TokenType.JSON: 141>, 'JSONB': <TokenType.JSONB: 142>, 'CHAR': <TokenType.CHAR: 125>, 'CHARACTER': <TokenType.CHAR: 125>, 'CHAR VARYING': <TokenType.VARCHAR: 127>, 'CHARACTER VARYING': <TokenType.VARCHAR: 127>, 'NCHAR': <TokenType.NCHAR: 126>, 'VARCHAR': <TokenType.VARCHAR: 127>, 'VARCHAR2': <TokenType.VARCHAR: 127>, 'NVARCHAR': <TokenType.NVARCHAR: 128>, 'NVARCHAR2': <TokenType.NVARCHAR: 128>, 'BPCHAR': <TokenType.BPCHAR: 129>, 'STR': <TokenType.TEXT: 130>, 'STRING': <TokenType.TEXT: 130>, 'TEXT': <TokenType.TEXT: 130>, 'LONGTEXT': <TokenType.LONGTEXT: 132>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 131>, 'TINYTEXT': <TokenType.TINYTEXT: 137>, 'CLOB': <TokenType.TEXT: 130>, 'LONGVARCHAR': <TokenType.TEXT: 130>, 'BINARY': <TokenType.BINARY: 139>, 'BLOB': <TokenType.VARBINARY: 140>, 'LONGBLOB': <TokenType.LONGBLOB: 135>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 134>, 'TINYBLOB': <TokenType.TINYBLOB: 136>, 'BYTEA': <TokenType.VARBINARY: 140>, 'VARBINARY': <TokenType.VARBINARY: 140>, 'TIME': <TokenType.TIME: 143>, 'TIMETZ': <TokenType.TIMETZ: 144>, 'TIME_NS': <TokenType.TIME_NS: 145>, 'TIMESTAMP': <TokenType.TIMESTAMP: 146>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 147>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 148>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 148>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 149>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 149>, 'DATE': <TokenType.DATE: 157>, 'DATETIME': <TokenType.DATETIME: 153>, 'INT4RANGE': <TokenType.INT4RANGE: 159>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 160>, 'INT8RANGE': <TokenType.INT8RANGE: 161>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 162>, 'NUMRANGE': <TokenType.NUMRANGE: 163>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 164>, 'TSRANGE': <TokenType.TSRANGE: 165>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 166>, 'TSTZRANGE': <TokenType.TSTZRANGE: 167>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 168>, 'DATERANGE': <TokenType.DATERANGE: 169>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 170>, 'UNIQUE': <TokenType.UNIQUE: 432>, 'VECTOR': <TokenType.VECTOR: 215>, 'STRUCT': <TokenType.STRUCT: 403>, 'SEQUENCE': <TokenType.SEQUENCE: 390>, 'VARIANT': <TokenType.VARIANT: 198>, 'ALTER': <TokenType.ALTER: 219>, 'ANALYZE': <TokenType.ANALYZE: 439>, 'CALL': <TokenType.COMMAND: 237>, 'COMMENT': <TokenType.COMMENT: 238>, 'EXPLAIN': <TokenType.COMMAND: 237>, 'GRANT': <TokenType.GRANT: 289>, 'REVOKE': <TokenType.REVOKE: 377>, 'OPTIMIZE': <TokenType.COMMAND: 237>, 'PREPARE': <TokenType.COMMAND: 237>, 'VACUUM': <TokenType.COMMAND: 237>, 'USER-DEFINED': <TokenType.USERDEFINED: 193>, 'USER': <TokenType.CURRENT_USER: 251>, 'ENDIF': <TokenType.END: 267>, 'LONG VARCHAR': <TokenType.TEXT: 130>, 'REGEXP_LIKE': <TokenType.RLIKE: 380>, 'SEPARATOR': <TokenType.SEPARATOR: 389>, 'SYSTIMESTAMP': <TokenType.SYSTIMESTAMP: 181>, 'MINUS': <TokenType.EXCEPT: 269>
BYTE_STRING_ESCAPES: ClassVar[list[str]] = ["'"]
```

--------------------------------

### Define Uncache Expression

Source: https://sqlglot.com/sqlglot/expressions/core.html

Example definition of the Uncache expression class.

```python

arg_types = {'this': True, 'exists': False}
key: ClassVar[str] = 'uncache'
required_args: 't.ClassVar[set[str]]' = {'this'}
```

--------------------------------

### MappingSchema.__init__

Source: https://sqlglot.com/sqlglot/schema.html

Initializes a new MappingSchema instance with an optional schema, visibility mapping, dialect, and normalization settings.

```APIDOC
## MappingSchema(schema=None, visible=None, dialect=None, normalize=True, udf_mapping=None)

### Description
Initializes a schema based on a nested mapping. The schema can be defined as {table: {col: type}}, {db: {table: {col: type}}}, or {catalog: {db: {table: {col: type}}}}.

### Parameters
- **schema** (dict[str, object] | None) - Optional - The nested mapping defining the database structure.
- **visible** (dict[str, object] | None) - Optional - Mapping of visible columns.
- **dialect** (DialectType) - Optional - The dialect used for type mappings and parsing.
- **normalize** (bool) - Optional - Whether to normalize identifier names.
- **udf_mapping** (dict[str, object] | None) - Optional - Mapping for user-defined functions.
```

--------------------------------

### Having Clause Usage

Source: https://sqlglot.com/sqlglot/expressions/query.html

Example of using the having method to filter grouped results.

```python
>>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
```

```python
return _apply_conjunction_builder(
            *expressions,
            instance=self,
            arg="having",
            append=append,
            into=Having,
            dialect=dialect,
            copy=copy,
            **opts,
        )
```

--------------------------------

### Define CurrentSchema Expression

Source: https://sqlglot.com/sqlglot/expressions/functions.html

Example definition of the CurrentSchema expression class.

```python

arg_types = {}
key: ClassVar[str] = 'currentroletype'
required_args: 't.ClassVar[set[str]]' = set()
##### Inherited Members sqlglot.expressions.core.Expr
    Expr     is_subquery     is_cast     is_data_type     is_primitive     dump     load     pipe     apply sqlglot.expressions.core.Expression
    this     expression     expressions     text     is_string     is_number     to_py     is_int     is_star     alias     alias_column_names     name     alias_or_name     output_name     type     is_type     is_leaf     meta     meta_get     copy     add_comments     pop_comments     append     set     set_kwargs     depth     iter_expressions     find     find_all     find_ancestor     parent_select     same_parent     root     walk     dfs     bfs     unnest     unalias     unnest_operands     flatten     to_s     sql     transform     replace     pop     assert_is     error_messages     and_     or_     not_     update_positions     as_     isin     between     is_     like     ilike     eq     neq     rlike     div     asc     desc     args     parent     arg_key     index     comments sqlglot.expressions.core.Func
    is_var_len_args     var_len_arg_key     from_arg_list     sql_names     sql_name     default_parser_mappings
class CurrentSchema(sqlglot.expressions.core.Expression, sqlglot.expressions.core.Func): View Source
```

```python
286class CurrentSchema(Expression, Func):
287    arg_types = {"this": False}
```

--------------------------------

### AthenaGenerator.__init__

Source: https://sqlglot.com/sqlglot/generators/athena.html

Initializes the AthenaGenerator with configuration options for SQL formatting and identifier handling.

```APIDOC
## AthenaGenerator.__init__

### Description
Initializes a new instance of the AthenaGenerator class.

### Parameters
- **pretty** (bool | int | None) - Optional - Whether to format the produced SQL string. Default: False.
- **identify** (str | bool) - Optional - Determines when an identifier should be quoted. Default: False.
- **normalize** (bool) - Optional - Whether to normalize identifiers to lowercase. Default: False.
- **pad** (int) - Optional - The pad size in a formatted string. Default: 2.
- **indent** (int) - Optional - The indentation size in a formatted string. Default: 2.
- **normalize_functions** (str | bool | None) - Optional - How to normalize function names. Default: True.
- **unsupported_level** (Any) - Optional - Determines the generator's behavior when it encounters unsupported expressions.
- **max_unsupported** (int) - Optional - Maximum number of unsupported messages to include. Default: 3.
- **leading_comma** (bool) - Optional - Whether the comma is leading or trailing in select expressions. Default: False.
- **max_text_width** (int) - Optional - The max number of characters in a segment before creating new lines. Default: 80.
- **comments** (bool) - Optional - Whether to preserve comments in the output SQL code. Default: True.
```

--------------------------------

### Initialize AbstractMappingSchema

Source: https://sqlglot.com/sqlglot/schema.html

Initializes the schema with optional table and UDF mappings, building internal tries for efficient lookup.

```python
155    def __init__(
156        self,
157        mapping: dict[str, object] | None = None,
158        udf_mapping: dict[str, object] | None = None,
159    ) -> None:
160        self.mapping: dict[str, object] = mapping or {}
161        self.mapping_trie: dict[str, object] = new_trie(
162            tuple(reversed(t)) for t in flatten_schema(self.mapping, depth=self.depth())
163        )
164        self.udf_mapping: dict[str, object] = udf_mapping or {}
165        self.udf_trie: dict[str, object] = new_trie(
166            tuple(reversed(t)) for t in flatten_schema(self.udf_mapping, depth=self.udf_depth())
167        )
168
169        self._supported_table_args: tuple[str, ...] = tuple()
```

--------------------------------

### Define CurrentRoleType Expression

Source: https://sqlglot.com/sqlglot/expressions/functions.html

Example definition of the CurrentRoleType expression class.

```python

arg_types = {}
key: ClassVar[str] = 'currentrole'
required_args: 't.ClassVar[set[str]]' = set()
##### Inherited Members sqlglot.expressions.core.Expr
    Expr     is_subquery     is_cast     is_data_type     is_primitive     dump     load     pipe     apply sqlglot.expressions.core.Expression
    this     expression     expressions     text     is_string     is_number     to_py     is_int     is_star     alias     alias_column_names     name     alias_or_name     output_name     type     is_type     is_leaf     meta     meta_get     copy     add_comments     pop_comments     append     set     set_kwargs     depth     iter_expressions     find     find_all     find_ancestor     parent_select     same_parent     root     walk     dfs     bfs     unnest     unalias     unnest_operands     flatten     to_s     sql     transform     replace     pop     assert_is     error_messages     and_     or_     not_     update_positions     as_     isin     between     is_     like     ilike     eq     neq     rlike     div     asc     desc     args     parent     arg_key     index     comments sqlglot.expressions.core.Func
    is_var_len_args     var_len_arg_key     from_arg_list     sql_names     sql_name     default_parser_mappings
class CurrentRoleType(sqlglot.expressions.core.Expression, sqlglot.expressions.core.Func): View Source
```

```python
282class CurrentRoleType(Expression, Func):
283    arg_types = {}
```

--------------------------------

### Define CurrentRegion Expression

Source: https://sqlglot.com/sqlglot/expressions/functions.html

Example definition of the CurrentRegion expression class.

```python

arg_types = {}
key: ClassVar[str] = 'currentregion'
required_args: 't.ClassVar[set[str]]' = set()
##### Inherited Members sqlglot.expressions.core.Expr
    Expr     is_subquery     is_cast     is_data_type     is_primitive     dump     load     pipe     apply sqlglot.expressions.core.Expression
    this     expression     expressions     text     is_string     is_number     to_py     is_int     is_star     alias     alias_column_names     name     alias_or_name     output_name     type     is_type     is_leaf     meta     meta_get     copy     add_comments     pop_comments     append     set     set_kwargs     depth     iter_expressions     find     find_all     find_ancestor     parent_select     same_parent     root     walk     dfs     bfs     unnest     unalias     unnest_operands     flatten     to_s     sql     transform     replace     pop     assert_is     error_messages     and_     or_     not_     update_positions     as_     isin     between     is_     like     ilike     eq     neq     rlike     div     asc     desc     args     parent     arg_key     index     comments sqlglot.expressions.core.Func
    is_var_len_args     var_len_arg_key     from_arg_list     sql_names     sql_name     default_parser_mappings
class CurrentRole(sqlglot.expressions.core.Expression, sqlglot.expressions.core.Func): View Source
```

```python
278class CurrentRole(Expression, Func):
279    arg_types = {}
```

--------------------------------

### Run Tests and Linting Commands

Source: https://sqlglot.com/

Use these Makefile commands to execute linting, unit tests, and cleanup tasks.

```makefile
make style   # Only linter checks
make unit    # Only unit tests (pure Python)
make test    # Unit and integration tests (pure Python)
make unitc   # Only unit tests (mypyc compiled)
make testc   # Unit and integration tests (mypyc compiled)
make check   # Full test suite & linter checks
make clean   # Remove compiled C artifacts (.so files, build dirs)
```

--------------------------------

### Initialize MappingSchema

Source: https://sqlglot.com/sqlglot/schema.html

Create a new MappingSchema instance with optional schema, visibility, dialect, and normalization settings.

```python
def __init__(
    self,
    schema: dict[str, object] | None = None,
    visible: dict[str, object] | None = None,
    dialect: DialectType = None,
    normalize: bool = True,
    udf_mapping: dict[str, object] | None = None,
) -> None:
    self.visible: dict[str, object] = {} if visible is None else visible
    self.normalize: bool = normalize
    self._dialect: Dialect = Dialect.get_or_raise(dialect)
    self._type_mapping_cache: dict[str, exp.DataType] = {}
    self._normalized_table_cache: dict[tuple[exp.Table, DialectType, bool], exp.Table] = {}
    self._normalized_name_cache: dict[tuple[str, DialectType, bool, bool], str] = {}
    self._find_cache: dict[tuple[exp.Table, bool], dict[str, object] | None] = {}
    self._depth: int = 0
    schema = {} if schema is None else schema
    udf_mapping = {} if udf_mapping is None else udf_mapping

    super().__init__(
        self._normalize(schema) if self.normalize else schema,
        self._normalize_udfs(udf_mapping) if self.normalize else udf_mapping,
    )
```

--------------------------------

### DType Enumeration Values

Source: https://sqlglot.com/sqlglot/expressions/datatypes.html

Example representation of the DType enumeration members.

```text
An enumeration.
ARRAY = <DType.ARRAY: 'ARRAY'>
AGGREGATEFUNCTION = <DType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>
SIMPLEAGGREGATEFUNCTION = <DType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>
BIGDECIMAL = <DType.BIGDECIMAL: 'BIGDECIMAL'>
```

--------------------------------

### Initialize a Table

Source: https://sqlglot.com/sqlglot/executor/table.html

Create a new Table instance with specified columns and rows. The constructor handles optional column ranges and initializes readers for row access.

```python
table = Table(columns=["col1", "col2"], rows=[(1, "a"), (2, "b")])
```

--------------------------------

### Get schema depth

Source: https://sqlglot.com/sqlglot/schema.html

Calculates the depth of the table or UDF mapping dictionaries.

```python
175    def depth(self) -> int:
176        return dict_depth(self.mapping)
```

```python
178    def udf_depth(self) -> int:
179        return dict_depth(self.udf_mapping)
```

--------------------------------

### AthenaParser.__init__

Source: https://sqlglot.com/sqlglot/parsers/athena.html

Initializes a new instance of the AthenaParser, configuring error handling and dialect-specific parsers.

```APIDOC
## AthenaParser.__init__

### Description
Initializes the AthenaParser with specified error handling configurations and optional dialect instances.

### Parameters
- **error_level** (ErrorLevel | None) - Optional - The desired error level. Default: ErrorLevel.IMMEDIATE.
- **error_message_context** (int) - Optional - The amount of context to capture from a query string when displaying the error message. Default: 100.
- **max_errors** (int) - Optional - Maximum number of error messages to include in a raised ParseError. Default: 3.
- **dialect** (DialectType) - Optional - The dialect configuration.
- **hive** (Hive | None) - Optional - An instance of the Hive dialect.
- **trino** (Trino | None) - Optional - An instance of the Trino dialect.
```

--------------------------------

### Get column data type

Source: https://sqlglot.com/sqlglot/schema.html

Retrieves the sqlglot.exp.DataType type of a column in the schema.

```python
79    @abc.abstractmethod
80    def get_column_type(
81        self,
82        table: exp.Table | str,
83        column: exp.Column | str,
84        dialect: DialectType = None,
85        normalize: bool | None = None,
86    ) -> exp.DataType:
87        """
88        Get the `sqlglot.exp.DataType` type of a column in the schema.
89
90        Args:
91            table: the source table.
92            column: the target column.
93            dialect: the SQL dialect that will be used to parse `table` if it's a string.
94            normalize: whether to normalize identifiers according to the dialect of interest.
95
96        Returns:
97            The resulting column type.
98        """
```

--------------------------------

### Initialize Tables Schema

Source: https://sqlglot.com/sqlglot/executor/table.html

Create an instance of the Tables class, which acts as a schema for multiple tables.

```python
tables_schema = Tables()
```

--------------------------------

### Get Type Name Property

Source: https://sqlglot.com/sqlglot/planner.html

Property to retrieve the name of the operation type.

```python
453    @property
454    def type_name(self) -> str:
455        return self.op.__name__
```

--------------------------------

### select(*expressions, dialect=None, copy=True, **opts)

Source: https://sqlglot.com/sqlglot/expressions/builders.html

Initializes a syntax tree from one or multiple SELECT expressions. This function allows you to start building a SELECT statement by providing the columns or expressions to be selected.

```APIDOC
## select(*expressions, dialect=None, copy=True, **opts)

### Description
Initializes a syntax tree from one or multiple SELECT expressions. This function allows you to start building a SELECT statement by providing the columns or expressions to be selected.

### Method
```python
def select(
    *expressions: ExpOrStr,
    dialect: DialectType = None,
    copy: bool = True,
    **opts: Unpack[ParserNoDialectArgs],
) -> Select:
```

### Parameters
* **expressions**: The SQL code string or expression to parse as the expressions of a SELECT statement. If an Expr instance is passed, it is used as-is.
* **dialect**: The dialect used to parse the input expressions (if an input expression is a SQL string).
* **copy**: Whether to copy the expressions. Defaults to True.
* ** **opts**: Other options to use to parse the input expressions (if an input expression is a SQL string).

### Example
```python
>>> select("col1", "col2").from_("tbl").sql()
'SELECT col1, col2 FROM tbl'
```

### Returns
Select: The syntax tree for the SELECT statement.
```

--------------------------------

### Get Table Length (Number of Rows)

Source: https://sqlglot.com/sqlglot/executor/table.html

Retrieve the number of rows in the table.

```python
len(table)
```

--------------------------------

### Define Seq8 Expression

Source: https://sqlglot.com/sqlglot/expressions/functions.html

Example of the internal structure for the Seq8 expression class.

```python

arg_types = {'this': False}
key: ClassVar[str] = 'seq8'
required_args: 't.ClassVar[set[str]]' = set()
```
Tokens:
Raw