sqlglot.expressions API documentation

Edit on GitHub

## Expressions

Every AST node in SQLGlot is represented by a subclass of `Expression`.

This module contains the implementation of all supported `Expression` types. Additionally, it exposes a number of helper functions, which are mainly used to programmatically build SQL expressions, such as `sqlglot.expressions.select`.

View Source

       1"""
       2## Expressions
       3
       4Every AST node in SQLGlot is represented by a subclass of `Expression`.
       5
       6This module contains the implementation of all supported `Expression` types. Additionally,
       7it exposes a number of helper functions, which are mainly used to programmatically build
       8SQL expressions, such as `sqlglot.expressions.select`.
       9
      10----
      11"""
      12
      13from __future__ import annotations
      14import datetime
      15import math
      16import numbers
      17import re
      18import textwrap
      19import typing as t
      20from collections import deque
      21from copy import deepcopy
      22from decimal import Decimal
      23from enum import auto
      24from functools import reduce
      25
      26from sqlglot.errors import ErrorLevel, ParseError
      27from sqlglot.helper import (
      28    AutoName,
      29    camel_to_snake_case,
      30    ensure_collection,
      31    ensure_list,
      32    seq_get,
      33    subclasses,
      34)
      35from sqlglot.tokens import Token, TokenError
      36
      37if t.TYPE_CHECKING:
      38    from typing_extensions import Self
      39    from sqlglot._typing import E, Lit
      40    from sqlglot.dialects.dialect import DialectType
      41
      42    Q = t.TypeVar("Q", bound="Query")
      43    S = t.TypeVar("S", bound="SetOperation")
      44
      45
      46class _Expression(type):
      47    def __new__(cls, clsname, bases, attrs):
      48        klass = super().__new__(cls, clsname, bases, attrs)
      49
      50        # When an Expression class is created, its key is automatically set to be
      51        # the lowercase version of the class' name.
      52        klass.key = clsname.lower()
      53
      54        # This is so that docstrings are not inherited in pdoc
      55        klass.__doc__ = klass.__doc__ or ""
      56
      57        return klass
      58
      59
      60SQLGLOT_META = "sqlglot.meta"
      61TABLE_PARTS = ("this", "db", "catalog")
      62COLUMN_PARTS = ("this", "table", "db", "catalog")
      63
      64
      65class Expression(metaclass=_Expression):
      66    """
      67    The base class for all expressions in a syntax tree. Each Expression encapsulates any necessary
      68    context, such as its child expressions, their names (arg keys), and whether a given child expression
      69    is optional or not.
      70
      71    Attributes:
      72        key: a unique key for each class in the Expression hierarchy. This is useful for hashing
      73            and representing expressions as strings.
      74        arg_types: determines the arguments (child nodes) supported by an expression. It maps
      75            arg keys to booleans that indicate whether the corresponding args are optional.
      76        parent: a reference to the parent expression (or None, in case of root expressions).
      77        arg_key: the arg key an expression is associated with, i.e. the name its parent expression
      78            uses to refer to it.
      79        index: the index of an expression if it is inside of a list argument in its parent.
      80        comments: a list of comments that are associated with a given expression. This is used in
      81            order to preserve comments when transpiling SQL code.
      82        type: the `sqlglot.expressions.DataType` type of an expression. This is inferred by the
      83            optimizer, in order to enable some transformations that require type information.
      84        meta: a dictionary that can be used to store useful metadata for a given expression.
      85
      86    Example:
      87        >>> class Foo(Expression):
      88        ...     arg_types = {"this": True, "expression": False}
      89
      90        The above definition informs us that Foo is an Expression that requires an argument called
      91        "this" and may also optionally receive an argument called "expression".
      92
      93    Args:
      94        args: a mapping used for retrieving the arguments of an expression, given their arg keys.
      95    """
      96
      97    key = "expression"
      98    arg_types = {"this": True}
      99    __slots__ = ("args", "parent", "arg_key", "index", "comments", "_type", "_meta", "_hash")
     100
     101    def __init__(self, **args: t.Any):
     102        self.args: t.Dict[str, t.Any] = args
     103        self.parent: t.Optional[Expression] = None
     104        self.arg_key: t.Optional[str] = None
     105        self.index: t.Optional[int] = None
     106        self.comments: t.Optional[t.List[str]] = None
     107        self._type: t.Optional[DataType] = None
     108        self._meta: t.Optional[t.Dict[str, t.Any]] = None
     109        self._hash: t.Optional[int] = None
     110
     111        for arg_key, value in self.args.items():
     112            self._set_parent(arg_key, value)
     113
     114    def __eq__(self, other) -> bool:
     115        return type(self) is type(other) and hash(self) == hash(other)
     116
     117    @property
     118    def hashable_args(self) -> t.Any:
     119        return frozenset(
     120            (k, tuple(_norm_arg(a) for a in v) if type(v) is list else _norm_arg(v))
     121            for k, v in self.args.items()
     122            if not (v is None or v is False or (type(v) is list and not v))
     123        )
     124
     125    def __hash__(self) -> int:
     126        if self._hash is not None:
     127            return self._hash
     128
     129        return hash((self.__class__, self.hashable_args))
     130
     131    @property
     132    def this(self) -> t.Any:
     133        """
     134        Retrieves the argument with key "this".
     135        """
     136        return self.args.get("this")
     137
     138    @property
     139    def expression(self) -> t.Any:
     140        """
     141        Retrieves the argument with key "expression".
     142        """
     143        return self.args.get("expression")
     144
     145    @property
     146    def expressions(self) -> t.List[t.Any]:
     147        """
     148        Retrieves the argument with key "expressions".
     149        """
     150        return self.args.get("expressions") or []
     151
     152    def text(self, key) -> str:
     153        """
     154        Returns a textual representation of the argument corresponding to "key". This can only be used
     155        for args that are strings or leaf Expression instances, such as identifiers and literals.
     156        """
     157        field = self.args.get(key)
     158        if isinstance(field, str):
     159            return field
     160        if isinstance(field, (Identifier, Literal, Var)):
     161            return field.this
     162        if isinstance(field, (Star, Null)):
     163            return field.name
     164        return ""
     165
     166    @property
     167    def is_string(self) -> bool:
     168        """
     169        Checks whether a Literal expression is a string.
     170        """
     171        return isinstance(self, Literal) and self.args["is_string"]
     172
     173    @property
     174    def is_number(self) -> bool:
     175        """
     176        Checks whether a Literal expression is a number.
     177        """
     178        return (isinstance(self, Literal) and not self.args["is_string"]) or (
     179            isinstance(self, Neg) and self.this.is_number
     180        )
     181
     182    def to_py(self) -> t.Any:
     183        """
     184        Returns a Python object equivalent of the SQL node.
     185        """
     186        raise ValueError(f"{self} cannot be converted to a Python object.")
     187
     188    @property
     189    def is_int(self) -> bool:
     190        """
     191        Checks whether an expression is an integer.
     192        """
     193        return self.is_number and isinstance(self.to_py(), int)
     194
     195    @property
     196    def is_star(self) -> bool:
     197        """Checks whether an expression is a star."""
     198        return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))
     199
     200    @property
     201    def alias(self) -> str:
     202        """
     203        Returns the alias of the expression, or an empty string if it's not aliased.
     204        """
     205        if isinstance(self.args.get("alias"), TableAlias):
     206            return self.args["alias"].name
     207        return self.text("alias")
     208
     209    @property
     210    def alias_column_names(self) -> t.List[str]:
     211        table_alias = self.args.get("alias")
     212        if not table_alias:
     213            return []
     214        return [c.name for c in table_alias.args.get("columns") or []]
     215
     216    @property
     217    def name(self) -> str:
     218        return self.text("this")
     219
     220    @property
     221    def alias_or_name(self) -> str:
     222        return self.alias or self.name
     223
     224    @property
     225    def output_name(self) -> str:
     226        """
     227        Name of the output column if this expression is a selection.
     228
     229        If the Expression has no output name, an empty string is returned.
     230
     231        Example:
     232            >>> from sqlglot import parse_one
     233            >>> parse_one("SELECT a").expressions[0].output_name
     234            'a'
     235            >>> parse_one("SELECT b AS c").expressions[0].output_name
     236            'c'
     237            >>> parse_one("SELECT 1 + 2").expressions[0].output_name
     238            ''
     239        """
     240        return ""
     241
     242    @property
     243    def type(self) -> t.Optional[DataType]:
     244        return self._type
     245
     246    @type.setter
     247    def type(self, dtype: t.Optional[DataType | DataType.Type | str]) -> None:
     248        if dtype and not isinstance(dtype, DataType):
     249            dtype = DataType.build(dtype)
     250        self._type = dtype  # type: ignore
     251
     252    def is_type(self, *dtypes) -> bool:
     253        return self.type is not None and self.type.is_type(*dtypes)
     254
     255    def is_leaf(self) -> bool:
     256        return not any(isinstance(v, (Expression, list)) for v in self.args.values())
     257
     258    @property
     259    def meta(self) -> t.Dict[str, t.Any]:
     260        if self._meta is None:
     261            self._meta = {}
     262        return self._meta
     263
     264    def __deepcopy__(self, memo):
     265        root = self.__class__()
     266        stack = [(self, root)]
     267
     268        while stack:
     269            node, copy = stack.pop()
     270
     271            if node.comments is not None:
     272                copy.comments = deepcopy(node.comments)
     273            if node._type is not None:
     274                copy._type = deepcopy(node._type)
     275            if node._meta is not None:
     276                copy._meta = deepcopy(node._meta)
     277            if node._hash is not None:
     278                copy._hash = node._hash
     279
     280            for k, vs in node.args.items():
     281                if hasattr(vs, "parent"):
     282                    stack.append((vs, vs.__class__()))
     283                    copy.set(k, stack[-1][-1])
     284                elif type(vs) is list:
     285                    copy.args[k] = []
     286
     287                    for v in vs:
     288                        if hasattr(v, "parent"):
     289                            stack.append((v, v.__class__()))
     290                            copy.append(k, stack[-1][-1])
     291                        else:
     292                            copy.append(k, v)
     293                else:
     294                    copy.args[k] = vs
     295
     296        return root
     297
     298    def copy(self):
     299        """
     300        Returns a deep copy of the expression.
     301        """
     302        return deepcopy(self)
     303
     304    def add_comments(self, comments: t.Optional[t.List[str]] = None) -> None:
     305        if self.comments is None:
     306            self.comments = []
     307
     308        if comments:
     309            for comment in comments:
     310                _, *meta = comment.split(SQLGLOT_META)
     311                if meta:
     312                    for kv in "".join(meta).split(","):
     313                        k, *v = kv.split("=")
     314                        value = v[0].strip() if v else True
     315                        self.meta[k.strip()] = value
     316                self.comments.append(comment)
     317
     318    def pop_comments(self) -> t.List[str]:
     319        comments = self.comments or []
     320        self.comments = None
     321        return comments
     322
     323    def append(self, arg_key: str, value: t.Any) -> None:
     324        """
     325        Appends value to arg_key if it's a list or sets it as a new list.
     326
     327        Args:
     328            arg_key (str): name of the list expression arg
     329            value (Any): value to append to the list
     330        """
     331        if type(self.args.get(arg_key)) is not list:
     332            self.args[arg_key] = []
     333        self._set_parent(arg_key, value)
     334        values = self.args[arg_key]
     335        if hasattr(value, "parent"):
     336            value.index = len(values)
     337        values.append(value)
     338
     339    def set(
     340        self,
     341        arg_key: str,
     342        value: t.Any,
     343        index: t.Optional[int] = None,
     344        overwrite: bool = True,
     345    ) -> None:
     346        """
     347        Sets arg_key to value.
     348
     349        Args:
     350            arg_key: name of the expression arg.
     351            value: value to set the arg to.
     352            index: if the arg is a list, this specifies what position to add the value in it.
     353            overwrite: assuming an index is given, this determines whether to overwrite the
     354                list entry instead of only inserting a new value (i.e., like list.insert).
     355        """
     356        if index is not None:
     357            expressions = self.args.get(arg_key) or []
     358
     359            if seq_get(expressions, index) is None:
     360                return
     361            if value is None:
     362                expressions.pop(index)
     363                for v in expressions[index:]:
     364                    v.index = v.index - 1
     365                return
     366
     367            if isinstance(value, list):
     368                expressions.pop(index)
     369                expressions[index:index] = value
     370            elif overwrite:
     371                expressions[index] = value
     372            else:
     373                expressions.insert(index, value)
     374
     375            value = expressions
     376        elif value is None:
     377            self.args.pop(arg_key, None)
     378            return
     379
     380        self.args[arg_key] = value
     381        self._set_parent(arg_key, value, index)
     382
     383    def _set_parent(self, arg_key: str, value: t.Any, index: t.Optional[int] = None) -> None:
     384        if hasattr(value, "parent"):
     385            value.parent = self
     386            value.arg_key = arg_key
     387            value.index = index
     388        elif type(value) is list:
     389            for index, v in enumerate(value):
     390                if hasattr(v, "parent"):
     391                    v.parent = self
     392                    v.arg_key = arg_key
     393                    v.index = index
     394
     395    @property
     396    def depth(self) -> int:
     397        """
     398        Returns the depth of this tree.
     399        """
     400        if self.parent:
     401            return self.parent.depth + 1
     402        return 0
     403
     404    def iter_expressions(self, reverse: bool = False) -> t.Iterator[Expression]:
     405        """Yields the key and expression for all arguments, exploding list args."""
     406        # remove tuple when python 3.7 is deprecated
     407        for vs in reversed(tuple(self.args.values())) if reverse else self.args.values():  # type: ignore
     408            if type(vs) is list:
     409                for v in reversed(vs) if reverse else vs:  # type: ignore
     410                    if hasattr(v, "parent"):
     411                        yield v
     412            else:
     413                if hasattr(vs, "parent"):
     414                    yield vs
     415
     416    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
     417        """
     418        Returns the first node in this tree which matches at least one of
     419        the specified types.
     420
     421        Args:
     422            expression_types: the expression type(s) to match.
     423            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
     424
     425        Returns:
     426            The node which matches the criteria or None if no such node was found.
     427        """
     428        return next(self.find_all(*expression_types, bfs=bfs), None)
     429
     430    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
     431        """
     432        Returns a generator object which visits all nodes in this tree and only
     433        yields those that match at least one of the specified expression types.
     434
     435        Args:
     436            expression_types: the expression type(s) to match.
     437            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
     438
     439        Returns:
     440            The generator object.
     441        """
     442        for expression in self.walk(bfs=bfs):
     443            if isinstance(expression, expression_types):
     444                yield expression
     445
     446    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
     447        """
     448        Returns a nearest parent matching expression_types.
     449
     450        Args:
     451            expression_types: the expression type(s) to match.
     452
     453        Returns:
     454            The parent node.
     455        """
     456        ancestor = self.parent
     457        while ancestor and not isinstance(ancestor, expression_types):
     458            ancestor = ancestor.parent
     459        return ancestor  # type: ignore
     460
     461    @property
     462    def parent_select(self) -> t.Optional[Select]:
     463        """
     464        Returns the parent select statement.
     465        """
     466        return self.find_ancestor(Select)
     467
     468    @property
     469    def same_parent(self) -> bool:
     470        """Returns if the parent is the same class as itself."""
     471        return type(self.parent) is self.__class__
     472
     473    def root(self) -> Expression:
     474        """
     475        Returns the root expression of this tree.
     476        """
     477        expression = self
     478        while expression.parent:
     479            expression = expression.parent
     480        return expression
     481
     482    def walk(
     483        self, bfs: bool = True, prune: t.Optional[t.Callable[[Expression], bool]] = None
     484    ) -> t.Iterator[Expression]:
     485        """
     486        Returns a generator object which visits all nodes in this tree.
     487
     488        Args:
     489            bfs: if set to True the BFS traversal order will be applied,
     490                otherwise the DFS traversal will be used instead.
     491            prune: callable that returns True if the generator should stop traversing
     492                this branch of the tree.
     493
     494        Returns:
     495            the generator object.
     496        """
     497        if bfs:
     498            yield from self.bfs(prune=prune)
     499        else:
     500            yield from self.dfs(prune=prune)
     501
     502    def dfs(
     503        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
     504    ) -> t.Iterator[Expression]:
     505        """
     506        Returns a generator object which visits all nodes in this tree in
     507        the DFS (Depth-first) order.
     508
     509        Returns:
     510            The generator object.
     511        """
     512        stack = [self]
     513
     514        while stack:
     515            node = stack.pop()
     516
     517            yield node
     518
     519            if prune and prune(node):
     520                continue
     521
     522            for v in node.iter_expressions(reverse=True):
     523                stack.append(v)
     524
     525    def bfs(
     526        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
     527    ) -> t.Iterator[Expression]:
     528        """
     529        Returns a generator object which visits all nodes in this tree in
     530        the BFS (Breadth-first) order.
     531
     532        Returns:
     533            The generator object.
     534        """
     535        queue = deque([self])
     536
     537        while queue:
     538            node = queue.popleft()
     539
     540            yield node
     541
     542            if prune and prune(node):
     543                continue
     544
     545            for v in node.iter_expressions():
     546                queue.append(v)
     547
     548    def unnest(self):
     549        """
     550        Returns the first non parenthesis child or self.
     551        """
     552        expression = self
     553        while type(expression) is Paren:
     554            expression = expression.this
     555        return expression
     556
     557    def unalias(self):
     558        """
     559        Returns the inner expression if this is an Alias.
     560        """
     561        if isinstance(self, Alias):
     562            return self.this
     563        return self
     564
     565    def unnest_operands(self):
     566        """
     567        Returns unnested operands as a tuple.
     568        """
     569        return tuple(arg.unnest() for arg in self.iter_expressions())
     570
     571    def flatten(self, unnest=True):
     572        """
     573        Returns a generator which yields child nodes whose parents are the same class.
     574
     575        A AND B AND C -> [A, B, C]
     576        """
     577        for node in self.dfs(prune=lambda n: n.parent and type(n) is not self.__class__):
     578            if type(node) is not self.__class__:
     579                yield node.unnest() if unnest and not isinstance(node, Subquery) else node
     580
     581    def __str__(self) -> str:
     582        return self.sql()
     583
     584    def __repr__(self) -> str:
     585        return _to_s(self)
     586
     587    def to_s(self) -> str:
     588        """
     589        Same as __repr__, but includes additional information which can be useful
     590        for debugging, like empty or missing args and the AST nodes' object IDs.
     591        """
     592        return _to_s(self, verbose=True)
     593
     594    def sql(self, dialect: DialectType = None, **opts) -> str:
     595        """
     596        Returns SQL string representation of this tree.
     597
     598        Args:
     599            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
     600            opts: other `sqlglot.generator.Generator` options.
     601
     602        Returns:
     603            The SQL string.
     604        """
     605        from sqlglot.dialects import Dialect
     606
     607        return Dialect.get_or_raise(dialect).generate(self, **opts)
     608
     609    def transform(self, fun: t.Callable, *args: t.Any, copy: bool = True, **kwargs) -> Expression:
     610        """
     611        Visits all tree nodes (excluding already transformed ones)
     612        and applies the given transformation function to each node.
     613
     614        Args:
     615            fun: a function which takes a node as an argument and returns a
     616                new transformed node or the same node without modifications. If the function
     617                returns None, then the corresponding node will be removed from the syntax tree.
     618            copy: if set to True a new tree instance is constructed, otherwise the tree is
     619                modified in place.
     620
     621        Returns:
     622            The transformed tree.
     623        """
     624        root = None
     625        new_node = None
     626
     627        for node in (self.copy() if copy else self).dfs(prune=lambda n: n is not new_node):
     628            parent, arg_key, index = node.parent, node.arg_key, node.index
     629            new_node = fun(node, *args, **kwargs)
     630
     631            if not root:
     632                root = new_node
     633            elif new_node is not node:
     634                parent.set(arg_key, new_node, index)
     635
     636        assert root
     637        return root.assert_is(Expression)
     638
     639    @t.overload
     640    def replace(self, expression: E) -> E: ...
     641
     642    @t.overload
     643    def replace(self, expression: None) -> None: ...
     644
     645    def replace(self, expression):
     646        """
     647        Swap out this expression with a new expression.
     648
     649        For example::
     650
     651            >>> tree = Select().select("x").from_("tbl")
     652            >>> tree.find(Column).replace(column("y"))
     653            Column(
     654              this=Identifier(this=y, quoted=False))
     655            >>> tree.sql()
     656            'SELECT y FROM tbl'
     657
     658        Args:
     659            expression: new node
     660
     661        Returns:
     662            The new expression or expressions.
     663        """
     664        parent = self.parent
     665
     666        if not parent or parent is expression:
     667            return expression
     668
     669        key = self.arg_key
     670        value = parent.args.get(key)
     671
     672        if type(expression) is list and isinstance(value, Expression):
     673            # We are trying to replace an Expression with a list, so it's assumed that
     674            # the intention was to really replace the parent of this expression.
     675            value.parent.replace(expression)
     676        else:
     677            parent.set(key, expression, self.index)
     678
     679        if expression is not self:
     680            self.parent = None
     681            self.arg_key = None
     682            self.index = None
     683
     684        return expression
     685
     686    def pop(self: E) -> E:
     687        """
     688        Remove this expression from its AST.
     689
     690        Returns:
     691            The popped expression.
     692        """
     693        self.replace(None)
     694        return self
     695
     696    def assert_is(self, type_: t.Type[E]) -> E:
     697        """
     698        Assert that this `Expression` is an instance of `type_`.
     699
     700        If it is NOT an instance of `type_`, this raises an assertion error.
     701        Otherwise, this returns this expression.
     702
     703        Examples:
     704            This is useful for type security in chained expressions:
     705
     706            >>> import sqlglot
     707            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
     708            'SELECT x, z FROM y'
     709        """
     710        if not isinstance(self, type_):
     711            raise AssertionError(f"{self} is not {type_}.")
     712        return self
     713
     714    def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
     715        """
     716        Checks if this expression is valid (e.g. all mandatory args are set).
     717
     718        Args:
     719            args: a sequence of values that were used to instantiate a Func expression. This is used
     720                to check that the provided arguments don't exceed the function argument limit.
     721
     722        Returns:
     723            A list of error messages for all possible errors that were found.
     724        """
     725        errors: t.List[str] = []
     726
     727        for k in self.args:
     728            if k not in self.arg_types:
     729                errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
     730        for k, mandatory in self.arg_types.items():
     731            v = self.args.get(k)
     732            if mandatory and (v is None or (isinstance(v, list) and not v)):
     733                errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
     734
     735        if (
     736            args
     737            and isinstance(self, Func)
     738            and len(args) > len(self.arg_types)
     739            and not self.is_var_len_args
     740        ):
     741            errors.append(
     742                f"The number of provided arguments ({len(args)}) is greater than "
     743                f"the maximum number of supported arguments ({len(self.arg_types)})"
     744            )
     745
     746        return errors
     747
     748    def dump(self):
     749        """
     750        Dump this Expression to a JSON-serializable dict.
     751        """
     752        from sqlglot.serde import dump
     753
     754        return dump(self)
     755
     756    @classmethod
     757    def load(cls, obj):
     758        """
     759        Load a dict (as returned by `Expression.dump`) into an Expression instance.
     760        """
     761        from sqlglot.serde import load
     762
     763        return load(obj)
     764
     765    def and_(
     766        self,
     767        *expressions: t.Optional[ExpOrStr],
     768        dialect: DialectType = None,
     769        copy: bool = True,
     770        **opts,
     771    ) -> Condition:
     772        """
     773        AND this condition with one or multiple expressions.
     774
     775        Example:
     776            >>> condition("x=1").and_("y=1").sql()
     777            'x = 1 AND y = 1'
     778
     779        Args:
     780            *expressions: the SQL code strings to parse.
     781                If an `Expression` instance is passed, it will be used as-is.
     782            dialect: the dialect used to parse the input expression.
     783            copy: whether to copy the involved expressions (only applies to Expressions).
     784            opts: other options to use to parse the input expressions.
     785
     786        Returns:
     787            The new And condition.
     788        """
     789        return and_(self, *expressions, dialect=dialect, copy=copy, **opts)
     790
     791    def or_(
     792        self,
     793        *expressions: t.Optional[ExpOrStr],
     794        dialect: DialectType = None,
     795        copy: bool = True,
     796        **opts,
     797    ) -> Condition:
     798        """
     799        OR this condition with one or multiple expressions.
     800
     801        Example:
     802            >>> condition("x=1").or_("y=1").sql()
     803            'x = 1 OR y = 1'
     804
     805        Args:
     806            *expressions: the SQL code strings to parse.
     807                If an `Expression` instance is passed, it will be used as-is.
     808            dialect: the dialect used to parse the input expression.
     809            copy: whether to copy the involved expressions (only applies to Expressions).
     810            opts: other options to use to parse the input expressions.
     811
     812        Returns:
     813            The new Or condition.
     814        """
     815        return or_(self, *expressions, dialect=dialect, copy=copy, **opts)
     816
     817    def not_(self, copy: bool = True):
     818        """
     819        Wrap this condition with NOT.
     820
     821        Example:
     822            >>> condition("x=1").not_().sql()
     823            'NOT x = 1'
     824
     825        Args:
     826            copy: whether to copy this object.
     827
     828        Returns:
     829            The new Not instance.
     830        """
     831        return not_(self, copy=copy)
     832
     833    def as_(
     834        self,
     835        alias: str | Identifier,
     836        quoted: t.Optional[bool] = None,
     837        dialect: DialectType = None,
     838        copy: bool = True,
     839        **opts,
     840    ) -> Alias:
     841        return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)
     842
     843    def _binop(self, klass: t.Type[E], other: t.Any, reverse: bool = False) -> E:
     844        this = self.copy()
     845        other = convert(other, copy=True)
     846        if not isinstance(this, klass) and not isinstance(other, klass):
     847            this = _wrap(this, Binary)
     848            other = _wrap(other, Binary)
     849        if reverse:
     850            return klass(this=other, expression=this)
     851        return klass(this=this, expression=other)
     852
     853    def __getitem__(self, other: ExpOrStr | t.Tuple[ExpOrStr]) -> Bracket:
     854        return Bracket(
     855            this=self.copy(), expressions=[convert(e, copy=True) for e in ensure_list(other)]
     856        )
     857
     858    def __iter__(self) -> t.Iterator:
     859        if "expressions" in self.arg_types:
     860            return iter(self.args.get("expressions") or [])
     861        # We define this because __getitem__ converts Expression into an iterable, which is
     862        # problematic because one can hit infinite loops if they do "for x in some_expr: ..."
     863        # See: https://peps.python.org/pep-0234/
     864        raise TypeError(f"'{self.__class__.__name__}' object is not iterable")
     865
     866    def isin(
     867        self,
     868        *expressions: t.Any,
     869        query: t.Optional[ExpOrStr] = None,
     870        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
     871        copy: bool = True,
     872        **opts,
     873    ) -> In:
     874        subquery = maybe_parse(query, copy=copy, **opts) if query else None
     875        if subquery and not isinstance(subquery, Subquery):
     876            subquery = subquery.subquery(copy=False)
     877
     878        return In(
     879            this=maybe_copy(self, copy),
     880            expressions=[convert(e, copy=copy) for e in expressions],
     881            query=subquery,
     882            unnest=(
     883                Unnest(
     884                    expressions=[
     885                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
     886                        for e in ensure_list(unnest)
     887                    ]
     888                )
     889                if unnest
     890                else None
     891            ),
     892        )
     893
     894    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
     895        return Between(
     896            this=maybe_copy(self, copy),
     897            low=convert(low, copy=copy, **opts),
     898            high=convert(high, copy=copy, **opts),
     899        )
     900
     901    def is_(self, other: ExpOrStr) -> Is:
     902        return self._binop(Is, other)
     903
     904    def like(self, other: ExpOrStr) -> Like:
     905        return self._binop(Like, other)
     906
     907    def ilike(self, other: ExpOrStr) -> ILike:
     908        return self._binop(ILike, other)
     909
     910    def eq(self, other: t.Any) -> EQ:
     911        return self._binop(EQ, other)
     912
     913    def neq(self, other: t.Any) -> NEQ:
     914        return self._binop(NEQ, other)
     915
     916    def rlike(self, other: ExpOrStr) -> RegexpLike:
     917        return self._binop(RegexpLike, other)
     918
     919    def div(self, other: ExpOrStr, typed: bool = False, safe: bool = False) -> Div:
     920        div = self._binop(Div, other)
     921        div.args["typed"] = typed
     922        div.args["safe"] = safe
     923        return div
     924
     925    def asc(self, nulls_first: bool = True) -> Ordered:
     926        return Ordered(this=self.copy(), nulls_first=nulls_first)
     927
     928    def desc(self, nulls_first: bool = False) -> Ordered:
     929        return Ordered(this=self.copy(), desc=True, nulls_first=nulls_first)
     930
     931    def __lt__(self, other: t.Any) -> LT:
     932        return self._binop(LT, other)
     933
     934    def __le__(self, other: t.Any) -> LTE:
     935        return self._binop(LTE, other)
     936
     937    def __gt__(self, other: t.Any) -> GT:
     938        return self._binop(GT, other)
     939
     940    def __ge__(self, other: t.Any) -> GTE:
     941        return self._binop(GTE, other)
     942
     943    def __add__(self, other: t.Any) -> Add:
     944        return self._binop(Add, other)
     945
     946    def __radd__(self, other: t.Any) -> Add:
     947        return self._binop(Add, other, reverse=True)
     948
     949    def __sub__(self, other: t.Any) -> Sub:
     950        return self._binop(Sub, other)
     951
     952    def __rsub__(self, other: t.Any) -> Sub:
     953        return self._binop(Sub, other, reverse=True)
     954
     955    def __mul__(self, other: t.Any) -> Mul:
     956        return self._binop(Mul, other)
     957
     958    def __rmul__(self, other: t.Any) -> Mul:
     959        return self._binop(Mul, other, reverse=True)
     960
     961    def __truediv__(self, other: t.Any) -> Div:
     962        return self._binop(Div, other)
     963
     964    def __rtruediv__(self, other: t.Any) -> Div:
     965        return self._binop(Div, other, reverse=True)
     966
     967    def __floordiv__(self, other: t.Any) -> IntDiv:
     968        return self._binop(IntDiv, other)
     969
     970    def __rfloordiv__(self, other: t.Any) -> IntDiv:
     971        return self._binop(IntDiv, other, reverse=True)
     972
     973    def __mod__(self, other: t.Any) -> Mod:
     974        return self._binop(Mod, other)
     975
     976    def __rmod__(self, other: t.Any) -> Mod:
     977        return self._binop(Mod, other, reverse=True)
     978
     979    def __pow__(self, other: t.Any) -> Pow:
     980        return self._binop(Pow, other)
     981
     982    def __rpow__(self, other: t.Any) -> Pow:
     983        return self._binop(Pow, other, reverse=True)
     984
     985    def __and__(self, other: t.Any) -> And:
     986        return self._binop(And, other)
     987
     988    def __rand__(self, other: t.Any) -> And:
     989        return self._binop(And, other, reverse=True)
     990
     991    def __or__(self, other: t.Any) -> Or:
     992        return self._binop(Or, other)
     993
     994    def __ror__(self, other: t.Any) -> Or:
     995        return self._binop(Or, other, reverse=True)
     996
     997    def __neg__(self) -> Neg:
     998        return Neg(this=_wrap(self.copy(), Binary))
     999
    1000    def __invert__(self) -> Not:
    1001        return not_(self.copy())
    1002
    1003
    1004IntoType = t.Union[
    1005    str,
    1006    t.Type[Expression],
    1007    t.Collection[t.Union[str, t.Type[Expression]]],
    1008]
    1009ExpOrStr = t.Union[str, Expression]
    1010
    1011
    1012class Condition(Expression):
    1013    """Logical conditions like x AND y, or simply x"""
    1014
    1015
    1016class Predicate(Condition):
    1017    """Relationships like x = y, x > 1, x >= y."""
    1018
    1019
    1020class DerivedTable(Expression):
    1021    @property
    1022    def selects(self) -> t.List[Expression]:
    1023        return self.this.selects if isinstance(self.this, Query) else []
    1024
    1025    @property
    1026    def named_selects(self) -> t.List[str]:
    1027        return [select.output_name for select in self.selects]
    1028
    1029
    1030class Query(Expression):
    1031    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    1032        """
    1033        Returns a `Subquery` that wraps around this query.
    1034
    1035        Example:
    1036            >>> subquery = Select().select("x").from_("tbl").subquery()
    1037            >>> Select().select("x").from_(subquery).sql()
    1038            'SELECT x FROM (SELECT x FROM tbl)'
    1039
    1040        Args:
    1041            alias: an optional alias for the subquery.
    1042            copy: if `False`, modify this expression instance in-place.
    1043        """
    1044        instance = maybe_copy(self, copy)
    1045        if not isinstance(alias, Expression):
    1046            alias = TableAlias(this=to_identifier(alias)) if alias else None
    1047
    1048        return Subquery(this=instance, alias=alias)
    1049
    1050    def limit(
    1051        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1052    ) -> Q:
    1053        """
    1054        Adds a LIMIT clause to this query.
    1055
    1056        Example:
    1057            >>> select("1").union(select("1")).limit(1).sql()
    1058            'SELECT 1 UNION SELECT 1 LIMIT 1'
    1059
    1060        Args:
    1061            expression: the SQL code string to parse.
    1062                This can also be an integer.
    1063                If a `Limit` instance is passed, it will be used as-is.
    1064                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    1065            dialect: the dialect used to parse the input expression.
    1066            copy: if `False`, modify this expression instance in-place.
    1067            opts: other options to use to parse the input expressions.
    1068
    1069        Returns:
    1070            A limited Select expression.
    1071        """
    1072        return _apply_builder(
    1073            expression=expression,
    1074            instance=self,
    1075            arg="limit",
    1076            into=Limit,
    1077            prefix="LIMIT",
    1078            dialect=dialect,
    1079            copy=copy,
    1080            into_arg="expression",
    1081            **opts,
    1082        )
    1083
    1084    def offset(
    1085        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1086    ) -> Q:
    1087        """
    1088        Set the OFFSET expression.
    1089
    1090        Example:
    1091            >>> Select().from_("tbl").select("x").offset(10).sql()
    1092            'SELECT x FROM tbl OFFSET 10'
    1093
    1094        Args:
    1095            expression: the SQL code string to parse.
    1096                This can also be an integer.
    1097                If a `Offset` instance is passed, this is used as-is.
    1098                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    1099            dialect: the dialect used to parse the input expression.
    1100            copy: if `False`, modify this expression instance in-place.
    1101            opts: other options to use to parse the input expressions.
    1102
    1103        Returns:
    1104            The modified Select expression.
    1105        """
    1106        return _apply_builder(
    1107            expression=expression,
    1108            instance=self,
    1109            arg="offset",
    1110            into=Offset,
    1111            prefix="OFFSET",
    1112            dialect=dialect,
    1113            copy=copy,
    1114            into_arg="expression",
    1115            **opts,
    1116        )
    1117
    1118    def order_by(
    1119        self: Q,
    1120        *expressions: t.Optional[ExpOrStr],
    1121        append: bool = True,
    1122        dialect: DialectType = None,
    1123        copy: bool = True,
    1124        **opts,
    1125    ) -> Q:
    1126        """
    1127        Set the ORDER BY expression.
    1128
    1129        Example:
    1130            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    1131            'SELECT x FROM tbl ORDER BY x DESC'
    1132
    1133        Args:
    1134            *expressions: the SQL code strings to parse.
    1135                If a `Group` instance is passed, this is used as-is.
    1136                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    1137            append: if `True`, add to any existing expressions.
    1138                Otherwise, this flattens all the `Order` expression into a single expression.
    1139            dialect: the dialect used to parse the input expression.
    1140            copy: if `False`, modify this expression instance in-place.
    1141            opts: other options to use to parse the input expressions.
    1142
    1143        Returns:
    1144            The modified Select expression.
    1145        """
    1146        return _apply_child_list_builder(
    1147            *expressions,
    1148            instance=self,
    1149            arg="order",
    1150            append=append,
    1151            copy=copy,
    1152            prefix="ORDER BY",
    1153            into=Order,
    1154            dialect=dialect,
    1155            **opts,
    1156        )
    1157
    1158    @property
    1159    def ctes(self) -> t.List[CTE]:
    1160        """Returns a list of all the CTEs attached to this query."""
    1161        with_ = self.args.get("with")
    1162        return with_.expressions if with_ else []
    1163
    1164    @property
    1165    def selects(self) -> t.List[Expression]:
    1166        """Returns the query's projections."""
    1167        raise NotImplementedError("Query objects must implement `selects`")
    1168
    1169    @property
    1170    def named_selects(self) -> t.List[str]:
    1171        """Returns the output names of the query's projections."""
    1172        raise NotImplementedError("Query objects must implement `named_selects`")
    1173
    1174    def select(
    1175        self: Q,
    1176        *expressions: t.Optional[ExpOrStr],
    1177        append: bool = True,
    1178        dialect: DialectType = None,
    1179        copy: bool = True,
    1180        **opts,
    1181    ) -> Q:
    1182        """
    1183        Append to or set the SELECT expressions.
    1184
    1185        Example:
    1186            >>> Select().select("x", "y").sql()
    1187            'SELECT x, y'
    1188
    1189        Args:
    1190            *expressions: the SQL code strings to parse.
    1191                If an `Expression` instance is passed, it will be used as-is.
    1192            append: if `True`, add to any existing expressions.
    1193                Otherwise, this resets the expressions.
    1194            dialect: the dialect used to parse the input expressions.
    1195            copy: if `False`, modify this expression instance in-place.
    1196            opts: other options to use to parse the input expressions.
    1197
    1198        Returns:
    1199            The modified Query expression.
    1200        """
    1201        raise NotImplementedError("Query objects must implement `select`")
    1202
    1203    def with_(
    1204        self: Q,
    1205        alias: ExpOrStr,
    1206        as_: ExpOrStr,
    1207        recursive: t.Optional[bool] = None,
    1208        materialized: t.Optional[bool] = None,
    1209        append: bool = True,
    1210        dialect: DialectType = None,
    1211        copy: bool = True,
    1212        **opts,
    1213    ) -> Q:
    1214        """
    1215        Append to or set the common table expressions.
    1216
    1217        Example:
    1218            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    1219            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    1220
    1221        Args:
    1222            alias: the SQL code string to parse as the table name.
    1223                If an `Expression` instance is passed, this is used as-is.
    1224            as_: the SQL code string to parse as the table expression.
    1225                If an `Expression` instance is passed, it will be used as-is.
    1226            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1227            materialized: set the MATERIALIZED part of the expression.
    1228            append: if `True`, add to any existing expressions.
    1229                Otherwise, this resets the expressions.
    1230            dialect: the dialect used to parse the input expression.
    1231            copy: if `False`, modify this expression instance in-place.
    1232            opts: other options to use to parse the input expressions.
    1233
    1234        Returns:
    1235            The modified expression.
    1236        """
    1237        return _apply_cte_builder(
    1238            self,
    1239            alias,
    1240            as_,
    1241            recursive=recursive,
    1242            materialized=materialized,
    1243            append=append,
    1244            dialect=dialect,
    1245            copy=copy,
    1246            **opts,
    1247        )
    1248
    1249    def union(
    1250        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1251    ) -> Union:
    1252        """
    1253        Builds a UNION expression.
    1254
    1255        Example:
    1256            >>> import sqlglot
    1257            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    1258            'SELECT * FROM foo UNION SELECT * FROM bla'
    1259
    1260        Args:
    1261            expressions: the SQL code strings.
    1262                If `Expression` instances are passed, they will be used as-is.
    1263            distinct: set the DISTINCT flag if and only if this is true.
    1264            dialect: the dialect used to parse the input expression.
    1265            opts: other options to use to parse the input expressions.
    1266
    1267        Returns:
    1268            The new Union expression.
    1269        """
    1270        return union(self, *expressions, distinct=distinct, dialect=dialect, **opts)
    1271
    1272    def intersect(
    1273        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1274    ) -> Intersect:
    1275        """
    1276        Builds an INTERSECT expression.
    1277
    1278        Example:
    1279            >>> import sqlglot
    1280            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    1281            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    1282
    1283        Args:
    1284            expressions: the SQL code strings.
    1285                If `Expression` instances are passed, they will be used as-is.
    1286            distinct: set the DISTINCT flag if and only if this is true.
    1287            dialect: the dialect used to parse the input expression.
    1288            opts: other options to use to parse the input expressions.
    1289
    1290        Returns:
    1291            The new Intersect expression.
    1292        """
    1293        return intersect(self, *expressions, distinct=distinct, dialect=dialect, **opts)
    1294
    1295    def except_(
    1296        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1297    ) -> Except:
    1298        """
    1299        Builds an EXCEPT expression.
    1300
    1301        Example:
    1302            >>> import sqlglot
    1303            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    1304            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    1305
    1306        Args:
    1307            expressions: the SQL code strings.
    1308                If `Expression` instance are passed, they will be used as-is.
    1309            distinct: set the DISTINCT flag if and only if this is true.
    1310            dialect: the dialect used to parse the input expression.
    1311            opts: other options to use to parse the input expressions.
    1312
    1313        Returns:
    1314            The new Except expression.
    1315        """
    1316        return except_(self, *expressions, distinct=distinct, dialect=dialect, **opts)
    1317
    1318
    1319class UDTF(DerivedTable):
    1320    @property
    1321    def selects(self) -> t.List[Expression]:
    1322        alias = self.args.get("alias")
    1323        return alias.columns if alias else []
    1324
    1325
    1326class Cache(Expression):
    1327    arg_types = {
    1328        "this": True,
    1329        "lazy": False,
    1330        "options": False,
    1331        "expression": False,
    1332    }
    1333
    1334
    1335class Uncache(Expression):
    1336    arg_types = {"this": True, "exists": False}
    1337
    1338
    1339class Refresh(Expression):
    1340    pass
    1341
    1342
    1343class DDL(Expression):
    1344    @property
    1345    def ctes(self) -> t.List[CTE]:
    1346        """Returns a list of all the CTEs attached to this statement."""
    1347        with_ = self.args.get("with")
    1348        return with_.expressions if with_ else []
    1349
    1350    @property
    1351    def selects(self) -> t.List[Expression]:
    1352        """If this statement contains a query (e.g. a CTAS), this returns the query's projections."""
    1353        return self.expression.selects if isinstance(self.expression, Query) else []
    1354
    1355    @property
    1356    def named_selects(self) -> t.List[str]:
    1357        """
    1358        If this statement contains a query (e.g. a CTAS), this returns the output
    1359        names of the query's projections.
    1360        """
    1361        return self.expression.named_selects if isinstance(self.expression, Query) else []
    1362
    1363
    1364class DML(Expression):
    1365    def returning(
    1366        self,
    1367        expression: ExpOrStr,
    1368        dialect: DialectType = None,
    1369        copy: bool = True,
    1370        **opts,
    1371    ) -> "Self":
    1372        """
    1373        Set the RETURNING expression. Not supported by all dialects.
    1374
    1375        Example:
    1376            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1377            'DELETE FROM tbl RETURNING *'
    1378
    1379        Args:
    1380            expression: the SQL code strings to parse.
    1381                If an `Expression` instance is passed, it will be used as-is.
    1382            dialect: the dialect used to parse the input expressions.
    1383            copy: if `False`, modify this expression instance in-place.
    1384            opts: other options to use to parse the input expressions.
    1385
    1386        Returns:
    1387            Delete: the modified expression.
    1388        """
    1389        return _apply_builder(
    1390            expression=expression,
    1391            instance=self,
    1392            arg="returning",
    1393            prefix="RETURNING",
    1394            dialect=dialect,
    1395            copy=copy,
    1396            into=Returning,
    1397            **opts,
    1398        )
    1399
    1400
    1401class Create(DDL):
    1402    arg_types = {
    1403        "with": False,
    1404        "this": True,
    1405        "kind": True,
    1406        "expression": False,
    1407        "exists": False,
    1408        "properties": False,
    1409        "replace": False,
    1410        "refresh": False,
    1411        "unique": False,
    1412        "indexes": False,
    1413        "no_schema_binding": False,
    1414        "begin": False,
    1415        "end": False,
    1416        "clone": False,
    1417        "concurrently": False,
    1418        "clustered": False,
    1419    }
    1420
    1421    @property
    1422    def kind(self) -> t.Optional[str]:
    1423        kind = self.args.get("kind")
    1424        return kind and kind.upper()
    1425
    1426
    1427class SequenceProperties(Expression):
    1428    arg_types = {
    1429        "increment": False,
    1430        "minvalue": False,
    1431        "maxvalue": False,
    1432        "cache": False,
    1433        "start": False,
    1434        "owned": False,
    1435        "options": False,
    1436    }
    1437
    1438
    1439class TruncateTable(Expression):
    1440    arg_types = {
    1441        "expressions": True,
    1442        "is_database": False,
    1443        "exists": False,
    1444        "only": False,
    1445        "cluster": False,
    1446        "identity": False,
    1447        "option": False,
    1448        "partition": False,
    1449    }
    1450
    1451
    1452# https://docs.snowflake.com/en/sql-reference/sql/create-clone
    1453# https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_table_clone_statement
    1454# https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_table_copy
    1455class Clone(Expression):
    1456    arg_types = {"this": True, "shallow": False, "copy": False}
    1457
    1458
    1459class Describe(Expression):
    1460    arg_types = {
    1461        "this": True,
    1462        "style": False,
    1463        "kind": False,
    1464        "expressions": False,
    1465        "partition": False,
    1466    }
    1467
    1468
    1469# https://duckdb.org/docs/guides/meta/summarize.html
    1470class Summarize(Expression):
    1471    arg_types = {"this": True, "table": False}
    1472
    1473
    1474class Kill(Expression):
    1475    arg_types = {"this": True, "kind": False}
    1476
    1477
    1478class Pragma(Expression):
    1479    pass
    1480
    1481
    1482class Declare(Expression):
    1483    arg_types = {"expressions": True}
    1484
    1485
    1486class DeclareItem(Expression):
    1487    arg_types = {"this": True, "kind": True, "default": False}
    1488
    1489
    1490class Set(Expression):
    1491    arg_types = {"expressions": False, "unset": False, "tag": False}
    1492
    1493
    1494class Heredoc(Expression):
    1495    arg_types = {"this": True, "tag": False}
    1496
    1497
    1498class SetItem(Expression):
    1499    arg_types = {
    1500        "this": False,
    1501        "expressions": False,
    1502        "kind": False,
    1503        "collate": False,  # MySQL SET NAMES statement
    1504        "global": False,
    1505    }
    1506
    1507
    1508class Show(Expression):
    1509    arg_types = {
    1510        "this": True,
    1511        "history": False,
    1512        "terse": False,
    1513        "target": False,
    1514        "offset": False,
    1515        "starts_with": False,
    1516        "limit": False,
    1517        "from": False,
    1518        "like": False,
    1519        "where": False,
    1520        "db": False,
    1521        "scope": False,
    1522        "scope_kind": False,
    1523        "full": False,
    1524        "mutex": False,
    1525        "query": False,
    1526        "channel": False,
    1527        "global": False,
    1528        "log": False,
    1529        "position": False,
    1530        "types": False,
    1531    }
    1532
    1533
    1534class UserDefinedFunction(Expression):
    1535    arg_types = {"this": True, "expressions": False, "wrapped": False}
    1536
    1537
    1538class CharacterSet(Expression):
    1539    arg_types = {"this": True, "default": False}
    1540
    1541
    1542class With(Expression):
    1543    arg_types = {"expressions": True, "recursive": False}
    1544
    1545    @property
    1546    def recursive(self) -> bool:
    1547        return bool(self.args.get("recursive"))
    1548
    1549
    1550class WithinGroup(Expression):
    1551    arg_types = {"this": True, "expression": False}
    1552
    1553
    1554# clickhouse supports scalar ctes
    1555# https://clickhouse.com/docs/en/sql-reference/statements/select/with
    1556class CTE(DerivedTable):
    1557    arg_types = {
    1558        "this": True,
    1559        "alias": True,
    1560        "scalar": False,
    1561        "materialized": False,
    1562    }
    1563
    1564
    1565class ProjectionDef(Expression):
    1566    arg_types = {"this": True, "expression": True}
    1567
    1568
    1569class TableAlias(Expression):
    1570    arg_types = {"this": False, "columns": False}
    1571
    1572    @property
    1573    def columns(self):
    1574        return self.args.get("columns") or []
    1575
    1576
    1577class BitString(Condition):
    1578    pass
    1579
    1580
    1581class HexString(Condition):
    1582    pass
    1583
    1584
    1585class ByteString(Condition):
    1586    pass
    1587
    1588
    1589class RawString(Condition):
    1590    pass
    1591
    1592
    1593class UnicodeString(Condition):
    1594    arg_types = {"this": True, "escape": False}
    1595
    1596
    1597class Column(Condition):
    1598    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
    1599
    1600    @property
    1601    def table(self) -> str:
    1602        return self.text("table")
    1603
    1604    @property
    1605    def db(self) -> str:
    1606        return self.text("db")
    1607
    1608    @property
    1609    def catalog(self) -> str:
    1610        return self.text("catalog")
    1611
    1612    @property
    1613    def output_name(self) -> str:
    1614        return self.name
    1615
    1616    @property
    1617    def parts(self) -> t.List[Identifier]:
    1618        """Return the parts of a column in order catalog, db, table, name."""
    1619        return [
    1620            t.cast(Identifier, self.args[part])
    1621            for part in ("catalog", "db", "table", "this")
    1622            if self.args.get(part)
    1623        ]
    1624
    1625    def to_dot(self) -> Dot | Identifier:
    1626        """Converts the column into a dot expression."""
    1627        parts = self.parts
    1628        parent = self.parent
    1629
    1630        while parent:
    1631            if isinstance(parent, Dot):
    1632                parts.append(parent.expression)
    1633            parent = parent.parent
    1634
    1635        return Dot.build(deepcopy(parts)) if len(parts) > 1 else parts[0]
    1636
    1637
    1638class ColumnPosition(Expression):
    1639    arg_types = {"this": False, "position": True}
    1640
    1641
    1642class ColumnDef(Expression):
    1643    arg_types = {
    1644        "this": True,
    1645        "kind": False,
    1646        "constraints": False,
    1647        "exists": False,
    1648        "position": False,
    1649    }
    1650
    1651    @property
    1652    def constraints(self) -> t.List[ColumnConstraint]:
    1653        return self.args.get("constraints") or []
    1654
    1655    @property
    1656    def kind(self) -> t.Optional[DataType]:
    1657        return self.args.get("kind")
    1658
    1659
    1660class AlterColumn(Expression):
    1661    arg_types = {
    1662        "this": True,
    1663        "dtype": False,
    1664        "collate": False,
    1665        "using": False,
    1666        "default": False,
    1667        "drop": False,
    1668        "comment": False,
    1669        "allow_null": False,
    1670    }
    1671
    1672
    1673# https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE.html
    1674class AlterDistStyle(Expression):
    1675    pass
    1676
    1677
    1678class AlterSortKey(Expression):
    1679    arg_types = {"this": False, "expressions": False, "compound": False}
    1680
    1681
    1682class AlterSet(Expression):
    1683    arg_types = {
    1684        "expressions": False,
    1685        "option": False,
    1686        "tablespace": False,
    1687        "access_method": False,
    1688        "file_format": False,
    1689        "copy_options": False,
    1690        "tag": False,
    1691        "location": False,
    1692        "serde": False,
    1693    }
    1694
    1695
    1696class RenameColumn(Expression):
    1697    arg_types = {"this": True, "to": True, "exists": False}
    1698
    1699
    1700class AlterRename(Expression):
    1701    pass
    1702
    1703
    1704class SwapTable(Expression):
    1705    pass
    1706
    1707
    1708class Comment(Expression):
    1709    arg_types = {
    1710        "this": True,
    1711        "kind": True,
    1712        "expression": True,
    1713        "exists": False,
    1714        "materialized": False,
    1715    }
    1716
    1717
    1718class Comprehension(Expression):
    1719    arg_types = {"this": True, "expression": True, "iterator": True, "condition": False}
    1720
    1721
    1722# https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
    1723class MergeTreeTTLAction(Expression):
    1724    arg_types = {
    1725        "this": True,
    1726        "delete": False,
    1727        "recompress": False,
    1728        "to_disk": False,
    1729        "to_volume": False,
    1730    }
    1731
    1732
    1733# https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
    1734class MergeTreeTTL(Expression):
    1735    arg_types = {
    1736        "expressions": True,
    1737        "where": False,
    1738        "group": False,
    1739        "aggregates": False,
    1740    }
    1741
    1742
    1743# https://dev.mysql.com/doc/refman/8.0/en/create-table.html
    1744class IndexConstraintOption(Expression):
    1745    arg_types = {
    1746        "key_block_size": False,
    1747        "using": False,
    1748        "parser": False,
    1749        "comment": False,
    1750        "visible": False,
    1751        "engine_attr": False,
    1752        "secondary_engine_attr": False,
    1753    }
    1754
    1755
    1756class ColumnConstraint(Expression):
    1757    arg_types = {"this": False, "kind": True}
    1758
    1759    @property
    1760    def kind(self) -> ColumnConstraintKind:
    1761        return self.args["kind"]
    1762
    1763
    1764class ColumnConstraintKind(Expression):
    1765    pass
    1766
    1767
    1768class AutoIncrementColumnConstraint(ColumnConstraintKind):
    1769    pass
    1770
    1771
    1772class PeriodForSystemTimeConstraint(ColumnConstraintKind):
    1773    arg_types = {"this": True, "expression": True}
    1774
    1775
    1776class CaseSpecificColumnConstraint(ColumnConstraintKind):
    1777    arg_types = {"not_": True}
    1778
    1779
    1780class CharacterSetColumnConstraint(ColumnConstraintKind):
    1781    arg_types = {"this": True}
    1782
    1783
    1784class CheckColumnConstraint(ColumnConstraintKind):
    1785    arg_types = {"this": True, "enforced": False}
    1786
    1787
    1788class ClusteredColumnConstraint(ColumnConstraintKind):
    1789    pass
    1790
    1791
    1792class CollateColumnConstraint(ColumnConstraintKind):
    1793    pass
    1794
    1795
    1796class CommentColumnConstraint(ColumnConstraintKind):
    1797    pass
    1798
    1799
    1800class CompressColumnConstraint(ColumnConstraintKind):
    1801    arg_types = {"this": False}
    1802
    1803
    1804class DateFormatColumnConstraint(ColumnConstraintKind):
    1805    arg_types = {"this": True}
    1806
    1807
    1808class DefaultColumnConstraint(ColumnConstraintKind):
    1809    pass
    1810
    1811
    1812class EncodeColumnConstraint(ColumnConstraintKind):
    1813    pass
    1814
    1815
    1816# https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-EXCLUDE
    1817class ExcludeColumnConstraint(ColumnConstraintKind):
    1818    pass
    1819
    1820
    1821class EphemeralColumnConstraint(ColumnConstraintKind):
    1822    arg_types = {"this": False}
    1823
    1824
    1825class WithOperator(Expression):
    1826    arg_types = {"this": True, "op": True}
    1827
    1828
    1829class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
    1830    # this: True -> ALWAYS, this: False -> BY DEFAULT
    1831    arg_types = {
    1832        "this": False,
    1833        "expression": False,
    1834        "on_null": False,
    1835        "start": False,
    1836        "increment": False,
    1837        "minvalue": False,
    1838        "maxvalue": False,
    1839        "cycle": False,
    1840    }
    1841
    1842
    1843class GeneratedAsRowColumnConstraint(ColumnConstraintKind):
    1844    arg_types = {"start": False, "hidden": False}
    1845
    1846
    1847# https://dev.mysql.com/doc/refman/8.0/en/create-table.html
    1848# https://github.com/ClickHouse/ClickHouse/blob/master/src/Parsers/ParserCreateQuery.h#L646
    1849class IndexColumnConstraint(ColumnConstraintKind):
    1850    arg_types = {
    1851        "this": False,
    1852        "expressions": False,
    1853        "kind": False,
    1854        "index_type": False,
    1855        "options": False,
    1856        "expression": False,  # Clickhouse
    1857        "granularity": False,
    1858    }
    1859
    1860
    1861class InlineLengthColumnConstraint(ColumnConstraintKind):
    1862    pass
    1863
    1864
    1865class NonClusteredColumnConstraint(ColumnConstraintKind):
    1866    pass
    1867
    1868
    1869class NotForReplicationColumnConstraint(ColumnConstraintKind):
    1870    arg_types = {}
    1871
    1872
    1873# https://docs.snowflake.com/en/sql-reference/sql/create-table
    1874class MaskingPolicyColumnConstraint(ColumnConstraintKind):
    1875    arg_types = {"this": True, "expressions": False}
    1876
    1877
    1878class NotNullColumnConstraint(ColumnConstraintKind):
    1879    arg_types = {"allow_null": False}
    1880
    1881
    1882# https://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html
    1883class OnUpdateColumnConstraint(ColumnConstraintKind):
    1884    pass
    1885
    1886
    1887# https://docs.snowflake.com/en/sql-reference/sql/create-table
    1888class TagColumnConstraint(ColumnConstraintKind):
    1889    arg_types = {"expressions": True}
    1890
    1891
    1892# https://docs.snowflake.com/en/sql-reference/sql/create-external-table#optional-parameters
    1893class TransformColumnConstraint(ColumnConstraintKind):
    1894    pass
    1895
    1896
    1897class PrimaryKeyColumnConstraint(ColumnConstraintKind):
    1898    arg_types = {"desc": False}
    1899
    1900
    1901class TitleColumnConstraint(ColumnConstraintKind):
    1902    pass
    1903
    1904
    1905class UniqueColumnConstraint(ColumnConstraintKind):
    1906    arg_types = {"this": False, "index_type": False, "on_conflict": False, "nulls": False}
    1907
    1908
    1909class UppercaseColumnConstraint(ColumnConstraintKind):
    1910    arg_types: t.Dict[str, t.Any] = {}
    1911
    1912
    1913class PathColumnConstraint(ColumnConstraintKind):
    1914    pass
    1915
    1916
    1917# https://docs.snowflake.com/en/sql-reference/sql/create-table
    1918class ProjectionPolicyColumnConstraint(ColumnConstraintKind):
    1919    pass
    1920
    1921
    1922# computed column expression
    1923# https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql?view=sql-server-ver16
    1924class ComputedColumnConstraint(ColumnConstraintKind):
    1925    arg_types = {"this": True, "persisted": False, "not_null": False}
    1926
    1927
    1928class Constraint(Expression):
    1929    arg_types = {"this": True, "expressions": True}
    1930
    1931
    1932class Delete(DML):
    1933    arg_types = {
    1934        "with": False,
    1935        "this": False,
    1936        "using": False,
    1937        "where": False,
    1938        "returning": False,
    1939        "limit": False,
    1940        "tables": False,  # Multiple-Table Syntax (MySQL)
    1941        "cluster": False,  # Clickhouse
    1942    }
    1943
    1944    def delete(
    1945        self,
    1946        table: ExpOrStr,
    1947        dialect: DialectType = None,
    1948        copy: bool = True,
    1949        **opts,
    1950    ) -> Delete:
    1951        """
    1952        Create a DELETE expression or replace the table on an existing DELETE expression.
    1953
    1954        Example:
    1955            >>> delete("tbl").sql()
    1956            'DELETE FROM tbl'
    1957
    1958        Args:
    1959            table: the table from which to delete.
    1960            dialect: the dialect used to parse the input expression.
    1961            copy: if `False`, modify this expression instance in-place.
    1962            opts: other options to use to parse the input expressions.
    1963
    1964        Returns:
    1965            Delete: the modified expression.
    1966        """
    1967        return _apply_builder(
    1968            expression=table,
    1969            instance=self,
    1970            arg="this",
    1971            dialect=dialect,
    1972            into=Table,
    1973            copy=copy,
    1974            **opts,
    1975        )
    1976
    1977    def where(
    1978        self,
    1979        *expressions: t.Optional[ExpOrStr],
    1980        append: bool = True,
    1981        dialect: DialectType = None,
    1982        copy: bool = True,
    1983        **opts,
    1984    ) -> Delete:
    1985        """
    1986        Append to or set the WHERE expressions.
    1987
    1988        Example:
    1989            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1990            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1991
    1992        Args:
    1993            *expressions: the SQL code strings to parse.
    1994                If an `Expression` instance is passed, it will be used as-is.
    1995                Multiple expressions are combined with an AND operator.
    1996            append: if `True`, AND the new expressions to any existing expression.
    1997                Otherwise, this resets the expression.
    1998            dialect: the dialect used to parse the input expressions.
    1999            copy: if `False`, modify this expression instance in-place.
    2000            opts: other options to use to parse the input expressions.
    2001
    2002        Returns:
    2003            Delete: the modified expression.
    2004        """
    2005        return _apply_conjunction_builder(
    2006            *expressions,
    2007            instance=self,
    2008            arg="where",
    2009            append=append,
    2010            into=Where,
    2011            dialect=dialect,
    2012            copy=copy,
    2013            **opts,
    2014        )
    2015
    2016
    2017class Drop(Expression):
    2018    arg_types = {
    2019        "this": False,
    2020        "kind": False,
    2021        "expressions": False,
    2022        "exists": False,
    2023        "temporary": False,
    2024        "materialized": False,
    2025        "cascade": False,
    2026        "constraints": False,
    2027        "purge": False,
    2028        "cluster": False,
    2029        "concurrently": False,
    2030    }
    2031
    2032    @property
    2033    def kind(self) -> t.Optional[str]:
    2034        kind = self.args.get("kind")
    2035        return kind and kind.upper()
    2036
    2037
    2038class Filter(Expression):
    2039    arg_types = {"this": True, "expression": True}
    2040
    2041
    2042class Check(Expression):
    2043    pass
    2044
    2045
    2046class Changes(Expression):
    2047    arg_types = {"information": True, "at_before": False, "end": False}
    2048
    2049
    2050# https://docs.snowflake.com/en/sql-reference/constructs/connect-by
    2051class Connect(Expression):
    2052    arg_types = {"start": False, "connect": True, "nocycle": False}
    2053
    2054
    2055class CopyParameter(Expression):
    2056    arg_types = {"this": True, "expression": False, "expressions": False}
    2057
    2058
    2059class Copy(DML):
    2060    arg_types = {
    2061        "this": True,
    2062        "kind": True,
    2063        "files": True,
    2064        "credentials": False,
    2065        "format": False,
    2066        "params": False,
    2067    }
    2068
    2069
    2070class Credentials(Expression):
    2071    arg_types = {
    2072        "credentials": False,
    2073        "encryption": False,
    2074        "storage": False,
    2075        "iam_role": False,
    2076        "region": False,
    2077    }
    2078
    2079
    2080class Prior(Expression):
    2081    pass
    2082
    2083
    2084class Directory(Expression):
    2085    # https://spark.apache.org/docs/3.0.0-preview/sql-ref-syntax-dml-insert-overwrite-directory-hive.html
    2086    arg_types = {"this": True, "local": False, "row_format": False}
    2087
    2088
    2089class ForeignKey(Expression):
    2090    arg_types = {
    2091        "expressions": True,
    2092        "reference": False,
    2093        "delete": False,
    2094        "update": False,
    2095    }
    2096
    2097
    2098class ColumnPrefix(Expression):
    2099    arg_types = {"this": True, "expression": True}
    2100
    2101
    2102class PrimaryKey(Expression):
    2103    arg_types = {"expressions": True, "options": False}
    2104
    2105
    2106# https://www.postgresql.org/docs/9.1/sql-selectinto.html
    2107# https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_INTO.html#r_SELECT_INTO-examples
    2108class Into(Expression):
    2109    arg_types = {
    2110        "this": False,
    2111        "temporary": False,
    2112        "unlogged": False,
    2113        "bulk_collect": False,
    2114        "expressions": False,
    2115    }
    2116
    2117
    2118class From(Expression):
    2119    @property
    2120    def name(self) -> str:
    2121        return self.this.name
    2122
    2123    @property
    2124    def alias_or_name(self) -> str:
    2125        return self.this.alias_or_name
    2126
    2127
    2128class Having(Expression):
    2129    pass
    2130
    2131
    2132class Hint(Expression):
    2133    arg_types = {"expressions": True}
    2134
    2135
    2136class JoinHint(Expression):
    2137    arg_types = {"this": True, "expressions": True}
    2138
    2139
    2140class Identifier(Expression):
    2141    arg_types = {"this": True, "quoted": False, "global": False, "temporary": False}
    2142
    2143    @property
    2144    def quoted(self) -> bool:
    2145        return bool(self.args.get("quoted"))
    2146
    2147    @property
    2148    def hashable_args(self) -> t.Any:
    2149        return (self.this, self.quoted)
    2150
    2151    @property
    2152    def output_name(self) -> str:
    2153        return self.name
    2154
    2155
    2156# https://www.postgresql.org/docs/current/indexes-opclass.html
    2157class Opclass(Expression):
    2158    arg_types = {"this": True, "expression": True}
    2159
    2160
    2161class Index(Expression):
    2162    arg_types = {
    2163        "this": False,
    2164        "table": False,
    2165        "unique": False,
    2166        "primary": False,
    2167        "amp": False,  # teradata
    2168        "params": False,
    2169    }
    2170
    2171
    2172class IndexParameters(Expression):
    2173    arg_types = {
    2174        "using": False,
    2175        "include": False,
    2176        "columns": False,
    2177        "with_storage": False,
    2178        "partition_by": False,
    2179        "tablespace": False,
    2180        "where": False,
    2181        "on": False,
    2182    }
    2183
    2184
    2185class Insert(DDL, DML):
    2186    arg_types = {
    2187        "hint": False,
    2188        "with": False,
    2189        "is_function": False,
    2190        "this": False,
    2191        "expression": False,
    2192        "conflict": False,
    2193        "returning": False,
    2194        "overwrite": False,
    2195        "exists": False,
    2196        "alternative": False,
    2197        "where": False,
    2198        "ignore": False,
    2199        "by_name": False,
    2200        "stored": False,
    2201        "partition": False,
    2202        "settings": False,
    2203        "source": False,
    2204    }
    2205
    2206    def with_(
    2207        self,
    2208        alias: ExpOrStr,
    2209        as_: ExpOrStr,
    2210        recursive: t.Optional[bool] = None,
    2211        materialized: t.Optional[bool] = None,
    2212        append: bool = True,
    2213        dialect: DialectType = None,
    2214        copy: bool = True,
    2215        **opts,
    2216    ) -> Insert:
    2217        """
    2218        Append to or set the common table expressions.
    2219
    2220        Example:
    2221            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    2222            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    2223
    2224        Args:
    2225            alias: the SQL code string to parse as the table name.
    2226                If an `Expression` instance is passed, this is used as-is.
    2227            as_: the SQL code string to parse as the table expression.
    2228                If an `Expression` instance is passed, it will be used as-is.
    2229            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2230            materialized: set the MATERIALIZED part of the expression.
    2231            append: if `True`, add to any existing expressions.
    2232                Otherwise, this resets the expressions.
    2233            dialect: the dialect used to parse the input expression.
    2234            copy: if `False`, modify this expression instance in-place.
    2235            opts: other options to use to parse the input expressions.
    2236
    2237        Returns:
    2238            The modified expression.
    2239        """
    2240        return _apply_cte_builder(
    2241            self,
    2242            alias,
    2243            as_,
    2244            recursive=recursive,
    2245            materialized=materialized,
    2246            append=append,
    2247            dialect=dialect,
    2248            copy=copy,
    2249            **opts,
    2250        )
    2251
    2252
    2253class ConditionalInsert(Expression):
    2254    arg_types = {"this": True, "expression": False, "else_": False}
    2255
    2256
    2257class MultitableInserts(Expression):
    2258    arg_types = {"expressions": True, "kind": True, "source": True}
    2259
    2260
    2261class OnConflict(Expression):
    2262    arg_types = {
    2263        "duplicate": False,
    2264        "expressions": False,
    2265        "action": False,
    2266        "conflict_keys": False,
    2267        "constraint": False,
    2268    }
    2269
    2270
    2271class OnCondition(Expression):
    2272    arg_types = {"error": False, "empty": False, "null": False}
    2273
    2274
    2275class Returning(Expression):
    2276    arg_types = {"expressions": True, "into": False}
    2277
    2278
    2279# https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html
    2280class Introducer(Expression):
    2281    arg_types = {"this": True, "expression": True}
    2282
    2283
    2284# national char, like n'utf8'
    2285class National(Expression):
    2286    pass
    2287
    2288
    2289class LoadData(Expression):
    2290    arg_types = {
    2291        "this": True,
    2292        "local": False,
    2293        "overwrite": False,
    2294        "inpath": True,
    2295        "partition": False,
    2296        "input_format": False,
    2297        "serde": False,
    2298    }
    2299
    2300
    2301class Partition(Expression):
    2302    arg_types = {"expressions": True}
    2303
    2304
    2305class PartitionRange(Expression):
    2306    arg_types = {"this": True, "expression": True}
    2307
    2308
    2309# https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
    2310class PartitionId(Expression):
    2311    pass
    2312
    2313
    2314class Fetch(Expression):
    2315    arg_types = {
    2316        "direction": False,
    2317        "count": False,
    2318        "percent": False,
    2319        "with_ties": False,
    2320    }
    2321
    2322
    2323class Grant(Expression):
    2324    arg_types = {
    2325        "privileges": True,
    2326        "kind": False,
    2327        "securable": True,
    2328        "principals": True,
    2329        "grant_option": False,
    2330    }
    2331
    2332
    2333class Group(Expression):
    2334    arg_types = {
    2335        "expressions": False,
    2336        "grouping_sets": False,
    2337        "cube": False,
    2338        "rollup": False,
    2339        "totals": False,
    2340        "all": False,
    2341    }
    2342
    2343
    2344class Cube(Expression):
    2345    arg_types = {"expressions": False}
    2346
    2347
    2348class Rollup(Expression):
    2349    arg_types = {"expressions": False}
    2350
    2351
    2352class GroupingSets(Expression):
    2353    arg_types = {"expressions": True}
    2354
    2355
    2356class Lambda(Expression):
    2357    arg_types = {"this": True, "expressions": True}
    2358
    2359
    2360class Limit(Expression):
    2361    arg_types = {"this": False, "expression": True, "offset": False, "expressions": False}
    2362
    2363
    2364class Literal(Condition):
    2365    arg_types = {"this": True, "is_string": True}
    2366
    2367    @property
    2368    def hashable_args(self) -> t.Any:
    2369        return (self.this, self.args.get("is_string"))
    2370
    2371    @classmethod
    2372    def number(cls, number) -> Literal:
    2373        return cls(this=str(number), is_string=False)
    2374
    2375    @classmethod
    2376    def string(cls, string) -> Literal:
    2377        return cls(this=str(string), is_string=True)
    2378
    2379    @property
    2380    def output_name(self) -> str:
    2381        return self.name
    2382
    2383    def to_py(self) -> int | str | Decimal:
    2384        if self.is_number:
    2385            try:
    2386                return int(self.this)
    2387            except ValueError:
    2388                return Decimal(self.this)
    2389        return self.this
    2390
    2391
    2392class Join(Expression):
    2393    arg_types = {
    2394        "this": True,
    2395        "on": False,
    2396        "side": False,
    2397        "kind": False,
    2398        "using": False,
    2399        "method": False,
    2400        "global": False,
    2401        "hint": False,
    2402        "match_condition": False,  # Snowflake
    2403        "expressions": False,
    2404    }
    2405
    2406    @property
    2407    def method(self) -> str:
    2408        return self.text("method").upper()
    2409
    2410    @property
    2411    def kind(self) -> str:
    2412        return self.text("kind").upper()
    2413
    2414    @property
    2415    def side(self) -> str:
    2416        return self.text("side").upper()
    2417
    2418    @property
    2419    def hint(self) -> str:
    2420        return self.text("hint").upper()
    2421
    2422    @property
    2423    def alias_or_name(self) -> str:
    2424        return self.this.alias_or_name
    2425
    2426    def on(
    2427        self,
    2428        *expressions: t.Optional[ExpOrStr],
    2429        append: bool = True,
    2430        dialect: DialectType = None,
    2431        copy: bool = True,
    2432        **opts,
    2433    ) -> Join:
    2434        """
    2435        Append to or set the ON expressions.
    2436
    2437        Example:
    2438            >>> import sqlglot
    2439            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    2440            'JOIN x ON y = 1'
    2441
    2442        Args:
    2443            *expressions: the SQL code strings to parse.
    2444                If an `Expression` instance is passed, it will be used as-is.
    2445                Multiple expressions are combined with an AND operator.
    2446            append: if `True`, AND the new expressions to any existing expression.
    2447                Otherwise, this resets the expression.
    2448            dialect: the dialect used to parse the input expressions.
    2449            copy: if `False`, modify this expression instance in-place.
    2450            opts: other options to use to parse the input expressions.
    2451
    2452        Returns:
    2453            The modified Join expression.
    2454        """
    2455        join = _apply_conjunction_builder(
    2456            *expressions,
    2457            instance=self,
    2458            arg="on",
    2459            append=append,
    2460            dialect=dialect,
    2461            copy=copy,
    2462            **opts,
    2463        )
    2464
    2465        if join.kind == "CROSS":
    2466            join.set("kind", None)
    2467
    2468        return join
    2469
    2470    def using(
    2471        self,
    2472        *expressions: t.Optional[ExpOrStr],
    2473        append: bool = True,
    2474        dialect: DialectType = None,
    2475        copy: bool = True,
    2476        **opts,
    2477    ) -> Join:
    2478        """
    2479        Append to or set the USING expressions.
    2480
    2481        Example:
    2482            >>> import sqlglot
    2483            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    2484            'JOIN x USING (foo, bla)'
    2485
    2486        Args:
    2487            *expressions: the SQL code strings to parse.
    2488                If an `Expression` instance is passed, it will be used as-is.
    2489            append: if `True`, concatenate the new expressions to the existing "using" list.
    2490                Otherwise, this resets the expression.
    2491            dialect: the dialect used to parse the input expressions.
    2492            copy: if `False`, modify this expression instance in-place.
    2493            opts: other options to use to parse the input expressions.
    2494
    2495        Returns:
    2496            The modified Join expression.
    2497        """
    2498        join = _apply_list_builder(
    2499            *expressions,
    2500            instance=self,
    2501            arg="using",
    2502            append=append,
    2503            dialect=dialect,
    2504            copy=copy,
    2505            **opts,
    2506        )
    2507
    2508        if join.kind == "CROSS":
    2509            join.set("kind", None)
    2510
    2511        return join
    2512
    2513
    2514class Lateral(UDTF):
    2515    arg_types = {
    2516        "this": True,
    2517        "view": False,
    2518        "outer": False,
    2519        "alias": False,
    2520        "cross_apply": False,  # True -> CROSS APPLY, False -> OUTER APPLY
    2521    }
    2522
    2523
    2524class MatchRecognizeMeasure(Expression):
    2525    arg_types = {
    2526        "this": True,
    2527        "window_frame": False,
    2528    }
    2529
    2530
    2531class MatchRecognize(Expression):
    2532    arg_types = {
    2533        "partition_by": False,
    2534        "order": False,
    2535        "measures": False,
    2536        "rows": False,
    2537        "after": False,
    2538        "pattern": False,
    2539        "define": False,
    2540        "alias": False,
    2541    }
    2542
    2543
    2544# Clickhouse FROM FINAL modifier
    2545# https://clickhouse.com/docs/en/sql-reference/statements/select/from/#final-modifier
    2546class Final(Expression):
    2547    pass
    2548
    2549
    2550class Offset(Expression):
    2551    arg_types = {"this": False, "expression": True, "expressions": False}
    2552
    2553
    2554class Order(Expression):
    2555    arg_types = {"this": False, "expressions": True, "siblings": False}
    2556
    2557
    2558# https://clickhouse.com/docs/en/sql-reference/statements/select/order-by#order-by-expr-with-fill-modifier
    2559class WithFill(Expression):
    2560    arg_types = {
    2561        "from": False,
    2562        "to": False,
    2563        "step": False,
    2564        "interpolate": False,
    2565    }
    2566
    2567
    2568# hive specific sorts
    2569# https://cwiki.apache.org/confluence/display/Hive/LanguageManual+SortBy
    2570class Cluster(Order):
    2571    pass
    2572
    2573
    2574class Distribute(Order):
    2575    pass
    2576
    2577
    2578class Sort(Order):
    2579    pass
    2580
    2581
    2582class Ordered(Expression):
    2583    arg_types = {"this": True, "desc": False, "nulls_first": True, "with_fill": False}
    2584
    2585
    2586class Property(Expression):
    2587    arg_types = {"this": True, "value": True}
    2588
    2589
    2590class GrantPrivilege(Expression):
    2591    arg_types = {"this": True, "expressions": False}
    2592
    2593
    2594class GrantPrincipal(Expression):
    2595    arg_types = {"this": True, "kind": False}
    2596
    2597
    2598class AllowedValuesProperty(Expression):
    2599    arg_types = {"expressions": True}
    2600
    2601
    2602class AlgorithmProperty(Property):
    2603    arg_types = {"this": True}
    2604
    2605
    2606class AutoIncrementProperty(Property):
    2607    arg_types = {"this": True}
    2608
    2609
    2610# https://docs.aws.amazon.com/prescriptive-guidance/latest/materialized-views-redshift/refreshing-materialized-views.html
    2611class AutoRefreshProperty(Property):
    2612    arg_types = {"this": True}
    2613
    2614
    2615class BackupProperty(Property):
    2616    arg_types = {"this": True}
    2617
    2618
    2619class BlockCompressionProperty(Property):
    2620    arg_types = {
    2621        "autotemp": False,
    2622        "always": False,
    2623        "default": False,
    2624        "manual": False,
    2625        "never": False,
    2626    }
    2627
    2628
    2629class CharacterSetProperty(Property):
    2630    arg_types = {"this": True, "default": True}
    2631
    2632
    2633class ChecksumProperty(Property):
    2634    arg_types = {"on": False, "default": False}
    2635
    2636
    2637class CollateProperty(Property):
    2638    arg_types = {"this": True, "default": False}
    2639
    2640
    2641class CopyGrantsProperty(Property):
    2642    arg_types = {}
    2643
    2644
    2645class DataBlocksizeProperty(Property):
    2646    arg_types = {
    2647        "size": False,
    2648        "units": False,
    2649        "minimum": False,
    2650        "maximum": False,
    2651        "default": False,
    2652    }
    2653
    2654
    2655class DataDeletionProperty(Property):
    2656    arg_types = {"on": True, "filter_col": False, "retention_period": False}
    2657
    2658
    2659class DefinerProperty(Property):
    2660    arg_types = {"this": True}
    2661
    2662
    2663class DistKeyProperty(Property):
    2664    arg_types = {"this": True}
    2665
    2666
    2667# https://docs.starrocks.io/docs/sql-reference/sql-statements/data-definition/CREATE_TABLE/#distribution_desc
    2668# https://doris.apache.org/docs/sql-manual/sql-statements/Data-Definition-Statements/Create/CREATE-TABLE?_highlight=create&_highlight=table#distribution_desc
    2669class DistributedByProperty(Property):
    2670    arg_types = {"expressions": False, "kind": True, "buckets": False, "order": False}
    2671
    2672
    2673class DistStyleProperty(Property):
    2674    arg_types = {"this": True}
    2675
    2676
    2677class DuplicateKeyProperty(Property):
    2678    arg_types = {"expressions": True}
    2679
    2680
    2681class EngineProperty(Property):
    2682    arg_types = {"this": True}
    2683
    2684
    2685class HeapProperty(Property):
    2686    arg_types = {}
    2687
    2688
    2689class ToTableProperty(Property):
    2690    arg_types = {"this": True}
    2691
    2692
    2693class ExecuteAsProperty(Property):
    2694    arg_types = {"this": True}
    2695
    2696
    2697class ExternalProperty(Property):
    2698    arg_types = {"this": False}
    2699
    2700
    2701class FallbackProperty(Property):
    2702    arg_types = {"no": True, "protection": False}
    2703
    2704
    2705class FileFormatProperty(Property):
    2706    arg_types = {"this": True}
    2707
    2708
    2709class FreespaceProperty(Property):
    2710    arg_types = {"this": True, "percent": False}
    2711
    2712
    2713class GlobalProperty(Property):
    2714    arg_types = {}
    2715
    2716
    2717class IcebergProperty(Property):
    2718    arg_types = {}
    2719
    2720
    2721class InheritsProperty(Property):
    2722    arg_types = {"expressions": True}
    2723
    2724
    2725class InputModelProperty(Property):
    2726    arg_types = {"this": True}
    2727
    2728
    2729class OutputModelProperty(Property):
    2730    arg_types = {"this": True}
    2731
    2732
    2733class IsolatedLoadingProperty(Property):
    2734    arg_types = {"no": False, "concurrent": False, "target": False}
    2735
    2736
    2737class JournalProperty(Property):
    2738    arg_types = {
    2739        "no": False,
    2740        "dual": False,
    2741        "before": False,
    2742        "local": False,
    2743        "after": False,
    2744    }
    2745
    2746
    2747class LanguageProperty(Property):
    2748    arg_types = {"this": True}
    2749
    2750
    2751# spark ddl
    2752class ClusteredByProperty(Property):
    2753    arg_types = {"expressions": True, "sorted_by": False, "buckets": True}
    2754
    2755
    2756class DictProperty(Property):
    2757    arg_types = {"this": True, "kind": True, "settings": False}
    2758
    2759
    2760class DictSubProperty(Property):
    2761    pass
    2762
    2763
    2764class DictRange(Property):
    2765    arg_types = {"this": True, "min": True, "max": True}
    2766
    2767
    2768class DynamicProperty(Property):
    2769    arg_types = {}
    2770
    2771
    2772# Clickhouse CREATE ... ON CLUSTER modifier
    2773# https://clickhouse.com/docs/en/sql-reference/distributed-ddl
    2774class OnCluster(Property):
    2775    arg_types = {"this": True}
    2776
    2777
    2778# Clickhouse EMPTY table "property"
    2779class EmptyProperty(Property):
    2780    arg_types = {}
    2781
    2782
    2783class LikeProperty(Property):
    2784    arg_types = {"this": True, "expressions": False}
    2785
    2786
    2787class LocationProperty(Property):
    2788    arg_types = {"this": True}
    2789
    2790
    2791class LockProperty(Property):
    2792    arg_types = {"this": True}
    2793
    2794
    2795class LockingProperty(Property):
    2796    arg_types = {
    2797        "this": False,
    2798        "kind": True,
    2799        "for_or_in": False,
    2800        "lock_type": True,
    2801        "override": False,
    2802    }
    2803
    2804
    2805class LogProperty(Property):
    2806    arg_types = {"no": True}
    2807
    2808
    2809class MaterializedProperty(Property):
    2810    arg_types = {"this": False}
    2811
    2812
    2813class MergeBlockRatioProperty(Property):
    2814    arg_types = {"this": False, "no": False, "default": False, "percent": False}
    2815
    2816
    2817class NoPrimaryIndexProperty(Property):
    2818    arg_types = {}
    2819
    2820
    2821class OnProperty(Property):
    2822    arg_types = {"this": True}
    2823
    2824
    2825class OnCommitProperty(Property):
    2826    arg_types = {"delete": False}
    2827
    2828
    2829class PartitionedByProperty(Property):
    2830    arg_types = {"this": True}
    2831
    2832
    2833# https://www.postgresql.org/docs/current/sql-createtable.html
    2834class PartitionBoundSpec(Expression):
    2835    # this -> IN / MODULUS, expression -> REMAINDER, from_expressions -> FROM (...), to_expressions -> TO (...)
    2836    arg_types = {
    2837        "this": False,
    2838        "expression": False,
    2839        "from_expressions": False,
    2840        "to_expressions": False,
    2841    }
    2842
    2843
    2844class PartitionedOfProperty(Property):
    2845    # this -> parent_table (schema), expression -> FOR VALUES ... / DEFAULT
    2846    arg_types = {"this": True, "expression": True}
    2847
    2848
    2849class StreamingTableProperty(Property):
    2850    arg_types = {}
    2851
    2852
    2853class RemoteWithConnectionModelProperty(Property):
    2854    arg_types = {"this": True}
    2855
    2856
    2857class ReturnsProperty(Property):
    2858    arg_types = {"this": False, "is_table": False, "table": False, "null": False}
    2859
    2860
    2861class StrictProperty(Property):
    2862    arg_types = {}
    2863
    2864
    2865class RowFormatProperty(Property):
    2866    arg_types = {"this": True}
    2867
    2868
    2869class RowFormatDelimitedProperty(Property):
    2870    # https://cwiki.apache.org/confluence/display/hive/languagemanual+dml
    2871    arg_types = {
    2872        "fields": False,
    2873        "escaped": False,
    2874        "collection_items": False,
    2875        "map_keys": False,
    2876        "lines": False,
    2877        "null": False,
    2878        "serde": False,
    2879    }
    2880
    2881
    2882class RowFormatSerdeProperty(Property):
    2883    arg_types = {"this": True, "serde_properties": False}
    2884
    2885
    2886# https://spark.apache.org/docs/3.1.2/sql-ref-syntax-qry-select-transform.html
    2887class QueryTransform(Expression):
    2888    arg_types = {
    2889        "expressions": True,
    2890        "command_script": True,
    2891        "schema": False,
    2892        "row_format_before": False,
    2893        "record_writer": False,
    2894        "row_format_after": False,
    2895        "record_reader": False,
    2896    }
    2897
    2898
    2899class SampleProperty(Property):
    2900    arg_types = {"this": True}
    2901
    2902
    2903# https://prestodb.io/docs/current/sql/create-view.html#synopsis
    2904class SecurityProperty(Property):
    2905    arg_types = {"this": True}
    2906
    2907
    2908class SchemaCommentProperty(Property):
    2909    arg_types = {"this": True}
    2910
    2911
    2912class SerdeProperties(Property):
    2913    arg_types = {"expressions": True, "with": False}
    2914
    2915
    2916class SetProperty(Property):
    2917    arg_types = {"multi": True}
    2918
    2919
    2920class SharingProperty(Property):
    2921    arg_types = {"this": False}
    2922
    2923
    2924class SetConfigProperty(Property):
    2925    arg_types = {"this": True}
    2926
    2927
    2928class SettingsProperty(Property):
    2929    arg_types = {"expressions": True}
    2930
    2931
    2932class SortKeyProperty(Property):
    2933    arg_types = {"this": True, "compound": False}
    2934
    2935
    2936class SqlReadWriteProperty(Property):
    2937    arg_types = {"this": True}
    2938
    2939
    2940class SqlSecurityProperty(Property):
    2941    arg_types = {"definer": True}
    2942
    2943
    2944class StabilityProperty(Property):
    2945    arg_types = {"this": True}
    2946
    2947
    2948class TemporaryProperty(Property):
    2949    arg_types = {"this": False}
    2950
    2951
    2952class SecureProperty(Property):
    2953    arg_types = {}
    2954
    2955
    2956class TransformModelProperty(Property):
    2957    arg_types = {"expressions": True}
    2958
    2959
    2960class TransientProperty(Property):
    2961    arg_types = {"this": False}
    2962
    2963
    2964class UnloggedProperty(Property):
    2965    arg_types = {}
    2966
    2967
    2968# https://learn.microsoft.com/en-us/sql/t-sql/statements/create-view-transact-sql?view=sql-server-ver16
    2969class ViewAttributeProperty(Property):
    2970    arg_types = {"this": True}
    2971
    2972
    2973class VolatileProperty(Property):
    2974    arg_types = {"this": False}
    2975
    2976
    2977class WithDataProperty(Property):
    2978    arg_types = {"no": True, "statistics": False}
    2979
    2980
    2981class WithJournalTableProperty(Property):
    2982    arg_types = {"this": True}
    2983
    2984
    2985class WithSchemaBindingProperty(Property):
    2986    arg_types = {"this": True}
    2987
    2988
    2989class WithSystemVersioningProperty(Property):
    2990    arg_types = {
    2991        "on": False,
    2992        "this": False,
    2993        "data_consistency": False,
    2994        "retention_period": False,
    2995        "with": True,
    2996    }
    2997
    2998
    2999class Properties(Expression):
    3000    arg_types = {"expressions": True}
    3001
    3002    NAME_TO_PROPERTY = {
    3003        "ALGORITHM": AlgorithmProperty,
    3004        "AUTO_INCREMENT": AutoIncrementProperty,
    3005        "CHARACTER SET": CharacterSetProperty,
    3006        "CLUSTERED_BY": ClusteredByProperty,
    3007        "COLLATE": CollateProperty,
    3008        "COMMENT": SchemaCommentProperty,
    3009        "DEFINER": DefinerProperty,
    3010        "DISTKEY": DistKeyProperty,
    3011        "DISTRIBUTED_BY": DistributedByProperty,
    3012        "DISTSTYLE": DistStyleProperty,
    3013        "ENGINE": EngineProperty,
    3014        "EXECUTE AS": ExecuteAsProperty,
    3015        "FORMAT": FileFormatProperty,
    3016        "LANGUAGE": LanguageProperty,
    3017        "LOCATION": LocationProperty,
    3018        "LOCK": LockProperty,
    3019        "PARTITIONED_BY": PartitionedByProperty,
    3020        "RETURNS": ReturnsProperty,
    3021        "ROW_FORMAT": RowFormatProperty,
    3022        "SORTKEY": SortKeyProperty,
    3023    }
    3024
    3025    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    3026
    3027    # CREATE property locations
    3028    # Form: schema specified
    3029    #   create [POST_CREATE]
    3030    #     table a [POST_NAME]
    3031    #     (b int) [POST_SCHEMA]
    3032    #     with ([POST_WITH])
    3033    #     index (b) [POST_INDEX]
    3034    #
    3035    # Form: alias selection
    3036    #   create [POST_CREATE]
    3037    #     table a [POST_NAME]
    3038    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    3039    #     index (c) [POST_INDEX]
    3040    class Location(AutoName):
    3041        POST_CREATE = auto()
    3042        POST_NAME = auto()
    3043        POST_SCHEMA = auto()
    3044        POST_WITH = auto()
    3045        POST_ALIAS = auto()
    3046        POST_EXPRESSION = auto()
    3047        POST_INDEX = auto()
    3048        UNSUPPORTED = auto()
    3049
    3050    @classmethod
    3051    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3052        expressions = []
    3053        for key, value in properties_dict.items():
    3054            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3055            if property_cls:
    3056                expressions.append(property_cls(this=convert(value)))
    3057            else:
    3058                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3059
    3060        return cls(expressions=expressions)
    3061
    3062
    3063class Qualify(Expression):
    3064    pass
    3065
    3066
    3067class InputOutputFormat(Expression):
    3068    arg_types = {"input_format": False, "output_format": False}
    3069
    3070
    3071# https://www.ibm.com/docs/en/ias?topic=procedures-return-statement-in-sql
    3072class Return(Expression):
    3073    pass
    3074
    3075
    3076class Reference(Expression):
    3077    arg_types = {"this": True, "expressions": False, "options": False}
    3078
    3079
    3080class Tuple(Expression):
    3081    arg_types = {"expressions": False}
    3082
    3083    def isin(
    3084        self,
    3085        *expressions: t.Any,
    3086        query: t.Optional[ExpOrStr] = None,
    3087        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3088        copy: bool = True,
    3089        **opts,
    3090    ) -> In:
    3091        return In(
    3092            this=maybe_copy(self, copy),
    3093            expressions=[convert(e, copy=copy) for e in expressions],
    3094            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3095            unnest=(
    3096                Unnest(
    3097                    expressions=[
    3098                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3099                        for e in ensure_list(unnest)
    3100                    ]
    3101                )
    3102                if unnest
    3103                else None
    3104            ),
    3105        )
    3106
    3107
    3108QUERY_MODIFIERS = {
    3109    "match": False,
    3110    "laterals": False,
    3111    "joins": False,
    3112    "connect": False,
    3113    "pivots": False,
    3114    "prewhere": False,
    3115    "where": False,
    3116    "group": False,
    3117    "having": False,
    3118    "qualify": False,
    3119    "windows": False,
    3120    "distribute": False,
    3121    "sort": False,
    3122    "cluster": False,
    3123    "order": False,
    3124    "limit": False,
    3125    "offset": False,
    3126    "locks": False,
    3127    "sample": False,
    3128    "settings": False,
    3129    "format": False,
    3130    "options": False,
    3131}
    3132
    3133
    3134# https://learn.microsoft.com/en-us/sql/t-sql/queries/option-clause-transact-sql?view=sql-server-ver16
    3135# https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-query?view=sql-server-ver16
    3136class QueryOption(Expression):
    3137    arg_types = {"this": True, "expression": False}
    3138
    3139
    3140# https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver16
    3141class WithTableHint(Expression):
    3142    arg_types = {"expressions": True}
    3143
    3144
    3145# https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
    3146class IndexTableHint(Expression):
    3147    arg_types = {"this": True, "expressions": False, "target": False}
    3148
    3149
    3150# https://docs.snowflake.com/en/sql-reference/constructs/at-before
    3151class HistoricalData(Expression):
    3152    arg_types = {"this": True, "kind": True, "expression": True}
    3153
    3154
    3155class Table(Expression):
    3156    arg_types = {
    3157        "this": False,
    3158        "alias": False,
    3159        "db": False,
    3160        "catalog": False,
    3161        "laterals": False,
    3162        "joins": False,
    3163        "pivots": False,
    3164        "hints": False,
    3165        "system_time": False,
    3166        "version": False,
    3167        "format": False,
    3168        "pattern": False,
    3169        "ordinality": False,
    3170        "when": False,
    3171        "only": False,
    3172        "partition": False,
    3173        "changes": False,
    3174        "rows_from": False,
    3175        "sample": False,
    3176    }
    3177
    3178    @property
    3179    def name(self) -> str:
    3180        if isinstance(self.this, Func):
    3181            return ""
    3182        return self.this.name
    3183
    3184    @property
    3185    def db(self) -> str:
    3186        return self.text("db")
    3187
    3188    @property
    3189    def catalog(self) -> str:
    3190        return self.text("catalog")
    3191
    3192    @property
    3193    def selects(self) -> t.List[Expression]:
    3194        return []
    3195
    3196    @property
    3197    def named_selects(self) -> t.List[str]:
    3198        return []
    3199
    3200    @property
    3201    def parts(self) -> t.List[Expression]:
    3202        """Return the parts of a table in order catalog, db, table."""
    3203        parts: t.List[Expression] = []
    3204
    3205        for arg in ("catalog", "db", "this"):
    3206            part = self.args.get(arg)
    3207
    3208            if isinstance(part, Dot):
    3209                parts.extend(part.flatten())
    3210            elif isinstance(part, Expression):
    3211                parts.append(part)
    3212
    3213        return parts
    3214
    3215    def to_column(self, copy: bool = True) -> Alias | Column | Dot:
    3216        parts = self.parts
    3217        col = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3218        alias = self.args.get("alias")
    3219        if alias:
    3220            col = alias_(col, alias.this, copy=copy)
    3221        return col
    3222
    3223
    3224class SetOperation(Query):
    3225    arg_types = {
    3226        "with": False,
    3227        "this": True,
    3228        "expression": True,
    3229        "distinct": False,
    3230        "by_name": False,
    3231        **QUERY_MODIFIERS,
    3232    }
    3233
    3234    def select(
    3235        self: S,
    3236        *expressions: t.Optional[ExpOrStr],
    3237        append: bool = True,
    3238        dialect: DialectType = None,
    3239        copy: bool = True,
    3240        **opts,
    3241    ) -> S:
    3242        this = maybe_copy(self, copy)
    3243        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3244        this.expression.unnest().select(
    3245            *expressions, append=append, dialect=dialect, copy=False, **opts
    3246        )
    3247        return this
    3248
    3249    @property
    3250    def named_selects(self) -> t.List[str]:
    3251        return self.this.unnest().named_selects
    3252
    3253    @property
    3254    def is_star(self) -> bool:
    3255        return self.this.is_star or self.expression.is_star
    3256
    3257    @property
    3258    def selects(self) -> t.List[Expression]:
    3259        return self.this.unnest().selects
    3260
    3261    @property
    3262    def left(self) -> Query:
    3263        return self.this
    3264
    3265    @property
    3266    def right(self) -> Query:
    3267        return self.expression
    3268
    3269
    3270class Union(SetOperation):
    3271    pass
    3272
    3273
    3274class Except(SetOperation):
    3275    pass
    3276
    3277
    3278class Intersect(SetOperation):
    3279    pass
    3280
    3281
    3282class Update(DML):
    3283    arg_types = {
    3284        "with": False,
    3285        "this": False,
    3286        "expressions": True,
    3287        "from": False,
    3288        "where": False,
    3289        "returning": False,
    3290        "order": False,
    3291        "limit": False,
    3292    }
    3293
    3294    def table(
    3295        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3296    ) -> Update:
    3297        """
    3298        Set the table to update.
    3299
    3300        Example:
    3301            >>> Update().table("my_table").set_("x = 1").sql()
    3302            'UPDATE my_table SET x = 1'
    3303
    3304        Args:
    3305            expression : the SQL code strings to parse.
    3306                If a `Table` instance is passed, this is used as-is.
    3307                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3308            dialect: the dialect used to parse the input expression.
    3309            copy: if `False`, modify this expression instance in-place.
    3310            opts: other options to use to parse the input expressions.
    3311
    3312        Returns:
    3313            The modified Update expression.
    3314        """
    3315        return _apply_builder(
    3316            expression=expression,
    3317            instance=self,
    3318            arg="this",
    3319            into=Table,
    3320            prefix=None,
    3321            dialect=dialect,
    3322            copy=copy,
    3323            **opts,
    3324        )
    3325
    3326    def set_(
    3327        self,
    3328        *expressions: ExpOrStr,
    3329        append: bool = True,
    3330        dialect: DialectType = None,
    3331        copy: bool = True,
    3332        **opts,
    3333    ) -> Update:
    3334        """
    3335        Append to or set the SET expressions.
    3336
    3337        Example:
    3338            >>> Update().table("my_table").set_("x = 1").sql()
    3339            'UPDATE my_table SET x = 1'
    3340
    3341        Args:
    3342            *expressions: the SQL code strings to parse.
    3343                If `Expression` instance(s) are passed, they will be used as-is.
    3344                Multiple expressions are combined with a comma.
    3345            append: if `True`, add the new expressions to any existing SET expressions.
    3346                Otherwise, this resets the expressions.
    3347            dialect: the dialect used to parse the input expressions.
    3348            copy: if `False`, modify this expression instance in-place.
    3349            opts: other options to use to parse the input expressions.
    3350        """
    3351        return _apply_list_builder(
    3352            *expressions,
    3353            instance=self,
    3354            arg="expressions",
    3355            append=append,
    3356            into=Expression,
    3357            prefix=None,
    3358            dialect=dialect,
    3359            copy=copy,
    3360            **opts,
    3361        )
    3362
    3363    def where(
    3364        self,
    3365        *expressions: t.Optional[ExpOrStr],
    3366        append: bool = True,
    3367        dialect: DialectType = None,
    3368        copy: bool = True,
    3369        **opts,
    3370    ) -> Select:
    3371        """
    3372        Append to or set the WHERE expressions.
    3373
    3374        Example:
    3375            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3376            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3377
    3378        Args:
    3379            *expressions: the SQL code strings to parse.
    3380                If an `Expression` instance is passed, it will be used as-is.
    3381                Multiple expressions are combined with an AND operator.
    3382            append: if `True`, AND the new expressions to any existing expression.
    3383                Otherwise, this resets the expression.
    3384            dialect: the dialect used to parse the input expressions.
    3385            copy: if `False`, modify this expression instance in-place.
    3386            opts: other options to use to parse the input expressions.
    3387
    3388        Returns:
    3389            Select: the modified expression.
    3390        """
    3391        return _apply_conjunction_builder(
    3392            *expressions,
    3393            instance=self,
    3394            arg="where",
    3395            append=append,
    3396            into=Where,
    3397            dialect=dialect,
    3398            copy=copy,
    3399            **opts,
    3400        )
    3401
    3402    def from_(
    3403        self,
    3404        expression: t.Optional[ExpOrStr] = None,
    3405        dialect: DialectType = None,
    3406        copy: bool = True,
    3407        **opts,
    3408    ) -> Update:
    3409        """
    3410        Set the FROM expression.
    3411
    3412        Example:
    3413            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3414            'UPDATE my_table SET x = 1 FROM baz'
    3415
    3416        Args:
    3417            expression : the SQL code strings to parse.
    3418                If a `From` instance is passed, this is used as-is.
    3419                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3420                If nothing is passed in then a from is not applied to the expression
    3421            dialect: the dialect used to parse the input expression.
    3422            copy: if `False`, modify this expression instance in-place.
    3423            opts: other options to use to parse the input expressions.
    3424
    3425        Returns:
    3426            The modified Update expression.
    3427        """
    3428        if not expression:
    3429            return maybe_copy(self, copy)
    3430
    3431        return _apply_builder(
    3432            expression=expression,
    3433            instance=self,
    3434            arg="from",
    3435            into=From,
    3436            prefix="FROM",
    3437            dialect=dialect,
    3438            copy=copy,
    3439            **opts,
    3440        )
    3441
    3442    def with_(
    3443        self,
    3444        alias: ExpOrStr,
    3445        as_: ExpOrStr,
    3446        recursive: t.Optional[bool] = None,
    3447        materialized: t.Optional[bool] = None,
    3448        append: bool = True,
    3449        dialect: DialectType = None,
    3450        copy: bool = True,
    3451        **opts,
    3452    ) -> Update:
    3453        """
    3454        Append to or set the common table expressions.
    3455
    3456        Example:
    3457            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3458            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3459
    3460        Args:
    3461            alias: the SQL code string to parse as the table name.
    3462                If an `Expression` instance is passed, this is used as-is.
    3463            as_: the SQL code string to parse as the table expression.
    3464                If an `Expression` instance is passed, it will be used as-is.
    3465            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3466            materialized: set the MATERIALIZED part of the expression.
    3467            append: if `True`, add to any existing expressions.
    3468                Otherwise, this resets the expressions.
    3469            dialect: the dialect used to parse the input expression.
    3470            copy: if `False`, modify this expression instance in-place.
    3471            opts: other options to use to parse the input expressions.
    3472
    3473        Returns:
    3474            The modified expression.
    3475        """
    3476        return _apply_cte_builder(
    3477            self,
    3478            alias,
    3479            as_,
    3480            recursive=recursive,
    3481            materialized=materialized,
    3482            append=append,
    3483            dialect=dialect,
    3484            copy=copy,
    3485            **opts,
    3486        )
    3487
    3488
    3489class Values(UDTF):
    3490    arg_types = {"expressions": True, "alias": False}
    3491
    3492
    3493class Var(Expression):
    3494    pass
    3495
    3496
    3497class Version(Expression):
    3498    """
    3499    Time travel, iceberg, bigquery etc
    3500    https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots
    3501    https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html
    3502    https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of
    3503    https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16
    3504    this is either TIMESTAMP or VERSION
    3505    kind is ("AS OF", "BETWEEN")
    3506    """
    3507
    3508    arg_types = {"this": True, "kind": True, "expression": False}
    3509
    3510
    3511class Schema(Expression):
    3512    arg_types = {"this": False, "expressions": False}
    3513
    3514
    3515# https://dev.mysql.com/doc/refman/8.0/en/select.html
    3516# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SELECT.html
    3517class Lock(Expression):
    3518    arg_types = {"update": True, "expressions": False, "wait": False}
    3519
    3520
    3521class Select(Query):
    3522    arg_types = {
    3523        "with": False,
    3524        "kind": False,
    3525        "expressions": False,
    3526        "hint": False,
    3527        "distinct": False,
    3528        "into": False,
    3529        "from": False,
    3530        "operation_modifiers": False,
    3531        **QUERY_MODIFIERS,
    3532    }
    3533
    3534    def from_(
    3535        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3536    ) -> Select:
    3537        """
    3538        Set the FROM expression.
    3539
    3540        Example:
    3541            >>> Select().from_("tbl").select("x").sql()
    3542            'SELECT x FROM tbl'
    3543
    3544        Args:
    3545            expression : the SQL code strings to parse.
    3546                If a `From` instance is passed, this is used as-is.
    3547                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3548            dialect: the dialect used to parse the input expression.
    3549            copy: if `False`, modify this expression instance in-place.
    3550            opts: other options to use to parse the input expressions.
    3551
    3552        Returns:
    3553            The modified Select expression.
    3554        """
    3555        return _apply_builder(
    3556            expression=expression,
    3557            instance=self,
    3558            arg="from",
    3559            into=From,
    3560            prefix="FROM",
    3561            dialect=dialect,
    3562            copy=copy,
    3563            **opts,
    3564        )
    3565
    3566    def group_by(
    3567        self,
    3568        *expressions: t.Optional[ExpOrStr],
    3569        append: bool = True,
    3570        dialect: DialectType = None,
    3571        copy: bool = True,
    3572        **opts,
    3573    ) -> Select:
    3574        """
    3575        Set the GROUP BY expression.
    3576
    3577        Example:
    3578            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3579            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3580
    3581        Args:
    3582            *expressions: the SQL code strings to parse.
    3583                If a `Group` instance is passed, this is used as-is.
    3584                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3585                If nothing is passed in then a group by is not applied to the expression
    3586            append: if `True`, add to any existing expressions.
    3587                Otherwise, this flattens all the `Group` expression into a single expression.
    3588            dialect: the dialect used to parse the input expression.
    3589            copy: if `False`, modify this expression instance in-place.
    3590            opts: other options to use to parse the input expressions.
    3591
    3592        Returns:
    3593            The modified Select expression.
    3594        """
    3595        if not expressions:
    3596            return self if not copy else self.copy()
    3597
    3598        return _apply_child_list_builder(
    3599            *expressions,
    3600            instance=self,
    3601            arg="group",
    3602            append=append,
    3603            copy=copy,
    3604            prefix="GROUP BY",
    3605            into=Group,
    3606            dialect=dialect,
    3607            **opts,
    3608        )
    3609
    3610    def sort_by(
    3611        self,
    3612        *expressions: t.Optional[ExpOrStr],
    3613        append: bool = True,
    3614        dialect: DialectType = None,
    3615        copy: bool = True,
    3616        **opts,
    3617    ) -> Select:
    3618        """
    3619        Set the SORT BY expression.
    3620
    3621        Example:
    3622            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3623            'SELECT x FROM tbl SORT BY x DESC'
    3624
    3625        Args:
    3626            *expressions: the SQL code strings to parse.
    3627                If a `Group` instance is passed, this is used as-is.
    3628                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3629            append: if `True`, add to any existing expressions.
    3630                Otherwise, this flattens all the `Order` expression into a single expression.
    3631            dialect: the dialect used to parse the input expression.
    3632            copy: if `False`, modify this expression instance in-place.
    3633            opts: other options to use to parse the input expressions.
    3634
    3635        Returns:
    3636            The modified Select expression.
    3637        """
    3638        return _apply_child_list_builder(
    3639            *expressions,
    3640            instance=self,
    3641            arg="sort",
    3642            append=append,
    3643            copy=copy,
    3644            prefix="SORT BY",
    3645            into=Sort,
    3646            dialect=dialect,
    3647            **opts,
    3648        )
    3649
    3650    def cluster_by(
    3651        self,
    3652        *expressions: t.Optional[ExpOrStr],
    3653        append: bool = True,
    3654        dialect: DialectType = None,
    3655        copy: bool = True,
    3656        **opts,
    3657    ) -> Select:
    3658        """
    3659        Set the CLUSTER BY expression.
    3660
    3661        Example:
    3662            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3663            'SELECT x FROM tbl CLUSTER BY x DESC'
    3664
    3665        Args:
    3666            *expressions: the SQL code strings to parse.
    3667                If a `Group` instance is passed, this is used as-is.
    3668                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3669            append: if `True`, add to any existing expressions.
    3670                Otherwise, this flattens all the `Order` expression into a single expression.
    3671            dialect: the dialect used to parse the input expression.
    3672            copy: if `False`, modify this expression instance in-place.
    3673            opts: other options to use to parse the input expressions.
    3674
    3675        Returns:
    3676            The modified Select expression.
    3677        """
    3678        return _apply_child_list_builder(
    3679            *expressions,
    3680            instance=self,
    3681            arg="cluster",
    3682            append=append,
    3683            copy=copy,
    3684            prefix="CLUSTER BY",
    3685            into=Cluster,
    3686            dialect=dialect,
    3687            **opts,
    3688        )
    3689
    3690    def select(
    3691        self,
    3692        *expressions: t.Optional[ExpOrStr],
    3693        append: bool = True,
    3694        dialect: DialectType = None,
    3695        copy: bool = True,
    3696        **opts,
    3697    ) -> Select:
    3698        return _apply_list_builder(
    3699            *expressions,
    3700            instance=self,
    3701            arg="expressions",
    3702            append=append,
    3703            dialect=dialect,
    3704            into=Expression,
    3705            copy=copy,
    3706            **opts,
    3707        )
    3708
    3709    def lateral(
    3710        self,
    3711        *expressions: t.Optional[ExpOrStr],
    3712        append: bool = True,
    3713        dialect: DialectType = None,
    3714        copy: bool = True,
    3715        **opts,
    3716    ) -> Select:
    3717        """
    3718        Append to or set the LATERAL expressions.
    3719
    3720        Example:
    3721            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3722            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3723
    3724        Args:
    3725            *expressions: the SQL code strings to parse.
    3726                If an `Expression` instance is passed, it will be used as-is.
    3727            append: if `True`, add to any existing expressions.
    3728                Otherwise, this resets the expressions.
    3729            dialect: the dialect used to parse the input expressions.
    3730            copy: if `False`, modify this expression instance in-place.
    3731            opts: other options to use to parse the input expressions.
    3732
    3733        Returns:
    3734            The modified Select expression.
    3735        """
    3736        return _apply_list_builder(
    3737            *expressions,
    3738            instance=self,
    3739            arg="laterals",
    3740            append=append,
    3741            into=Lateral,
    3742            prefix="LATERAL VIEW",
    3743            dialect=dialect,
    3744            copy=copy,
    3745            **opts,
    3746        )
    3747
    3748    def join(
    3749        self,
    3750        expression: ExpOrStr,
    3751        on: t.Optional[ExpOrStr] = None,
    3752        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3753        append: bool = True,
    3754        join_type: t.Optional[str] = None,
    3755        join_alias: t.Optional[Identifier | str] = None,
    3756        dialect: DialectType = None,
    3757        copy: bool = True,
    3758        **opts,
    3759    ) -> Select:
    3760        """
    3761        Append to or set the JOIN expressions.
    3762
    3763        Example:
    3764            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3765            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3766
    3767            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3768            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3769
    3770            Use `join_type` to change the type of join:
    3771
    3772            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3773            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3774
    3775        Args:
    3776            expression: the SQL code string to parse.
    3777                If an `Expression` instance is passed, it will be used as-is.
    3778            on: optionally specify the join "on" criteria as a SQL string.
    3779                If an `Expression` instance is passed, it will be used as-is.
    3780            using: optionally specify the join "using" criteria as a SQL string.
    3781                If an `Expression` instance is passed, it will be used as-is.
    3782            append: if `True`, add to any existing expressions.
    3783                Otherwise, this resets the expressions.
    3784            join_type: if set, alter the parsed join type.
    3785            join_alias: an optional alias for the joined source.
    3786            dialect: the dialect used to parse the input expressions.
    3787            copy: if `False`, modify this expression instance in-place.
    3788            opts: other options to use to parse the input expressions.
    3789
    3790        Returns:
    3791            Select: the modified expression.
    3792        """
    3793        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3794
    3795        try:
    3796            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3797        except ParseError:
    3798            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3799
    3800        join = expression if isinstance(expression, Join) else Join(this=expression)
    3801
    3802        if isinstance(join.this, Select):
    3803            join.this.replace(join.this.subquery())
    3804
    3805        if join_type:
    3806            method: t.Optional[Token]
    3807            side: t.Optional[Token]
    3808            kind: t.Optional[Token]
    3809
    3810            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3811
    3812            if method:
    3813                join.set("method", method.text)
    3814            if side:
    3815                join.set("side", side.text)
    3816            if kind:
    3817                join.set("kind", kind.text)
    3818
    3819        if on:
    3820            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3821            join.set("on", on)
    3822
    3823        if using:
    3824            join = _apply_list_builder(
    3825                *ensure_list(using),
    3826                instance=join,
    3827                arg="using",
    3828                append=append,
    3829                copy=copy,
    3830                into=Identifier,
    3831                **opts,
    3832            )
    3833
    3834        if join_alias:
    3835            join.set("this", alias_(join.this, join_alias, table=True))
    3836
    3837        return _apply_list_builder(
    3838            join,
    3839            instance=self,
    3840            arg="joins",
    3841            append=append,
    3842            copy=copy,
    3843            **opts,
    3844        )
    3845
    3846    def where(
    3847        self,
    3848        *expressions: t.Optional[ExpOrStr],
    3849        append: bool = True,
    3850        dialect: DialectType = None,
    3851        copy: bool = True,
    3852        **opts,
    3853    ) -> Select:
    3854        """
    3855        Append to or set the WHERE expressions.
    3856
    3857        Example:
    3858            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3859            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3860
    3861        Args:
    3862            *expressions: the SQL code strings to parse.
    3863                If an `Expression` instance is passed, it will be used as-is.
    3864                Multiple expressions are combined with an AND operator.
    3865            append: if `True`, AND the new expressions to any existing expression.
    3866                Otherwise, this resets the expression.
    3867            dialect: the dialect used to parse the input expressions.
    3868            copy: if `False`, modify this expression instance in-place.
    3869            opts: other options to use to parse the input expressions.
    3870
    3871        Returns:
    3872            Select: the modified expression.
    3873        """
    3874        return _apply_conjunction_builder(
    3875            *expressions,
    3876            instance=self,
    3877            arg="where",
    3878            append=append,
    3879            into=Where,
    3880            dialect=dialect,
    3881            copy=copy,
    3882            **opts,
    3883        )
    3884
    3885    def having(
    3886        self,
    3887        *expressions: t.Optional[ExpOrStr],
    3888        append: bool = True,
    3889        dialect: DialectType = None,
    3890        copy: bool = True,
    3891        **opts,
    3892    ) -> Select:
    3893        """
    3894        Append to or set the HAVING expressions.
    3895
    3896        Example:
    3897            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3898            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3899
    3900        Args:
    3901            *expressions: the SQL code strings to parse.
    3902                If an `Expression` instance is passed, it will be used as-is.
    3903                Multiple expressions are combined with an AND operator.
    3904            append: if `True`, AND the new expressions to any existing expression.
    3905                Otherwise, this resets the expression.
    3906            dialect: the dialect used to parse the input expressions.
    3907            copy: if `False`, modify this expression instance in-place.
    3908            opts: other options to use to parse the input expressions.
    3909
    3910        Returns:
    3911            The modified Select expression.
    3912        """
    3913        return _apply_conjunction_builder(
    3914            *expressions,
    3915            instance=self,
    3916            arg="having",
    3917            append=append,
    3918            into=Having,
    3919            dialect=dialect,
    3920            copy=copy,
    3921            **opts,
    3922        )
    3923
    3924    def window(
    3925        self,
    3926        *expressions: t.Optional[ExpOrStr],
    3927        append: bool = True,
    3928        dialect: DialectType = None,
    3929        copy: bool = True,
    3930        **opts,
    3931    ) -> Select:
    3932        return _apply_list_builder(
    3933            *expressions,
    3934            instance=self,
    3935            arg="windows",
    3936            append=append,
    3937            into=Window,
    3938            dialect=dialect,
    3939            copy=copy,
    3940            **opts,
    3941        )
    3942
    3943    def qualify(
    3944        self,
    3945        *expressions: t.Optional[ExpOrStr],
    3946        append: bool = True,
    3947        dialect: DialectType = None,
    3948        copy: bool = True,
    3949        **opts,
    3950    ) -> Select:
    3951        return _apply_conjunction_builder(
    3952            *expressions,
    3953            instance=self,
    3954            arg="qualify",
    3955            append=append,
    3956            into=Qualify,
    3957            dialect=dialect,
    3958            copy=copy,
    3959            **opts,
    3960        )
    3961
    3962    def distinct(
    3963        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3964    ) -> Select:
    3965        """
    3966        Set the OFFSET expression.
    3967
    3968        Example:
    3969            >>> Select().from_("tbl").select("x").distinct().sql()
    3970            'SELECT DISTINCT x FROM tbl'
    3971
    3972        Args:
    3973            ons: the expressions to distinct on
    3974            distinct: whether the Select should be distinct
    3975            copy: if `False`, modify this expression instance in-place.
    3976
    3977        Returns:
    3978            Select: the modified expression.
    3979        """
    3980        instance = maybe_copy(self, copy)
    3981        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3982        instance.set("distinct", Distinct(on=on) if distinct else None)
    3983        return instance
    3984
    3985    def ctas(
    3986        self,
    3987        table: ExpOrStr,
    3988        properties: t.Optional[t.Dict] = None,
    3989        dialect: DialectType = None,
    3990        copy: bool = True,
    3991        **opts,
    3992    ) -> Create:
    3993        """
    3994        Convert this expression to a CREATE TABLE AS statement.
    3995
    3996        Example:
    3997            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3998            'CREATE TABLE x AS SELECT * FROM tbl'
    3999
    4000        Args:
    4001            table: the SQL code string to parse as the table name.
    4002                If another `Expression` instance is passed, it will be used as-is.
    4003            properties: an optional mapping of table properties
    4004            dialect: the dialect used to parse the input table.
    4005            copy: if `False`, modify this expression instance in-place.
    4006            opts: other options to use to parse the input table.
    4007
    4008        Returns:
    4009            The new Create expression.
    4010        """
    4011        instance = maybe_copy(self, copy)
    4012        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4013
    4014        properties_expression = None
    4015        if properties:
    4016            properties_expression = Properties.from_dict(properties)
    4017
    4018        return Create(
    4019            this=table_expression,
    4020            kind="TABLE",
    4021            expression=instance,
    4022            properties=properties_expression,
    4023        )
    4024
    4025    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4026        """
    4027        Set the locking read mode for this expression.
    4028
    4029        Examples:
    4030            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4031            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4032
    4033            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4034            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4035
    4036        Args:
    4037            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4038            copy: if `False`, modify this expression instance in-place.
    4039
    4040        Returns:
    4041            The modified expression.
    4042        """
    4043        inst = maybe_copy(self, copy)
    4044        inst.set("locks", [Lock(update=update)])
    4045
    4046        return inst
    4047
    4048    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4049        """
    4050        Set hints for this expression.
    4051
    4052        Examples:
    4053            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4054            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4055
    4056        Args:
    4057            hints: The SQL code strings to parse as the hints.
    4058                If an `Expression` instance is passed, it will be used as-is.
    4059            dialect: The dialect used to parse the hints.
    4060            copy: If `False`, modify this expression instance in-place.
    4061
    4062        Returns:
    4063            The modified expression.
    4064        """
    4065        inst = maybe_copy(self, copy)
    4066        inst.set(
    4067            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4068        )
    4069
    4070        return inst
    4071
    4072    @property
    4073    def named_selects(self) -> t.List[str]:
    4074        return [e.output_name for e in self.expressions if e.alias_or_name]
    4075
    4076    @property
    4077    def is_star(self) -> bool:
    4078        return any(expression.is_star for expression in self.expressions)
    4079
    4080    @property
    4081    def selects(self) -> t.List[Expression]:
    4082        return self.expressions
    4083
    4084
    4085UNWRAPPED_QUERIES = (Select, SetOperation)
    4086
    4087
    4088class Subquery(DerivedTable, Query):
    4089    arg_types = {
    4090        "this": True,
    4091        "alias": False,
    4092        "with": False,
    4093        **QUERY_MODIFIERS,
    4094    }
    4095
    4096    def unnest(self):
    4097        """Returns the first non subquery."""
    4098        expression = self
    4099        while isinstance(expression, Subquery):
    4100            expression = expression.this
    4101        return expression
    4102
    4103    def unwrap(self) -> Subquery:
    4104        expression = self
    4105        while expression.same_parent and expression.is_wrapper:
    4106            expression = t.cast(Subquery, expression.parent)
    4107        return expression
    4108
    4109    def select(
    4110        self,
    4111        *expressions: t.Optional[ExpOrStr],
    4112        append: bool = True,
    4113        dialect: DialectType = None,
    4114        copy: bool = True,
    4115        **opts,
    4116    ) -> Subquery:
    4117        this = maybe_copy(self, copy)
    4118        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4119        return this
    4120
    4121    @property
    4122    def is_wrapper(self) -> bool:
    4123        """
    4124        Whether this Subquery acts as a simple wrapper around another expression.
    4125
    4126        SELECT * FROM (((SELECT * FROM t)))
    4127                      ^
    4128                      This corresponds to a "wrapper" Subquery node
    4129        """
    4130        return all(v is None for k, v in self.args.items() if k != "this")
    4131
    4132    @property
    4133    def is_star(self) -> bool:
    4134        return self.this.is_star
    4135
    4136    @property
    4137    def output_name(self) -> str:
    4138        return self.alias
    4139
    4140
    4141class TableSample(Expression):
    4142    arg_types = {
    4143        "expressions": False,
    4144        "method": False,
    4145        "bucket_numerator": False,
    4146        "bucket_denominator": False,
    4147        "bucket_field": False,
    4148        "percent": False,
    4149        "rows": False,
    4150        "size": False,
    4151        "seed": False,
    4152    }
    4153
    4154
    4155class Tag(Expression):
    4156    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    4157
    4158    arg_types = {
    4159        "this": False,
    4160        "prefix": False,
    4161        "postfix": False,
    4162    }
    4163
    4164
    4165# Represents both the standard SQL PIVOT operator and DuckDB's "simplified" PIVOT syntax
    4166# https://duckdb.org/docs/sql/statements/pivot
    4167class Pivot(Expression):
    4168    arg_types = {
    4169        "this": False,
    4170        "alias": False,
    4171        "expressions": False,
    4172        "field": False,
    4173        "unpivot": False,
    4174        "using": False,
    4175        "group": False,
    4176        "columns": False,
    4177        "include_nulls": False,
    4178        "default_on_null": False,
    4179    }
    4180
    4181    @property
    4182    def unpivot(self) -> bool:
    4183        return bool(self.args.get("unpivot"))
    4184
    4185
    4186class Window(Condition):
    4187    arg_types = {
    4188        "this": True,
    4189        "partition_by": False,
    4190        "order": False,
    4191        "spec": False,
    4192        "alias": False,
    4193        "over": False,
    4194        "first": False,
    4195    }
    4196
    4197
    4198class WindowSpec(Expression):
    4199    arg_types = {
    4200        "kind": False,
    4201        "start": False,
    4202        "start_side": False,
    4203        "end": False,
    4204        "end_side": False,
    4205    }
    4206
    4207
    4208class PreWhere(Expression):
    4209    pass
    4210
    4211
    4212class Where(Expression):
    4213    pass
    4214
    4215
    4216class Star(Expression):
    4217    arg_types = {"except": False, "replace": False, "rename": False}
    4218
    4219    @property
    4220    def name(self) -> str:
    4221        return "*"
    4222
    4223    @property
    4224    def output_name(self) -> str:
    4225        return self.name
    4226
    4227
    4228class Parameter(Condition):
    4229    arg_types = {"this": True, "expression": False}
    4230
    4231
    4232class SessionParameter(Condition):
    4233    arg_types = {"this": True, "kind": False}
    4234
    4235
    4236class Placeholder(Condition):
    4237    arg_types = {"this": False, "kind": False}
    4238
    4239    @property
    4240    def name(self) -> str:
    4241        return self.this or "?"
    4242
    4243
    4244class Null(Condition):
    4245    arg_types: t.Dict[str, t.Any] = {}
    4246
    4247    @property
    4248    def name(self) -> str:
    4249        return "NULL"
    4250
    4251    def to_py(self) -> Lit[None]:
    4252        return None
    4253
    4254
    4255class Boolean(Condition):
    4256    def to_py(self) -> bool:
    4257        return self.this
    4258
    4259
    4260class DataTypeParam(Expression):
    4261    arg_types = {"this": True, "expression": False}
    4262
    4263    @property
    4264    def name(self) -> str:
    4265        return self.this.name
    4266
    4267
    4268# The `nullable` arg is helpful when transpiling types from other dialects to ClickHouse, which
    4269# assumes non-nullable types by default. Values `None` and `True` mean the type is nullable.
    4270class DataType(Expression):
    4271    arg_types = {
    4272        "this": True,
    4273        "expressions": False,
    4274        "nested": False,
    4275        "values": False,
    4276        "prefix": False,
    4277        "kind": False,
    4278        "nullable": False,
    4279    }
    4280
    4281    class Type(AutoName):
    4282        ARRAY = auto()
    4283        AGGREGATEFUNCTION = auto()
    4284        SIMPLEAGGREGATEFUNCTION = auto()
    4285        BIGDECIMAL = auto()
    4286        BIGINT = auto()
    4287        BIGSERIAL = auto()
    4288        BINARY = auto()
    4289        BIT = auto()
    4290        BOOLEAN = auto()
    4291        BPCHAR = auto()
    4292        CHAR = auto()
    4293        DATE = auto()
    4294        DATE32 = auto()
    4295        DATEMULTIRANGE = auto()
    4296        DATERANGE = auto()
    4297        DATETIME = auto()
    4298        DATETIME64 = auto()
    4299        DECIMAL = auto()
    4300        DECIMAL32 = auto()
    4301        DECIMAL64 = auto()
    4302        DECIMAL128 = auto()
    4303        DOUBLE = auto()
    4304        ENUM = auto()
    4305        ENUM8 = auto()
    4306        ENUM16 = auto()
    4307        FIXEDSTRING = auto()
    4308        FLOAT = auto()
    4309        GEOGRAPHY = auto()
    4310        GEOMETRY = auto()
    4311        HLLSKETCH = auto()
    4312        HSTORE = auto()
    4313        IMAGE = auto()
    4314        INET = auto()
    4315        INT = auto()
    4316        INT128 = auto()
    4317        INT256 = auto()
    4318        INT4MULTIRANGE = auto()
    4319        INT4RANGE = auto()
    4320        INT8MULTIRANGE = auto()
    4321        INT8RANGE = auto()
    4322        INTERVAL = auto()
    4323        IPADDRESS = auto()
    4324        IPPREFIX = auto()
    4325        IPV4 = auto()
    4326        IPV6 = auto()
    4327        JSON = auto()
    4328        JSONB = auto()
    4329        LIST = auto()
    4330        LONGBLOB = auto()
    4331        LONGTEXT = auto()
    4332        LOWCARDINALITY = auto()
    4333        MAP = auto()
    4334        MEDIUMBLOB = auto()
    4335        MEDIUMINT = auto()
    4336        MEDIUMTEXT = auto()
    4337        MONEY = auto()
    4338        NAME = auto()
    4339        NCHAR = auto()
    4340        NESTED = auto()
    4341        NULL = auto()
    4342        NUMMULTIRANGE = auto()
    4343        NUMRANGE = auto()
    4344        NVARCHAR = auto()
    4345        OBJECT = auto()
    4346        RANGE = auto()
    4347        ROWVERSION = auto()
    4348        SERIAL = auto()
    4349        SET = auto()
    4350        SMALLINT = auto()
    4351        SMALLMONEY = auto()
    4352        SMALLSERIAL = auto()
    4353        STRUCT = auto()
    4354        SUPER = auto()
    4355        TEXT = auto()
    4356        TINYBLOB = auto()
    4357        TINYTEXT = auto()
    4358        TIME = auto()
    4359        TIMETZ = auto()
    4360        TIMESTAMP = auto()
    4361        TIMESTAMPNTZ = auto()
    4362        TIMESTAMPLTZ = auto()
    4363        TIMESTAMPTZ = auto()
    4364        TIMESTAMP_S = auto()
    4365        TIMESTAMP_MS = auto()
    4366        TIMESTAMP_NS = auto()
    4367        TINYINT = auto()
    4368        TSMULTIRANGE = auto()
    4369        TSRANGE = auto()
    4370        TSTZMULTIRANGE = auto()
    4371        TSTZRANGE = auto()
    4372        UBIGINT = auto()
    4373        UINT = auto()
    4374        UINT128 = auto()
    4375        UINT256 = auto()
    4376        UMEDIUMINT = auto()
    4377        UDECIMAL = auto()
    4378        UNION = auto()
    4379        UNIQUEIDENTIFIER = auto()
    4380        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4381        USERDEFINED = "USER-DEFINED"
    4382        USMALLINT = auto()
    4383        UTINYINT = auto()
    4384        UUID = auto()
    4385        VARBINARY = auto()
    4386        VARCHAR = auto()
    4387        VARIANT = auto()
    4388        VECTOR = auto()
    4389        XML = auto()
    4390        YEAR = auto()
    4391        TDIGEST = auto()
    4392
    4393    STRUCT_TYPES = {
    4394        Type.NESTED,
    4395        Type.OBJECT,
    4396        Type.STRUCT,
    4397        Type.UNION,
    4398    }
    4399
    4400    ARRAY_TYPES = {
    4401        Type.ARRAY,
    4402        Type.LIST,
    4403    }
    4404
    4405    NESTED_TYPES = {
    4406        *STRUCT_TYPES,
    4407        *ARRAY_TYPES,
    4408        Type.MAP,
    4409    }
    4410
    4411    TEXT_TYPES = {
    4412        Type.CHAR,
    4413        Type.NCHAR,
    4414        Type.NVARCHAR,
    4415        Type.TEXT,
    4416        Type.VARCHAR,
    4417        Type.NAME,
    4418    }
    4419
    4420    SIGNED_INTEGER_TYPES = {
    4421        Type.BIGINT,
    4422        Type.INT,
    4423        Type.INT128,
    4424        Type.INT256,
    4425        Type.MEDIUMINT,
    4426        Type.SMALLINT,
    4427        Type.TINYINT,
    4428    }
    4429
    4430    UNSIGNED_INTEGER_TYPES = {
    4431        Type.UBIGINT,
    4432        Type.UINT,
    4433        Type.UINT128,
    4434        Type.UINT256,
    4435        Type.UMEDIUMINT,
    4436        Type.USMALLINT,
    4437        Type.UTINYINT,
    4438    }
    4439
    4440    INTEGER_TYPES = {
    4441        *SIGNED_INTEGER_TYPES,
    4442        *UNSIGNED_INTEGER_TYPES,
    4443        Type.BIT,
    4444    }
    4445
    4446    FLOAT_TYPES = {
    4447        Type.DOUBLE,
    4448        Type.FLOAT,
    4449    }
    4450
    4451    REAL_TYPES = {
    4452        *FLOAT_TYPES,
    4453        Type.BIGDECIMAL,
    4454        Type.DECIMAL,
    4455        Type.DECIMAL32,
    4456        Type.DECIMAL64,
    4457        Type.DECIMAL128,
    4458        Type.MONEY,
    4459        Type.SMALLMONEY,
    4460        Type.UDECIMAL,
    4461    }
    4462
    4463    NUMERIC_TYPES = {
    4464        *INTEGER_TYPES,
    4465        *REAL_TYPES,
    4466    }
    4467
    4468    TEMPORAL_TYPES = {
    4469        Type.DATE,
    4470        Type.DATE32,
    4471        Type.DATETIME,
    4472        Type.DATETIME64,
    4473        Type.TIME,
    4474        Type.TIMESTAMP,
    4475        Type.TIMESTAMPNTZ,
    4476        Type.TIMESTAMPLTZ,
    4477        Type.TIMESTAMPTZ,
    4478        Type.TIMESTAMP_MS,
    4479        Type.TIMESTAMP_NS,
    4480        Type.TIMESTAMP_S,
    4481        Type.TIMETZ,
    4482    }
    4483
    4484    @classmethod
    4485    def build(
    4486        cls,
    4487        dtype: DATA_TYPE,
    4488        dialect: DialectType = None,
    4489        udt: bool = False,
    4490        copy: bool = True,
    4491        **kwargs,
    4492    ) -> DataType:
    4493        """
    4494        Constructs a DataType object.
    4495
    4496        Args:
    4497            dtype: the data type of interest.
    4498            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4499            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4500                DataType, thus creating a user-defined type.
    4501            copy: whether to copy the data type.
    4502            kwargs: additional arguments to pass in the constructor of DataType.
    4503
    4504        Returns:
    4505            The constructed DataType object.
    4506        """
    4507        from sqlglot import parse_one
    4508
    4509        if isinstance(dtype, str):
    4510            if dtype.upper() == "UNKNOWN":
    4511                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4512
    4513            try:
    4514                data_type_exp = parse_one(
    4515                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4516                )
    4517            except ParseError:
    4518                if udt:
    4519                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4520                raise
    4521        elif isinstance(dtype, DataType.Type):
    4522            data_type_exp = DataType(this=dtype)
    4523        elif isinstance(dtype, DataType):
    4524            return maybe_copy(dtype, copy)
    4525        else:
    4526            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4527
    4528        return DataType(**{**data_type_exp.args, **kwargs})
    4529
    4530    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4531        """
    4532        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4533        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4534
    4535        Args:
    4536            dtypes: the data types to compare this DataType to.
    4537            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4538                If false, it means that NULLABLE<INT> is equivalent to INT.
    4539
    4540        Returns:
    4541            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4542        """
    4543        self_is_nullable = self.args.get("nullable")
    4544        for dtype in dtypes:
    4545            other_type = DataType.build(dtype, copy=False, udt=True)
    4546            other_is_nullable = other_type.args.get("nullable")
    4547            if (
    4548                other_type.expressions
    4549                or (check_nullable and (self_is_nullable or other_is_nullable))
    4550                or self.this == DataType.Type.USERDEFINED
    4551                or other_type.this == DataType.Type.USERDEFINED
    4552            ):
    4553                matches = self == other_type
    4554            else:
    4555                matches = self.this == other_type.this
    4556
    4557            if matches:
    4558                return True
    4559        return False
    4560
    4561
    4562DATA_TYPE = t.Union[str, DataType, DataType.Type]
    4563
    4564
    4565# https://www.postgresql.org/docs/15/datatype-pseudo.html
    4566class PseudoType(DataType):
    4567    arg_types = {"this": True}
    4568
    4569
    4570# https://www.postgresql.org/docs/15/datatype-oid.html
    4571class ObjectIdentifier(DataType):
    4572    arg_types = {"this": True}
    4573
    4574
    4575# WHERE x <OP> EXISTS|ALL|ANY|SOME(SELECT ...)
    4576class SubqueryPredicate(Predicate):
    4577    pass
    4578
    4579
    4580class All(SubqueryPredicate):
    4581    pass
    4582
    4583
    4584class Any(SubqueryPredicate):
    4585    pass
    4586
    4587
    4588class Exists(SubqueryPredicate):
    4589    pass
    4590
    4591
    4592# Commands to interact with the databases or engines. For most of the command
    4593# expressions we parse whatever comes after the command's name as a string.
    4594class Command(Expression):
    4595    arg_types = {"this": True, "expression": False}
    4596
    4597
    4598class Transaction(Expression):
    4599    arg_types = {"this": False, "modes": False, "mark": False}
    4600
    4601
    4602class Commit(Expression):
    4603    arg_types = {"chain": False, "this": False, "durability": False}
    4604
    4605
    4606class Rollback(Expression):
    4607    arg_types = {"savepoint": False, "this": False}
    4608
    4609
    4610class Alter(Expression):
    4611    arg_types = {
    4612        "this": True,
    4613        "kind": True,
    4614        "actions": True,
    4615        "exists": False,
    4616        "only": False,
    4617        "options": False,
    4618        "cluster": False,
    4619        "not_valid": False,
    4620    }
    4621
    4622    @property
    4623    def kind(self) -> t.Optional[str]:
    4624        kind = self.args.get("kind")
    4625        return kind and kind.upper()
    4626
    4627    @property
    4628    def actions(self) -> t.List[Expression]:
    4629        return self.args.get("actions") or []
    4630
    4631
    4632class AddConstraint(Expression):
    4633    arg_types = {"expressions": True}
    4634
    4635
    4636class DropPartition(Expression):
    4637    arg_types = {"expressions": True, "exists": False}
    4638
    4639
    4640# https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#replace-partition
    4641class ReplacePartition(Expression):
    4642    arg_types = {"expression": True, "source": True}
    4643
    4644
    4645# Binary expressions like (ADD a b)
    4646class Binary(Condition):
    4647    arg_types = {"this": True, "expression": True}
    4648
    4649    @property
    4650    def left(self) -> Expression:
    4651        return self.this
    4652
    4653    @property
    4654    def right(self) -> Expression:
    4655        return self.expression
    4656
    4657
    4658class Add(Binary):
    4659    pass
    4660
    4661
    4662class Connector(Binary):
    4663    pass
    4664
    4665
    4666class And(Connector):
    4667    pass
    4668
    4669
    4670class Or(Connector):
    4671    pass
    4672
    4673
    4674class BitwiseAnd(Binary):
    4675    pass
    4676
    4677
    4678class BitwiseLeftShift(Binary):
    4679    pass
    4680
    4681
    4682class BitwiseOr(Binary):
    4683    pass
    4684
    4685
    4686class BitwiseRightShift(Binary):
    4687    pass
    4688
    4689
    4690class BitwiseXor(Binary):
    4691    pass
    4692
    4693
    4694class Div(Binary):
    4695    arg_types = {"this": True, "expression": True, "typed": False, "safe": False}
    4696
    4697
    4698class Overlaps(Binary):
    4699    pass
    4700
    4701
    4702class Dot(Binary):
    4703    @property
    4704    def is_star(self) -> bool:
    4705        return self.expression.is_star
    4706
    4707    @property
    4708    def name(self) -> str:
    4709        return self.expression.name
    4710
    4711    @property
    4712    def output_name(self) -> str:
    4713        return self.name
    4714
    4715    @classmethod
    4716    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    4717        """Build a Dot object with a sequence of expressions."""
    4718        if len(expressions) < 2:
    4719            raise ValueError("Dot requires >= 2 expressions.")
    4720
    4721        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))
    4722
    4723    @property
    4724    def parts(self) -> t.List[Expression]:
    4725        """Return the parts of a table / column in order catalog, db, table."""
    4726        this, *parts = self.flatten()
    4727
    4728        parts.reverse()
    4729
    4730        for arg in COLUMN_PARTS:
    4731            part = this.args.get(arg)
    4732
    4733            if isinstance(part, Expression):
    4734                parts.append(part)
    4735
    4736        parts.reverse()
    4737        return parts
    4738
    4739
    4740class DPipe(Binary):
    4741    arg_types = {"this": True, "expression": True, "safe": False}
    4742
    4743
    4744class EQ(Binary, Predicate):
    4745    pass
    4746
    4747
    4748class NullSafeEQ(Binary, Predicate):
    4749    pass
    4750
    4751
    4752class NullSafeNEQ(Binary, Predicate):
    4753    pass
    4754
    4755
    4756# Represents e.g. := in DuckDB which is mostly used for setting parameters
    4757class PropertyEQ(Binary):
    4758    pass
    4759
    4760
    4761class Distance(Binary):
    4762    pass
    4763
    4764
    4765class Escape(Binary):
    4766    pass
    4767
    4768
    4769class Glob(Binary, Predicate):
    4770    pass
    4771
    4772
    4773class GT(Binary, Predicate):
    4774    pass
    4775
    4776
    4777class GTE(Binary, Predicate):
    4778    pass
    4779
    4780
    4781class ILike(Binary, Predicate):
    4782    pass
    4783
    4784
    4785class ILikeAny(Binary, Predicate):
    4786    pass
    4787
    4788
    4789class IntDiv(Binary):
    4790    pass
    4791
    4792
    4793class Is(Binary, Predicate):
    4794    pass
    4795
    4796
    4797class Kwarg(Binary):
    4798    """Kwarg in special functions like func(kwarg => y)."""
    4799
    4800
    4801class Like(Binary, Predicate):
    4802    pass
    4803
    4804
    4805class LikeAny(Binary, Predicate):
    4806    pass
    4807
    4808
    4809class LT(Binary, Predicate):
    4810    pass
    4811
    4812
    4813class LTE(Binary, Predicate):
    4814    pass
    4815
    4816
    4817class Mod(Binary):
    4818    pass
    4819
    4820
    4821class Mul(Binary):
    4822    pass
    4823
    4824
    4825class NEQ(Binary, Predicate):
    4826    pass
    4827
    4828
    4829# https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-PATH
    4830class Operator(Binary):
    4831    arg_types = {"this": True, "operator": True, "expression": True}
    4832
    4833
    4834class SimilarTo(Binary, Predicate):
    4835    pass
    4836
    4837
    4838class Slice(Binary):
    4839    arg_types = {"this": False, "expression": False}
    4840
    4841
    4842class Sub(Binary):
    4843    pass
    4844
    4845
    4846# Unary Expressions
    4847# (NOT a)
    4848class Unary(Condition):
    4849    pass
    4850
    4851
    4852class BitwiseNot(Unary):
    4853    pass
    4854
    4855
    4856class Not(Unary):
    4857    pass
    4858
    4859
    4860class Paren(Unary):
    4861    @property
    4862    def output_name(self) -> str:
    4863        return self.this.name
    4864
    4865
    4866class Neg(Unary):
    4867    def to_py(self) -> int | Decimal:
    4868        if self.is_number:
    4869            return self.this.to_py() * -1
    4870        return super().to_py()
    4871
    4872
    4873class Alias(Expression):
    4874    arg_types = {"this": True, "alias": False}
    4875
    4876    @property
    4877    def output_name(self) -> str:
    4878        return self.alias
    4879
    4880
    4881# BigQuery requires the UNPIVOT column list aliases to be either strings or ints, but
    4882# other dialects require identifiers. This enables us to transpile between them easily.
    4883class PivotAlias(Alias):
    4884    pass
    4885
    4886
    4887# Represents Snowflake's ANY [ ORDER BY ... ] syntax
    4888# https://docs.snowflake.com/en/sql-reference/constructs/pivot
    4889class PivotAny(Expression):
    4890    arg_types = {"this": False}
    4891
    4892
    4893class Aliases(Expression):
    4894    arg_types = {"this": True, "expressions": True}
    4895
    4896    @property
    4897    def aliases(self):
    4898        return self.expressions
    4899
    4900
    4901# https://docs.aws.amazon.com/redshift/latest/dg/query-super.html
    4902class AtIndex(Expression):
    4903    arg_types = {"this": True, "expression": True}
    4904
    4905
    4906class AtTimeZone(Expression):
    4907    arg_types = {"this": True, "zone": True}
    4908
    4909
    4910class FromTimeZone(Expression):
    4911    arg_types = {"this": True, "zone": True}
    4912
    4913
    4914class Between(Predicate):
    4915    arg_types = {"this": True, "low": True, "high": True}
    4916
    4917
    4918class Bracket(Condition):
    4919    # https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#array_subscript_operator
    4920    arg_types = {
    4921        "this": True,
    4922        "expressions": True,
    4923        "offset": False,
    4924        "safe": False,
    4925        "returns_list_for_maps": False,
    4926    }
    4927
    4928    @property
    4929    def output_name(self) -> str:
    4930        if len(self.expressions) == 1:
    4931            return self.expressions[0].output_name
    4932
    4933        return super().output_name
    4934
    4935
    4936class Distinct(Expression):
    4937    arg_types = {"expressions": False, "on": False}
    4938
    4939
    4940class In(Predicate):
    4941    arg_types = {
    4942        "this": True,
    4943        "expressions": False,
    4944        "query": False,
    4945        "unnest": False,
    4946        "field": False,
    4947        "is_global": False,
    4948    }
    4949
    4950
    4951# https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#for-in
    4952class ForIn(Expression):
    4953    arg_types = {"this": True, "expression": True}
    4954
    4955
    4956class TimeUnit(Expression):
    4957    """Automatically converts unit arg into a var."""
    4958
    4959    arg_types = {"unit": False}
    4960
    4961    UNABBREVIATED_UNIT_NAME = {
    4962        "D": "DAY",
    4963        "H": "HOUR",
    4964        "M": "MINUTE",
    4965        "MS": "MILLISECOND",
    4966        "NS": "NANOSECOND",
    4967        "Q": "QUARTER",
    4968        "S": "SECOND",
    4969        "US": "MICROSECOND",
    4970        "W": "WEEK",
    4971        "Y": "YEAR",
    4972    }
    4973
    4974    VAR_LIKE = (Column, Literal, Var)
    4975
    4976    def __init__(self, **args):
    4977        unit = args.get("unit")
    4978        if isinstance(unit, self.VAR_LIKE):
    4979            args["unit"] = Var(
    4980                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    4981            )
    4982        elif isinstance(unit, Week):
    4983            unit.set("this", Var(this=unit.this.name.upper()))
    4984
    4985        super().__init__(**args)
    4986
    4987    @property
    4988    def unit(self) -> t.Optional[Var | IntervalSpan]:
    4989        return self.args.get("unit")
    4990
    4991
    4992class IntervalOp(TimeUnit):
    4993    arg_types = {"unit": False, "expression": True}
    4994
    4995    def interval(self):
    4996        return Interval(
    4997            this=self.expression.copy(),
    4998            unit=self.unit.copy() if self.unit else None,
    4999        )
    5000
    5001
    5002# https://www.oracletutorial.com/oracle-basics/oracle-interval/
    5003# https://trino.io/docs/current/language/types.html#interval-day-to-second
    5004# https://docs.databricks.com/en/sql/language-manual/data-types/interval-type.html
    5005class IntervalSpan(DataType):
    5006    arg_types = {"this": True, "expression": True}
    5007
    5008
    5009class Interval(TimeUnit):
    5010    arg_types = {"this": False, "unit": False}
    5011
    5012
    5013class IgnoreNulls(Expression):
    5014    pass
    5015
    5016
    5017class RespectNulls(Expression):
    5018    pass
    5019
    5020
    5021# https://cloud.google.com/bigquery/docs/reference/standard-sql/aggregate-function-calls#max_min_clause
    5022class HavingMax(Expression):
    5023    arg_types = {"this": True, "expression": True, "max": True}
    5024
    5025
    5026# Functions
    5027class Func(Condition):
    5028    """
    5029    The base class for all function expressions.
    5030
    5031    Attributes:
    5032        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    5033            treated as a variable length argument and the argument's value will be stored as a list.
    5034        _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this
    5035            function expression. These values are used to map this node to a name during parsing as
    5036            well as to provide the function's name during SQL string generation. By default the SQL
    5037            name is set to the expression's class name transformed to snake case.
    5038    """
    5039
    5040    is_var_len_args = False
    5041
    5042    @classmethod
    5043    def from_arg_list(cls, args):
    5044        if cls.is_var_len_args:
    5045            all_arg_keys = list(cls.arg_types)
    5046            # If this function supports variable length argument treat the last argument as such.
    5047            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5048            num_non_var = len(non_var_len_arg_keys)
    5049
    5050            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5051            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5052        else:
    5053            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5054
    5055        return cls(**args_dict)
    5056
    5057    @classmethod
    5058    def sql_names(cls):
    5059        if cls is Func:
    5060            raise NotImplementedError(
    5061                "SQL name is only supported by concrete function implementations"
    5062            )
    5063        if "_sql_names" not in cls.__dict__:
    5064            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5065        return cls._sql_names
    5066
    5067    @classmethod
    5068    def sql_name(cls):
    5069        return cls.sql_names()[0]
    5070
    5071    @classmethod
    5072    def default_parser_mappings(cls):
    5073        return {name: cls.from_arg_list for name in cls.sql_names()}
    5074
    5075
    5076class AggFunc(Func):
    5077    pass
    5078
    5079
    5080class ParameterizedAgg(AggFunc):
    5081    arg_types = {"this": True, "expressions": True, "params": True}
    5082
    5083
    5084class Abs(Func):
    5085    pass
    5086
    5087
    5088class ArgMax(AggFunc):
    5089    arg_types = {"this": True, "expression": True, "count": False}
    5090    _sql_names = ["ARG_MAX", "ARGMAX", "MAX_BY"]
    5091
    5092
    5093class ArgMin(AggFunc):
    5094    arg_types = {"this": True, "expression": True, "count": False}
    5095    _sql_names = ["ARG_MIN", "ARGMIN", "MIN_BY"]
    5096
    5097
    5098class ApproxTopK(AggFunc):
    5099    arg_types = {"this": True, "expression": False, "counters": False}
    5100
    5101
    5102class Flatten(Func):
    5103    pass
    5104
    5105
    5106# https://spark.apache.org/docs/latest/api/sql/index.html#transform
    5107class Transform(Func):
    5108    arg_types = {"this": True, "expression": True}
    5109
    5110
    5111class Anonymous(Func):
    5112    arg_types = {"this": True, "expressions": False}
    5113    is_var_len_args = True
    5114
    5115    @property
    5116    def name(self) -> str:
    5117        return self.this if isinstance(self.this, str) else self.this.name
    5118
    5119
    5120class AnonymousAggFunc(AggFunc):
    5121    arg_types = {"this": True, "expressions": False}
    5122    is_var_len_args = True
    5123
    5124
    5125# https://clickhouse.com/docs/en/sql-reference/aggregate-functions/combinators
    5126class CombinedAggFunc(AnonymousAggFunc):
    5127    arg_types = {"this": True, "expressions": False, "parts": True}
    5128
    5129
    5130class CombinedParameterizedAgg(ParameterizedAgg):
    5131    arg_types = {"this": True, "expressions": True, "params": True, "parts": True}
    5132
    5133
    5134# https://docs.snowflake.com/en/sql-reference/functions/hll
    5135# https://docs.aws.amazon.com/redshift/latest/dg/r_HLL_function.html
    5136class Hll(AggFunc):
    5137    arg_types = {"this": True, "expressions": False}
    5138    is_var_len_args = True
    5139
    5140
    5141class ApproxDistinct(AggFunc):
    5142    arg_types = {"this": True, "accuracy": False}
    5143    _sql_names = ["APPROX_DISTINCT", "APPROX_COUNT_DISTINCT"]
    5144
    5145
    5146class Apply(Func):
    5147    arg_types = {"this": True, "expression": True}
    5148
    5149
    5150class Array(Func):
    5151    arg_types = {"expressions": False, "bracket_notation": False}
    5152    is_var_len_args = True
    5153
    5154
    5155# https://docs.snowflake.com/en/sql-reference/functions/to_array
    5156class ToArray(Func):
    5157    pass
    5158
    5159
    5160# https://materialize.com/docs/sql/types/list/
    5161class List(Func):
    5162    arg_types = {"expressions": False}
    5163    is_var_len_args = True
    5164
    5165
    5166# String pad, kind True -> LPAD, False -> RPAD
    5167class Pad(Func):
    5168    arg_types = {"this": True, "expression": True, "fill_pattern": False, "is_left": True}
    5169
    5170
    5171# https://docs.snowflake.com/en/sql-reference/functions/to_char
    5172# https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/TO_CHAR-number.html
    5173class ToChar(Func):
    5174    arg_types = {"this": True, "format": False, "nlsparam": False}
    5175
    5176
    5177# https://docs.snowflake.com/en/sql-reference/functions/to_decimal
    5178# https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/TO_NUMBER.html
    5179class ToNumber(Func):
    5180    arg_types = {
    5181        "this": True,
    5182        "format": False,
    5183        "nlsparam": False,
    5184        "precision": False,
    5185        "scale": False,
    5186    }
    5187
    5188
    5189class Columns(Func):
    5190    arg_types = {"this": True, "unpack": False}
    5191
    5192
    5193# https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16#syntax
    5194class Convert(Func):
    5195    arg_types = {"this": True, "expression": True, "style": False}
    5196
    5197
    5198class ConvertTimezone(Func):
    5199    arg_types = {"source_tz": False, "target_tz": True, "timestamp": True}
    5200
    5201
    5202class GenerateSeries(Func):
    5203    arg_types = {"start": True, "end": True, "step": False, "is_end_exclusive": False}
    5204
    5205
    5206# Postgres' GENERATE_SERIES function returns a row set, i.e. it implicitly explodes when it's
    5207# used in a projection, so this expression is a helper that facilitates transpilation to other
    5208# dialects. For example, we'd generate UNNEST(GENERATE_SERIES(...)) in DuckDB
    5209class ExplodingGenerateSeries(GenerateSeries):
    5210    pass
    5211
    5212
    5213class ArrayAgg(AggFunc):
    5214    arg_types = {"this": True, "nulls_excluded": False}
    5215
    5216
    5217class ArrayUniqueAgg(AggFunc):
    5218    pass
    5219
    5220
    5221class ArrayAll(Func):
    5222    arg_types = {"this": True, "expression": True}
    5223
    5224
    5225# Represents Python's `any(f(x) for x in array)`, where `array` is `this` and `f` is `expression`
    5226class ArrayAny(Func):
    5227    arg_types = {"this": True, "expression": True}
    5228
    5229
    5230class ArrayConcat(Func):
    5231    _sql_names = ["ARRAY_CONCAT", "ARRAY_CAT"]
    5232    arg_types = {"this": True, "expressions": False}
    5233    is_var_len_args = True
    5234
    5235
    5236class ArrayConstructCompact(Func):
    5237    arg_types = {"expressions": True}
    5238    is_var_len_args = True
    5239
    5240
    5241class ArrayContains(Binary, Func):
    5242    _sql_names = ["ARRAY_CONTAINS", "ARRAY_HAS"]
    5243
    5244
    5245class ArrayContainsAll(Binary, Func):
    5246    _sql_names = ["ARRAY_CONTAINS_ALL", "ARRAY_HAS_ALL"]
    5247
    5248
    5249class ArrayFilter(Func):
    5250    arg_types = {"this": True, "expression": True}
    5251    _sql_names = ["FILTER", "ARRAY_FILTER"]
    5252
    5253
    5254class ArrayToString(Func):
    5255    arg_types = {"this": True, "expression": True, "null": False}
    5256    _sql_names = ["ARRAY_TO_STRING", "ARRAY_JOIN"]
    5257
    5258
    5259class StringToArray(Func):
    5260    arg_types = {"this": True, "expression": True, "null": False}
    5261    _sql_names = ["STRING_TO_ARRAY", "SPLIT_BY_STRING"]
    5262
    5263
    5264class ArrayOverlaps(Binary, Func):
    5265    pass
    5266
    5267
    5268class ArraySize(Func):
    5269    arg_types = {"this": True, "expression": False}
    5270    _sql_names = ["ARRAY_SIZE", "ARRAY_LENGTH"]
    5271
    5272
    5273class ArraySort(Func):
    5274    arg_types = {"this": True, "expression": False}
    5275
    5276
    5277class ArraySum(Func):
    5278    arg_types = {"this": True, "expression": False}
    5279
    5280
    5281class ArrayUnionAgg(AggFunc):
    5282    pass
    5283
    5284
    5285class Avg(AggFunc):
    5286    pass
    5287
    5288
    5289class AnyValue(AggFunc):
    5290    pass
    5291
    5292
    5293class Lag(AggFunc):
    5294    arg_types = {"this": True, "offset": False, "default": False}
    5295
    5296
    5297class Lead(AggFunc):
    5298    arg_types = {"this": True, "offset": False, "default": False}
    5299
    5300
    5301# some dialects have a distinction between first and first_value, usually first is an aggregate func
    5302# and first_value is a window func
    5303class First(AggFunc):
    5304    pass
    5305
    5306
    5307class Last(AggFunc):
    5308    pass
    5309
    5310
    5311class FirstValue(AggFunc):
    5312    pass
    5313
    5314
    5315class LastValue(AggFunc):
    5316    pass
    5317
    5318
    5319class NthValue(AggFunc):
    5320    arg_types = {"this": True, "offset": True}
    5321
    5322
    5323class Case(Func):
    5324    arg_types = {"this": False, "ifs": True, "default": False}
    5325
    5326    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5327        instance = maybe_copy(self, copy)
    5328        instance.append(
    5329            "ifs",
    5330            If(
    5331                this=maybe_parse(condition, copy=copy, **opts),
    5332                true=maybe_parse(then, copy=copy, **opts),
    5333            ),
    5334        )
    5335        return instance
    5336
    5337    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5338        instance = maybe_copy(self, copy)
    5339        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5340        return instance
    5341
    5342
    5343class Cast(Func):
    5344    arg_types = {
    5345        "this": True,
    5346        "to": True,
    5347        "format": False,
    5348        "safe": False,
    5349        "action": False,
    5350    }
    5351
    5352    @property
    5353    def name(self) -> str:
    5354        return self.this.name
    5355
    5356    @property
    5357    def to(self) -> DataType:
    5358        return self.args["to"]
    5359
    5360    @property
    5361    def output_name(self) -> str:
    5362        return self.name
    5363
    5364    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5365        """
    5366        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5367        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5368        array<int> != array<float>.
    5369
    5370        Args:
    5371            dtypes: the data types to compare this Cast's DataType to.
    5372
    5373        Returns:
    5374            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5375        """
    5376        return self.to.is_type(*dtypes)
    5377
    5378
    5379class TryCast(Cast):
    5380    pass
    5381
    5382
    5383class Try(Func):
    5384    pass
    5385
    5386
    5387class CastToStrType(Func):
    5388    arg_types = {"this": True, "to": True}
    5389
    5390
    5391class Collate(Binary, Func):
    5392    pass
    5393
    5394
    5395class Ceil(Func):
    5396    arg_types = {"this": True, "decimals": False}
    5397    _sql_names = ["CEIL", "CEILING"]
    5398
    5399
    5400class Coalesce(Func):
    5401    arg_types = {"this": True, "expressions": False, "is_nvl": False}
    5402    is_var_len_args = True
    5403    _sql_names = ["COALESCE", "IFNULL", "NVL"]
    5404
    5405
    5406class Chr(Func):
    5407    arg_types = {"expressions": True, "charset": False}
    5408    is_var_len_args = True
    5409    _sql_names = ["CHR", "CHAR"]
    5410
    5411
    5412class Concat(Func):
    5413    arg_types = {"expressions": True, "safe": False, "coalesce": False}
    5414    is_var_len_args = True
    5415
    5416
    5417class ConcatWs(Concat):
    5418    _sql_names = ["CONCAT_WS"]
    5419
    5420
    5421# https://docs.oracle.com/cd/B13789_01/server.101/b10759/operators004.htm#i1035022
    5422class ConnectByRoot(Func):
    5423    pass
    5424
    5425
    5426class Count(AggFunc):
    5427    arg_types = {"this": False, "expressions": False, "big_int": False}
    5428    is_var_len_args = True
    5429
    5430
    5431class CountIf(AggFunc):
    5432    _sql_names = ["COUNT_IF", "COUNTIF"]
    5433
    5434
    5435# cube root
    5436class Cbrt(Func):
    5437    pass
    5438
    5439
    5440class CurrentDate(Func):
    5441    arg_types = {"this": False}
    5442
    5443
    5444class CurrentDatetime(Func):
    5445    arg_types = {"this": False}
    5446
    5447
    5448class CurrentTime(Func):
    5449    arg_types = {"this": False}
    5450
    5451
    5452class CurrentTimestamp(Func):
    5453    arg_types = {"this": False, "sysdate": False}
    5454
    5455
    5456class CurrentUser(Func):
    5457    arg_types = {"this": False}
    5458
    5459
    5460class DateAdd(Func, IntervalOp):
    5461    arg_types = {"this": True, "expression": True, "unit": False}
    5462
    5463
    5464class DateSub(Func, IntervalOp):
    5465    arg_types = {"this": True, "expression": True, "unit": False}
    5466
    5467
    5468class DateDiff(Func, TimeUnit):
    5469    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    5470    arg_types = {"this": True, "expression": True, "unit": False}
    5471
    5472
    5473class DateTrunc(Func):
    5474    arg_types = {"unit": True, "this": True, "zone": False}
    5475
    5476    def __init__(self, **args):
    5477        unit = args.get("unit")
    5478        if isinstance(unit, TimeUnit.VAR_LIKE):
    5479            args["unit"] = Literal.string(
    5480                (TimeUnit.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5481            )
    5482        elif isinstance(unit, Week):
    5483            unit.set("this", Literal.string(unit.this.name.upper()))
    5484
    5485        super().__init__(**args)
    5486
    5487    @property
    5488    def unit(self) -> Expression:
    5489        return self.args["unit"]
    5490
    5491
    5492# https://cloud.google.com/bigquery/docs/reference/standard-sql/datetime_functions#datetime
    5493# expression can either be time_expr or time_zone
    5494class Datetime(Func):
    5495    arg_types = {"this": True, "expression": False}
    5496
    5497
    5498class DatetimeAdd(Func, IntervalOp):
    5499    arg_types = {"this": True, "expression": True, "unit": False}
    5500
    5501
    5502class DatetimeSub(Func, IntervalOp):
    5503    arg_types = {"this": True, "expression": True, "unit": False}
    5504
    5505
    5506class DatetimeDiff(Func, TimeUnit):
    5507    arg_types = {"this": True, "expression": True, "unit": False}
    5508
    5509
    5510class DatetimeTrunc(Func, TimeUnit):
    5511    arg_types = {"this": True, "unit": True, "zone": False}
    5512
    5513
    5514class DayOfWeek(Func):
    5515    _sql_names = ["DAY_OF_WEEK", "DAYOFWEEK"]
    5516
    5517
    5518# https://duckdb.org/docs/sql/functions/datepart.html#part-specifiers-only-usable-as-date-part-specifiers
    5519# ISO day of week function in duckdb is ISODOW
    5520class DayOfWeekIso(Func):
    5521    _sql_names = ["DAYOFWEEK_ISO", "ISODOW"]
    5522
    5523
    5524class DayOfMonth(Func):
    5525    _sql_names = ["DAY_OF_MONTH", "DAYOFMONTH"]
    5526
    5527
    5528class DayOfYear(Func):
    5529    _sql_names = ["DAY_OF_YEAR", "DAYOFYEAR"]
    5530
    5531
    5532class ToDays(Func):
    5533    pass
    5534
    5535
    5536class WeekOfYear(Func):
    5537    _sql_names = ["WEEK_OF_YEAR", "WEEKOFYEAR"]
    5538
    5539
    5540class MonthsBetween(Func):
    5541    arg_types = {"this": True, "expression": True, "roundoff": False}
    5542
    5543
    5544class LastDay(Func, TimeUnit):
    5545    _sql_names = ["LAST_DAY", "LAST_DAY_OF_MONTH"]
    5546    arg_types = {"this": True, "unit": False}
    5547
    5548
    5549class Extract(Func):
    5550    arg_types = {"this": True, "expression": True}
    5551
    5552
    5553class Timestamp(Func):
    5554    arg_types = {"this": False, "zone": False, "with_tz": False}
    5555
    5556
    5557class TimestampAdd(Func, TimeUnit):
    5558    arg_types = {"this": True, "expression": True, "unit": False}
    5559
    5560
    5561class TimestampSub(Func, TimeUnit):
    5562    arg_types = {"this": True, "expression": True, "unit": False}
    5563
    5564
    5565class TimestampDiff(Func, TimeUnit):
    5566    _sql_names = ["TIMESTAMPDIFF", "TIMESTAMP_DIFF"]
    5567    arg_types = {"this": True, "expression": True, "unit": False}
    5568
    5569
    5570class TimestampTrunc(Func, TimeUnit):
    5571    arg_types = {"this": True, "unit": True, "zone": False}
    5572
    5573
    5574class TimeAdd(Func, TimeUnit):
    5575    arg_types = {"this": True, "expression": True, "unit": False}
    5576
    5577
    5578class TimeSub(Func, TimeUnit):
    5579    arg_types = {"this": True, "expression": True, "unit": False}
    5580
    5581
    5582class TimeDiff(Func, TimeUnit):
    5583    arg_types = {"this": True, "expression": True, "unit": False}
    5584
    5585
    5586class TimeTrunc(Func, TimeUnit):
    5587    arg_types = {"this": True, "unit": True, "zone": False}
    5588
    5589
    5590class DateFromParts(Func):
    5591    _sql_names = ["DATE_FROM_PARTS", "DATEFROMPARTS"]
    5592    arg_types = {"year": True, "month": True, "day": True}
    5593
    5594
    5595class TimeFromParts(Func):
    5596    _sql_names = ["TIME_FROM_PARTS", "TIMEFROMPARTS"]
    5597    arg_types = {
    5598        "hour": True,
    5599        "min": True,
    5600        "sec": True,
    5601        "nano": False,
    5602        "fractions": False,
    5603        "precision": False,
    5604    }
    5605
    5606
    5607class DateStrToDate(Func):
    5608    pass
    5609
    5610
    5611class DateToDateStr(Func):
    5612    pass
    5613
    5614
    5615class DateToDi(Func):
    5616    pass
    5617
    5618
    5619# https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions#date
    5620class Date(Func):
    5621    arg_types = {"this": False, "zone": False, "expressions": False}
    5622    is_var_len_args = True
    5623
    5624
    5625class Day(Func):
    5626    pass
    5627
    5628
    5629class Decode(Func):
    5630    arg_types = {"this": True, "charset": True, "replace": False}
    5631
    5632
    5633class DiToDate(Func):
    5634    pass
    5635
    5636
    5637class Encode(Func):
    5638    arg_types = {"this": True, "charset": True}
    5639
    5640
    5641class Exp(Func):
    5642    pass
    5643
    5644
    5645# https://docs.snowflake.com/en/sql-reference/functions/flatten
    5646class Explode(Func, UDTF):
    5647    arg_types = {"this": True, "expressions": False}
    5648    is_var_len_args = True
    5649
    5650
    5651# https://spark.apache.org/docs/latest/api/sql/#inline
    5652class Inline(Func):
    5653    pass
    5654
    5655
    5656class ExplodeOuter(Explode):
    5657    pass
    5658
    5659
    5660class Posexplode(Explode):
    5661    pass
    5662
    5663
    5664class PosexplodeOuter(Posexplode, ExplodeOuter):
    5665    pass
    5666
    5667
    5668class Unnest(Func, UDTF):
    5669    arg_types = {
    5670        "expressions": True,
    5671        "alias": False,
    5672        "offset": False,
    5673        "explode_array": False,
    5674    }
    5675
    5676    @property
    5677    def selects(self) -> t.List[Expression]:
    5678        columns = super().selects
    5679        offset = self.args.get("offset")
    5680        if offset:
    5681            columns = columns + [to_identifier("offset") if offset is True else offset]
    5682        return columns
    5683
    5684
    5685class Floor(Func):
    5686    arg_types = {"this": True, "decimals": False}
    5687
    5688
    5689class FromBase64(Func):
    5690    pass
    5691
    5692
    5693class ToBase64(Func):
    5694    pass
    5695
    5696
    5697# https://trino.io/docs/current/functions/datetime.html#from_iso8601_timestamp
    5698class FromISO8601Timestamp(Func):
    5699    _sql_names = ["FROM_ISO8601_TIMESTAMP"]
    5700
    5701
    5702class GapFill(Func):
    5703    arg_types = {
    5704        "this": True,
    5705        "ts_column": True,
    5706        "bucket_width": True,
    5707        "partitioning_columns": False,
    5708        "value_columns": False,
    5709        "origin": False,
    5710        "ignore_nulls": False,
    5711    }
    5712
    5713
    5714# https://cloud.google.com/bigquery/docs/reference/standard-sql/array_functions#generate_date_array
    5715class GenerateDateArray(Func):
    5716    arg_types = {"start": True, "end": True, "step": False}
    5717
    5718
    5719# https://cloud.google.com/bigquery/docs/reference/standard-sql/array_functions#generate_timestamp_array
    5720class GenerateTimestampArray(Func):
    5721    arg_types = {"start": True, "end": True, "step": True}
    5722
    5723
    5724class Greatest(Func):
    5725    arg_types = {"this": True, "expressions": False}
    5726    is_var_len_args = True
    5727
    5728
    5729class GroupConcat(AggFunc):
    5730    arg_types = {"this": True, "separator": False}
    5731
    5732
    5733class Hex(Func):
    5734    pass
    5735
    5736
    5737class LowerHex(Hex):
    5738    pass
    5739
    5740
    5741class Xor(Connector, Func):
    5742    arg_types = {"this": False, "expression": False, "expressions": False}
    5743
    5744
    5745class If(Func):
    5746    arg_types = {"this": True, "true": True, "false": False}
    5747    _sql_names = ["IF", "IIF"]
    5748
    5749
    5750class Nullif(Func):
    5751    arg_types = {"this": True, "expression": True}
    5752
    5753
    5754class Initcap(Func):
    5755    arg_types = {"this": True, "expression": False}
    5756
    5757
    5758class IsNan(Func):
    5759    _sql_names = ["IS_NAN", "ISNAN"]
    5760
    5761
    5762class IsInf(Func):
    5763    _sql_names = ["IS_INF", "ISINF"]
    5764
    5765
    5766# https://www.postgresql.org/docs/current/functions-json.html
    5767class JSON(Expression):
    5768    arg_types = {"this": False, "with": False, "unique": False}
    5769
    5770
    5771class JSONPath(Expression):
    5772    arg_types = {"expressions": True, "escape": False}
    5773
    5774    @property
    5775    def output_name(self) -> str:
    5776        last_segment = self.expressions[-1].this
    5777        return last_segment if isinstance(last_segment, str) else ""
    5778
    5779
    5780class JSONPathPart(Expression):
    5781    arg_types = {}
    5782
    5783
    5784class JSONPathFilter(JSONPathPart):
    5785    arg_types = {"this": True}
    5786
    5787
    5788class JSONPathKey(JSONPathPart):
    5789    arg_types = {"this": True}
    5790
    5791
    5792class JSONPathRecursive(JSONPathPart):
    5793    arg_types = {"this": False}
    5794
    5795
    5796class JSONPathRoot(JSONPathPart):
    5797    pass
    5798
    5799
    5800class JSONPathScript(JSONPathPart):
    5801    arg_types = {"this": True}
    5802
    5803
    5804class JSONPathSlice(JSONPathPart):
    5805    arg_types = {"start": False, "end": False, "step": False}
    5806
    5807
    5808class JSONPathSelector(JSONPathPart):
    5809    arg_types = {"this": True}
    5810
    5811
    5812class JSONPathSubscript(JSONPathPart):
    5813    arg_types = {"this": True}
    5814
    5815
    5816class JSONPathUnion(JSONPathPart):
    5817    arg_types = {"expressions": True}
    5818
    5819
    5820class JSONPathWildcard(JSONPathPart):
    5821    pass
    5822
    5823
    5824class FormatJson(Expression):
    5825    pass
    5826
    5827
    5828class JSONKeyValue(Expression):
    5829    arg_types = {"this": True, "expression": True}
    5830
    5831
    5832class JSONObject(Func):
    5833    arg_types = {
    5834        "expressions": False,
    5835        "null_handling": False,
    5836        "unique_keys": False,
    5837        "return_type": False,
    5838        "encoding": False,
    5839    }
    5840
    5841
    5842class JSONObjectAgg(AggFunc):
    5843    arg_types = {
    5844        "expressions": False,
    5845        "null_handling": False,
    5846        "unique_keys": False,
    5847        "return_type": False,
    5848        "encoding": False,
    5849    }
    5850
    5851
    5852# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_ARRAY.html
    5853class JSONArray(Func):
    5854    arg_types = {
    5855        "expressions": True,
    5856        "null_handling": False,
    5857        "return_type": False,
    5858        "strict": False,
    5859    }
    5860
    5861
    5862# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_ARRAYAGG.html
    5863class JSONArrayAgg(Func):
    5864    arg_types = {
    5865        "this": True,
    5866        "order": False,
    5867        "null_handling": False,
    5868        "return_type": False,
    5869        "strict": False,
    5870    }
    5871
    5872
    5873class JSONExists(Func):
    5874    arg_types = {"this": True, "path": True, "passing": False, "on_condition": False}
    5875
    5876
    5877# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_TABLE.html
    5878# Note: parsing of JSON column definitions is currently incomplete.
    5879class JSONColumnDef(Expression):
    5880    arg_types = {"this": False, "kind": False, "path": False, "nested_schema": False}
    5881
    5882
    5883class JSONSchema(Expression):
    5884    arg_types = {"expressions": True}
    5885
    5886
    5887# https://dev.mysql.com/doc/refman/8.4/en/json-search-functions.html#function_json-value
    5888class JSONValue(Expression):
    5889    arg_types = {
    5890        "this": True,
    5891        "path": True,
    5892        "returning": False,
    5893        "on_condition": False,
    5894    }
    5895
    5896
    5897# # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_TABLE.html
    5898class JSONTable(Func):
    5899    arg_types = {
    5900        "this": True,
    5901        "schema": True,
    5902        "path": False,
    5903        "error_handling": False,
    5904        "empty_handling": False,
    5905    }
    5906
    5907
    5908# https://docs.snowflake.com/en/sql-reference/functions/object_insert
    5909class ObjectInsert(Func):
    5910    arg_types = {
    5911        "this": True,
    5912        "key": True,
    5913        "value": True,
    5914        "update_flag": False,
    5915    }
    5916
    5917
    5918class OpenJSONColumnDef(Expression):
    5919    arg_types = {"this": True, "kind": True, "path": False, "as_json": False}
    5920
    5921
    5922class OpenJSON(Func):
    5923    arg_types = {"this": True, "path": False, "expressions": False}
    5924
    5925
    5926class JSONBContains(Binary, Func):
    5927    _sql_names = ["JSONB_CONTAINS"]
    5928
    5929
    5930class JSONExtract(Binary, Func):
    5931    arg_types = {
    5932        "this": True,
    5933        "expression": True,
    5934        "only_json_types": False,
    5935        "expressions": False,
    5936        "variant_extract": False,
    5937        "json_query": False,
    5938        "option": False,
    5939    }
    5940    _sql_names = ["JSON_EXTRACT"]
    5941    is_var_len_args = True
    5942
    5943    @property
    5944    def output_name(self) -> str:
    5945        return self.expression.output_name if not self.expressions else ""
    5946
    5947
    5948class JSONExtractScalar(Binary, Func):
    5949    arg_types = {"this": True, "expression": True, "only_json_types": False, "expressions": False}
    5950    _sql_names = ["JSON_EXTRACT_SCALAR"]
    5951    is_var_len_args = True
    5952
    5953    @property
    5954    def output_name(self) -> str:
    5955        return self.expression.output_name
    5956
    5957
    5958class JSONBExtract(Binary, Func):
    5959    _sql_names = ["JSONB_EXTRACT"]
    5960
    5961
    5962class JSONBExtractScalar(Binary, Func):
    5963    _sql_names = ["JSONB_EXTRACT_SCALAR"]
    5964
    5965
    5966class JSONFormat(Func):
    5967    arg_types = {"this": False, "options": False}
    5968    _sql_names = ["JSON_FORMAT"]
    5969
    5970
    5971# https://dev.mysql.com/doc/refman/8.0/en/json-search-functions.html#operator_member-of
    5972class JSONArrayContains(Binary, Predicate, Func):
    5973    _sql_names = ["JSON_ARRAY_CONTAINS"]
    5974
    5975
    5976class ParseJSON(Func):
    5977    # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
    5978    # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
    5979    _sql_names = ["PARSE_JSON", "JSON_PARSE"]
    5980    arg_types = {"this": True, "expression": False, "safe": False}
    5981
    5982
    5983class Least(Func):
    5984    arg_types = {"this": True, "expressions": False}
    5985    is_var_len_args = True
    5986
    5987
    5988class Left(Func):
    5989    arg_types = {"this": True, "expression": True}
    5990
    5991
    5992class Right(Func):
    5993    arg_types = {"this": True, "expression": True}
    5994
    5995
    5996class Length(Func):
    5997    arg_types = {"this": True, "binary": False}
    5998    _sql_names = ["LENGTH", "LEN"]
    5999
    6000
    6001class Levenshtein(Func):
    6002    arg_types = {
    6003        "this": True,
    6004        "expression": False,
    6005        "ins_cost": False,
    6006        "del_cost": False,
    6007        "sub_cost": False,
    6008    }
    6009
    6010
    6011class Ln(Func):
    6012    pass
    6013
    6014
    6015class Log(Func):
    6016    arg_types = {"this": True, "expression": False}
    6017
    6018
    6019class LogicalOr(AggFunc):
    6020    _sql_names = ["LOGICAL_OR", "BOOL_OR", "BOOLOR_AGG"]
    6021
    6022
    6023class LogicalAnd(AggFunc):
    6024    _sql_names = ["LOGICAL_AND", "BOOL_AND", "BOOLAND_AGG"]
    6025
    6026
    6027class Lower(Func):
    6028    _sql_names = ["LOWER", "LCASE"]
    6029
    6030
    6031class Map(Func):
    6032    arg_types = {"keys": False, "values": False}
    6033
    6034    @property
    6035    def keys(self) -> t.List[Expression]:
    6036        keys = self.args.get("keys")
    6037        return keys.expressions if keys else []
    6038
    6039    @property
    6040    def values(self) -> t.List[Expression]:
    6041        values = self.args.get("values")
    6042        return values.expressions if values else []
    6043
    6044
    6045# Represents the MAP {...} syntax in DuckDB - basically convert a struct to a MAP
    6046class ToMap(Func):
    6047    pass
    6048
    6049
    6050class MapFromEntries(Func):
    6051    pass
    6052
    6053
    6054# https://learn.microsoft.com/en-us/sql/t-sql/language-elements/scope-resolution-operator-transact-sql?view=sql-server-ver16
    6055class ScopeResolution(Expression):
    6056    arg_types = {"this": False, "expression": True}
    6057
    6058
    6059class Stream(Expression):
    6060    pass
    6061
    6062
    6063class StarMap(Func):
    6064    pass
    6065
    6066
    6067class VarMap(Func):
    6068    arg_types = {"keys": True, "values": True}
    6069    is_var_len_args = True
    6070
    6071    @property
    6072    def keys(self) -> t.List[Expression]:
    6073        return self.args["keys"].expressions
    6074
    6075    @property
    6076    def values(self) -> t.List[Expression]:
    6077        return self.args["values"].expressions
    6078
    6079
    6080# https://dev.mysql.com/doc/refman/8.0/en/fulltext-search.html
    6081class MatchAgainst(Func):
    6082    arg_types = {"this": True, "expressions": True, "modifier": False}
    6083
    6084
    6085class Max(AggFunc):
    6086    arg_types = {"this": True, "expressions": False}
    6087    is_var_len_args = True
    6088
    6089
    6090class MD5(Func):
    6091    _sql_names = ["MD5"]
    6092
    6093
    6094# Represents the variant of the MD5 function that returns a binary value
    6095class MD5Digest(Func):
    6096    _sql_names = ["MD5_DIGEST"]
    6097
    6098
    6099class Min(AggFunc):
    6100    arg_types = {"this": True, "expressions": False}
    6101    is_var_len_args = True
    6102
    6103
    6104class Month(Func):
    6105    pass
    6106
    6107
    6108class AddMonths(Func):
    6109    arg_types = {"this": True, "expression": True}
    6110
    6111
    6112class Nvl2(Func):
    6113    arg_types = {"this": True, "true": True, "false": False}
    6114
    6115
    6116class Normalize(Func):
    6117    arg_types = {"this": True, "form": False}
    6118
    6119
    6120class Overlay(Func):
    6121    arg_types = {"this": True, "expression": True, "from": True, "for": False}
    6122
    6123
    6124# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-predict#mlpredict_function
    6125class Predict(Func):
    6126    arg_types = {"this": True, "expression": True, "params_struct": False}
    6127
    6128
    6129class Pow(Binary, Func):
    6130    _sql_names = ["POWER", "POW"]
    6131
    6132
    6133class PercentileCont(AggFunc):
    6134    arg_types = {"this": True, "expression": False}
    6135
    6136
    6137class PercentileDisc(AggFunc):
    6138    arg_types = {"this": True, "expression": False}
    6139
    6140
    6141class Quantile(AggFunc):
    6142    arg_types = {"this": True, "quantile": True}
    6143
    6144
    6145class ApproxQuantile(Quantile):
    6146    arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}
    6147
    6148
    6149class Quarter(Func):
    6150    pass
    6151
    6152
    6153# https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Functions-Expressions-and-Predicates/Arithmetic-Trigonometric-Hyperbolic-Operators/Functions/RANDOM/RANDOM-Function-Syntax
    6154# teradata lower and upper bounds
    6155class Rand(Func):
    6156    _sql_names = ["RAND", "RANDOM"]
    6157    arg_types = {"this": False, "lower": False, "upper": False}
    6158
    6159
    6160class Randn(Func):
    6161    arg_types = {"this": False}
    6162
    6163
    6164class RangeN(Func):
    6165    arg_types = {"this": True, "expressions": True, "each": False}
    6166
    6167
    6168class ReadCSV(Func):
    6169    _sql_names = ["READ_CSV"]
    6170    is_var_len_args = True
    6171    arg_types = {"this": True, "expressions": False}
    6172
    6173
    6174class Reduce(Func):
    6175    arg_types = {"this": True, "initial": True, "merge": True, "finish": False}
    6176
    6177
    6178class RegexpExtract(Func):
    6179    arg_types = {
    6180        "this": True,
    6181        "expression": True,
    6182        "position": False,
    6183        "occurrence": False,
    6184        "parameters": False,
    6185        "group": False,
    6186    }
    6187
    6188
    6189class RegexpReplace(Func):
    6190    arg_types = {
    6191        "this": True,
    6192        "expression": True,
    6193        "replacement": False,
    6194        "position": False,
    6195        "occurrence": False,
    6196        "modifiers": False,
    6197    }
    6198
    6199
    6200class RegexpLike(Binary, Func):
    6201    arg_types = {"this": True, "expression": True, "flag": False}
    6202
    6203
    6204class RegexpILike(Binary, Func):
    6205    arg_types = {"this": True, "expression": True, "flag": False}
    6206
    6207
    6208# https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.split.html
    6209# limit is the number of times a pattern is applied
    6210class RegexpSplit(Func):
    6211    arg_types = {"this": True, "expression": True, "limit": False}
    6212
    6213
    6214class Repeat(Func):
    6215    arg_types = {"this": True, "times": True}
    6216
    6217
    6218# https://learn.microsoft.com/en-us/sql/t-sql/functions/round-transact-sql?view=sql-server-ver16
    6219# tsql third argument function == trunctaion if not 0
    6220class Round(Func):
    6221    arg_types = {"this": True, "decimals": False, "truncate": False}
    6222
    6223
    6224class RowNumber(Func):
    6225    arg_types: t.Dict[str, t.Any] = {}
    6226
    6227
    6228class SafeDivide(Func):
    6229    arg_types = {"this": True, "expression": True}
    6230
    6231
    6232class SHA(Func):
    6233    _sql_names = ["SHA", "SHA1"]
    6234
    6235
    6236class SHA2(Func):
    6237    _sql_names = ["SHA2"]
    6238    arg_types = {"this": True, "length": False}
    6239
    6240
    6241class Sign(Func):
    6242    _sql_names = ["SIGN", "SIGNUM"]
    6243
    6244
    6245class SortArray(Func):
    6246    arg_types = {"this": True, "asc": False}
    6247
    6248
    6249class Split(Func):
    6250    arg_types = {"this": True, "expression": True, "limit": False}
    6251
    6252
    6253# https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.split_part.html
    6254class SplitPart(Func):
    6255    arg_types = {"this": True, "delimiter": True, "part_index": True}
    6256
    6257
    6258# Start may be omitted in the case of postgres
    6259# https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
    6260class Substring(Func):
    6261    _sql_names = ["SUBSTRING", "SUBSTR"]
    6262    arg_types = {"this": True, "start": False, "length": False}
    6263
    6264
    6265class StandardHash(Func):
    6266    arg_types = {"this": True, "expression": False}
    6267
    6268
    6269class StartsWith(Func):
    6270    _sql_names = ["STARTS_WITH", "STARTSWITH"]
    6271    arg_types = {"this": True, "expression": True}
    6272
    6273
    6274class StrPosition(Func):
    6275    arg_types = {
    6276        "this": True,
    6277        "substr": True,
    6278        "position": False,
    6279        "instance": False,
    6280    }
    6281
    6282
    6283class StrToDate(Func):
    6284    arg_types = {"this": True, "format": False, "safe": False}
    6285
    6286
    6287class StrToTime(Func):
    6288    arg_types = {"this": True, "format": True, "zone": False, "safe": False}
    6289
    6290
    6291# Spark allows unix_timestamp()
    6292# https://spark.apache.org/docs/3.1.3/api/python/reference/api/pyspark.sql.functions.unix_timestamp.html
    6293class StrToUnix(Func):
    6294    arg_types = {"this": False, "format": False}
    6295
    6296
    6297# https://prestodb.io/docs/current/functions/string.html
    6298# https://spark.apache.org/docs/latest/api/sql/index.html#str_to_map
    6299class StrToMap(Func):
    6300    arg_types = {
    6301        "this": True,
    6302        "pair_delim": False,
    6303        "key_value_delim": False,
    6304        "duplicate_resolution_callback": False,
    6305    }
    6306
    6307
    6308class NumberToStr(Func):
    6309    arg_types = {"this": True, "format": True, "culture": False}
    6310
    6311
    6312class FromBase(Func):
    6313    arg_types = {"this": True, "expression": True}
    6314
    6315
    6316class Struct(Func):
    6317    arg_types = {"expressions": False}
    6318    is_var_len_args = True
    6319
    6320
    6321class StructExtract(Func):
    6322    arg_types = {"this": True, "expression": True}
    6323
    6324
    6325# https://learn.microsoft.com/en-us/sql/t-sql/functions/stuff-transact-sql?view=sql-server-ver16
    6326# https://docs.snowflake.com/en/sql-reference/functions/insert
    6327class Stuff(Func):
    6328    _sql_names = ["STUFF", "INSERT"]
    6329    arg_types = {"this": True, "start": True, "length": True, "expression": True}
    6330
    6331
    6332class Sum(AggFunc):
    6333    pass
    6334
    6335
    6336class Sqrt(Func):
    6337    pass
    6338
    6339
    6340class Stddev(AggFunc):
    6341    _sql_names = ["STDDEV", "STDEV"]
    6342
    6343
    6344class StddevPop(AggFunc):
    6345    pass
    6346
    6347
    6348class StddevSamp(AggFunc):
    6349    pass
    6350
    6351
    6352# https://cloud.google.com/bigquery/docs/reference/standard-sql/time_functions#time
    6353class Time(Func):
    6354    arg_types = {"this": False, "zone": False}
    6355
    6356
    6357class TimeToStr(Func):
    6358    arg_types = {"this": True, "format": True, "culture": False, "zone": False}
    6359
    6360
    6361class TimeToTimeStr(Func):
    6362    pass
    6363
    6364
    6365class TimeToUnix(Func):
    6366    pass
    6367
    6368
    6369class TimeStrToDate(Func):
    6370    pass
    6371
    6372
    6373class TimeStrToTime(Func):
    6374    arg_types = {"this": True, "zone": False}
    6375
    6376
    6377class TimeStrToUnix(Func):
    6378    pass
    6379
    6380
    6381class Trim(Func):
    6382    arg_types = {
    6383        "this": True,
    6384        "expression": False,
    6385        "position": False,
    6386        "collation": False,
    6387    }
    6388
    6389
    6390class TsOrDsAdd(Func, TimeUnit):
    6391    # return_type is used to correctly cast the arguments of this expression when transpiling it
    6392    arg_types = {"this": True, "expression": True, "unit": False, "return_type": False}
    6393
    6394    @property
    6395    def return_type(self) -> DataType:
    6396        return DataType.build(self.args.get("return_type") or DataType.Type.DATE)
    6397
    6398
    6399class TsOrDsDiff(Func, TimeUnit):
    6400    arg_types = {"this": True, "expression": True, "unit": False}
    6401
    6402
    6403class TsOrDsToDateStr(Func):
    6404    pass
    6405
    6406
    6407class TsOrDsToDate(Func):
    6408    arg_types = {"this": True, "format": False, "safe": False}
    6409
    6410
    6411class TsOrDsToTime(Func):
    6412    pass
    6413
    6414
    6415class TsOrDsToTimestamp(Func):
    6416    pass
    6417
    6418
    6419class TsOrDiToDi(Func):
    6420    pass
    6421
    6422
    6423class Unhex(Func):
    6424    pass
    6425
    6426
    6427# https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions#unix_date
    6428class UnixDate(Func):
    6429    pass
    6430
    6431
    6432class UnixToStr(Func):
    6433    arg_types = {"this": True, "format": False}
    6434
    6435
    6436# https://prestodb.io/docs/current/functions/datetime.html
    6437# presto has weird zone/hours/minutes
    6438class UnixToTime(Func):
    6439    arg_types = {
    6440        "this": True,
    6441        "scale": False,
    6442        "zone": False,
    6443        "hours": False,
    6444        "minutes": False,
    6445        "format": False,
    6446    }
    6447
    6448    SECONDS = Literal.number(0)
    6449    DECIS = Literal.number(1)
    6450    CENTIS = Literal.number(2)
    6451    MILLIS = Literal.number(3)
    6452    DECIMILLIS = Literal.number(4)
    6453    CENTIMILLIS = Literal.number(5)
    6454    MICROS = Literal.number(6)
    6455    DECIMICROS = Literal.number(7)
    6456    CENTIMICROS = Literal.number(8)
    6457    NANOS = Literal.number(9)
    6458
    6459
    6460class UnixToTimeStr(Func):
    6461    pass
    6462
    6463
    6464class Uuid(Func):
    6465    _sql_names = ["UUID", "GEN_RANDOM_UUID", "GENERATE_UUID", "UUID_STRING"]
    6466
    6467    arg_types = {"this": False, "name": False}
    6468
    6469
    6470class TimestampFromParts(Func):
    6471    _sql_names = ["TIMESTAMP_FROM_PARTS", "TIMESTAMPFROMPARTS"]
    6472    arg_types = {
    6473        "year": True,
    6474        "month": True,
    6475        "day": True,
    6476        "hour": True,
    6477        "min": True,
    6478        "sec": True,
    6479        "nano": False,
    6480        "zone": False,
    6481        "milli": False,
    6482    }
    6483
    6484
    6485class Upper(Func):
    6486    _sql_names = ["UPPER", "UCASE"]
    6487
    6488
    6489class Corr(Binary, AggFunc):
    6490    pass
    6491
    6492
    6493class Variance(AggFunc):
    6494    _sql_names = ["VARIANCE", "VARIANCE_SAMP", "VAR_SAMP"]
    6495
    6496
    6497class VariancePop(AggFunc):
    6498    _sql_names = ["VARIANCE_POP", "VAR_POP"]
    6499
    6500
    6501class CovarSamp(Binary, AggFunc):
    6502    pass
    6503
    6504
    6505class CovarPop(Binary, AggFunc):
    6506    pass
    6507
    6508
    6509class Week(Func):
    6510    arg_types = {"this": True, "mode": False}
    6511
    6512
    6513class XMLTable(Func):
    6514    arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}
    6515
    6516
    6517class Year(Func):
    6518    pass
    6519
    6520
    6521class Use(Expression):
    6522    arg_types = {"this": True, "kind": False}
    6523
    6524
    6525class Merge(DML):
    6526    arg_types = {
    6527        "this": True,
    6528        "using": True,
    6529        "on": True,
    6530        "expressions": True,
    6531        "with": False,
    6532        "returning": False,
    6533    }
    6534
    6535
    6536class When(Func):
    6537    arg_types = {"matched": True, "source": False, "condition": False, "then": True}
    6538
    6539
    6540# https://docs.oracle.com/javadb/10.8.3.0/ref/rrefsqljnextvaluefor.html
    6541# https://learn.microsoft.com/en-us/sql/t-sql/functions/next-value-for-transact-sql?view=sql-server-ver16
    6542class NextValueFor(Func):
    6543    arg_types = {"this": True, "order": False}
    6544
    6545
    6546# Refers to a trailing semi-colon. This is only used to preserve trailing comments
    6547# select 1; -- my comment
    6548class Semicolon(Expression):
    6549    arg_types = {}
    6550
    6551
    6552def _norm_arg(arg):
    6553    return arg.lower() if type(arg) is str else arg
    6554
    6555
    6556ALL_FUNCTIONS = subclasses(__name__, Func, (AggFunc, Anonymous, Func))
    6557FUNCTION_BY_NAME = {name: func for func in ALL_FUNCTIONS for name in func.sql_names()}
    6558
    6559JSON_PATH_PARTS = subclasses(__name__, JSONPathPart, (JSONPathPart,))
    6560
    6561PERCENTILES = (PercentileCont, PercentileDisc)
    6562
    6563
    6564# Helpers
    6565@t.overload
    6566def maybe_parse(
    6567    sql_or_expression: ExpOrStr,
    6568    *,
    6569    into: t.Type[E],
    6570    dialect: DialectType = None,
    6571    prefix: t.Optional[str] = None,
    6572    copy: bool = False,
    6573    **opts,
    6574) -> E: ...
    6575
    6576
    6577@t.overload
    6578def maybe_parse(
    6579    sql_or_expression: str | E,
    6580    *,
    6581    into: t.Optional[IntoType] = None,
    6582    dialect: DialectType = None,
    6583    prefix: t.Optional[str] = None,
    6584    copy: bool = False,
    6585    **opts,
    6586) -> E: ...
    6587
    6588
    6589def maybe_parse(
    6590    sql_or_expression: ExpOrStr,
    6591    *,
    6592    into: t.Optional[IntoType] = None,
    6593    dialect: DialectType = None,
    6594    prefix: t.Optional[str] = None,
    6595    copy: bool = False,
    6596    **opts,
    6597) -> Expression:
    6598    """Gracefully handle a possible string or expression.
    6599
    6600    Example:
    6601        >>> maybe_parse("1")
    6602        Literal(this=1, is_string=False)
    6603        >>> maybe_parse(to_identifier("x"))
    6604        Identifier(this=x, quoted=False)
    6605
    6606    Args:
    6607        sql_or_expression: the SQL code string or an expression
    6608        into: the SQLGlot Expression to parse into
    6609        dialect: the dialect used to parse the input expressions (in the case that an
    6610            input expression is a SQL string).
    6611        prefix: a string to prefix the sql with before it gets parsed
    6612            (automatically includes a space)
    6613        copy: whether to copy the expression.
    6614        **opts: other options to use to parse the input expressions (again, in the case
    6615            that an input expression is a SQL string).
    6616
    6617    Returns:
    6618        Expression: the parsed or given expression.
    6619    """
    6620    if isinstance(sql_or_expression, Expression):
    6621        if copy:
    6622            return sql_or_expression.copy()
    6623        return sql_or_expression
    6624
    6625    if sql_or_expression is None:
    6626        raise ParseError("SQL cannot be None")
    6627
    6628    import sqlglot
    6629
    6630    sql = str(sql_or_expression)
    6631    if prefix:
    6632        sql = f"{prefix} {sql}"
    6633
    6634    return sqlglot.parse_one(sql, read=dialect, into=into, **opts)
    6635
    6636
    6637@t.overload
    6638def maybe_copy(instance: None, copy: bool = True) -> None: ...
    6639
    6640
    6641@t.overload
    6642def maybe_copy(instance: E, copy: bool = True) -> E: ...
    6643
    6644
    6645def maybe_copy(instance, copy=True):
    6646    return instance.copy() if copy and instance else instance
    6647
    6648
    6649def _to_s(node: t.Any, verbose: bool = False, level: int = 0) -> str:
    6650    """Generate a textual representation of an Expression tree"""
    6651    indent = "\n" + ("  " * (level + 1))
    6652    delim = f",{indent}"
    6653
    6654    if isinstance(node, Expression):
    6655        args = {k: v for k, v in node.args.items() if (v is not None and v != []) or verbose}
    6656
    6657        if (node.type or verbose) and not isinstance(node, DataType):
    6658            args["_type"] = node.type
    6659        if node.comments or verbose:
    6660            args["_comments"] = node.comments
    6661
    6662        if verbose:
    6663            args["_id"] = id(node)
    6664
    6665        # Inline leaves for a more compact representation
    6666        if node.is_leaf():
    6667            indent = ""
    6668            delim = ", "
    6669
    6670        items = delim.join([f"{k}={_to_s(v, verbose, level + 1)}" for k, v in args.items()])
    6671        return f"{node.__class__.__name__}({indent}{items})"
    6672
    6673    if isinstance(node, list):
    6674        items = delim.join(_to_s(i, verbose, level + 1) for i in node)
    6675        items = f"{indent}{items}" if items else ""
    6676        return f"[{items}]"
    6677
    6678    # Indent multiline strings to match the current level
    6679    return indent.join(textwrap.dedent(str(node).strip("\n")).splitlines())
    6680
    6681
    6682def _is_wrong_expression(expression, into):
    6683    return isinstance(expression, Expression) and not isinstance(expression, into)
    6684
    6685
    6686def _apply_builder(
    6687    expression,
    6688    instance,
    6689    arg,
    6690    copy=True,
    6691    prefix=None,
    6692    into=None,
    6693    dialect=None,
    6694    into_arg="this",
    6695    **opts,
    6696):
    6697    if _is_wrong_expression(expression, into):
    6698        expression = into(**{into_arg: expression})
    6699    instance = maybe_copy(instance, copy)
    6700    expression = maybe_parse(
    6701        sql_or_expression=expression,
    6702        prefix=prefix,
    6703        into=into,
    6704        dialect=dialect,
    6705        **opts,
    6706    )
    6707    instance.set(arg, expression)
    6708    return instance
    6709
    6710
    6711def _apply_child_list_builder(
    6712    *expressions,
    6713    instance,
    6714    arg,
    6715    append=True,
    6716    copy=True,
    6717    prefix=None,
    6718    into=None,
    6719    dialect=None,
    6720    properties=None,
    6721    **opts,
    6722):
    6723    instance = maybe_copy(instance, copy)
    6724    parsed = []
    6725    properties = {} if properties is None else properties
    6726
    6727    for expression in expressions:
    6728        if expression is not None:
    6729            if _is_wrong_expression(expression, into):
    6730                expression = into(expressions=[expression])
    6731
    6732            expression = maybe_parse(
    6733                expression,
    6734                into=into,
    6735                dialect=dialect,
    6736                prefix=prefix,
    6737                **opts,
    6738            )
    6739            for k, v in expression.args.items():
    6740                if k == "expressions":
    6741                    parsed.extend(v)
    6742                else:
    6743                    properties[k] = v
    6744
    6745    existing = instance.args.get(arg)
    6746    if append and existing:
    6747        parsed = existing.expressions + parsed
    6748
    6749    child = into(expressions=parsed)
    6750    for k, v in properties.items():
    6751        child.set(k, v)
    6752    instance.set(arg, child)
    6753
    6754    return instance
    6755
    6756
    6757def _apply_list_builder(
    6758    *expressions,
    6759    instance,
    6760    arg,
    6761    append=True,
    6762    copy=True,
    6763    prefix=None,
    6764    into=None,
    6765    dialect=None,
    6766    **opts,
    6767):
    6768    inst = maybe_copy(instance, copy)
    6769
    6770    expressions = [
    6771        maybe_parse(
    6772            sql_or_expression=expression,
    6773            into=into,
    6774            prefix=prefix,
    6775            dialect=dialect,
    6776            **opts,
    6777        )
    6778        for expression in expressions
    6779        if expression is not None
    6780    ]
    6781
    6782    existing_expressions = inst.args.get(arg)
    6783    if append and existing_expressions:
    6784        expressions = existing_expressions + expressions
    6785
    6786    inst.set(arg, expressions)
    6787    return inst
    6788
    6789
    6790def _apply_conjunction_builder(
    6791    *expressions,
    6792    instance,
    6793    arg,
    6794    into=None,
    6795    append=True,
    6796    copy=True,
    6797    dialect=None,
    6798    **opts,
    6799):
    6800    expressions = [exp for exp in expressions if exp is not None and exp != ""]
    6801    if not expressions:
    6802        return instance
    6803
    6804    inst = maybe_copy(instance, copy)
    6805
    6806    existing = inst.args.get(arg)
    6807    if append and existing is not None:
    6808        expressions = [existing.this if into else existing] + list(expressions)
    6809
    6810    node = and_(*expressions, dialect=dialect, copy=copy, **opts)
    6811
    6812    inst.set(arg, into(this=node) if into else node)
    6813    return inst
    6814
    6815
    6816def _apply_cte_builder(
    6817    instance: E,
    6818    alias: ExpOrStr,
    6819    as_: ExpOrStr,
    6820    recursive: t.Optional[bool] = None,
    6821    materialized: t.Optional[bool] = None,
    6822    append: bool = True,
    6823    dialect: DialectType = None,
    6824    copy: bool = True,
    6825    **opts,
    6826) -> E:
    6827    alias_expression = maybe_parse(alias, dialect=dialect, into=TableAlias, **opts)
    6828    as_expression = maybe_parse(as_, dialect=dialect, **opts)
    6829    cte = CTE(this=as_expression, alias=alias_expression, materialized=materialized)
    6830    return _apply_child_list_builder(
    6831        cte,
    6832        instance=instance,
    6833        arg="with",
    6834        append=append,
    6835        copy=copy,
    6836        into=With,
    6837        properties={"recursive": recursive or False},
    6838    )
    6839
    6840
    6841def _combine(
    6842    expressions: t.Sequence[t.Optional[ExpOrStr]],
    6843    operator: t.Type[Connector],
    6844    dialect: DialectType = None,
    6845    copy: bool = True,
    6846    **opts,
    6847) -> Expression:
    6848    conditions = [
    6849        condition(expression, dialect=dialect, copy=copy, **opts)
    6850        for expression in expressions
    6851        if expression is not None
    6852    ]
    6853
    6854    this, *rest = conditions
    6855    if rest:
    6856        this = _wrap(this, Connector)
    6857    for expression in rest:
    6858        this = operator(this=this, expression=_wrap(expression, Connector))
    6859
    6860    return this
    6861
    6862
    6863def _wrap(expression: E, kind: t.Type[Expression]) -> E | Paren:
    6864    return Paren(this=expression) if isinstance(expression, kind) else expression
    6865
    6866
    6867def _apply_set_operation(
    6868    *expressions: ExpOrStr,
    6869    set_operation: t.Type[S],
    6870    distinct: bool = True,
    6871    dialect: DialectType = None,
    6872    copy: bool = True,
    6873    **opts,
    6874) -> S:
    6875    return reduce(
    6876        lambda x, y: set_operation(this=x, expression=y, distinct=distinct),
    6877        (maybe_parse(e, dialect=dialect, copy=copy, **opts) for e in expressions),
    6878    )
    6879
    6880
    6881def union(
    6882    *expressions: ExpOrStr,
    6883    distinct: bool = True,
    6884    dialect: DialectType = None,
    6885    copy: bool = True,
    6886    **opts,
    6887) -> Union:
    6888    """
    6889    Initializes a syntax tree for the `UNION` operation.
    6890
    6891    Example:
    6892        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6893        'SELECT * FROM foo UNION SELECT * FROM bla'
    6894
    6895    Args:
    6896        expressions: the SQL code strings, corresponding to the `UNION`'s operands.
    6897            If `Expression` instances are passed, they will be used as-is.
    6898        distinct: set the DISTINCT flag if and only if this is true.
    6899        dialect: the dialect used to parse the input expression.
    6900        copy: whether to copy the expression.
    6901        opts: other options to use to parse the input expressions.
    6902
    6903    Returns:
    6904        The new Union instance.
    6905    """
    6906    assert len(expressions) >= 2, "At least two expressions are required by `union`."
    6907    return _apply_set_operation(
    6908        *expressions, set_operation=Union, distinct=distinct, dialect=dialect, copy=copy, **opts
    6909    )
    6910
    6911
    6912def intersect(
    6913    *expressions: ExpOrStr,
    6914    distinct: bool = True,
    6915    dialect: DialectType = None,
    6916    copy: bool = True,
    6917    **opts,
    6918) -> Intersect:
    6919    """
    6920    Initializes a syntax tree for the `INTERSECT` operation.
    6921
    6922    Example:
    6923        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6924        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    6925
    6926    Args:
    6927        expressions: the SQL code strings, corresponding to the `INTERSECT`'s operands.
    6928            If `Expression` instances are passed, they will be used as-is.
    6929        distinct: set the DISTINCT flag if and only if this is true.
    6930        dialect: the dialect used to parse the input expression.
    6931        copy: whether to copy the expression.
    6932        opts: other options to use to parse the input expressions.
    6933
    6934    Returns:
    6935        The new Intersect instance.
    6936    """
    6937    assert len(expressions) >= 2, "At least two expressions are required by `intersect`."
    6938    return _apply_set_operation(
    6939        *expressions, set_operation=Intersect, distinct=distinct, dialect=dialect, copy=copy, **opts
    6940    )
    6941
    6942
    6943def except_(
    6944    *expressions: ExpOrStr,
    6945    distinct: bool = True,
    6946    dialect: DialectType = None,
    6947    copy: bool = True,
    6948    **opts,
    6949) -> Except:
    6950    """
    6951    Initializes a syntax tree for the `EXCEPT` operation.
    6952
    6953    Example:
    6954        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6955        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    6956
    6957    Args:
    6958        expressions: the SQL code strings, corresponding to the `EXCEPT`'s operands.
    6959            If `Expression` instances are passed, they will be used as-is.
    6960        distinct: set the DISTINCT flag if and only if this is true.
    6961        dialect: the dialect used to parse the input expression.
    6962        copy: whether to copy the expression.
    6963        opts: other options to use to parse the input expressions.
    6964
    6965    Returns:
    6966        The new Except instance.
    6967    """
    6968    assert len(expressions) >= 2, "At least two expressions are required by `except_`."
    6969    return _apply_set_operation(
    6970        *expressions, set_operation=Except, distinct=distinct, dialect=dialect, copy=copy, **opts
    6971    )
    6972
    6973
    6974def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    6975    """
    6976    Initializes a syntax tree from one or multiple SELECT expressions.
    6977
    6978    Example:
    6979        >>> select("col1", "col2").from_("tbl").sql()
    6980        'SELECT col1, col2 FROM tbl'
    6981
    6982    Args:
    6983        *expressions: the SQL code string to parse as the expressions of a
    6984            SELECT statement. If an Expression instance is passed, this is used as-is.
    6985        dialect: the dialect used to parse the input expressions (in the case that an
    6986            input expression is a SQL string).
    6987        **opts: other options to use to parse the input expressions (again, in the case
    6988            that an input expression is a SQL string).
    6989
    6990    Returns:
    6991        Select: the syntax tree for the SELECT statement.
    6992    """
    6993    return Select().select(*expressions, dialect=dialect, **opts)
    6994
    6995
    6996def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    6997    """
    6998    Initializes a syntax tree from a FROM expression.
    6999
    7000    Example:
    7001        >>> from_("tbl").select("col1", "col2").sql()
    7002        'SELECT col1, col2 FROM tbl'
    7003
    7004    Args:
    7005        *expression: the SQL code string to parse as the FROM expressions of a
    7006            SELECT statement. If an Expression instance is passed, this is used as-is.
    7007        dialect: the dialect used to parse the input expression (in the case that the
    7008            input expression is a SQL string).
    7009        **opts: other options to use to parse the input expressions (again, in the case
    7010            that the input expression is a SQL string).
    7011
    7012    Returns:
    7013        Select: the syntax tree for the SELECT statement.
    7014    """
    7015    return Select().from_(expression, dialect=dialect, **opts)
    7016
    7017
    7018def update(
    7019    table: str | Table,
    7020    properties: t.Optional[dict] = None,
    7021    where: t.Optional[ExpOrStr] = None,
    7022    from_: t.Optional[ExpOrStr] = None,
    7023    with_: t.Optional[t.Dict[str, ExpOrStr]] = None,
    7024    dialect: DialectType = None,
    7025    **opts,
    7026) -> Update:
    7027    """
    7028    Creates an update statement.
    7029
    7030    Example:
    7031        >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz_cte", where="baz_cte.id > 1 and my_table.id = baz_cte.id", with_={"baz_cte": "SELECT id FROM foo"}).sql()
    7032        "WITH baz_cte AS (SELECT id FROM foo) UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz_cte WHERE baz_cte.id > 1 AND my_table.id = baz_cte.id"
    7033
    7034    Args:
    7035        properties: dictionary of properties to SET which are
    7036            auto converted to sql objects eg None -> NULL
    7037        where: sql conditional parsed into a WHERE statement
    7038        from_: sql statement parsed into a FROM statement
    7039        with_: dictionary of CTE aliases / select statements to include in a WITH clause.
    7040        dialect: the dialect used to parse the input expressions.
    7041        **opts: other options to use to parse the input expressions.
    7042
    7043    Returns:
    7044        Update: the syntax tree for the UPDATE statement.
    7045    """
    7046    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    7047    if properties:
    7048        update_expr.set(
    7049            "expressions",
    7050            [
    7051                EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    7052                for k, v in properties.items()
    7053            ],
    7054        )
    7055    if from_:
    7056        update_expr.set(
    7057            "from",
    7058            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    7059        )
    7060    if isinstance(where, Condition):
    7061        where = Where(this=where)
    7062    if where:
    7063        update_expr.set(
    7064            "where",
    7065            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    7066        )
    7067    if with_:
    7068        cte_list = [
    7069            alias_(CTE(this=maybe_parse(qry, dialect=dialect, **opts)), alias, table=True)
    7070            for alias, qry in with_.items()
    7071        ]
    7072        update_expr.set(
    7073            "with",
    7074            With(expressions=cte_list),
    7075        )
    7076    return update_expr
    7077
    7078
    7079def delete(
    7080    table: ExpOrStr,
    7081    where: t.Optional[ExpOrStr] = None,
    7082    returning: t.Optional[ExpOrStr] = None,
    7083    dialect: DialectType = None,
    7084    **opts,
    7085) -> Delete:
    7086    """
    7087    Builds a delete statement.
    7088
    7089    Example:
    7090        >>> delete("my_table", where="id > 1").sql()
    7091        'DELETE FROM my_table WHERE id > 1'
    7092
    7093    Args:
    7094        where: sql conditional parsed into a WHERE statement
    7095        returning: sql conditional parsed into a RETURNING statement
    7096        dialect: the dialect used to parse the input expressions.
    7097        **opts: other options to use to parse the input expressions.
    7098
    7099    Returns:
    7100        Delete: the syntax tree for the DELETE statement.
    7101    """
    7102    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    7103    if where:
    7104        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    7105    if returning:
    7106        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    7107    return delete_expr
    7108
    7109
    7110def insert(
    7111    expression: ExpOrStr,
    7112    into: ExpOrStr,
    7113    columns: t.Optional[t.Sequence[str | Identifier]] = None,
    7114    overwrite: t.Optional[bool] = None,
    7115    returning: t.Optional[ExpOrStr] = None,
    7116    dialect: DialectType = None,
    7117    copy: bool = True,
    7118    **opts,
    7119) -> Insert:
    7120    """
    7121    Builds an INSERT statement.
    7122
    7123    Example:
    7124        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    7125        'INSERT INTO tbl VALUES (1, 2, 3)'
    7126
    7127    Args:
    7128        expression: the sql string or expression of the INSERT statement
    7129        into: the tbl to insert data to.
    7130        columns: optionally the table's column names.
    7131        overwrite: whether to INSERT OVERWRITE or not.
    7132        returning: sql conditional parsed into a RETURNING statement
    7133        dialect: the dialect used to parse the input expressions.
    7134        copy: whether to copy the expression.
    7135        **opts: other options to use to parse the input expressions.
    7136
    7137    Returns:
    7138        Insert: the syntax tree for the INSERT statement.
    7139    """
    7140    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7141    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    7142
    7143    if columns:
    7144        this = Schema(this=this, expressions=[to_identifier(c, copy=copy) for c in columns])
    7145
    7146    insert = Insert(this=this, expression=expr, overwrite=overwrite)
    7147
    7148    if returning:
    7149        insert = insert.returning(returning, dialect=dialect, copy=False, **opts)
    7150
    7151    return insert
    7152
    7153
    7154def merge(
    7155    *when_exprs: ExpOrStr,
    7156    into: ExpOrStr,
    7157    using: ExpOrStr,
    7158    on: ExpOrStr,
    7159    returning: t.Optional[ExpOrStr] = None,
    7160    dialect: DialectType = None,
    7161    copy: bool = True,
    7162    **opts,
    7163) -> Merge:
    7164    """
    7165    Builds a MERGE statement.
    7166
    7167    Example:
    7168        >>> merge("WHEN MATCHED THEN UPDATE SET col1 = source_table.col1",
    7169        ...       "WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)",
    7170        ...       into="my_table",
    7171        ...       using="source_table",
    7172        ...       on="my_table.id = source_table.id").sql()
    7173        'MERGE INTO my_table USING source_table ON my_table.id = source_table.id WHEN MATCHED THEN UPDATE SET col1 = source_table.col1 WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)'
    7174
    7175    Args:
    7176        *when_exprs: The WHEN clauses specifying actions for matched and unmatched rows.
    7177        into: The target table to merge data into.
    7178        using: The source table to merge data from.
    7179        on: The join condition for the merge.
    7180        returning: The columns to return from the merge.
    7181        dialect: The dialect used to parse the input expressions.
    7182        copy: Whether to copy the expression.
    7183        **opts: Other options to use to parse the input expressions.
    7184
    7185    Returns:
    7186        Merge: The syntax tree for the MERGE statement.
    7187    """
    7188    merge = Merge(
    7189        this=maybe_parse(into, dialect=dialect, copy=copy, **opts),
    7190        using=maybe_parse(using, dialect=dialect, copy=copy, **opts),
    7191        on=maybe_parse(on, dialect=dialect, copy=copy, **opts),
    7192        expressions=[
    7193            maybe_parse(when_expr, dialect=dialect, copy=copy, into=When, **opts)
    7194            for when_expr in when_exprs
    7195        ],
    7196    )
    7197    if returning:
    7198        merge = merge.returning(returning, dialect=dialect, copy=False, **opts)
    7199
    7200    return merge
    7201
    7202
    7203def condition(
    7204    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    7205) -> Condition:
    7206    """
    7207    Initialize a logical condition expression.
    7208
    7209    Example:
    7210        >>> condition("x=1").sql()
    7211        'x = 1'
    7212
    7213        This is helpful for composing larger logical syntax trees:
    7214        >>> where = condition("x=1")
    7215        >>> where = where.and_("y=1")
    7216        >>> Select().from_("tbl").select("*").where(where).sql()
    7217        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    7218
    7219    Args:
    7220        *expression: the SQL code string to parse.
    7221            If an Expression instance is passed, this is used as-is.
    7222        dialect: the dialect used to parse the input expression (in the case that the
    7223            input expression is a SQL string).
    7224        copy: Whether to copy `expression` (only applies to expressions).
    7225        **opts: other options to use to parse the input expressions (again, in the case
    7226            that the input expression is a SQL string).
    7227
    7228    Returns:
    7229        The new Condition instance
    7230    """
    7231    return maybe_parse(
    7232        expression,
    7233        into=Condition,
    7234        dialect=dialect,
    7235        copy=copy,
    7236        **opts,
    7237    )
    7238
    7239
    7240def and_(
    7241    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7242) -> Condition:
    7243    """
    7244    Combine multiple conditions with an AND logical operator.
    7245
    7246    Example:
    7247        >>> and_("x=1", and_("y=1", "z=1")).sql()
    7248        'x = 1 AND (y = 1 AND z = 1)'
    7249
    7250    Args:
    7251        *expressions: the SQL code strings to parse.
    7252            If an Expression instance is passed, this is used as-is.
    7253        dialect: the dialect used to parse the input expression.
    7254        copy: whether to copy `expressions` (only applies to Expressions).
    7255        **opts: other options to use to parse the input expressions.
    7256
    7257    Returns:
    7258        The new condition
    7259    """
    7260    return t.cast(Condition, _combine(expressions, And, dialect, copy=copy, **opts))
    7261
    7262
    7263def or_(
    7264    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7265) -> Condition:
    7266    """
    7267    Combine multiple conditions with an OR logical operator.
    7268
    7269    Example:
    7270        >>> or_("x=1", or_("y=1", "z=1")).sql()
    7271        'x = 1 OR (y = 1 OR z = 1)'
    7272
    7273    Args:
    7274        *expressions: the SQL code strings to parse.
    7275            If an Expression instance is passed, this is used as-is.
    7276        dialect: the dialect used to parse the input expression.
    7277        copy: whether to copy `expressions` (only applies to Expressions).
    7278        **opts: other options to use to parse the input expressions.
    7279
    7280    Returns:
    7281        The new condition
    7282    """
    7283    return t.cast(Condition, _combine(expressions, Or, dialect, copy=copy, **opts))
    7284
    7285
    7286def xor(
    7287    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7288) -> Condition:
    7289    """
    7290    Combine multiple conditions with an XOR logical operator.
    7291
    7292    Example:
    7293        >>> xor("x=1", xor("y=1", "z=1")).sql()
    7294        'x = 1 XOR (y = 1 XOR z = 1)'
    7295
    7296    Args:
    7297        *expressions: the SQL code strings to parse.
    7298            If an Expression instance is passed, this is used as-is.
    7299        dialect: the dialect used to parse the input expression.
    7300        copy: whether to copy `expressions` (only applies to Expressions).
    7301        **opts: other options to use to parse the input expressions.
    7302
    7303    Returns:
    7304        The new condition
    7305    """
    7306    return t.cast(Condition, _combine(expressions, Xor, dialect, copy=copy, **opts))
    7307
    7308
    7309def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    7310    """
    7311    Wrap a condition with a NOT operator.
    7312
    7313    Example:
    7314        >>> not_("this_suit='black'").sql()
    7315        "NOT this_suit = 'black'"
    7316
    7317    Args:
    7318        expression: the SQL code string to parse.
    7319            If an Expression instance is passed, this is used as-is.
    7320        dialect: the dialect used to parse the input expression.
    7321        copy: whether to copy the expression or not.
    7322        **opts: other options to use to parse the input expressions.
    7323
    7324    Returns:
    7325        The new condition.
    7326    """
    7327    this = condition(
    7328        expression,
    7329        dialect=dialect,
    7330        copy=copy,
    7331        **opts,
    7332    )
    7333    return Not(this=_wrap(this, Connector))
    7334
    7335
    7336def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    7337    """
    7338    Wrap an expression in parentheses.
    7339
    7340    Example:
    7341        >>> paren("5 + 3").sql()
    7342        '(5 + 3)'
    7343
    7344    Args:
    7345        expression: the SQL code string to parse.
    7346            If an Expression instance is passed, this is used as-is.
    7347        copy: whether to copy the expression or not.
    7348
    7349    Returns:
    7350        The wrapped expression.
    7351    """
    7352    return Paren(this=maybe_parse(expression, copy=copy))
    7353
    7354
    7355SAFE_IDENTIFIER_RE: t.Pattern[str] = re.compile(r"^[_a-zA-Z][\w]*$")
    7356
    7357
    7358@t.overload
    7359def to_identifier(name: None, quoted: t.Optional[bool] = None, copy: bool = True) -> None: ...
    7360
    7361
    7362@t.overload
    7363def to_identifier(
    7364    name: str | Identifier, quoted: t.Optional[bool] = None, copy: bool = True
    7365) -> Identifier: ...
    7366
    7367
    7368def to_identifier(name, quoted=None, copy=True):
    7369    """Builds an identifier.
    7370
    7371    Args:
    7372        name: The name to turn into an identifier.
    7373        quoted: Whether to force quote the identifier.
    7374        copy: Whether to copy name if it's an Identifier.
    7375
    7376    Returns:
    7377        The identifier ast node.
    7378    """
    7379
    7380    if name is None:
    7381        return None
    7382
    7383    if isinstance(name, Identifier):
    7384        identifier = maybe_copy(name, copy)
    7385    elif isinstance(name, str):
    7386        identifier = Identifier(
    7387            this=name,
    7388            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    7389        )
    7390    else:
    7391        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    7392    return identifier
    7393
    7394
    7395def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Identifier:
    7396    """
    7397    Parses a given string into an identifier.
    7398
    7399    Args:
    7400        name: The name to parse into an identifier.
    7401        dialect: The dialect to parse against.
    7402
    7403    Returns:
    7404        The identifier ast node.
    7405    """
    7406    try:
    7407        expression = maybe_parse(name, dialect=dialect, into=Identifier)
    7408    except (ParseError, TokenError):
    7409        expression = to_identifier(name)
    7410
    7411    return expression
    7412
    7413
    7414INTERVAL_STRING_RE = re.compile(r"\s*([0-9]+)\s*([a-zA-Z]+)\s*")
    7415
    7416
    7417def to_interval(interval: str | Literal) -> Interval:
    7418    """Builds an interval expression from a string like '1 day' or '5 months'."""
    7419    if isinstance(interval, Literal):
    7420        if not interval.is_string:
    7421            raise ValueError("Invalid interval string.")
    7422
    7423        interval = interval.this
    7424
    7425    interval_parts = INTERVAL_STRING_RE.match(interval)  # type: ignore
    7426
    7427    if not interval_parts:
    7428        raise ValueError("Invalid interval string.")
    7429
    7430    return Interval(
    7431        this=Literal.string(interval_parts.group(1)),
    7432        unit=Var(this=interval_parts.group(2).upper()),
    7433    )
    7434
    7435
    7436def to_table(
    7437    sql_path: str | Table, dialect: DialectType = None, copy: bool = True, **kwargs
    7438) -> Table:
    7439    """
    7440    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    7441    If a table is passed in then that table is returned.
    7442
    7443    Args:
    7444        sql_path: a `[catalog].[schema].[table]` string.
    7445        dialect: the source dialect according to which the table name will be parsed.
    7446        copy: Whether to copy a table if it is passed in.
    7447        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    7448
    7449    Returns:
    7450        A table expression.
    7451    """
    7452    if isinstance(sql_path, Table):
    7453        return maybe_copy(sql_path, copy=copy)
    7454
    7455    table = maybe_parse(sql_path, into=Table, dialect=dialect)
    7456
    7457    for k, v in kwargs.items():
    7458        table.set(k, v)
    7459
    7460    return table
    7461
    7462
    7463def to_column(
    7464    sql_path: str | Column,
    7465    quoted: t.Optional[bool] = None,
    7466    dialect: DialectType = None,
    7467    copy: bool = True,
    7468    **kwargs,
    7469) -> Column:
    7470    """
    7471    Create a column from a `[table].[column]` sql path. Table is optional.
    7472    If a column is passed in then that column is returned.
    7473
    7474    Args:
    7475        sql_path: a `[table].[column]` string.
    7476        quoted: Whether or not to force quote identifiers.
    7477        dialect: the source dialect according to which the column name will be parsed.
    7478        copy: Whether to copy a column if it is passed in.
    7479        kwargs: the kwargs to instantiate the resulting `Column` expression with.
    7480
    7481    Returns:
    7482        A column expression.
    7483    """
    7484    if isinstance(sql_path, Column):
    7485        return maybe_copy(sql_path, copy=copy)
    7486
    7487    try:
    7488        col = maybe_parse(sql_path, into=Column, dialect=dialect)
    7489    except ParseError:
    7490        return column(*reversed(sql_path.split(".")), quoted=quoted, **kwargs)
    7491
    7492    for k, v in kwargs.items():
    7493        col.set(k, v)
    7494
    7495    if quoted:
    7496        for i in col.find_all(Identifier):
    7497            i.set("quoted", True)
    7498
    7499    return col
    7500
    7501
    7502def alias_(
    7503    expression: ExpOrStr,
    7504    alias: t.Optional[str | Identifier],
    7505    table: bool | t.Sequence[str | Identifier] = False,
    7506    quoted: t.Optional[bool] = None,
    7507    dialect: DialectType = None,
    7508    copy: bool = True,
    7509    **opts,
    7510):
    7511    """Create an Alias expression.
    7512
    7513    Example:
    7514        >>> alias_('foo', 'bar').sql()
    7515        'foo AS bar'
    7516
    7517        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    7518        '(SELECT 1, 2) AS bar(a, b)'
    7519
    7520    Args:
    7521        expression: the SQL code strings to parse.
    7522            If an Expression instance is passed, this is used as-is.
    7523        alias: the alias name to use. If the name has
    7524            special characters it is quoted.
    7525        table: Whether to create a table alias, can also be a list of columns.
    7526        quoted: whether to quote the alias
    7527        dialect: the dialect used to parse the input expression.
    7528        copy: Whether to copy the expression.
    7529        **opts: other options to use to parse the input expressions.
    7530
    7531    Returns:
    7532        Alias: the aliased expression
    7533    """
    7534    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7535    alias = to_identifier(alias, quoted=quoted)
    7536
    7537    if table:
    7538        table_alias = TableAlias(this=alias)
    7539        exp.set("alias", table_alias)
    7540
    7541        if not isinstance(table, bool):
    7542            for column in table:
    7543                table_alias.append("columns", to_identifier(column, quoted=quoted))
    7544
    7545        return exp
    7546
    7547    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    7548    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    7549    # for the complete Window expression.
    7550    #
    7551    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    7552
    7553    if "alias" in exp.arg_types and not isinstance(exp, Window):
    7554        exp.set("alias", alias)
    7555        return exp
    7556    return Alias(this=exp, alias=alias)
    7557
    7558
    7559def subquery(
    7560    expression: ExpOrStr,
    7561    alias: t.Optional[Identifier | str] = None,
    7562    dialect: DialectType = None,
    7563    **opts,
    7564) -> Select:
    7565    """
    7566    Build a subquery expression that's selected from.
    7567
    7568    Example:
    7569        >>> subquery('select x from tbl', 'bar').select('x').sql()
    7570        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    7571
    7572    Args:
    7573        expression: the SQL code strings to parse.
    7574            If an Expression instance is passed, this is used as-is.
    7575        alias: the alias name to use.
    7576        dialect: the dialect used to parse the input expression.
    7577        **opts: other options to use to parse the input expressions.
    7578
    7579    Returns:
    7580        A new Select instance with the subquery expression included.
    7581    """
    7582
    7583    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias, **opts)
    7584    return Select().from_(expression, dialect=dialect, **opts)
    7585
    7586
    7587@t.overload
    7588def column(
    7589    col: str | Identifier,
    7590    table: t.Optional[str | Identifier] = None,
    7591    db: t.Optional[str | Identifier] = None,
    7592    catalog: t.Optional[str | Identifier] = None,
    7593    *,
    7594    fields: t.Collection[t.Union[str, Identifier]],
    7595    quoted: t.Optional[bool] = None,
    7596    copy: bool = True,
    7597) -> Dot:
    7598    pass
    7599
    7600
    7601@t.overload
    7602def column(
    7603    col: str | Identifier,
    7604    table: t.Optional[str | Identifier] = None,
    7605    db: t.Optional[str | Identifier] = None,
    7606    catalog: t.Optional[str | Identifier] = None,
    7607    *,
    7608    fields: Lit[None] = None,
    7609    quoted: t.Optional[bool] = None,
    7610    copy: bool = True,
    7611) -> Column:
    7612    pass
    7613
    7614
    7615def column(
    7616    col,
    7617    table=None,
    7618    db=None,
    7619    catalog=None,
    7620    *,
    7621    fields=None,
    7622    quoted=None,
    7623    copy=True,
    7624):
    7625    """
    7626    Build a Column.
    7627
    7628    Args:
    7629        col: Column name.
    7630        table: Table name.
    7631        db: Database name.
    7632        catalog: Catalog name.
    7633        fields: Additional fields using dots.
    7634        quoted: Whether to force quotes on the column's identifiers.
    7635        copy: Whether to copy identifiers if passed in.
    7636
    7637    Returns:
    7638        The new Column instance.
    7639    """
    7640    this = Column(
    7641        this=to_identifier(col, quoted=quoted, copy=copy),
    7642        table=to_identifier(table, quoted=quoted, copy=copy),
    7643        db=to_identifier(db, quoted=quoted, copy=copy),
    7644        catalog=to_identifier(catalog, quoted=quoted, copy=copy),
    7645    )
    7646
    7647    if fields:
    7648        this = Dot.build(
    7649            (this, *(to_identifier(field, quoted=quoted, copy=copy) for field in fields))
    7650        )
    7651    return this
    7652
    7653
    7654def cast(
    7655    expression: ExpOrStr, to: DATA_TYPE, copy: bool = True, dialect: DialectType = None, **opts
    7656) -> Cast:
    7657    """Cast an expression to a data type.
    7658
    7659    Example:
    7660        >>> cast('x + 1', 'int').sql()
    7661        'CAST(x + 1 AS INT)'
    7662
    7663    Args:
    7664        expression: The expression to cast.
    7665        to: The datatype to cast to.
    7666        copy: Whether to copy the supplied expressions.
    7667        dialect: The target dialect. This is used to prevent a re-cast in the following scenario:
    7668            - The expression to be cast is already a exp.Cast expression
    7669            - The existing cast is to a type that is logically equivalent to new type
    7670
    7671            For example, if :expression='CAST(x as DATETIME)' and :to=Type.TIMESTAMP,
    7672            but in the target dialect DATETIME is mapped to TIMESTAMP, then we will NOT return `CAST(x (as DATETIME) as TIMESTAMP)`
    7673            and instead just return the original expression `CAST(x as DATETIME)`.
    7674
    7675            This is to prevent it being output as a double cast `CAST(x (as TIMESTAMP) as TIMESTAMP)` once the DATETIME -> TIMESTAMP
    7676            mapping is applied in the target dialect generator.
    7677
    7678    Returns:
    7679        The new Cast instance.
    7680    """
    7681    expr = maybe_parse(expression, copy=copy, dialect=dialect, **opts)
    7682    data_type = DataType.build(to, copy=copy, dialect=dialect, **opts)
    7683
    7684    # dont re-cast if the expression is already a cast to the correct type
    7685    if isinstance(expr, Cast):
    7686        from sqlglot.dialects.dialect import Dialect
    7687
    7688        target_dialect = Dialect.get_or_raise(dialect)
    7689        type_mapping = target_dialect.generator_class.TYPE_MAPPING
    7690
    7691        existing_cast_type: DataType.Type = expr.to.this
    7692        new_cast_type: DataType.Type = data_type.this
    7693        types_are_equivalent = type_mapping.get(
    7694            existing_cast_type, existing_cast_type
    7695        ) == type_mapping.get(new_cast_type, new_cast_type)
    7696        if expr.is_type(data_type) or types_are_equivalent:
    7697            return expr
    7698
    7699    expr = Cast(this=expr, to=data_type)
    7700    expr.type = data_type
    7701
    7702    return expr
    7703
    7704
    7705def table_(
    7706    table: Identifier | str,
    7707    db: t.Optional[Identifier | str] = None,
    7708    catalog: t.Optional[Identifier | str] = None,
    7709    quoted: t.Optional[bool] = None,
    7710    alias: t.Optional[Identifier | str] = None,
    7711) -> Table:
    7712    """Build a Table.
    7713
    7714    Args:
    7715        table: Table name.
    7716        db: Database name.
    7717        catalog: Catalog name.
    7718        quote: Whether to force quotes on the table's identifiers.
    7719        alias: Table's alias.
    7720
    7721    Returns:
    7722        The new Table instance.
    7723    """
    7724    return Table(
    7725        this=to_identifier(table, quoted=quoted) if table else None,
    7726        db=to_identifier(db, quoted=quoted) if db else None,
    7727        catalog=to_identifier(catalog, quoted=quoted) if catalog else None,
    7728        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    7729    )
    7730
    7731
    7732def values(
    7733    values: t.Iterable[t.Tuple[t.Any, ...]],
    7734    alias: t.Optional[str] = None,
    7735    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    7736) -> Values:
    7737    """Build VALUES statement.
    7738
    7739    Example:
    7740        >>> values([(1, '2')]).sql()
    7741        "VALUES (1, '2')"
    7742
    7743    Args:
    7744        values: values statements that will be converted to SQL
    7745        alias: optional alias
    7746        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    7747         If either are provided then an alias is also required.
    7748
    7749    Returns:
    7750        Values: the Values expression object
    7751    """
    7752    if columns and not alias:
    7753        raise ValueError("Alias is required when providing columns")
    7754
    7755    return Values(
    7756        expressions=[convert(tup) for tup in values],
    7757        alias=(
    7758            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    7759            if columns
    7760            else (TableAlias(this=to_identifier(alias)) if alias else None)
    7761        ),
    7762    )
    7763
    7764
    7765def var(name: t.Optional[ExpOrStr]) -> Var:
    7766    """Build a SQL variable.
    7767
    7768    Example:
    7769        >>> repr(var('x'))
    7770        'Var(this=x)'
    7771
    7772        >>> repr(var(column('x', table='y')))
    7773        'Var(this=x)'
    7774
    7775    Args:
    7776        name: The name of the var or an expression who's name will become the var.
    7777
    7778    Returns:
    7779        The new variable node.
    7780    """
    7781    if not name:
    7782        raise ValueError("Cannot convert empty name into var.")
    7783
    7784    if isinstance(name, Expression):
    7785        name = name.name
    7786    return Var(this=name)
    7787
    7788
    7789def rename_table(
    7790    old_name: str | Table,
    7791    new_name: str | Table,
    7792    dialect: DialectType = None,
    7793) -> Alter:
    7794    """Build ALTER TABLE... RENAME... expression
    7795
    7796    Args:
    7797        old_name: The old name of the table
    7798        new_name: The new name of the table
    7799        dialect: The dialect to parse the table.
    7800
    7801    Returns:
    7802        Alter table expression
    7803    """
    7804    old_table = to_table(old_name, dialect=dialect)
    7805    new_table = to_table(new_name, dialect=dialect)
    7806    return Alter(
    7807        this=old_table,
    7808        kind="TABLE",
    7809        actions=[
    7810            AlterRename(this=new_table),
    7811        ],
    7812    )
    7813
    7814
    7815def rename_column(
    7816    table_name: str | Table,
    7817    old_column_name: str | Column,
    7818    new_column_name: str | Column,
    7819    exists: t.Optional[bool] = None,
    7820    dialect: DialectType = None,
    7821) -> Alter:
    7822    """Build ALTER TABLE... RENAME COLUMN... expression
    7823
    7824    Args:
    7825        table_name: Name of the table
    7826        old_column: The old name of the column
    7827        new_column: The new name of the column
    7828        exists: Whether to add the `IF EXISTS` clause
    7829        dialect: The dialect to parse the table/column.
    7830
    7831    Returns:
    7832        Alter table expression
    7833    """
    7834    table = to_table(table_name, dialect=dialect)
    7835    old_column = to_column(old_column_name, dialect=dialect)
    7836    new_column = to_column(new_column_name, dialect=dialect)
    7837    return Alter(
    7838        this=table,
    7839        kind="TABLE",
    7840        actions=[
    7841            RenameColumn(this=old_column, to=new_column, exists=exists),
    7842        ],
    7843    )
    7844
    7845
    7846def convert(value: t.Any, copy: bool = False) -> Expression:
    7847    """Convert a python value into an expression object.
    7848
    7849    Raises an error if a conversion is not possible.
    7850
    7851    Args:
    7852        value: A python object.
    7853        copy: Whether to copy `value` (only applies to Expressions and collections).
    7854
    7855    Returns:
    7856        The equivalent expression object.
    7857    """
    7858    if isinstance(value, Expression):
    7859        return maybe_copy(value, copy)
    7860    if isinstance(value, str):
    7861        return Literal.string(value)
    7862    if isinstance(value, bool):
    7863        return Boolean(this=value)
    7864    if value is None or (isinstance(value, float) and math.isnan(value)):
    7865        return null()
    7866    if isinstance(value, numbers.Number):
    7867        return Literal.number(value)
    7868    if isinstance(value, bytes):
    7869        return HexString(this=value.hex())
    7870    if isinstance(value, datetime.datetime):
    7871        datetime_literal = Literal.string(value.isoformat(sep=" "))
    7872
    7873        tz = None
    7874        if value.tzinfo:
    7875            # this works for zoneinfo.ZoneInfo, pytz.timezone and datetime.datetime.utc to return IANA timezone names like "America/Los_Angeles"
    7876            # instead of abbreviations like "PDT". This is for consistency with other timezone handling functions in SQLGlot
    7877            tz = Literal.string(str(value.tzinfo))
    7878
    7879        return TimeStrToTime(this=datetime_literal, zone=tz)
    7880    if isinstance(value, datetime.date):
    7881        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    7882        return DateStrToDate(this=date_literal)
    7883    if isinstance(value, tuple):
    7884        if hasattr(value, "_fields"):
    7885            return Struct(
    7886                expressions=[
    7887                    PropertyEQ(
    7888                        this=to_identifier(k), expression=convert(getattr(value, k), copy=copy)
    7889                    )
    7890                    for k in value._fields
    7891                ]
    7892            )
    7893        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    7894    if isinstance(value, list):
    7895        return Array(expressions=[convert(v, copy=copy) for v in value])
    7896    if isinstance(value, dict):
    7897        return Map(
    7898            keys=Array(expressions=[convert(k, copy=copy) for k in value]),
    7899            values=Array(expressions=[convert(v, copy=copy) for v in value.values()]),
    7900        )
    7901    if hasattr(value, "__dict__"):
    7902        return Struct(
    7903            expressions=[
    7904                PropertyEQ(this=to_identifier(k), expression=convert(v, copy=copy))
    7905                for k, v in value.__dict__.items()
    7906            ]
    7907        )
    7908    raise ValueError(f"Cannot convert {value}")
    7909
    7910
    7911def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    7912    """
    7913    Replace children of an expression with the result of a lambda fun(child) -> exp.
    7914    """
    7915    for k, v in tuple(expression.args.items()):
    7916        is_list_arg = type(v) is list
    7917
    7918        child_nodes = v if is_list_arg else [v]
    7919        new_child_nodes = []
    7920
    7921        for cn in child_nodes:
    7922            if isinstance(cn, Expression):
    7923                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    7924                    new_child_nodes.append(child_node)
    7925            else:
    7926                new_child_nodes.append(cn)
    7927
    7928        expression.set(k, new_child_nodes if is_list_arg else seq_get(new_child_nodes, 0))
    7929
    7930
    7931def replace_tree(
    7932    expression: Expression,
    7933    fun: t.Callable,
    7934    prune: t.Optional[t.Callable[[Expression], bool]] = None,
    7935) -> Expression:
    7936    """
    7937    Replace an entire tree with the result of function calls on each node.
    7938
    7939    This will be traversed in reverse dfs, so leaves first.
    7940    If new nodes are created as a result of function calls, they will also be traversed.
    7941    """
    7942    stack = list(expression.dfs(prune=prune))
    7943
    7944    while stack:
    7945        node = stack.pop()
    7946        new_node = fun(node)
    7947
    7948        if new_node is not node:
    7949            node.replace(new_node)
    7950
    7951            if isinstance(new_node, Expression):
    7952                stack.append(new_node)
    7953
    7954    return new_node
    7955
    7956
    7957def column_table_names(expression: Expression, exclude: str = "") -> t.Set[str]:
    7958    """
    7959    Return all table names referenced through columns in an expression.
    7960
    7961    Example:
    7962        >>> import sqlglot
    7963        >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
    7964        ['a', 'c']
    7965
    7966    Args:
    7967        expression: expression to find table names.
    7968        exclude: a table name to exclude
    7969
    7970    Returns:
    7971        A list of unique names.
    7972    """
    7973    return {
    7974        table
    7975        for table in (column.table for column in expression.find_all(Column))
    7976        if table and table != exclude
    7977    }
    7978
    7979
    7980def table_name(table: Table | str, dialect: DialectType = None, identify: bool = False) -> str:
    7981    """Get the full name of a table as a string.
    7982
    7983    Args:
    7984        table: Table expression node or string.
    7985        dialect: The dialect to generate the table name for.
    7986        identify: Determines when an identifier should be quoted. Possible values are:
    7987            False (default): Never quote, except in cases where it's mandatory by the dialect.
    7988            True: Always quote.
    7989
    7990    Examples:
    7991        >>> from sqlglot import exp, parse_one
    7992        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    7993        'a.b.c'
    7994
    7995    Returns:
    7996        The table name.
    7997    """
    7998
    7999    table = maybe_parse(table, into=Table, dialect=dialect)
    8000
    8001    if not table:
    8002        raise ValueError(f"Cannot parse {table}")
    8003
    8004    return ".".join(
    8005        (
    8006            part.sql(dialect=dialect, identify=True, copy=False)
    8007            if identify or not SAFE_IDENTIFIER_RE.match(part.name)
    8008            else part.name
    8009        )
    8010        for part in table.parts
    8011    )
    8012
    8013
    8014def normalize_table_name(table: str | Table, dialect: DialectType = None, copy: bool = True) -> str:
    8015    """Returns a case normalized table name without quotes.
    8016
    8017    Args:
    8018        table: the table to normalize
    8019        dialect: the dialect to use for normalization rules
    8020        copy: whether to copy the expression.
    8021
    8022    Examples:
    8023        >>> normalize_table_name("`A-B`.c", dialect="bigquery")
    8024        'A-B.c'
    8025    """
    8026    from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
    8027
    8028    return ".".join(
    8029        p.name
    8030        for p in normalize_identifiers(
    8031            to_table(table, dialect=dialect, copy=copy), dialect=dialect
    8032        ).parts
    8033    )
    8034
    8035
    8036def replace_tables(
    8037    expression: E, mapping: t.Dict[str, str], dialect: DialectType = None, copy: bool = True
    8038) -> E:
    8039    """Replace all tables in expression according to the mapping.
    8040
    8041    Args:
    8042        expression: expression node to be transformed and replaced.
    8043        mapping: mapping of table names.
    8044        dialect: the dialect of the mapping table
    8045        copy: whether to copy the expression.
    8046
    8047    Examples:
    8048        >>> from sqlglot import exp, parse_one
    8049        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    8050        'SELECT * FROM c /* a.b */'
    8051
    8052    Returns:
    8053        The mapped expression.
    8054    """
    8055
    8056    mapping = {normalize_table_name(k, dialect=dialect): v for k, v in mapping.items()}
    8057
    8058    def _replace_tables(node: Expression) -> Expression:
    8059        if isinstance(node, Table):
    8060            original = normalize_table_name(node, dialect=dialect)
    8061            new_name = mapping.get(original)
    8062
    8063            if new_name:
    8064                table = to_table(
    8065                    new_name,
    8066                    **{k: v for k, v in node.args.items() if k not in TABLE_PARTS},
    8067                    dialect=dialect,
    8068                )
    8069                table.add_comments([original])
    8070                return table
    8071        return node
    8072
    8073    return expression.transform(_replace_tables, copy=copy)  # type: ignore
    8074
    8075
    8076def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    8077    """Replace placeholders in an expression.
    8078
    8079    Args:
    8080        expression: expression node to be transformed and replaced.
    8081        args: positional names that will substitute unnamed placeholders in the given order.
    8082        kwargs: keyword arguments that will substitute named placeholders.
    8083
    8084    Examples:
    8085        >>> from sqlglot import exp, parse_one
    8086        >>> replace_placeholders(
    8087        ...     parse_one("select * from :tbl where ? = ?"),
    8088        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    8089        ... ).sql()
    8090        "SELECT * FROM foo WHERE str_col = 'b'"
    8091
    8092    Returns:
    8093        The mapped expression.
    8094    """
    8095
    8096    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    8097        if isinstance(node, Placeholder):
    8098            if node.this:
    8099                new_name = kwargs.get(node.this)
    8100                if new_name is not None:
    8101                    return convert(new_name)
    8102            else:
    8103                try:
    8104                    return convert(next(args))
    8105                except StopIteration:
    8106                    pass
    8107        return node
    8108
    8109    return expression.transform(_replace_placeholders, iter(args), **kwargs)
    8110
    8111
    8112def expand(
    8113    expression: Expression,
    8114    sources: t.Dict[str, Query],
    8115    dialect: DialectType = None,
    8116    copy: bool = True,
    8117) -> Expression:
    8118    """Transforms an expression by expanding all referenced sources into subqueries.
    8119
    8120    Examples:
    8121        >>> from sqlglot import parse_one
    8122        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    8123        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    8124
    8125        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    8126        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    8127
    8128    Args:
    8129        expression: The expression to expand.
    8130        sources: A dictionary of name to Queries.
    8131        dialect: The dialect of the sources dict.
    8132        copy: Whether to copy the expression during transformation. Defaults to True.
    8133
    8134    Returns:
    8135        The transformed expression.
    8136    """
    8137    sources = {normalize_table_name(k, dialect=dialect): v for k, v in sources.items()}
    8138
    8139    def _expand(node: Expression):
    8140        if isinstance(node, Table):
    8141            name = normalize_table_name(node, dialect=dialect)
    8142            source = sources.get(name)
    8143            if source:
    8144                subquery = source.subquery(node.alias or name)
    8145                subquery.comments = [f"source: {name}"]
    8146                return subquery.transform(_expand, copy=False)
    8147        return node
    8148
    8149    return expression.transform(_expand, copy=copy)
    8150
    8151
    8152def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwargs) -> Func:
    8153    """
    8154    Returns a Func expression.
    8155
    8156    Examples:
    8157        >>> func("abs", 5).sql()
    8158        'ABS(5)'
    8159
    8160        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    8161        'CAST(5 AS DOUBLE)'
    8162
    8163    Args:
    8164        name: the name of the function to build.
    8165        args: the args used to instantiate the function of interest.
    8166        copy: whether to copy the argument expressions.
    8167        dialect: the source dialect.
    8168        kwargs: the kwargs used to instantiate the function of interest.
    8169
    8170    Note:
    8171        The arguments `args` and `kwargs` are mutually exclusive.
    8172
    8173    Returns:
    8174        An instance of the function of interest, or an anonymous function, if `name` doesn't
    8175        correspond to an existing `sqlglot.expressions.Func` class.
    8176    """
    8177    if args and kwargs:
    8178        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    8179
    8180    from sqlglot.dialects.dialect import Dialect
    8181
    8182    dialect = Dialect.get_or_raise(dialect)
    8183
    8184    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect, copy=copy) for arg in args]
    8185    kwargs = {key: maybe_parse(value, dialect=dialect, copy=copy) for key, value in kwargs.items()}
    8186
    8187    constructor = dialect.parser_class.FUNCTIONS.get(name.upper())
    8188    if constructor:
    8189        if converted:
    8190            if "dialect" in constructor.__code__.co_varnames:
    8191                function = constructor(converted, dialect=dialect)
    8192            else:
    8193                function = constructor(converted)
    8194        elif constructor.__name__ == "from_arg_list":
    8195            function = constructor.__self__(**kwargs)  # type: ignore
    8196        else:
    8197            constructor = FUNCTION_BY_NAME.get(name.upper())
    8198            if constructor:
    8199                function = constructor(**kwargs)
    8200            else:
    8201                raise ValueError(
    8202                    f"Unable to convert '{name}' into a Func. Either manually construct "
    8203                    "the Func expression of interest or parse the function call."
    8204                )
    8205    else:
    8206        kwargs = kwargs or {"expressions": converted}
    8207        function = Anonymous(this=name, **kwargs)
    8208
    8209    for error_message in function.error_messages(converted):
    8210        raise ValueError(error_message)
    8211
    8212    return function
    8213
    8214
    8215def case(
    8216    expression: t.Optional[ExpOrStr] = None,
    8217    **opts,
    8218) -> Case:
    8219    """
    8220    Initialize a CASE statement.
    8221
    8222    Example:
    8223        case().when("a = 1", "foo").else_("bar")
    8224
    8225    Args:
    8226        expression: Optionally, the input expression (not all dialects support this)
    8227        **opts: Extra keyword arguments for parsing `expression`
    8228    """
    8229    if expression is not None:
    8230        this = maybe_parse(expression, **opts)
    8231    else:
    8232        this = None
    8233    return Case(this=this, ifs=[])
    8234
    8235
    8236def array(
    8237    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8238) -> Array:
    8239    """
    8240    Returns an array.
    8241
    8242    Examples:
    8243        >>> array(1, 'x').sql()
    8244        'ARRAY(1, x)'
    8245
    8246    Args:
    8247        expressions: the expressions to add to the array.
    8248        copy: whether to copy the argument expressions.
    8249        dialect: the source dialect.
    8250        kwargs: the kwargs used to instantiate the function of interest.
    8251
    8252    Returns:
    8253        An array expression.
    8254    """
    8255    return Array(
    8256        expressions=[
    8257            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8258            for expression in expressions
    8259        ]
    8260    )
    8261
    8262
    8263def tuple_(
    8264    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8265) -> Tuple:
    8266    """
    8267    Returns an tuple.
    8268
    8269    Examples:
    8270        >>> tuple_(1, 'x').sql()
    8271        '(1, x)'
    8272
    8273    Args:
    8274        expressions: the expressions to add to the tuple.
    8275        copy: whether to copy the argument expressions.
    8276        dialect: the source dialect.
    8277        kwargs: the kwargs used to instantiate the function of interest.
    8278
    8279    Returns:
    8280        A tuple expression.
    8281    """
    8282    return Tuple(
    8283        expressions=[
    8284            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8285            for expression in expressions
    8286        ]
    8287    )
    8288
    8289
    8290def true() -> Boolean:
    8291    """
    8292    Returns a true Boolean expression.
    8293    """
    8294    return Boolean(this=True)
    8295
    8296
    8297def false() -> Boolean:
    8298    """
    8299    Returns a false Boolean expression.
    8300    """
    8301    return Boolean(this=False)
    8302
    8303
    8304def null() -> Null:
    8305    """
    8306    Returns a Null expression.
    8307    """
    8308    return Null()
    8309
    8310
    8311NONNULL_CONSTANTS = (
    8312    Literal,
    8313    Boolean,
    8314)
    8315
    8316CONSTANTS = (
    8317    Literal,
    8318    Boolean,
    8319    Null,
    8320)

SQLGLOT_META = 'sqlglot.meta'
TABLE_PARTS = ('this', 'db', 'catalog')
COLUMN_PARTS = ('this', 'table', 'db', 'catalog')
class Expression: View Source

      66class Expression(metaclass=_Expression):
      67    """
      68    The base class for all expressions in a syntax tree. Each Expression encapsulates any necessary
      69    context, such as its child expressions, their names (arg keys), and whether a given child expression
      70    is optional or not.
      71
      72    Attributes:
      73        key: a unique key for each class in the Expression hierarchy. This is useful for hashing
      74            and representing expressions as strings.
      75        arg_types: determines the arguments (child nodes) supported by an expression. It maps
      76            arg keys to booleans that indicate whether the corresponding args are optional.
      77        parent: a reference to the parent expression (or None, in case of root expressions).
      78        arg_key: the arg key an expression is associated with, i.e. the name its parent expression
      79            uses to refer to it.
      80        index: the index of an expression if it is inside of a list argument in its parent.
      81        comments: a list of comments that are associated with a given expression. This is used in
      82            order to preserve comments when transpiling SQL code.
      83        type: the `sqlglot.expressions.DataType` type of an expression. This is inferred by the
      84            optimizer, in order to enable some transformations that require type information.
      85        meta: a dictionary that can be used to store useful metadata for a given expression.
      86
      87    Example:
      88        >>> class Foo(Expression):
      89        ...     arg_types = {"this": True, "expression": False}
      90
      91        The above definition informs us that Foo is an Expression that requires an argument called
      92        "this" and may also optionally receive an argument called "expression".
      93
      94    Args:
      95        args: a mapping used for retrieving the arguments of an expression, given their arg keys.
      96    """
      97
      98    key = "expression"
      99    arg_types = {"this": True}
     100    __slots__ = ("args", "parent", "arg_key", "index", "comments", "_type", "_meta", "_hash")
     101
     102    def __init__(self, **args: t.Any):
     103        self.args: t.Dict[str, t.Any] = args
     104        self.parent: t.Optional[Expression] = None
     105        self.arg_key: t.Optional[str] = None
     106        self.index: t.Optional[int] = None
     107        self.comments: t.Optional[t.List[str]] = None
     108        self._type: t.Optional[DataType] = None
     109        self._meta: t.Optional[t.Dict[str, t.Any]] = None
     110        self._hash: t.Optional[int] = None
     111
     112        for arg_key, value in self.args.items():
     113            self._set_parent(arg_key, value)
     114
     115    def __eq__(self, other) -> bool:
     116        return type(self) is type(other) and hash(self) == hash(other)
     117
     118    @property
     119    def hashable_args(self) -> t.Any:
     120        return frozenset(
     121            (k, tuple(_norm_arg(a) for a in v) if type(v) is list else _norm_arg(v))
     122            for k, v in self.args.items()
     123            if not (v is None or v is False or (type(v) is list and not v))
     124        )
     125
     126    def __hash__(self) -> int:
     127        if self._hash is not None:
     128            return self._hash
     129
     130        return hash((self.__class__, self.hashable_args))
     131
     132    @property
     133    def this(self) -> t.Any:
     134        """
     135        Retrieves the argument with key "this".
     136        """
     137        return self.args.get("this")
     138
     139    @property
     140    def expression(self) -> t.Any:
     141        """
     142        Retrieves the argument with key "expression".
     143        """
     144        return self.args.get("expression")
     145
     146    @property
     147    def expressions(self) -> t.List[t.Any]:
     148        """
     149        Retrieves the argument with key "expressions".
     150        """
     151        return self.args.get("expressions") or []
     152
     153    def text(self, key) -> str:
     154        """
     155        Returns a textual representation of the argument corresponding to "key". This can only be used
     156        for args that are strings or leaf Expression instances, such as identifiers and literals.
     157        """
     158        field = self.args.get(key)
     159        if isinstance(field, str):
     160            return field
     161        if isinstance(field, (Identifier, Literal, Var)):
     162            return field.this
     163        if isinstance(field, (Star, Null)):
     164            return field.name
     165        return ""
     166
     167    @property
     168    def is_string(self) -> bool:
     169        """
     170        Checks whether a Literal expression is a string.
     171        """
     172        return isinstance(self, Literal) and self.args["is_string"]
     173
     174    @property
     175    def is_number(self) -> bool:
     176        """
     177        Checks whether a Literal expression is a number.
     178        """
     179        return (isinstance(self, Literal) and not self.args["is_string"]) or (
     180            isinstance(self, Neg) and self.this.is_number
     181        )
     182
     183    def to_py(self) -> t.Any:
     184        """
     185        Returns a Python object equivalent of the SQL node.
     186        """
     187        raise ValueError(f"{self} cannot be converted to a Python object.")
     188
     189    @property
     190    def is_int(self) -> bool:
     191        """
     192        Checks whether an expression is an integer.
     193        """
     194        return self.is_number and isinstance(self.to_py(), int)
     195
     196    @property
     197    def is_star(self) -> bool:
     198        """Checks whether an expression is a star."""
     199        return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))
     200
     201    @property
     202    def alias(self) -> str:
     203        """
     204        Returns the alias of the expression, or an empty string if it's not aliased.
     205        """
     206        if isinstance(self.args.get("alias"), TableAlias):
     207            return self.args["alias"].name
     208        return self.text("alias")
     209
     210    @property
     211    def alias_column_names(self) -> t.List[str]:
     212        table_alias = self.args.get("alias")
     213        if not table_alias:
     214            return []
     215        return [c.name for c in table_alias.args.get("columns") or []]
     216
     217    @property
     218    def name(self) -> str:
     219        return self.text("this")
     220
     221    @property
     222    def alias_or_name(self) -> str:
     223        return self.alias or self.name
     224
     225    @property
     226    def output_name(self) -> str:
     227        """
     228        Name of the output column if this expression is a selection.
     229
     230        If the Expression has no output name, an empty string is returned.
     231
     232        Example:
     233            >>> from sqlglot import parse_one
     234            >>> parse_one("SELECT a").expressions[0].output_name
     235            'a'
     236            >>> parse_one("SELECT b AS c").expressions[0].output_name
     237            'c'
     238            >>> parse_one("SELECT 1 + 2").expressions[0].output_name
     239            ''
     240        """
     241        return ""
     242
     243    @property
     244    def type(self) -> t.Optional[DataType]:
     245        return self._type
     246
     247    @type.setter
     248    def type(self, dtype: t.Optional[DataType | DataType.Type | str]) -> None:
     249        if dtype and not isinstance(dtype, DataType):
     250            dtype = DataType.build(dtype)
     251        self._type = dtype  # type: ignore
     252
     253    def is_type(self, *dtypes) -> bool:
     254        return self.type is not None and self.type.is_type(*dtypes)
     255
     256    def is_leaf(self) -> bool:
     257        return not any(isinstance(v, (Expression, list)) for v in self.args.values())
     258
     259    @property
     260    def meta(self) -> t.Dict[str, t.Any]:
     261        if self._meta is None:
     262            self._meta = {}
     263        return self._meta
     264
     265    def __deepcopy__(self, memo):
     266        root = self.__class__()
     267        stack = [(self, root)]
     268
     269        while stack:
     270            node, copy = stack.pop()
     271
     272            if node.comments is not None:
     273                copy.comments = deepcopy(node.comments)
     274            if node._type is not None:
     275                copy._type = deepcopy(node._type)
     276            if node._meta is not None:
     277                copy._meta = deepcopy(node._meta)
     278            if node._hash is not None:
     279                copy._hash = node._hash
     280
     281            for k, vs in node.args.items():
     282                if hasattr(vs, "parent"):
     283                    stack.append((vs, vs.__class__()))
     284                    copy.set(k, stack[-1][-1])
     285                elif type(vs) is list:
     286                    copy.args[k] = []
     287
     288                    for v in vs:
     289                        if hasattr(v, "parent"):
     290                            stack.append((v, v.__class__()))
     291                            copy.append(k, stack[-1][-1])
     292                        else:
     293                            copy.append(k, v)
     294                else:
     295                    copy.args[k] = vs
     296
     297        return root
     298
     299    def copy(self):
     300        """
     301        Returns a deep copy of the expression.
     302        """
     303        return deepcopy(self)
     304
     305    def add_comments(self, comments: t.Optional[t.List[str]] = None) -> None:
     306        if self.comments is None:
     307            self.comments = []
     308
     309        if comments:
     310            for comment in comments:
     311                _, *meta = comment.split(SQLGLOT_META)
     312                if meta:
     313                    for kv in "".join(meta).split(","):
     314                        k, *v = kv.split("=")
     315                        value = v[0].strip() if v else True
     316                        self.meta[k.strip()] = value
     317                self.comments.append(comment)
     318
     319    def pop_comments(self) -> t.List[str]:
     320        comments = self.comments or []
     321        self.comments = None
     322        return comments
     323
     324    def append(self, arg_key: str, value: t.Any) -> None:
     325        """
     326        Appends value to arg_key if it's a list or sets it as a new list.
     327
     328        Args:
     329            arg_key (str): name of the list expression arg
     330            value (Any): value to append to the list
     331        """
     332        if type(self.args.get(arg_key)) is not list:
     333            self.args[arg_key] = []
     334        self._set_parent(arg_key, value)
     335        values = self.args[arg_key]
     336        if hasattr(value, "parent"):
     337            value.index = len(values)
     338        values.append(value)
     339
     340    def set(
     341        self,
     342        arg_key: str,
     343        value: t.Any,
     344        index: t.Optional[int] = None,
     345        overwrite: bool = True,
     346    ) -> None:
     347        """
     348        Sets arg_key to value.
     349
     350        Args:
     351            arg_key: name of the expression arg.
     352            value: value to set the arg to.
     353            index: if the arg is a list, this specifies what position to add the value in it.
     354            overwrite: assuming an index is given, this determines whether to overwrite the
     355                list entry instead of only inserting a new value (i.e., like list.insert).
     356        """
     357        if index is not None:
     358            expressions = self.args.get(arg_key) or []
     359
     360            if seq_get(expressions, index) is None:
     361                return
     362            if value is None:
     363                expressions.pop(index)
     364                for v in expressions[index:]:
     365                    v.index = v.index - 1
     366                return
     367
     368            if isinstance(value, list):
     369                expressions.pop(index)
     370                expressions[index:index] = value
     371            elif overwrite:
     372                expressions[index] = value
     373            else:
     374                expressions.insert(index, value)
     375
     376            value = expressions
     377        elif value is None:
     378            self.args.pop(arg_key, None)
     379            return
     380
     381        self.args[arg_key] = value
     382        self._set_parent(arg_key, value, index)
     383
     384    def _set_parent(self, arg_key: str, value: t.Any, index: t.Optional[int] = None) -> None:
     385        if hasattr(value, "parent"):
     386            value.parent = self
     387            value.arg_key = arg_key
     388            value.index = index
     389        elif type(value) is list:
     390            for index, v in enumerate(value):
     391                if hasattr(v, "parent"):
     392                    v.parent = self
     393                    v.arg_key = arg_key
     394                    v.index = index
     395
     396    @property
     397    def depth(self) -> int:
     398        """
     399        Returns the depth of this tree.
     400        """
     401        if self.parent:
     402            return self.parent.depth + 1
     403        return 0
     404
     405    def iter_expressions(self, reverse: bool = False) -> t.Iterator[Expression]:
     406        """Yields the key and expression for all arguments, exploding list args."""
     407        # remove tuple when python 3.7 is deprecated
     408        for vs in reversed(tuple(self.args.values())) if reverse else self.args.values():  # type: ignore
     409            if type(vs) is list:
     410                for v in reversed(vs) if reverse else vs:  # type: ignore
     411                    if hasattr(v, "parent"):
     412                        yield v
     413            else:
     414                if hasattr(vs, "parent"):
     415                    yield vs
     416
     417    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
     418        """
     419        Returns the first node in this tree which matches at least one of
     420        the specified types.
     421
     422        Args:
     423            expression_types: the expression type(s) to match.
     424            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
     425
     426        Returns:
     427            The node which matches the criteria or None if no such node was found.
     428        """
     429        return next(self.find_all(*expression_types, bfs=bfs), None)
     430
     431    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
     432        """
     433        Returns a generator object which visits all nodes in this tree and only
     434        yields those that match at least one of the specified expression types.
     435
     436        Args:
     437            expression_types: the expression type(s) to match.
     438            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
     439
     440        Returns:
     441            The generator object.
     442        """
     443        for expression in self.walk(bfs=bfs):
     444            if isinstance(expression, expression_types):
     445                yield expression
     446
     447    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
     448        """
     449        Returns a nearest parent matching expression_types.
     450
     451        Args:
     452            expression_types: the expression type(s) to match.
     453
     454        Returns:
     455            The parent node.
     456        """
     457        ancestor = self.parent
     458        while ancestor and not isinstance(ancestor, expression_types):
     459            ancestor = ancestor.parent
     460        return ancestor  # type: ignore
     461
     462    @property
     463    def parent_select(self) -> t.Optional[Select]:
     464        """
     465        Returns the parent select statement.
     466        """
     467        return self.find_ancestor(Select)
     468
     469    @property
     470    def same_parent(self) -> bool:
     471        """Returns if the parent is the same class as itself."""
     472        return type(self.parent) is self.__class__
     473
     474    def root(self) -> Expression:
     475        """
     476        Returns the root expression of this tree.
     477        """
     478        expression = self
     479        while expression.parent:
     480            expression = expression.parent
     481        return expression
     482
     483    def walk(
     484        self, bfs: bool = True, prune: t.Optional[t.Callable[[Expression], bool]] = None
     485    ) -> t.Iterator[Expression]:
     486        """
     487        Returns a generator object which visits all nodes in this tree.
     488
     489        Args:
     490            bfs: if set to True the BFS traversal order will be applied,
     491                otherwise the DFS traversal will be used instead.
     492            prune: callable that returns True if the generator should stop traversing
     493                this branch of the tree.
     494
     495        Returns:
     496            the generator object.
     497        """
     498        if bfs:
     499            yield from self.bfs(prune=prune)
     500        else:
     501            yield from self.dfs(prune=prune)
     502
     503    def dfs(
     504        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
     505    ) -> t.Iterator[Expression]:
     506        """
     507        Returns a generator object which visits all nodes in this tree in
     508        the DFS (Depth-first) order.
     509
     510        Returns:
     511            The generator object.
     512        """
     513        stack = [self]
     514
     515        while stack:
     516            node = stack.pop()
     517
     518            yield node
     519
     520            if prune and prune(node):
     521                continue
     522
     523            for v in node.iter_expressions(reverse=True):
     524                stack.append(v)
     525
     526    def bfs(
     527        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
     528    ) -> t.Iterator[Expression]:
     529        """
     530        Returns a generator object which visits all nodes in this tree in
     531        the BFS (Breadth-first) order.
     532
     533        Returns:
     534            The generator object.
     535        """
     536        queue = deque([self])
     537
     538        while queue:
     539            node = queue.popleft()
     540
     541            yield node
     542
     543            if prune and prune(node):
     544                continue
     545
     546            for v in node.iter_expressions():
     547                queue.append(v)
     548
     549    def unnest(self):
     550        """
     551        Returns the first non parenthesis child or self.
     552        """
     553        expression = self
     554        while type(expression) is Paren:
     555            expression = expression.this
     556        return expression
     557
     558    def unalias(self):
     559        """
     560        Returns the inner expression if this is an Alias.
     561        """
     562        if isinstance(self, Alias):
     563            return self.this
     564        return self
     565
     566    def unnest_operands(self):
     567        """
     568        Returns unnested operands as a tuple.
     569        """
     570        return tuple(arg.unnest() for arg in self.iter_expressions())
     571
     572    def flatten(self, unnest=True):
     573        """
     574        Returns a generator which yields child nodes whose parents are the same class.
     575
     576        A AND B AND C -> [A, B, C]
     577        """
     578        for node in self.dfs(prune=lambda n: n.parent and type(n) is not self.__class__):
     579            if type(node) is not self.__class__:
     580                yield node.unnest() if unnest and not isinstance(node, Subquery) else node
     581
     582    def __str__(self) -> str:
     583        return self.sql()
     584
     585    def __repr__(self) -> str:
     586        return _to_s(self)
     587
     588    def to_s(self) -> str:
     589        """
     590        Same as __repr__, but includes additional information which can be useful
     591        for debugging, like empty or missing args and the AST nodes' object IDs.
     592        """
     593        return _to_s(self, verbose=True)
     594
     595    def sql(self, dialect: DialectType = None, **opts) -> str:
     596        """
     597        Returns SQL string representation of this tree.
     598
     599        Args:
     600            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
     601            opts: other `sqlglot.generator.Generator` options.
     602
     603        Returns:
     604            The SQL string.
     605        """
     606        from sqlglot.dialects import Dialect
     607
     608        return Dialect.get_or_raise(dialect).generate(self, **opts)
     609
     610    def transform(self, fun: t.Callable, *args: t.Any, copy: bool = True, **kwargs) -> Expression:
     611        """
     612        Visits all tree nodes (excluding already transformed ones)
     613        and applies the given transformation function to each node.
     614
     615        Args:
     616            fun: a function which takes a node as an argument and returns a
     617                new transformed node or the same node without modifications. If the function
     618                returns None, then the corresponding node will be removed from the syntax tree.
     619            copy: if set to True a new tree instance is constructed, otherwise the tree is
     620                modified in place.
     621
     622        Returns:
     623            The transformed tree.
     624        """
     625        root = None
     626        new_node = None
     627
     628        for node in (self.copy() if copy else self).dfs(prune=lambda n: n is not new_node):
     629            parent, arg_key, index = node.parent, node.arg_key, node.index
     630            new_node = fun(node, *args, **kwargs)
     631
     632            if not root:
     633                root = new_node
     634            elif new_node is not node:
     635                parent.set(arg_key, new_node, index)
     636
     637        assert root
     638        return root.assert_is(Expression)
     639
     640    @t.overload
     641    def replace(self, expression: E) -> E: ...
     642
     643    @t.overload
     644    def replace(self, expression: None) -> None: ...
     645
     646    def replace(self, expression):
     647        """
     648        Swap out this expression with a new expression.
     649
     650        For example::
     651
     652            >>> tree = Select().select("x").from_("tbl")
     653            >>> tree.find(Column).replace(column("y"))
     654            Column(
     655              this=Identifier(this=y, quoted=False))
     656            >>> tree.sql()
     657            'SELECT y FROM tbl'
     658
     659        Args:
     660            expression: new node
     661
     662        Returns:
     663            The new expression or expressions.
     664        """
     665        parent = self.parent
     666
     667        if not parent or parent is expression:
     668            return expression
     669
     670        key = self.arg_key
     671        value = parent.args.get(key)
     672
     673        if type(expression) is list and isinstance(value, Expression):
     674            # We are trying to replace an Expression with a list, so it's assumed that
     675            # the intention was to really replace the parent of this expression.
     676            value.parent.replace(expression)
     677        else:
     678            parent.set(key, expression, self.index)
     679
     680        if expression is not self:
     681            self.parent = None
     682            self.arg_key = None
     683            self.index = None
     684
     685        return expression
     686
     687    def pop(self: E) -> E:
     688        """
     689        Remove this expression from its AST.
     690
     691        Returns:
     692            The popped expression.
     693        """
     694        self.replace(None)
     695        return self
     696
     697    def assert_is(self, type_: t.Type[E]) -> E:
     698        """
     699        Assert that this `Expression` is an instance of `type_`.
     700
     701        If it is NOT an instance of `type_`, this raises an assertion error.
     702        Otherwise, this returns this expression.
     703
     704        Examples:
     705            This is useful for type security in chained expressions:
     706
     707            >>> import sqlglot
     708            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
     709            'SELECT x, z FROM y'
     710        """
     711        if not isinstance(self, type_):
     712            raise AssertionError(f"{self} is not {type_}.")
     713        return self
     714
     715    def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
     716        """
     717        Checks if this expression is valid (e.g. all mandatory args are set).
     718
     719        Args:
     720            args: a sequence of values that were used to instantiate a Func expression. This is used
     721                to check that the provided arguments don't exceed the function argument limit.
     722
     723        Returns:
     724            A list of error messages for all possible errors that were found.
     725        """
     726        errors: t.List[str] = []
     727
     728        for k in self.args:
     729            if k not in self.arg_types:
     730                errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
     731        for k, mandatory in self.arg_types.items():
     732            v = self.args.get(k)
     733            if mandatory and (v is None or (isinstance(v, list) and not v)):
     734                errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
     735
     736        if (
     737            args
     738            and isinstance(self, Func)
     739            and len(args) > len(self.arg_types)
     740            and not self.is_var_len_args
     741        ):
     742            errors.append(
     743                f"The number of provided arguments ({len(args)}) is greater than "
     744                f"the maximum number of supported arguments ({len(self.arg_types)})"
     745            )
     746
     747        return errors
     748
     749    def dump(self):
     750        """
     751        Dump this Expression to a JSON-serializable dict.
     752        """
     753        from sqlglot.serde import dump
     754
     755        return dump(self)
     756
     757    @classmethod
     758    def load(cls, obj):
     759        """
     760        Load a dict (as returned by `Expression.dump`) into an Expression instance.
     761        """
     762        from sqlglot.serde import load
     763
     764        return load(obj)
     765
     766    def and_(
     767        self,
     768        *expressions: t.Optional[ExpOrStr],
     769        dialect: DialectType = None,
     770        copy: bool = True,
     771        **opts,
     772    ) -> Condition:
     773        """
     774        AND this condition with one or multiple expressions.
     775
     776        Example:
     777            >>> condition("x=1").and_("y=1").sql()
     778            'x = 1 AND y = 1'
     779
     780        Args:
     781            *expressions: the SQL code strings to parse.
     782                If an `Expression` instance is passed, it will be used as-is.
     783            dialect: the dialect used to parse the input expression.
     784            copy: whether to copy the involved expressions (only applies to Expressions).
     785            opts: other options to use to parse the input expressions.
     786
     787        Returns:
     788            The new And condition.
     789        """
     790        return and_(self, *expressions, dialect=dialect, copy=copy, **opts)
     791
     792    def or_(
     793        self,
     794        *expressions: t.Optional[ExpOrStr],
     795        dialect: DialectType = None,
     796        copy: bool = True,
     797        **opts,
     798    ) -> Condition:
     799        """
     800        OR this condition with one or multiple expressions.
     801
     802        Example:
     803            >>> condition("x=1").or_("y=1").sql()
     804            'x = 1 OR y = 1'
     805
     806        Args:
     807            *expressions: the SQL code strings to parse.
     808                If an `Expression` instance is passed, it will be used as-is.
     809            dialect: the dialect used to parse the input expression.
     810            copy: whether to copy the involved expressions (only applies to Expressions).
     811            opts: other options to use to parse the input expressions.
     812
     813        Returns:
     814            The new Or condition.
     815        """
     816        return or_(self, *expressions, dialect=dialect, copy=copy, **opts)
     817
     818    def not_(self, copy: bool = True):
     819        """
     820        Wrap this condition with NOT.
     821
     822        Example:
     823            >>> condition("x=1").not_().sql()
     824            'NOT x = 1'
     825
     826        Args:
     827            copy: whether to copy this object.
     828
     829        Returns:
     830            The new Not instance.
     831        """
     832        return not_(self, copy=copy)
     833
     834    def as_(
     835        self,
     836        alias: str | Identifier,
     837        quoted: t.Optional[bool] = None,
     838        dialect: DialectType = None,
     839        copy: bool = True,
     840        **opts,
     841    ) -> Alias:
     842        return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)
     843
     844    def _binop(self, klass: t.Type[E], other: t.Any, reverse: bool = False) -> E:
     845        this = self.copy()
     846        other = convert(other, copy=True)
     847        if not isinstance(this, klass) and not isinstance(other, klass):
     848            this = _wrap(this, Binary)
     849            other = _wrap(other, Binary)
     850        if reverse:
     851            return klass(this=other, expression=this)
     852        return klass(this=this, expression=other)
     853
     854    def __getitem__(self, other: ExpOrStr | t.Tuple[ExpOrStr]) -> Bracket:
     855        return Bracket(
     856            this=self.copy(), expressions=[convert(e, copy=True) for e in ensure_list(other)]
     857        )
     858
     859    def __iter__(self) -> t.Iterator:
     860        if "expressions" in self.arg_types:
     861            return iter(self.args.get("expressions") or [])
     862        # We define this because __getitem__ converts Expression into an iterable, which is
     863        # problematic because one can hit infinite loops if they do "for x in some_expr: ..."
     864        # See: https://peps.python.org/pep-0234/
     865        raise TypeError(f"'{self.__class__.__name__}' object is not iterable")
     866
     867    def isin(
     868        self,
     869        *expressions: t.Any,
     870        query: t.Optional[ExpOrStr] = None,
     871        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
     872        copy: bool = True,
     873        **opts,
     874    ) -> In:
     875        subquery = maybe_parse(query, copy=copy, **opts) if query else None
     876        if subquery and not isinstance(subquery, Subquery):
     877            subquery = subquery.subquery(copy=False)
     878
     879        return In(
     880            this=maybe_copy(self, copy),
     881            expressions=[convert(e, copy=copy) for e in expressions],
     882            query=subquery,
     883            unnest=(
     884                Unnest(
     885                    expressions=[
     886                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
     887                        for e in ensure_list(unnest)
     888                    ]
     889                )
     890                if unnest
     891                else None
     892            ),
     893        )
     894
     895    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
     896        return Between(
     897            this=maybe_copy(self, copy),
     898            low=convert(low, copy=copy, **opts),
     899            high=convert(high, copy=copy, **opts),
     900        )
     901
     902    def is_(self, other: ExpOrStr) -> Is:
     903        return self._binop(Is, other)
     904
     905    def like(self, other: ExpOrStr) -> Like:
     906        return self._binop(Like, other)
     907
     908    def ilike(self, other: ExpOrStr) -> ILike:
     909        return self._binop(ILike, other)
     910
     911    def eq(self, other: t.Any) -> EQ:
     912        return self._binop(EQ, other)
     913
     914    def neq(self, other: t.Any) -> NEQ:
     915        return self._binop(NEQ, other)
     916
     917    def rlike(self, other: ExpOrStr) -> RegexpLike:
     918        return self._binop(RegexpLike, other)
     919
     920    def div(self, other: ExpOrStr, typed: bool = False, safe: bool = False) -> Div:
     921        div = self._binop(Div, other)
     922        div.args["typed"] = typed
     923        div.args["safe"] = safe
     924        return div
     925
     926    def asc(self, nulls_first: bool = True) -> Ordered:
     927        return Ordered(this=self.copy(), nulls_first=nulls_first)
     928
     929    def desc(self, nulls_first: bool = False) -> Ordered:
     930        return Ordered(this=self.copy(), desc=True, nulls_first=nulls_first)
     931
     932    def __lt__(self, other: t.Any) -> LT:
     933        return self._binop(LT, other)
     934
     935    def __le__(self, other: t.Any) -> LTE:
     936        return self._binop(LTE, other)
     937
     938    def __gt__(self, other: t.Any) -> GT:
     939        return self._binop(GT, other)
     940
     941    def __ge__(self, other: t.Any) -> GTE:
     942        return self._binop(GTE, other)
     943
     944    def __add__(self, other: t.Any) -> Add:
     945        return self._binop(Add, other)
     946
     947    def __radd__(self, other: t.Any) -> Add:
     948        return self._binop(Add, other, reverse=True)
     949
     950    def __sub__(self, other: t.Any) -> Sub:
     951        return self._binop(Sub, other)
     952
     953    def __rsub__(self, other: t.Any) -> Sub:
     954        return self._binop(Sub, other, reverse=True)
     955
     956    def __mul__(self, other: t.Any) -> Mul:
     957        return self._binop(Mul, other)
     958
     959    def __rmul__(self, other: t.Any) -> Mul:
     960        return self._binop(Mul, other, reverse=True)
     961
     962    def __truediv__(self, other: t.Any) -> Div:
     963        return self._binop(Div, other)
     964
     965    def __rtruediv__(self, other: t.Any) -> Div:
     966        return self._binop(Div, other, reverse=True)
     967
     968    def __floordiv__(self, other: t.Any) -> IntDiv:
     969        return self._binop(IntDiv, other)
     970
     971    def __rfloordiv__(self, other: t.Any) -> IntDiv:
     972        return self._binop(IntDiv, other, reverse=True)
     973
     974    def __mod__(self, other: t.Any) -> Mod:
     975        return self._binop(Mod, other)
     976
     977    def __rmod__(self, other: t.Any) -> Mod:
     978        return self._binop(Mod, other, reverse=True)
     979
     980    def __pow__(self, other: t.Any) -> Pow:
     981        return self._binop(Pow, other)
     982
     983    def __rpow__(self, other: t.Any) -> Pow:
     984        return self._binop(Pow, other, reverse=True)
     985
     986    def __and__(self, other: t.Any) -> And:
     987        return self._binop(And, other)
     988
     989    def __rand__(self, other: t.Any) -> And:
     990        return self._binop(And, other, reverse=True)
     991
     992    def __or__(self, other: t.Any) -> Or:
     993        return self._binop(Or, other)
     994
     995    def __ror__(self, other: t.Any) -> Or:
     996        return self._binop(Or, other, reverse=True)
     997
     998    def __neg__(self) -> Neg:
     999        return Neg(this=_wrap(self.copy(), Binary))
    1000
    1001    def __invert__(self) -> Not:
    1002        return not_(self.copy())

The base class for all expressions in a syntax tree. Each Expression encapsulates any necessary context, such as its child expressions, their names (arg keys), and whether a given child expression is optional or not.

###### Attributes:

- key: a unique key for each class in the Expression hierarchy. This is useful for hashing and representing expressions as strings.
- arg_types: determines the arguments (child nodes) supported by an expression. It maps arg keys to booleans that indicate whether the corresponding args are optional.
- parent: a reference to the parent expression (or None, in case of root expressions).
- arg_key: the arg key an expression is associated with, i.e. the name its parent expression uses to refer to it.
- index: the index of an expression if it is inside of a list argument in its parent.
- comments: a list of comments that are associated with a given expression. This is used in order to preserve comments when transpiling SQL code.
- type: the `sqlglot.expressions.DataType` type of an expression. This is inferred by the optimizer, in order to enable some transformations that require type information.
- meta: a dictionary that can be used to store useful metadata for a given expression.

###### Example:

>     >>> class Foo(Expression):
>     ...     arg_types = {"this": True, "expression": False}

> The above definition informs us that Foo is an Expression that requires an argument called "this" and may also optionally receive an argument called "expression".

###### Arguments:

- args: a mapping used for retrieving the arguments of an expression, given their arg keys.

Expression(**args: Any) View Source

    102    def __init__(self, **args: t.Any):
    103        self.args: t.Dict[str, t.Any] = args
    104        self.parent: t.Optional[Expression] = None
    105        self.arg_key: t.Optional[str] = None
    106        self.index: t.Optional[int] = None
    107        self.comments: t.Optional[t.List[str]] = None
    108        self._type: t.Optional[DataType] = None
    109        self._meta: t.Optional[t.Dict[str, t.Any]] = None
    110        self._hash: t.Optional[int] = None
    111
    112        for arg_key, value in self.args.items():
    113            self._set_parent(arg_key, value)

key = 'expression'
arg_types = {'this': True}
args: Dict[str, Any]
parent: Optional[Expression]
arg_key: Optional[str]
index: Optional[int]
comments: Optional[List[str]]
hashable_args: Any View Source

    118    @property
    119    def hashable_args(self) -> t.Any:
    120        return frozenset(
    121            (k, tuple(_norm_arg(a) for a in v) if type(v) is list else _norm_arg(v))
    122            for k, v in self.args.items()
    123            if not (v is None or v is False or (type(v) is list and not v))
    124        )

this: Any View Source

    132    @property
    133    def this(self) -> t.Any:
    134        """
    135        Retrieves the argument with key "this".
    136        """
    137        return self.args.get("this")

Retrieves the argument with key "this".

expression: Any View Source

    139    @property
    140    def expression(self) -> t.Any:
    141        """
    142        Retrieves the argument with key "expression".
    143        """
    144        return self.args.get("expression")

Retrieves the argument with key "expression".

expressions: List[Any] View Source

    146    @property
    147    def expressions(self) -> t.List[t.Any]:
    148        """
    149        Retrieves the argument with key "expressions".
    150        """
    151        return self.args.get("expressions") or []

Retrieves the argument with key "expressions".

def text(self, key) -> str: View Source

    153    def text(self, key) -> str:
    154        """
    155        Returns a textual representation of the argument corresponding to "key". This can only be used
    156        for args that are strings or leaf Expression instances, such as identifiers and literals.
    157        """
    158        field = self.args.get(key)
    159        if isinstance(field, str):
    160            return field
    161        if isinstance(field, (Identifier, Literal, Var)):
    162            return field.this
    163        if isinstance(field, (Star, Null)):
    164            return field.name
    165        return ""

Returns a textual representation of the argument corresponding to "key". This can only be used for args that are strings or leaf Expression instances, such as identifiers and literals.

is_string: bool View Source

    167    @property
    168    def is_string(self) -> bool:
    169        """
    170        Checks whether a Literal expression is a string.
    171        """
    172        return isinstance(self, Literal) and self.args["is_string"]

Checks whether a Literal expression is a string.

is_number: bool View Source

    174    @property
    175    def is_number(self) -> bool:
    176        """
    177        Checks whether a Literal expression is a number.
    178        """
    179        return (isinstance(self, Literal) and not self.args["is_string"]) or (
    180            isinstance(self, Neg) and self.this.is_number
    181        )

Checks whether a Literal expression is a number.

def to_py(self) -> Any: View Source

    183    def to_py(self) -> t.Any:
    184        """
    185        Returns a Python object equivalent of the SQL node.
    186        """
    187        raise ValueError(f"{self} cannot be converted to a Python object.")

Returns a Python object equivalent of the SQL node.

is_int: bool View Source

    189    @property
    190    def is_int(self) -> bool:
    191        """
    192        Checks whether an expression is an integer.
    193        """
    194        return self.is_number and isinstance(self.to_py(), int)

Checks whether an expression is an integer.

is_star: bool View Source

    196    @property
    197    def is_star(self) -> bool:
    198        """Checks whether an expression is a star."""
    199        return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))

Checks whether an expression is a star.

alias: str View Source

    201    @property
    202    def alias(self) -> str:
    203        """
    204        Returns the alias of the expression, or an empty string if it's not aliased.
    205        """
    206        if isinstance(self.args.get("alias"), TableAlias):
    207            return self.args["alias"].name
    208        return self.text("alias")

Returns the alias of the expression, or an empty string if it's not aliased.

alias_column_names: List[str] View Source

    210    @property
    211    def alias_column_names(self) -> t.List[str]:
    212        table_alias = self.args.get("alias")
    213        if not table_alias:
    214            return []
    215        return [c.name for c in table_alias.args.get("columns") or []]

name: str View Source

    217    @property
    218    def name(self) -> str:
    219        return self.text("this")

alias_or_name: str View Source

    221    @property
    222    def alias_or_name(self) -> str:
    223        return self.alias or self.name

output_name: str View Source

    225    @property
    226    def output_name(self) -> str:
    227        """
    228        Name of the output column if this expression is a selection.
    229
    230        If the Expression has no output name, an empty string is returned.
    231
    232        Example:
    233            >>> from sqlglot import parse_one
    234            >>> parse_one("SELECT a").expressions[0].output_name
    235            'a'
    236            >>> parse_one("SELECT b AS c").expressions[0].output_name
    237            'c'
    238            >>> parse_one("SELECT 1 + 2").expressions[0].output_name
    239            ''
    240        """
    241        return ""

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

type: Optional[DataType] View Source

    243    @property
    244    def type(self) -> t.Optional[DataType]:
    245        return self._type

def is_type(self, *dtypes) -> bool: View Source

    253    def is_type(self, *dtypes) -> bool:
    254        return self.type is not None and self.type.is_type(*dtypes)

def is_leaf(self) -> bool: View Source

    256    def is_leaf(self) -> bool:
    257        return not any(isinstance(v, (Expression, list)) for v in self.args.values())

meta: Dict[str, Any] View Source

    259    @property
    260    def meta(self) -> t.Dict[str, t.Any]:
    261        if self._meta is None:
    262            self._meta = {}
    263        return self._meta

def copy(self): View Source

    299    def copy(self):
    300        """
    301        Returns a deep copy of the expression.
    302        """
    303        return deepcopy(self)

Returns a deep copy of the expression.

def add_comments(self, comments: Optional[List[str]] = None) -> None: View Source

    305    def add_comments(self, comments: t.Optional[t.List[str]] = None) -> None:
    306        if self.comments is None:
    307            self.comments = []
    308
    309        if comments:
    310            for comment in comments:
    311                _, *meta = comment.split(SQLGLOT_META)
    312                if meta:
    313                    for kv in "".join(meta).split(","):
    314                        k, *v = kv.split("=")
    315                        value = v[0].strip() if v else True
    316                        self.meta[k.strip()] = value
    317                self.comments.append(comment)

def pop_comments(self) -> List[str]: View Source

    319    def pop_comments(self) -> t.List[str]:
    320        comments = self.comments or []
    321        self.comments = None
    322        return comments

def append(self, arg_key: str, value: Any) -> None: View Source

    324    def append(self, arg_key: str, value: t.Any) -> None:
    325        """
    326        Appends value to arg_key if it's a list or sets it as a new list.
    327
    328        Args:
    329            arg_key (str): name of the list expression arg
    330            value (Any): value to append to the list
    331        """
    332        if type(self.args.get(arg_key)) is not list:
    333            self.args[arg_key] = []
    334        self._set_parent(arg_key, value)
    335        values = self.args[arg_key]
    336        if hasattr(value, "parent"):
    337            value.index = len(values)
    338        values.append(value)

Appends value to arg_key if it's a list or sets it as a new list.

###### Arguments:

- arg_key (str): name of the list expression arg
- value (Any): value to append to the list

def set( self, arg_key: str, value: Any, index: Optional[int] = None, overwrite: bool = True) -> None: View Source

    340    def set(
    341        self,
    342        arg_key: str,
    343        value: t.Any,
    344        index: t.Optional[int] = None,
    345        overwrite: bool = True,
    346    ) -> None:
    347        """
    348        Sets arg_key to value.
    349
    350        Args:
    351            arg_key: name of the expression arg.
    352            value: value to set the arg to.
    353            index: if the arg is a list, this specifies what position to add the value in it.
    354            overwrite: assuming an index is given, this determines whether to overwrite the
    355                list entry instead of only inserting a new value (i.e., like list.insert).
    356        """
    357        if index is not None:
    358            expressions = self.args.get(arg_key) or []
    359
    360            if seq_get(expressions, index) is None:
    361                return
    362            if value is None:
    363                expressions.pop(index)
    364                for v in expressions[index:]:
    365                    v.index = v.index - 1
    366                return
    367
    368            if isinstance(value, list):
    369                expressions.pop(index)
    370                expressions[index:index] = value
    371            elif overwrite:
    372                expressions[index] = value
    373            else:
    374                expressions.insert(index, value)
    375
    376            value = expressions
    377        elif value is None:
    378            self.args.pop(arg_key, None)
    379            return
    380
    381        self.args[arg_key] = value
    382        self._set_parent(arg_key, value, index)

Sets arg_key to value.

###### Arguments:

- arg_key: name of the expression arg.
- value: value to set the arg to.
- index: if the arg is a list, this specifies what position to add the value in it.
- overwrite: assuming an index is given, this determines whether to overwrite the list entry instead of only inserting a new value (i.e., like list.insert).

depth: int View Source

    396    @property
    397    def depth(self) -> int:
    398        """
    399        Returns the depth of this tree.
    400        """
    401        if self.parent:
    402            return self.parent.depth + 1
    403        return 0

Returns the depth of this tree.

def iter_expressions(self, reverse: bool = False) -> Iterator[Expression]: View Source

    405    def iter_expressions(self, reverse: bool = False) -> t.Iterator[Expression]:
    406        """Yields the key and expression for all arguments, exploding list args."""
    407        # remove tuple when python 3.7 is deprecated
    408        for vs in reversed(tuple(self.args.values())) if reverse else self.args.values():  # type: ignore
    409            if type(vs) is list:
    410                for v in reversed(vs) if reverse else vs:  # type: ignore
    411                    if hasattr(v, "parent"):
    412                        yield v
    413            else:
    414                if hasattr(vs, "parent"):
    415                    yield vs

Yields the key and expression for all arguments, exploding list args.

def find(self, *expression_types: Type[~E], bfs: bool = True) -> Optional[~E]: View Source

    417    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
    418        """
    419        Returns the first node in this tree which matches at least one of
    420        the specified types.
    421
    422        Args:
    423            expression_types: the expression type(s) to match.
    424            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    425
    426        Returns:
    427            The node which matches the criteria or None if no such node was found.
    428        """
    429        return next(self.find_all(*expression_types, bfs=bfs), None)

Returns the first node in this tree which matches at least one of the specified types.

###### Arguments:

- expression_types: the expression type(s) to match.
- bfs: whether to search the AST using the BFS algorithm (DFS is used if false).

###### Returns:

> The node which matches the criteria or None if no such node was found.

def find_all(self, *expression_types: Type[~E], bfs: bool = True) -> Iterator[~E]: View Source

    431    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
    432        """
    433        Returns a generator object which visits all nodes in this tree and only
    434        yields those that match at least one of the specified expression types.
    435
    436        Args:
    437            expression_types: the expression type(s) to match.
    438            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    439
    440        Returns:
    441            The generator object.
    442        """
    443        for expression in self.walk(bfs=bfs):
    444            if isinstance(expression, expression_types):
    445                yield expression

Returns a generator object which visits all nodes in this tree and only yields those that match at least one of the specified expression types.

###### Arguments:

- expression_types: the expression type(s) to match.
- bfs: whether to search the AST using the BFS algorithm (DFS is used if false).

###### Returns:

> The generator object.

def find_ancestor(self, *expression_types: Type[~E]) -> Optional[~E]: View Source

    447    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
    448        """
    449        Returns a nearest parent matching expression_types.
    450
    451        Args:
    452            expression_types: the expression type(s) to match.
    453
    454        Returns:
    455            The parent node.
    456        """
    457        ancestor = self.parent
    458        while ancestor and not isinstance(ancestor, expression_types):
    459            ancestor = ancestor.parent
    460        return ancestor  # type: ignore

Returns a nearest parent matching expression_types.

###### Arguments:

- expression_types: the expression type(s) to match.

###### Returns:

> The parent node.

parent_select: Optional[Select] View Source

    462    @property
    463    def parent_select(self) -> t.Optional[Select]:
    464        """
    465        Returns the parent select statement.
    466        """
    467        return self.find_ancestor(Select)

Returns the parent select statement.

same_parent: bool View Source

    469    @property
    470    def same_parent(self) -> bool:
    471        """Returns if the parent is the same class as itself."""
    472        return type(self.parent) is self.__class__

Returns if the parent is the same class as itself.

def root(self) -> Expression: View Source

    474    def root(self) -> Expression:
    475        """
    476        Returns the root expression of this tree.
    477        """
    478        expression = self
    479        while expression.parent:
    480            expression = expression.parent
    481        return expression

Returns the root expression of this tree.

def walk( self, bfs: bool = True, prune: Optional[Callable[[Expression], bool]] = None) -> Iterator[Expression]: View Source

    483    def walk(
    484        self, bfs: bool = True, prune: t.Optional[t.Callable[[Expression], bool]] = None
    485    ) -> t.Iterator[Expression]:
    486        """
    487        Returns a generator object which visits all nodes in this tree.
    488
    489        Args:
    490            bfs: if set to True the BFS traversal order will be applied,
    491                otherwise the DFS traversal will be used instead.
    492            prune: callable that returns True if the generator should stop traversing
    493                this branch of the tree.
    494
    495        Returns:
    496            the generator object.
    497        """
    498        if bfs:
    499            yield from self.bfs(prune=prune)
    500        else:
    501            yield from self.dfs(prune=prune)

Returns a generator object which visits all nodes in this tree.

###### Arguments:

- bfs: if set to True the BFS traversal order will be applied, otherwise the DFS traversal will be used instead.
- prune: callable that returns True if the generator should stop traversing this branch of the tree.

###### Returns:

> the generator object.

def dfs( self, prune: Optional[Callable[[Expression], bool]] = None) -> Iterator[Expression]: View Source

    503    def dfs(
    504        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
    505    ) -> t.Iterator[Expression]:
    506        """
    507        Returns a generator object which visits all nodes in this tree in
    508        the DFS (Depth-first) order.
    509
    510        Returns:
    511            The generator object.
    512        """
    513        stack = [self]
    514
    515        while stack:
    516            node = stack.pop()
    517
    518            yield node
    519
    520            if prune and prune(node):
    521                continue
    522
    523            for v in node.iter_expressions(reverse=True):
    524                stack.append(v)

Returns a generator object which visits all nodes in this tree in the DFS (Depth-first) order.

###### Returns:

> The generator object.

def bfs( self, prune: Optional[Callable[[Expression], bool]] = None) -> Iterator[Expression]: View Source

    526    def bfs(
    527        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
    528    ) -> t.Iterator[Expression]:
    529        """
    530        Returns a generator object which visits all nodes in this tree in
    531        the BFS (Breadth-first) order.
    532
    533        Returns:
    534            The generator object.
    535        """
    536        queue = deque([self])
    537
    538        while queue:
    539            node = queue.popleft()
    540
    541            yield node
    542
    543            if prune and prune(node):
    544                continue
    545
    546            for v in node.iter_expressions():
    547                queue.append(v)

Returns a generator object which visits all nodes in this tree in the BFS (Breadth-first) order.

###### Returns:

> The generator object.

def unnest(self): View Source

    549    def unnest(self):
    550        """
    551        Returns the first non parenthesis child or self.
    552        """
    553        expression = self
    554        while type(expression) is Paren:
    555            expression = expression.this
    556        return expression

Returns the first non parenthesis child or self.

def unalias(self): View Source

    558    def unalias(self):
    559        """
    560        Returns the inner expression if this is an Alias.
    561        """
    562        if isinstance(self, Alias):
    563            return self.this
    564        return self

Returns the inner expression if this is an Alias.

def unnest_operands(self): View Source

    566    def unnest_operands(self):
    567        """
    568        Returns unnested operands as a tuple.
    569        """
    570        return tuple(arg.unnest() for arg in self.iter_expressions())

Returns unnested operands as a tuple.

def flatten(self, unnest=True): View Source

    572    def flatten(self, unnest=True):
    573        """
    574        Returns a generator which yields child nodes whose parents are the same class.
    575
    576        A AND B AND C -> [A, B, C]
    577        """
    578        for node in self.dfs(prune=lambda n: n.parent and type(n) is not self.__class__):
    579            if type(node) is not self.__class__:
    580                yield node.unnest() if unnest and not isinstance(node, Subquery) else node

Returns a generator which yields child nodes whose parents are the same class.

A AND B AND C -> [A, B, C]

def to_s(self) -> str: View Source

    588    def to_s(self) -> str:
    589        """
    590        Same as __repr__, but includes additional information which can be useful
    591        for debugging, like empty or missing args and the AST nodes' object IDs.
    592        """
    593        return _to_s(self, verbose=True)

Same as __repr__, but includes additional information which can be useful for debugging, like empty or missing args and the AST nodes' object IDs.

def sql( self, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> str: View Source

    595    def sql(self, dialect: DialectType = None, **opts) -> str:
    596        """
    597        Returns SQL string representation of this tree.
    598
    599        Args:
    600            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
    601            opts: other `sqlglot.generator.Generator` options.
    602
    603        Returns:
    604            The SQL string.
    605        """
    606        from sqlglot.dialects import Dialect
    607
    608        return Dialect.get_or_raise(dialect).generate(self, **opts)

Returns SQL string representation of this tree.

###### Arguments:

- dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
- opts: other `sqlglot.generator.Generator` options.

###### Returns:

> The SQL string.

def transform( self, fun: Callable, *args: Any, copy: bool = True, **kwargs) -> Expression: View Source

    610    def transform(self, fun: t.Callable, *args: t.Any, copy: bool = True, **kwargs) -> Expression:
    611        """
    612        Visits all tree nodes (excluding already transformed ones)
    613        and applies the given transformation function to each node.
    614
    615        Args:
    616            fun: a function which takes a node as an argument and returns a
    617                new transformed node or the same node without modifications. If the function
    618                returns None, then the corresponding node will be removed from the syntax tree.
    619            copy: if set to True a new tree instance is constructed, otherwise the tree is
    620                modified in place.
    621
    622        Returns:
    623            The transformed tree.
    624        """
    625        root = None
    626        new_node = None
    627
    628        for node in (self.copy() if copy else self).dfs(prune=lambda n: n is not new_node):
    629            parent, arg_key, index = node.parent, node.arg_key, node.index
    630            new_node = fun(node, *args, **kwargs)
    631
    632            if not root:
    633                root = new_node
    634            elif new_node is not node:
    635                parent.set(arg_key, new_node, index)
    636
    637        assert root
    638        return root.assert_is(Expression)

Visits all tree nodes (excluding already transformed ones) and applies the given transformation function to each node.

###### Arguments:

- fun: a function which takes a node as an argument and returns a new transformed node or the same node without modifications. If the function returns None, then the corresponding node will be removed from the syntax tree.
- copy: if set to True a new tree instance is constructed, otherwise the tree is modified in place.

###### Returns:

> The transformed tree.

def replace(self, expression): View Source

    646    def replace(self, expression):
    647        """
    648        Swap out this expression with a new expression.
    649
    650        For example::
    651
    652            >>> tree = Select().select("x").from_("tbl")
    653            >>> tree.find(Column).replace(column("y"))
    654            Column(
    655              this=Identifier(this=y, quoted=False))
    656            >>> tree.sql()
    657            'SELECT y FROM tbl'
    658
    659        Args:
    660            expression: new node
    661
    662        Returns:
    663            The new expression or expressions.
    664        """
    665        parent = self.parent
    666
    667        if not parent or parent is expression:
    668            return expression
    669
    670        key = self.arg_key
    671        value = parent.args.get(key)
    672
    673        if type(expression) is list and isinstance(value, Expression):
    674            # We are trying to replace an Expression with a list, so it's assumed that
    675            # the intention was to really replace the parent of this expression.
    676            value.parent.replace(expression)
    677        else:
    678            parent.set(key, expression, self.index)
    679
    680        if expression is not self:
    681            self.parent = None
    682            self.arg_key = None
    683            self.index = None
    684
    685        return expression

Swap out this expression with a new expression.

For example::

    >>> tree = Select().select("x").from_("tbl")
    >>> tree.find(Column).replace(column("y"))
    Column(
      this=Identifier(this=y, quoted=False))
    >>> tree.sql()
    'SELECT y FROM tbl'

###### Arguments:

- expression: new node

###### Returns:

> The new expression or expressions.

def pop(self: ~E) -> ~E: View Source

    687    def pop(self: E) -> E:
    688        """
    689        Remove this expression from its AST.
    690
    691        Returns:
    692            The popped expression.
    693        """
    694        self.replace(None)
    695        return self

Remove this expression from its AST.

###### Returns:

> The popped expression.

def assert_is(self, type_: Type[~E]) -> ~E: View Source

    697    def assert_is(self, type_: t.Type[E]) -> E:
    698        """
    699        Assert that this `Expression` is an instance of `type_`.
    700
    701        If it is NOT an instance of `type_`, this raises an assertion error.
    702        Otherwise, this returns this expression.
    703
    704        Examples:
    705            This is useful for type security in chained expressions:
    706
    707            >>> import sqlglot
    708            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
    709            'SELECT x, z FROM y'
    710        """
    711        if not isinstance(self, type_):
    712            raise AssertionError(f"{self} is not {type_}.")
    713        return self

Assert that this `Expression` is an instance of `type_`.

If it is NOT an instance of `type_`, this raises an assertion error. Otherwise, this returns this expression.

###### Examples:

> This is useful for type security in chained expressions:

>     >>> import sqlglot
>     >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
>     'SELECT x, z FROM y'

def error_messages(self, args: Optional[Sequence] = None) -> List[str]: View Source

    715    def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
    716        """
    717        Checks if this expression is valid (e.g. all mandatory args are set).
    718
    719        Args:
    720            args: a sequence of values that were used to instantiate a Func expression. This is used
    721                to check that the provided arguments don't exceed the function argument limit.
    722
    723        Returns:
    724            A list of error messages for all possible errors that were found.
    725        """
    726        errors: t.List[str] = []
    727
    728        for k in self.args:
    729            if k not in self.arg_types:
    730                errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
    731        for k, mandatory in self.arg_types.items():
    732            v = self.args.get(k)
    733            if mandatory and (v is None or (isinstance(v, list) and not v)):
    734                errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
    735
    736        if (
    737            args
    738            and isinstance(self, Func)
    739            and len(args) > len(self.arg_types)
    740            and not self.is_var_len_args
    741        ):
    742            errors.append(
    743                f"The number of provided arguments ({len(args)}) is greater than "
    744                f"the maximum number of supported arguments ({len(self.arg_types)})"
    745            )
    746
    747        return errors

Checks if this expression is valid (e.g. all mandatory args are set).

###### Arguments:

- args: a sequence of values that were used to instantiate a Func expression. This is used to check that the provided arguments don't exceed the function argument limit.

###### Returns:

> A list of error messages for all possible errors that were found.

def dump(self): View Source

    749    def dump(self):
    750        """
    751        Dump this Expression to a JSON-serializable dict.
    752        """
    753        from sqlglot.serde import dump
    754
    755        return dump(self)

Dump this Expression to a JSON-serializable dict.

@classmethod
def load(cls, obj): View Source

    757    @classmethod
    758    def load(cls, obj):
    759        """
    760        Load a dict (as returned by `Expression.dump`) into an Expression instance.
    761        """
    762        from sqlglot.serde import load
    763
    764        return load(obj)

Load a dict (as returned by `Expression.dump`) into an Expression instance.

def and_( self, *expressions: Union[str, Expression, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    766    def and_(
    767        self,
    768        *expressions: t.Optional[ExpOrStr],
    769        dialect: DialectType = None,
    770        copy: bool = True,
    771        **opts,
    772    ) -> Condition:
    773        """
    774        AND this condition with one or multiple expressions.
    775
    776        Example:
    777            >>> condition("x=1").and_("y=1").sql()
    778            'x = 1 AND y = 1'
    779
    780        Args:
    781            *expressions: the SQL code strings to parse.
    782                If an `Expression` instance is passed, it will be used as-is.
    783            dialect: the dialect used to parse the input expression.
    784            copy: whether to copy the involved expressions (only applies to Expressions).
    785            opts: other options to use to parse the input expressions.
    786
    787        Returns:
    788            The new And condition.
    789        """
    790        return and_(self, *expressions, dialect=dialect, copy=copy, **opts)

AND this condition with one or multiple expressions.

###### Example:

>     >>> condition("x=1").and_("y=1").sql()
>     'x = 1 AND y = 1'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy the involved expressions (only applies to Expressions).
- opts: other options to use to parse the input expressions.

###### Returns:

> The new And condition.

def or_( self, *expressions: Union[str, Expression, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    792    def or_(
    793        self,
    794        *expressions: t.Optional[ExpOrStr],
    795        dialect: DialectType = None,
    796        copy: bool = True,
    797        **opts,
    798    ) -> Condition:
    799        """
    800        OR this condition with one or multiple expressions.
    801
    802        Example:
    803            >>> condition("x=1").or_("y=1").sql()
    804            'x = 1 OR y = 1'
    805
    806        Args:
    807            *expressions: the SQL code strings to parse.
    808                If an `Expression` instance is passed, it will be used as-is.
    809            dialect: the dialect used to parse the input expression.
    810            copy: whether to copy the involved expressions (only applies to Expressions).
    811            opts: other options to use to parse the input expressions.
    812
    813        Returns:
    814            The new Or condition.
    815        """
    816        return or_(self, *expressions, dialect=dialect, copy=copy, **opts)

OR this condition with one or multiple expressions.

###### Example:

>     >>> condition("x=1").or_("y=1").sql()
>     'x = 1 OR y = 1'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy the involved expressions (only applies to Expressions).
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Or condition.

def not_(self, copy: bool = True): View Source

    818    def not_(self, copy: bool = True):
    819        """
    820        Wrap this condition with NOT.
    821
    822        Example:
    823            >>> condition("x=1").not_().sql()
    824            'NOT x = 1'
    825
    826        Args:
    827            copy: whether to copy this object.
    828
    829        Returns:
    830            The new Not instance.
    831        """
    832        return not_(self, copy=copy)

Wrap this condition with NOT.

###### Example:

>     >>> condition("x=1").not_().sql()
>     'NOT x = 1'

###### Arguments:

- copy: whether to copy this object.

###### Returns:

> The new Not instance.

def as_( self, alias: str | Identifier, quoted: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Alias: View Source

    834    def as_(
    835        self,
    836        alias: str | Identifier,
    837        quoted: t.Optional[bool] = None,
    838        dialect: DialectType = None,
    839        copy: bool = True,
    840        **opts,
    841    ) -> Alias:
    842        return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)

def isin( self, *expressions: Any, query: Union[str, Expression, NoneType] = None, unnest: Union[str, Expression, NoneType, Collection[Union[str, Expression]]] = None, copy: bool = True, **opts) -> In: View Source

    867    def isin(
    868        self,
    869        *expressions: t.Any,
    870        query: t.Optional[ExpOrStr] = None,
    871        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    872        copy: bool = True,
    873        **opts,
    874    ) -> In:
    875        subquery = maybe_parse(query, copy=copy, **opts) if query else None
    876        if subquery and not isinstance(subquery, Subquery):
    877            subquery = subquery.subquery(copy=False)
    878
    879        return In(
    880            this=maybe_copy(self, copy),
    881            expressions=[convert(e, copy=copy) for e in expressions],
    882            query=subquery,
    883            unnest=(
    884                Unnest(
    885                    expressions=[
    886                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    887                        for e in ensure_list(unnest)
    888                    ]
    889                )
    890                if unnest
    891                else None
    892            ),
    893        )

def between( self, low: Any, high: Any, copy: bool = True, **opts) -> Between: View Source

    895    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
    896        return Between(
    897            this=maybe_copy(self, copy),
    898            low=convert(low, copy=copy, **opts),
    899            high=convert(high, copy=copy, **opts),
    900        )

def is_( self, other: Union[str, Expression]) -> Is: View Source

    902    def is_(self, other: ExpOrStr) -> Is:
    903        return self._binop(Is, other)

def like( self, other: Union[str, Expression]) -> Like: View Source

    905    def like(self, other: ExpOrStr) -> Like:
    906        return self._binop(Like, other)

def ilike( self, other: Union[str, Expression]) -> ILike: View Source

    908    def ilike(self, other: ExpOrStr) -> ILike:
    909        return self._binop(ILike, other)

def eq(self, other: Any) -> EQ: View Source

    911    def eq(self, other: t.Any) -> EQ:
    912        return self._binop(EQ, other)

def neq(self, other: Any) -> NEQ: View Source

    914    def neq(self, other: t.Any) -> NEQ:
    915        return self._binop(NEQ, other)

def rlike( self, other: Union[str, Expression]) -> RegexpLike: View Source

    917    def rlike(self, other: ExpOrStr) -> RegexpLike:
    918        return self._binop(RegexpLike, other)

def div( self, other: Union[str, Expression], typed: bool = False, safe: bool = False) -> Div: View Source

    920    def div(self, other: ExpOrStr, typed: bool = False, safe: bool = False) -> Div:
    921        div = self._binop(Div, other)
    922        div.args["typed"] = typed
    923        div.args["safe"] = safe
    924        return div

def asc(self, nulls_first: bool = True) -> Ordered: View Source

    926    def asc(self, nulls_first: bool = True) -> Ordered:
    927        return Ordered(this=self.copy(), nulls_first=nulls_first)

def desc(self, nulls_first: bool = False) -> Ordered: View Source

    929    def desc(self, nulls_first: bool = False) -> Ordered:
    930        return Ordered(this=self.copy(), desc=True, nulls_first=nulls_first)

IntoType = typing.Union[str, typing.Type[Expression], typing.Collection[typing.Union[str, typing.Type[Expression]]]]
ExpOrStr = typing.Union[str, Expression]
class Condition(Expression): View Source

    1013class Condition(Expression):
    1014    """Logical conditions like x AND y, or simply x"""

Logical conditions like x AND y, or simply x

key = 'condition'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Predicate(Condition): View Source

    1017class Predicate(Condition):
    1018    """Relationships like x = y, x > 1, x >= y."""

Relationships like x = y, x > 1, x >= y.

key = 'predicate'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DerivedTable(Expression): View Source

    1021class DerivedTable(Expression):
    1022    @property
    1023    def selects(self) -> t.List[Expression]:
    1024        return self.this.selects if isinstance(self.this, Query) else []
    1025
    1026    @property
    1027    def named_selects(self) -> t.List[str]:
    1028        return [select.output_name for select in self.selects]

selects: List[Expression] View Source

    1022    @property
    1023    def selects(self) -> t.List[Expression]:
    1024        return self.this.selects if isinstance(self.this, Query) else []

named_selects: List[str] View Source

    1026    @property
    1027    def named_selects(self) -> t.List[str]:
    1028        return [select.output_name for select in self.selects]

key = 'derivedtable'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Query(Expression): View Source

    1031class Query(Expression):
    1032    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    1033        """
    1034        Returns a `Subquery` that wraps around this query.
    1035
    1036        Example:
    1037            >>> subquery = Select().select("x").from_("tbl").subquery()
    1038            >>> Select().select("x").from_(subquery).sql()
    1039            'SELECT x FROM (SELECT x FROM tbl)'
    1040
    1041        Args:
    1042            alias: an optional alias for the subquery.
    1043            copy: if `False`, modify this expression instance in-place.
    1044        """
    1045        instance = maybe_copy(self, copy)
    1046        if not isinstance(alias, Expression):
    1047            alias = TableAlias(this=to_identifier(alias)) if alias else None
    1048
    1049        return Subquery(this=instance, alias=alias)
    1050
    1051    def limit(
    1052        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1053    ) -> Q:
    1054        """
    1055        Adds a LIMIT clause to this query.
    1056
    1057        Example:
    1058            >>> select("1").union(select("1")).limit(1).sql()
    1059            'SELECT 1 UNION SELECT 1 LIMIT 1'
    1060
    1061        Args:
    1062            expression: the SQL code string to parse.
    1063                This can also be an integer.
    1064                If a `Limit` instance is passed, it will be used as-is.
    1065                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    1066            dialect: the dialect used to parse the input expression.
    1067            copy: if `False`, modify this expression instance in-place.
    1068            opts: other options to use to parse the input expressions.
    1069
    1070        Returns:
    1071            A limited Select expression.
    1072        """
    1073        return _apply_builder(
    1074            expression=expression,
    1075            instance=self,
    1076            arg="limit",
    1077            into=Limit,
    1078            prefix="LIMIT",
    1079            dialect=dialect,
    1080            copy=copy,
    1081            into_arg="expression",
    1082            **opts,
    1083        )
    1084
    1085    def offset(
    1086        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1087    ) -> Q:
    1088        """
    1089        Set the OFFSET expression.
    1090
    1091        Example:
    1092            >>> Select().from_("tbl").select("x").offset(10).sql()
    1093            'SELECT x FROM tbl OFFSET 10'
    1094
    1095        Args:
    1096            expression: the SQL code string to parse.
    1097                This can also be an integer.
    1098                If a `Offset` instance is passed, this is used as-is.
    1099                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    1100            dialect: the dialect used to parse the input expression.
    1101            copy: if `False`, modify this expression instance in-place.
    1102            opts: other options to use to parse the input expressions.
    1103
    1104        Returns:
    1105            The modified Select expression.
    1106        """
    1107        return _apply_builder(
    1108            expression=expression,
    1109            instance=self,
    1110            arg="offset",
    1111            into=Offset,
    1112            prefix="OFFSET",
    1113            dialect=dialect,
    1114            copy=copy,
    1115            into_arg="expression",
    1116            **opts,
    1117        )
    1118
    1119    def order_by(
    1120        self: Q,
    1121        *expressions: t.Optional[ExpOrStr],
    1122        append: bool = True,
    1123        dialect: DialectType = None,
    1124        copy: bool = True,
    1125        **opts,
    1126    ) -> Q:
    1127        """
    1128        Set the ORDER BY expression.
    1129
    1130        Example:
    1131            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    1132            'SELECT x FROM tbl ORDER BY x DESC'
    1133
    1134        Args:
    1135            *expressions: the SQL code strings to parse.
    1136                If a `Group` instance is passed, this is used as-is.
    1137                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    1138            append: if `True`, add to any existing expressions.
    1139                Otherwise, this flattens all the `Order` expression into a single expression.
    1140            dialect: the dialect used to parse the input expression.
    1141            copy: if `False`, modify this expression instance in-place.
    1142            opts: other options to use to parse the input expressions.
    1143
    1144        Returns:
    1145            The modified Select expression.
    1146        """
    1147        return _apply_child_list_builder(
    1148            *expressions,
    1149            instance=self,
    1150            arg="order",
    1151            append=append,
    1152            copy=copy,
    1153            prefix="ORDER BY",
    1154            into=Order,
    1155            dialect=dialect,
    1156            **opts,
    1157        )
    1158
    1159    @property
    1160    def ctes(self) -> t.List[CTE]:
    1161        """Returns a list of all the CTEs attached to this query."""
    1162        with_ = self.args.get("with")
    1163        return with_.expressions if with_ else []
    1164
    1165    @property
    1166    def selects(self) -> t.List[Expression]:
    1167        """Returns the query's projections."""
    1168        raise NotImplementedError("Query objects must implement `selects`")
    1169
    1170    @property
    1171    def named_selects(self) -> t.List[str]:
    1172        """Returns the output names of the query's projections."""
    1173        raise NotImplementedError("Query objects must implement `named_selects`")
    1174
    1175    def select(
    1176        self: Q,
    1177        *expressions: t.Optional[ExpOrStr],
    1178        append: bool = True,
    1179        dialect: DialectType = None,
    1180        copy: bool = True,
    1181        **opts,
    1182    ) -> Q:
    1183        """
    1184        Append to or set the SELECT expressions.
    1185
    1186        Example:
    1187            >>> Select().select("x", "y").sql()
    1188            'SELECT x, y'
    1189
    1190        Args:
    1191            *expressions: the SQL code strings to parse.
    1192                If an `Expression` instance is passed, it will be used as-is.
    1193            append: if `True`, add to any existing expressions.
    1194                Otherwise, this resets the expressions.
    1195            dialect: the dialect used to parse the input expressions.
    1196            copy: if `False`, modify this expression instance in-place.
    1197            opts: other options to use to parse the input expressions.
    1198
    1199        Returns:
    1200            The modified Query expression.
    1201        """
    1202        raise NotImplementedError("Query objects must implement `select`")
    1203
    1204    def with_(
    1205        self: Q,
    1206        alias: ExpOrStr,
    1207        as_: ExpOrStr,
    1208        recursive: t.Optional[bool] = None,
    1209        materialized: t.Optional[bool] = None,
    1210        append: bool = True,
    1211        dialect: DialectType = None,
    1212        copy: bool = True,
    1213        **opts,
    1214    ) -> Q:
    1215        """
    1216        Append to or set the common table expressions.
    1217
    1218        Example:
    1219            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    1220            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    1221
    1222        Args:
    1223            alias: the SQL code string to parse as the table name.
    1224                If an `Expression` instance is passed, this is used as-is.
    1225            as_: the SQL code string to parse as the table expression.
    1226                If an `Expression` instance is passed, it will be used as-is.
    1227            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1228            materialized: set the MATERIALIZED part of the expression.
    1229            append: if `True`, add to any existing expressions.
    1230                Otherwise, this resets the expressions.
    1231            dialect: the dialect used to parse the input expression.
    1232            copy: if `False`, modify this expression instance in-place.
    1233            opts: other options to use to parse the input expressions.
    1234
    1235        Returns:
    1236            The modified expression.
    1237        """
    1238        return _apply_cte_builder(
    1239            self,
    1240            alias,
    1241            as_,
    1242            recursive=recursive,
    1243            materialized=materialized,
    1244            append=append,
    1245            dialect=dialect,
    1246            copy=copy,
    1247            **opts,
    1248        )
    1249
    1250    def union(
    1251        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1252    ) -> Union:
    1253        """
    1254        Builds a UNION expression.
    1255
    1256        Example:
    1257            >>> import sqlglot
    1258            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    1259            'SELECT * FROM foo UNION SELECT * FROM bla'
    1260
    1261        Args:
    1262            expressions: the SQL code strings.
    1263                If `Expression` instances are passed, they will be used as-is.
    1264            distinct: set the DISTINCT flag if and only if this is true.
    1265            dialect: the dialect used to parse the input expression.
    1266            opts: other options to use to parse the input expressions.
    1267
    1268        Returns:
    1269            The new Union expression.
    1270        """
    1271        return union(self, *expressions, distinct=distinct, dialect=dialect, **opts)
    1272
    1273    def intersect(
    1274        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1275    ) -> Intersect:
    1276        """
    1277        Builds an INTERSECT expression.
    1278
    1279        Example:
    1280            >>> import sqlglot
    1281            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    1282            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    1283
    1284        Args:
    1285            expressions: the SQL code strings.
    1286                If `Expression` instances are passed, they will be used as-is.
    1287            distinct: set the DISTINCT flag if and only if this is true.
    1288            dialect: the dialect used to parse the input expression.
    1289            opts: other options to use to parse the input expressions.
    1290
    1291        Returns:
    1292            The new Intersect expression.
    1293        """
    1294        return intersect(self, *expressions, distinct=distinct, dialect=dialect, **opts)
    1295
    1296    def except_(
    1297        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1298    ) -> Except:
    1299        """
    1300        Builds an EXCEPT expression.
    1301
    1302        Example:
    1303            >>> import sqlglot
    1304            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    1305            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    1306
    1307        Args:
    1308            expressions: the SQL code strings.
    1309                If `Expression` instance are passed, they will be used as-is.
    1310            distinct: set the DISTINCT flag if and only if this is true.
    1311            dialect: the dialect used to parse the input expression.
    1312            opts: other options to use to parse the input expressions.
    1313
    1314        Returns:
    1315            The new Except expression.
    1316        """
    1317        return except_(self, *expressions, distinct=distinct, dialect=dialect, **opts)

def subquery( self, alias: Union[str, Expression, NoneType] = None, copy: bool = True) -> Subquery: View Source

    1032    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    1033        """
    1034        Returns a `Subquery` that wraps around this query.
    1035
    1036        Example:
    1037            >>> subquery = Select().select("x").from_("tbl").subquery()
    1038            >>> Select().select("x").from_(subquery).sql()
    1039            'SELECT x FROM (SELECT x FROM tbl)'
    1040
    1041        Args:
    1042            alias: an optional alias for the subquery.
    1043            copy: if `False`, modify this expression instance in-place.
    1044        """
    1045        instance = maybe_copy(self, copy)
    1046        if not isinstance(alias, Expression):
    1047            alias = TableAlias(this=to_identifier(alias)) if alias else None
    1048
    1049        return Subquery(this=instance, alias=alias)

Returns a `Subquery` that wraps around this query.

###### Example:

>     >>> subquery = Select().select("x").from_("tbl").subquery()
>     >>> Select().select("x").from_(subquery).sql()
>     'SELECT x FROM (SELECT x FROM tbl)'

###### Arguments:

- alias: an optional alias for the subquery.
- copy: if `False`, modify this expression instance in-place.

def limit( self: ~Q, expression: Union[str, Expression, int], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1051    def limit(
    1052        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1053    ) -> Q:
    1054        """
    1055        Adds a LIMIT clause to this query.
    1056
    1057        Example:
    1058            >>> select("1").union(select("1")).limit(1).sql()
    1059            'SELECT 1 UNION SELECT 1 LIMIT 1'
    1060
    1061        Args:
    1062            expression: the SQL code string to parse.
    1063                This can also be an integer.
    1064                If a `Limit` instance is passed, it will be used as-is.
    1065                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    1066            dialect: the dialect used to parse the input expression.
    1067            copy: if `False`, modify this expression instance in-place.
    1068            opts: other options to use to parse the input expressions.
    1069
    1070        Returns:
    1071            A limited Select expression.
    1072        """
    1073        return _apply_builder(
    1074            expression=expression,
    1075            instance=self,
    1076            arg="limit",
    1077            into=Limit,
    1078            prefix="LIMIT",
    1079            dialect=dialect,
    1080            copy=copy,
    1081            into_arg="expression",
    1082            **opts,
    1083        )

Adds a LIMIT clause to this query.

###### Example:

>     >>> select("1").union(select("1")).limit(1).sql()
>     'SELECT 1 UNION SELECT 1 LIMIT 1'

###### Arguments:

- expression: the SQL code string to parse. This can also be an integer. If a `Limit` instance is passed, it will be used as-is. If another `Expression` instance is passed, it will be wrapped in a `Limit`.
- 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:

> A limited Select expression.

def offset( self: ~Q, expression: Union[str, Expression, int], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1085    def offset(
    1086        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1087    ) -> Q:
    1088        """
    1089        Set the OFFSET expression.
    1090
    1091        Example:
    1092            >>> Select().from_("tbl").select("x").offset(10).sql()
    1093            'SELECT x FROM tbl OFFSET 10'
    1094
    1095        Args:
    1096            expression: the SQL code string to parse.
    1097                This can also be an integer.
    1098                If a `Offset` instance is passed, this is used as-is.
    1099                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    1100            dialect: the dialect used to parse the input expression.
    1101            copy: if `False`, modify this expression instance in-place.
    1102            opts: other options to use to parse the input expressions.
    1103
    1104        Returns:
    1105            The modified Select expression.
    1106        """
    1107        return _apply_builder(
    1108            expression=expression,
    1109            instance=self,
    1110            arg="offset",
    1111            into=Offset,
    1112            prefix="OFFSET",
    1113            dialect=dialect,
    1114            copy=copy,
    1115            into_arg="expression",
    1116            **opts,
    1117        )

Set the OFFSET expression.

###### Example:

>     >>> Select().from_("tbl").select("x").offset(10).sql()
>     'SELECT x FROM tbl OFFSET 10'

###### Arguments:

- expression: the SQL code string to parse. This can also be an integer. If a `Offset` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Offset`.
- 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.

def order_by( self: ~Q, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1119    def order_by(
    1120        self: Q,
    1121        *expressions: t.Optional[ExpOrStr],
    1122        append: bool = True,
    1123        dialect: DialectType = None,
    1124        copy: bool = True,
    1125        **opts,
    1126    ) -> Q:
    1127        """
    1128        Set the ORDER BY expression.
    1129
    1130        Example:
    1131            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    1132            'SELECT x FROM tbl ORDER BY x DESC'
    1133
    1134        Args:
    1135            *expressions: the SQL code strings to parse.
    1136                If a `Group` instance is passed, this is used as-is.
    1137                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    1138            append: if `True`, add to any existing expressions.
    1139                Otherwise, this flattens all the `Order` expression into a single expression.
    1140            dialect: the dialect used to parse the input expression.
    1141            copy: if `False`, modify this expression instance in-place.
    1142            opts: other options to use to parse the input expressions.
    1143
    1144        Returns:
    1145            The modified Select expression.
    1146        """
    1147        return _apply_child_list_builder(
    1148            *expressions,
    1149            instance=self,
    1150            arg="order",
    1151            append=append,
    1152            copy=copy,
    1153            prefix="ORDER BY",
    1154            into=Order,
    1155            dialect=dialect,
    1156            **opts,
    1157        )

Set the ORDER BY expression.

###### Example:

>     >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
>     'SELECT x FROM tbl ORDER BY x DESC'

###### Arguments:

- *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Order`.
- 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.

ctes: List[CTE] View Source

    1159    @property
    1160    def ctes(self) -> t.List[CTE]:
    1161        """Returns a list of all the CTEs attached to this query."""
    1162        with_ = self.args.get("with")
    1163        return with_.expressions if with_ else []

Returns a list of all the CTEs attached to this query.

selects: List[Expression] View Source

    1165    @property
    1166    def selects(self) -> t.List[Expression]:
    1167        """Returns the query's projections."""
    1168        raise NotImplementedError("Query objects must implement `selects`")

Returns the query's projections.

named_selects: List[str] View Source

    1170    @property
    1171    def named_selects(self) -> t.List[str]:
    1172        """Returns the output names of the query's projections."""
    1173        raise NotImplementedError("Query objects must implement `named_selects`")

Returns the output names of the query's projections.

def select( self: ~Q, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1175    def select(
    1176        self: Q,
    1177        *expressions: t.Optional[ExpOrStr],
    1178        append: bool = True,
    1179        dialect: DialectType = None,
    1180        copy: bool = True,
    1181        **opts,
    1182    ) -> Q:
    1183        """
    1184        Append to or set the SELECT expressions.
    1185
    1186        Example:
    1187            >>> Select().select("x", "y").sql()
    1188            'SELECT x, y'
    1189
    1190        Args:
    1191            *expressions: the SQL code strings to parse.
    1192                If an `Expression` instance is passed, it will be used as-is.
    1193            append: if `True`, add to any existing expressions.
    1194                Otherwise, this resets the expressions.
    1195            dialect: the dialect used to parse the input expressions.
    1196            copy: if `False`, modify this expression instance in-place.
    1197            opts: other options to use to parse the input expressions.
    1198
    1199        Returns:
    1200            The modified Query expression.
    1201        """
    1202        raise NotImplementedError("Query objects must implement `select`")

Append to or set the SELECT expressions.

###### Example:

>     >>> Select().select("x", "y").sql()
>     'SELECT x, y'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Query expression.

def with_( self: ~Q, alias: Union[str, Expression], as_: Union[str, Expression], recursive: Optional[bool] = None, materialized: Optional[bool] = None, append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1204    def with_(
    1205        self: Q,
    1206        alias: ExpOrStr,
    1207        as_: ExpOrStr,
    1208        recursive: t.Optional[bool] = None,
    1209        materialized: t.Optional[bool] = None,
    1210        append: bool = True,
    1211        dialect: DialectType = None,
    1212        copy: bool = True,
    1213        **opts,
    1214    ) -> Q:
    1215        """
    1216        Append to or set the common table expressions.
    1217
    1218        Example:
    1219            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    1220            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    1221
    1222        Args:
    1223            alias: the SQL code string to parse as the table name.
    1224                If an `Expression` instance is passed, this is used as-is.
    1225            as_: the SQL code string to parse as the table expression.
    1226                If an `Expression` instance is passed, it will be used as-is.
    1227            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1228            materialized: set the MATERIALIZED part of the expression.
    1229            append: if `True`, add to any existing expressions.
    1230                Otherwise, this resets the expressions.
    1231            dialect: the dialect used to parse the input expression.
    1232            copy: if `False`, modify this expression instance in-place.
    1233            opts: other options to use to parse the input expressions.
    1234
    1235        Returns:
    1236            The modified expression.
    1237        """
    1238        return _apply_cte_builder(
    1239            self,
    1240            alias,
    1241            as_,
    1242            recursive=recursive,
    1243            materialized=materialized,
    1244            append=append,
    1245            dialect=dialect,
    1246            copy=copy,
    1247            **opts,
    1248        )

Append to or set the common table expressions.

###### Example:

>     >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
>     'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'

###### Arguments:

- alias: the SQL code string to parse as the table name. If an `Expression` instance is passed, this is used as-is.
- as_: the SQL code string to parse as the table expression. If an `Expression` instance is passed, it will be used as-is.
- recursive: set the RECURSIVE part of the expression. Defaults to `False`.
- materialized: set the MATERIALIZED part of the expression.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- 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 expression.

def union( self, *expressions: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Union: View Source

    1250    def union(
    1251        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1252    ) -> Union:
    1253        """
    1254        Builds a UNION expression.
    1255
    1256        Example:
    1257            >>> import sqlglot
    1258            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    1259            'SELECT * FROM foo UNION SELECT * FROM bla'
    1260
    1261        Args:
    1262            expressions: the SQL code strings.
    1263                If `Expression` instances are passed, they will be used as-is.
    1264            distinct: set the DISTINCT flag if and only if this is true.
    1265            dialect: the dialect used to parse the input expression.
    1266            opts: other options to use to parse the input expressions.
    1267
    1268        Returns:
    1269            The new Union expression.
    1270        """
    1271        return union(self, *expressions, distinct=distinct, dialect=dialect, **opts)

Builds a UNION expression.

###### Example:

>     >>> import sqlglot
>     >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
>     'SELECT * FROM foo UNION SELECT * FROM bla'

###### Arguments:

- expressions: the SQL code strings. If `Expression` instances are passed, they will be used as-is.
- distinct: set the DISTINCT flag if and only if this is true.
- dialect: the dialect used to parse the input expression.
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Union expression.

def intersect( self, *expressions: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Intersect: View Source

    1273    def intersect(
    1274        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1275    ) -> Intersect:
    1276        """
    1277        Builds an INTERSECT expression.
    1278
    1279        Example:
    1280            >>> import sqlglot
    1281            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    1282            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    1283
    1284        Args:
    1285            expressions: the SQL code strings.
    1286                If `Expression` instances are passed, they will be used as-is.
    1287            distinct: set the DISTINCT flag if and only if this is true.
    1288            dialect: the dialect used to parse the input expression.
    1289            opts: other options to use to parse the input expressions.
    1290
    1291        Returns:
    1292            The new Intersect expression.
    1293        """
    1294        return intersect(self, *expressions, distinct=distinct, dialect=dialect, **opts)

Builds an INTERSECT expression.

###### Example:

>     >>> import sqlglot
>     >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
>     'SELECT * FROM foo INTERSECT SELECT * FROM bla'

###### Arguments:

- expressions: the SQL code strings. If `Expression` instances are passed, they will be used as-is.
- distinct: set the DISTINCT flag if and only if this is true.
- dialect: the dialect used to parse the input expression.
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Intersect expression.

def except_( self, *expressions: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Except: View Source

    1296    def except_(
    1297        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1298    ) -> Except:
    1299        """
    1300        Builds an EXCEPT expression.
    1301
    1302        Example:
    1303            >>> import sqlglot
    1304            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    1305            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    1306
    1307        Args:
    1308            expressions: the SQL code strings.
    1309                If `Expression` instance are passed, they will be used as-is.
    1310            distinct: set the DISTINCT flag if and only if this is true.
    1311            dialect: the dialect used to parse the input expression.
    1312            opts: other options to use to parse the input expressions.
    1313
    1314        Returns:
    1315            The new Except expression.
    1316        """
    1317        return except_(self, *expressions, distinct=distinct, dialect=dialect, **opts)

Builds an EXCEPT expression.

###### Example:

>     >>> import sqlglot
>     >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
>     'SELECT * FROM foo EXCEPT SELECT * FROM bla'

###### Arguments:

- expressions: the SQL code strings. If `Expression` instance are passed, they will be used as-is.
- distinct: set the DISTINCT flag if and only if this is true.
- dialect: the dialect used to parse the input expression.
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Except expression.

key = 'query'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UDTF(DerivedTable): View Source

    1320class UDTF(DerivedTable):
    1321    @property
    1322    def selects(self) -> t.List[Expression]:
    1323        alias = self.args.get("alias")
    1324        return alias.columns if alias else []

selects: List[Expression] View Source

    1321    @property
    1322    def selects(self) -> t.List[Expression]:
    1323        alias = self.args.get("alias")
    1324        return alias.columns if alias else []

key = 'udtf'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DerivedTable
  named_selects

class Cache(Expression): View Source

    1327class Cache(Expression):
    1328    arg_types = {
    1329        "this": True,
    1330        "lazy": False,
    1331        "options": False,
    1332        "expression": False,
    1333    }

arg_types = {'this': True, 'lazy': False, 'options': False, 'expression': False}
key = 'cache'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Uncache(Expression): View Source

    1336class Uncache(Expression):
    1337    arg_types = {"this": True, "exists": False}

arg_types = {'this': True, 'exists': False}
key = 'uncache'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Refresh(Expression): View Source

    1340class Refresh(Expression):
    1341    pass

key = 'refresh'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DDL(Expression): View Source

    1344class DDL(Expression):
    1345    @property
    1346    def ctes(self) -> t.List[CTE]:
    1347        """Returns a list of all the CTEs attached to this statement."""
    1348        with_ = self.args.get("with")
    1349        return with_.expressions if with_ else []
    1350
    1351    @property
    1352    def selects(self) -> t.List[Expression]:
    1353        """If this statement contains a query (e.g. a CTAS), this returns the query's projections."""
    1354        return self.expression.selects if isinstance(self.expression, Query) else []
    1355
    1356    @property
    1357    def named_selects(self) -> t.List[str]:
    1358        """
    1359        If this statement contains a query (e.g. a CTAS), this returns the output
    1360        names of the query's projections.
    1361        """
    1362        return self.expression.named_selects if isinstance(self.expression, Query) else []

ctes: List[CTE] View Source

    1345    @property
    1346    def ctes(self) -> t.List[CTE]:
    1347        """Returns a list of all the CTEs attached to this statement."""
    1348        with_ = self.args.get("with")
    1349        return with_.expressions if with_ else []

Returns a list of all the CTEs attached to this statement.

selects: List[Expression] View Source

    1351    @property
    1352    def selects(self) -> t.List[Expression]:
    1353        """If this statement contains a query (e.g. a CTAS), this returns the query's projections."""
    1354        return self.expression.selects if isinstance(self.expression, Query) else []

If this statement contains a query (e.g. a CTAS), this returns the query's projections.

named_selects: List[str] View Source

    1356    @property
    1357    def named_selects(self) -> t.List[str]:
    1358        """
    1359        If this statement contains a query (e.g. a CTAS), this returns the output
    1360        names of the query's projections.
    1361        """
    1362        return self.expression.named_selects if isinstance(self.expression, Query) else []

If this statement contains a query (e.g. a CTAS), this returns the output names of the query's projections.

key = 'ddl'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DML(Expression): View Source

    1365class DML(Expression):
    1366    def returning(
    1367        self,
    1368        expression: ExpOrStr,
    1369        dialect: DialectType = None,
    1370        copy: bool = True,
    1371        **opts,
    1372    ) -> "Self":
    1373        """
    1374        Set the RETURNING expression. Not supported by all dialects.
    1375
    1376        Example:
    1377            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1378            'DELETE FROM tbl RETURNING *'
    1379
    1380        Args:
    1381            expression: the SQL code strings to parse.
    1382                If an `Expression` instance is passed, it will be used as-is.
    1383            dialect: the dialect used to parse the input expressions.
    1384            copy: if `False`, modify this expression instance in-place.
    1385            opts: other options to use to parse the input expressions.
    1386
    1387        Returns:
    1388            Delete: the modified expression.
    1389        """
    1390        return _apply_builder(
    1391            expression=expression,
    1392            instance=self,
    1393            arg="returning",
    1394            prefix="RETURNING",
    1395            dialect=dialect,
    1396            copy=copy,
    1397            into=Returning,
    1398            **opts,
    1399        )

def returning( self, expression: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> typing_extensions.Self: View Source

    1366    def returning(
    1367        self,
    1368        expression: ExpOrStr,
    1369        dialect: DialectType = None,
    1370        copy: bool = True,
    1371        **opts,
    1372    ) -> "Self":
    1373        """
    1374        Set the RETURNING expression. Not supported by all dialects.
    1375
    1376        Example:
    1377            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1378            'DELETE FROM tbl RETURNING *'
    1379
    1380        Args:
    1381            expression: the SQL code strings to parse.
    1382                If an `Expression` instance is passed, it will be used as-is.
    1383            dialect: the dialect used to parse the input expressions.
    1384            copy: if `False`, modify this expression instance in-place.
    1385            opts: other options to use to parse the input expressions.
    1386
    1387        Returns:
    1388            Delete: the modified expression.
    1389        """
    1390        return _apply_builder(
    1391            expression=expression,
    1392            instance=self,
    1393            arg="returning",
    1394            prefix="RETURNING",
    1395            dialect=dialect,
    1396            copy=copy,
    1397            into=Returning,
    1398            **opts,
    1399        )

Set the RETURNING expression. Not supported by all dialects.

###### Example:

>     >>> delete("tbl").returning("*", dialect="postgres").sql()
>     'DELETE FROM tbl RETURNING *'

###### Arguments:

- expression: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> Delete: the modified expression.

key = 'dml'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Create(DDL): View Source

    1402class Create(DDL):
    1403    arg_types = {
    1404        "with": False,
    1405        "this": True,
    1406        "kind": True,
    1407        "expression": False,
    1408        "exists": False,
    1409        "properties": False,
    1410        "replace": False,
    1411        "refresh": False,
    1412        "unique": False,
    1413        "indexes": False,
    1414        "no_schema_binding": False,
    1415        "begin": False,
    1416        "end": False,
    1417        "clone": False,
    1418        "concurrently": False,
    1419        "clustered": False,
    1420    }
    1421
    1422    @property
    1423    def kind(self) -> t.Optional[str]:
    1424        kind = self.args.get("kind")
    1425        return kind and kind.upper()

arg_types = {'with': False, 'this': True, 'kind': True, 'expression': False, 'exists': False, 'properties': False, 'replace': False, 'refresh': False, 'unique': False, 'indexes': False, 'no_schema_binding': False, 'begin': False, 'end': False, 'clone': False, 'concurrently': False, 'clustered': False}
kind: Optional[str] View Source

    1422    @property
    1423    def kind(self) -> t.Optional[str]:
    1424        kind = self.args.get("kind")
    1425        return kind and kind.upper()

key = 'create'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DDL
  ctes
  selects
  named_selects

class SequenceProperties(Expression): View Source

    1428class SequenceProperties(Expression):
    1429    arg_types = {
    1430        "increment": False,
    1431        "minvalue": False,
    1432        "maxvalue": False,
    1433        "cache": False,
    1434        "start": False,
    1435        "owned": False,
    1436        "options": False,
    1437    }

arg_types = {'increment': False, 'minvalue': False, 'maxvalue': False, 'cache': False, 'start': False, 'owned': False, 'options': False}
key = 'sequenceproperties'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TruncateTable(Expression): View Source

    1440class TruncateTable(Expression):
    1441    arg_types = {
    1442        "expressions": True,
    1443        "is_database": False,
    1444        "exists": False,
    1445        "only": False,
    1446        "cluster": False,
    1447        "identity": False,
    1448        "option": False,
    1449        "partition": False,
    1450    }

arg_types = {'expressions': True, 'is_database': False, 'exists': False, 'only': False, 'cluster': False, 'identity': False, 'option': False, 'partition': False}
key = 'truncatetable'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Clone(Expression): View Source

    1456class Clone(Expression):
    1457    arg_types = {"this": True, "shallow": False, "copy": False}

arg_types = {'this': True, 'shallow': False, 'copy': False}
key = 'clone'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Describe(Expression): View Source

    1460class Describe(Expression):
    1461    arg_types = {
    1462        "this": True,
    1463        "style": False,
    1464        "kind": False,
    1465        "expressions": False,
    1466        "partition": False,
    1467    }

arg_types = {'this': True, 'style': False, 'kind': False, 'expressions': False, 'partition': False}
key = 'describe'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Summarize(Expression): View Source

    1471class Summarize(Expression):
    1472    arg_types = {"this": True, "table": False}

arg_types = {'this': True, 'table': False}
key = 'summarize'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Kill(Expression): View Source

    1475class Kill(Expression):
    1476    arg_types = {"this": True, "kind": False}

arg_types = {'this': True, 'kind': False}
key = 'kill'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Pragma(Expression): View Source

    1479class Pragma(Expression):
    1480    pass

key = 'pragma'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Declare(Expression): View Source

    1483class Declare(Expression):
    1484    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'declare'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DeclareItem(Expression): View Source

    1487class DeclareItem(Expression):
    1488    arg_types = {"this": True, "kind": True, "default": False}

arg_types = {'this': True, 'kind': True, 'default': False}
key = 'declareitem'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Set(Expression): View Source

    1491class Set(Expression):
    1492    arg_types = {"expressions": False, "unset": False, "tag": False}

arg_types = {'expressions': False, 'unset': False, 'tag': False}
key = 'set'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Heredoc(Expression): View Source

    1495class Heredoc(Expression):
    1496    arg_types = {"this": True, "tag": False}

arg_types = {'this': True, 'tag': False}
key = 'heredoc'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetItem(Expression): View Source

    1499class SetItem(Expression):
    1500    arg_types = {
    1501        "this": False,
    1502        "expressions": False,
    1503        "kind": False,
    1504        "collate": False,  # MySQL SET NAMES statement
    1505        "global": False,
    1506    }

arg_types = {'this': False, 'expressions': False, 'kind': False, 'collate': False, 'global': False}
key = 'setitem'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Show(Expression): View Source

    1509class Show(Expression):
    1510    arg_types = {
    1511        "this": True,
    1512        "history": False,
    1513        "terse": False,
    1514        "target": False,
    1515        "offset": False,
    1516        "starts_with": False,
    1517        "limit": False,
    1518        "from": False,
    1519        "like": False,
    1520        "where": False,
    1521        "db": False,
    1522        "scope": False,
    1523        "scope_kind": False,
    1524        "full": False,
    1525        "mutex": False,
    1526        "query": False,
    1527        "channel": False,
    1528        "global": False,
    1529        "log": False,
    1530        "position": False,
    1531        "types": False,
    1532    }

arg_types = {'this': True, 'history': False, 'terse': False, 'target': False, 'offset': False, 'starts_with': False, 'limit': False, 'from': False, 'like': False, 'where': False, 'db': False, 'scope': False, 'scope_kind': False, 'full': False, 'mutex': False, 'query': False, 'channel': False, 'global': False, 'log': False, 'position': False, 'types': False}
key = 'show'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UserDefinedFunction(Expression): View Source

    1535class UserDefinedFunction(Expression):
    1536    arg_types = {"this": True, "expressions": False, "wrapped": False}

arg_types = {'this': True, 'expressions': False, 'wrapped': False}
key = 'userdefinedfunction'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CharacterSet(Expression): View Source

    1539class CharacterSet(Expression):
    1540    arg_types = {"this": True, "default": False}

arg_types = {'this': True, 'default': False}
key = 'characterset'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class With(Expression): View Source

    1543class With(Expression):
    1544    arg_types = {"expressions": True, "recursive": False}
    1545
    1546    @property
    1547    def recursive(self) -> bool:
    1548        return bool(self.args.get("recursive"))

arg_types = {'expressions': True, 'recursive': False}
recursive: bool View Source

    1546    @property
    1547    def recursive(self) -> bool:
    1548        return bool(self.args.get("recursive"))

key = 'with'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithinGroup(Expression): View Source

    1551class WithinGroup(Expression):
    1552    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'withingroup'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CTE(DerivedTable): View Source

    1557class CTE(DerivedTable):
    1558    arg_types = {
    1559        "this": True,
    1560        "alias": True,
    1561        "scalar": False,
    1562        "materialized": False,
    1563    }

arg_types = {'this': True, 'alias': True, 'scalar': False, 'materialized': False}
key = 'cte'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DerivedTable
  selects
  named_selects

class ProjectionDef(Expression): View Source

    1566class ProjectionDef(Expression):
    1567    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'projectiondef'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TableAlias(Expression): View Source

    1570class TableAlias(Expression):
    1571    arg_types = {"this": False, "columns": False}
    1572
    1573    @property
    1574    def columns(self):
    1575        return self.args.get("columns") or []

arg_types = {'this': False, 'columns': False}
columns View Source

    1573    @property
    1574    def columns(self):
    1575        return self.args.get("columns") or []

key = 'tablealias'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BitString(Condition): View Source

    1578class BitString(Condition):
    1579    pass

key = 'bitstring'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HexString(Condition): View Source

    1582class HexString(Condition):
    1583    pass

key = 'hexstring'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ByteString(Condition): View Source

    1586class ByteString(Condition):
    1587    pass

key = 'bytestring'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RawString(Condition): View Source

    1590class RawString(Condition):
    1591    pass

key = 'rawstring'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UnicodeString(Condition): View Source

    1594class UnicodeString(Condition):
    1595    arg_types = {"this": True, "escape": False}

arg_types = {'this': True, 'escape': False}
key = 'unicodestring'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Column(Condition): View Source

    1598class Column(Condition):
    1599    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
    1600
    1601    @property
    1602    def table(self) -> str:
    1603        return self.text("table")
    1604
    1605    @property
    1606    def db(self) -> str:
    1607        return self.text("db")
    1608
    1609    @property
    1610    def catalog(self) -> str:
    1611        return self.text("catalog")
    1612
    1613    @property
    1614    def output_name(self) -> str:
    1615        return self.name
    1616
    1617    @property
    1618    def parts(self) -> t.List[Identifier]:
    1619        """Return the parts of a column in order catalog, db, table, name."""
    1620        return [
    1621            t.cast(Identifier, self.args[part])
    1622            for part in ("catalog", "db", "table", "this")
    1623            if self.args.get(part)
    1624        ]
    1625
    1626    def to_dot(self) -> Dot | Identifier:
    1627        """Converts the column into a dot expression."""
    1628        parts = self.parts
    1629        parent = self.parent
    1630
    1631        while parent:
    1632            if isinstance(parent, Dot):
    1633                parts.append(parent.expression)
    1634            parent = parent.parent
    1635
    1636        return Dot.build(deepcopy(parts)) if len(parts) > 1 else parts[0]

arg_types = {'this': True, 'table': False, 'db': False, 'catalog': False, 'join_mark': False}
table: str View Source

    1601    @property
    1602    def table(self) -> str:
    1603        return self.text("table")

db: str View Source

    1605    @property
    1606    def db(self) -> str:
    1607        return self.text("db")

catalog: str View Source

    1609    @property
    1610    def catalog(self) -> str:
    1611        return self.text("catalog")

output_name: str View Source

    1613    @property
    1614    def output_name(self) -> str:
    1615        return self.name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

parts: List[Identifier] View Source

    1617    @property
    1618    def parts(self) -> t.List[Identifier]:
    1619        """Return the parts of a column in order catalog, db, table, name."""
    1620        return [
    1621            t.cast(Identifier, self.args[part])
    1622            for part in ("catalog", "db", "table", "this")
    1623            if self.args.get(part)
    1624        ]

Return the parts of a column in order catalog, db, table, name.

def to_dot(self) -> Dot | Identifier: View Source

    1626    def to_dot(self) -> Dot | Identifier:
    1627        """Converts the column into a dot expression."""
    1628        parts = self.parts
    1629        parent = self.parent
    1630
    1631        while parent:
    1632            if isinstance(parent, Dot):
    1633                parts.append(parent.expression)
    1634            parent = parent.parent
    1635
    1636        return Dot.build(deepcopy(parts)) if len(parts) > 1 else parts[0]

Converts the column into a dot expression.

key = 'column'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnPosition(Expression): View Source

    1639class ColumnPosition(Expression):
    1640    arg_types = {"this": False, "position": True}

arg_types = {'this': False, 'position': True}
key = 'columnposition'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnDef(Expression): View Source

    1643class ColumnDef(Expression):
    1644    arg_types = {
    1645        "this": True,
    1646        "kind": False,
    1647        "constraints": False,
    1648        "exists": False,
    1649        "position": False,
    1650    }
    1651
    1652    @property
    1653    def constraints(self) -> t.List[ColumnConstraint]:
    1654        return self.args.get("constraints") or []
    1655
    1656    @property
    1657    def kind(self) -> t.Optional[DataType]:
    1658        return self.args.get("kind")

arg_types = {'this': True, 'kind': False, 'constraints': False, 'exists': False, 'position': False}
constraints: List[ColumnConstraint] View Source

    1652    @property
    1653    def constraints(self) -> t.List[ColumnConstraint]:
    1654        return self.args.get("constraints") or []

kind: Optional[DataType] View Source

    1656    @property
    1657    def kind(self) -> t.Optional[DataType]:
    1658        return self.args.get("kind")

key = 'columndef'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterColumn(Expression): View Source

    1661class AlterColumn(Expression):
    1662    arg_types = {
    1663        "this": True,
    1664        "dtype": False,
    1665        "collate": False,
    1666        "using": False,
    1667        "default": False,
    1668        "drop": False,
    1669        "comment": False,
    1670        "allow_null": False,
    1671    }

arg_types = {'this': True, 'dtype': False, 'collate': False, 'using': False, 'default': False, 'drop': False, 'comment': False, 'allow_null': False}
key = 'altercolumn'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterDistStyle(Expression): View Source

    1675class AlterDistStyle(Expression):
    1676    pass

key = 'alterdiststyle'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterSortKey(Expression): View Source

    1679class AlterSortKey(Expression):
    1680    arg_types = {"this": False, "expressions": False, "compound": False}

arg_types = {'this': False, 'expressions': False, 'compound': False}
key = 'altersortkey'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterSet(Expression): View Source

    1683class AlterSet(Expression):
    1684    arg_types = {
    1685        "expressions": False,
    1686        "option": False,
    1687        "tablespace": False,
    1688        "access_method": False,
    1689        "file_format": False,
    1690        "copy_options": False,
    1691        "tag": False,
    1692        "location": False,
    1693        "serde": False,
    1694    }

arg_types = {'expressions': False, 'option': False, 'tablespace': False, 'access_method': False, 'file_format': False, 'copy_options': False, 'tag': False, 'location': False, 'serde': False}
key = 'alterset'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RenameColumn(Expression): View Source

    1697class RenameColumn(Expression):
    1698    arg_types = {"this": True, "to": True, "exists": False}

arg_types = {'this': True, 'to': True, 'exists': False}
key = 'renamecolumn'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterRename(Expression): View Source

    1701class AlterRename(Expression):
    1702    pass

key = 'alterrename'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SwapTable(Expression): View Source

    1705class SwapTable(Expression):
    1706    pass

key = 'swaptable'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Comment(Expression): View Source

    1709class Comment(Expression):
    1710    arg_types = {
    1711        "this": True,
    1712        "kind": True,
    1713        "expression": True,
    1714        "exists": False,
    1715        "materialized": False,
    1716    }

arg_types = {'this': True, 'kind': True, 'expression': True, 'exists': False, 'materialized': False}
key = 'comment'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Comprehension(Expression): View Source

    1719class Comprehension(Expression):
    1720    arg_types = {"this": True, "expression": True, "iterator": True, "condition": False}

arg_types = {'this': True, 'expression': True, 'iterator': True, 'condition': False}
key = 'comprehension'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MergeTreeTTLAction(Expression): View Source

    1724class MergeTreeTTLAction(Expression):
    1725    arg_types = {
    1726        "this": True,
    1727        "delete": False,
    1728        "recompress": False,
    1729        "to_disk": False,
    1730        "to_volume": False,
    1731    }

arg_types = {'this': True, 'delete': False, 'recompress': False, 'to_disk': False, 'to_volume': False}
key = 'mergetreettlaction'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MergeTreeTTL(Expression): View Source

    1735class MergeTreeTTL(Expression):
    1736    arg_types = {
    1737        "expressions": True,
    1738        "where": False,
    1739        "group": False,
    1740        "aggregates": False,
    1741    }

arg_types = {'expressions': True, 'where': False, 'group': False, 'aggregates': False}
key = 'mergetreettl'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexConstraintOption(Expression): View Source

    1745class IndexConstraintOption(Expression):
    1746    arg_types = {
    1747        "key_block_size": False,
    1748        "using": False,
    1749        "parser": False,
    1750        "comment": False,
    1751        "visible": False,
    1752        "engine_attr": False,
    1753        "secondary_engine_attr": False,
    1754    }

arg_types = {'key_block_size': False, 'using': False, 'parser': False, 'comment': False, 'visible': False, 'engine_attr': False, 'secondary_engine_attr': False}
key = 'indexconstraintoption'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnConstraint(Expression): View Source

    1757class ColumnConstraint(Expression):
    1758    arg_types = {"this": False, "kind": True}
    1759
    1760    @property
    1761    def kind(self) -> ColumnConstraintKind:
    1762        return self.args["kind"]

arg_types = {'this': False, 'kind': True}
kind: ColumnConstraintKind View Source

    1760    @property
    1761    def kind(self) -> ColumnConstraintKind:
    1762        return self.args["kind"]

key = 'columnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnConstraintKind(Expression): View Source

    1765class ColumnConstraintKind(Expression):
    1766    pass

key = 'columnconstraintkind'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AutoIncrementColumnConstraint(ColumnConstraintKind): View Source

    1769class AutoIncrementColumnConstraint(ColumnConstraintKind):
    1770    pass

key = 'autoincrementcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PeriodForSystemTimeConstraint(ColumnConstraintKind): View Source

    1773class PeriodForSystemTimeConstraint(ColumnConstraintKind):
    1774    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'periodforsystemtimeconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CaseSpecificColumnConstraint(ColumnConstraintKind): View Source

    1777class CaseSpecificColumnConstraint(ColumnConstraintKind):
    1778    arg_types = {"not_": True}

arg_types = {'not_': True}
key = 'casespecificcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CharacterSetColumnConstraint(ColumnConstraintKind): View Source

    1781class CharacterSetColumnConstraint(ColumnConstraintKind):
    1782    arg_types = {"this": True}

arg_types = {'this': True}
key = 'charactersetcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CheckColumnConstraint(ColumnConstraintKind): View Source

    1785class CheckColumnConstraint(ColumnConstraintKind):
    1786    arg_types = {"this": True, "enforced": False}

arg_types = {'this': True, 'enforced': False}
key = 'checkcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ClusteredColumnConstraint(ColumnConstraintKind): View Source

    1789class ClusteredColumnConstraint(ColumnConstraintKind):
    1790    pass

key = 'clusteredcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CollateColumnConstraint(ColumnConstraintKind): View Source

    1793class CollateColumnConstraint(ColumnConstraintKind):
    1794    pass

key = 'collatecolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CommentColumnConstraint(ColumnConstraintKind): View Source

    1797class CommentColumnConstraint(ColumnConstraintKind):
    1798    pass

key = 'commentcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CompressColumnConstraint(ColumnConstraintKind): View Source

    1801class CompressColumnConstraint(ColumnConstraintKind):
    1802    arg_types = {"this": False}

arg_types = {'this': False}
key = 'compresscolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateFormatColumnConstraint(ColumnConstraintKind): View Source

    1805class DateFormatColumnConstraint(ColumnConstraintKind):
    1806    arg_types = {"this": True}

arg_types = {'this': True}
key = 'dateformatcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DefaultColumnConstraint(ColumnConstraintKind): View Source

    1809class DefaultColumnConstraint(ColumnConstraintKind):
    1810    pass

key = 'defaultcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EncodeColumnConstraint(ColumnConstraintKind): View Source

    1813class EncodeColumnConstraint(ColumnConstraintKind):
    1814    pass

key = 'encodecolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ExcludeColumnConstraint(ColumnConstraintKind): View Source

    1818class ExcludeColumnConstraint(ColumnConstraintKind):
    1819    pass

key = 'excludecolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EphemeralColumnConstraint(ColumnConstraintKind): View Source

    1822class EphemeralColumnConstraint(ColumnConstraintKind):
    1823    arg_types = {"this": False}

arg_types = {'this': False}
key = 'ephemeralcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithOperator(Expression): View Source

    1826class WithOperator(Expression):
    1827    arg_types = {"this": True, "op": True}

arg_types = {'this': True, 'op': True}
key = 'withoperator'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind): View Source

    1830class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
    1831    # this: True -> ALWAYS, this: False -> BY DEFAULT
    1832    arg_types = {
    1833        "this": False,
    1834        "expression": False,
    1835        "on_null": False,
    1836        "start": False,
    1837        "increment": False,
    1838        "minvalue": False,
    1839        "maxvalue": False,
    1840        "cycle": False,
    1841    }

arg_types = {'this': False, 'expression': False, 'on_null': False, 'start': False, 'increment': False, 'minvalue': False, 'maxvalue': False, 'cycle': False}
key = 'generatedasidentitycolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GeneratedAsRowColumnConstraint(ColumnConstraintKind): View Source

    1844class GeneratedAsRowColumnConstraint(ColumnConstraintKind):
    1845    arg_types = {"start": False, "hidden": False}

arg_types = {'start': False, 'hidden': False}
key = 'generatedasrowcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexColumnConstraint(ColumnConstraintKind): View Source

    1850class IndexColumnConstraint(ColumnConstraintKind):
    1851    arg_types = {
    1852        "this": False,
    1853        "expressions": False,
    1854        "kind": False,
    1855        "index_type": False,
    1856        "options": False,
    1857        "expression": False,  # Clickhouse
    1858        "granularity": False,
    1859    }

arg_types = {'this': False, 'expressions': False, 'kind': False, 'index_type': False, 'options': False, 'expression': False, 'granularity': False}
key = 'indexcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InlineLengthColumnConstraint(ColumnConstraintKind): View Source

    1862class InlineLengthColumnConstraint(ColumnConstraintKind):
    1863    pass

key = 'inlinelengthcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NonClusteredColumnConstraint(ColumnConstraintKind): View Source

    1866class NonClusteredColumnConstraint(ColumnConstraintKind):
    1867    pass

key = 'nonclusteredcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NotForReplicationColumnConstraint(ColumnConstraintKind): View Source

    1870class NotForReplicationColumnConstraint(ColumnConstraintKind):
    1871    arg_types = {}

arg_types = {}
key = 'notforreplicationcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MaskingPolicyColumnConstraint(ColumnConstraintKind): View Source

    1875class MaskingPolicyColumnConstraint(ColumnConstraintKind):
    1876    arg_types = {"this": True, "expressions": False}

arg_types = {'this': True, 'expressions': False}
key = 'maskingpolicycolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NotNullColumnConstraint(ColumnConstraintKind): View Source

    1879class NotNullColumnConstraint(ColumnConstraintKind):
    1880    arg_types = {"allow_null": False}

arg_types = {'allow_null': False}
key = 'notnullcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnUpdateColumnConstraint(ColumnConstraintKind): View Source

    1884class OnUpdateColumnConstraint(ColumnConstraintKind):
    1885    pass

key = 'onupdatecolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TagColumnConstraint(ColumnConstraintKind): View Source

    1889class TagColumnConstraint(ColumnConstraintKind):
    1890    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'tagcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TransformColumnConstraint(ColumnConstraintKind): View Source

    1894class TransformColumnConstraint(ColumnConstraintKind):
    1895    pass

key = 'transformcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PrimaryKeyColumnConstraint(ColumnConstraintKind): View Source

    1898class PrimaryKeyColumnConstraint(ColumnConstraintKind):
    1899    arg_types = {"desc": False}

arg_types = {'desc': False}
key = 'primarykeycolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TitleColumnConstraint(ColumnConstraintKind): View Source

    1902class TitleColumnConstraint(ColumnConstraintKind):
    1903    pass

key = 'titlecolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UniqueColumnConstraint(ColumnConstraintKind): View Source

    1906class UniqueColumnConstraint(ColumnConstraintKind):
    1907    arg_types = {"this": False, "index_type": False, "on_conflict": False, "nulls": False}

arg_types = {'this': False, 'index_type': False, 'on_conflict': False, 'nulls': False}
key = 'uniquecolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UppercaseColumnConstraint(ColumnConstraintKind): View Source

    1910class UppercaseColumnConstraint(ColumnConstraintKind):
    1911    arg_types: t.Dict[str, t.Any] = {}

arg_types: Dict[str, Any] = {}
key = 'uppercasecolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PathColumnConstraint(ColumnConstraintKind): View Source

    1914class PathColumnConstraint(ColumnConstraintKind):
    1915    pass

key = 'pathcolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ProjectionPolicyColumnConstraint(ColumnConstraintKind): View Source

    1919class ProjectionPolicyColumnConstraint(ColumnConstraintKind):
    1920    pass

key = 'projectionpolicycolumnconstraint'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ComputedColumnConstraint(ColumnConstraintKind): View Source

    1925class ComputedColumnConstraint(ColumnConstraintKind):
    1926    arg_types = {"this": True, "persisted": False, "not_null": False}

arg_types = {'this': True, 'persisted': False, 'not_null': False}
key = 'computedcolumnconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Constraint(Expression): View Source

    1929class Constraint(Expression):
    1930    arg_types = {"this": True, "expressions": True}

arg_types = {'this': True, 'expressions': True}
key = 'constraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Delete(DML): View Source

    1933class Delete(DML):
    1934    arg_types = {
    1935        "with": False,
    1936        "this": False,
    1937        "using": False,
    1938        "where": False,
    1939        "returning": False,
    1940        "limit": False,
    1941        "tables": False,  # Multiple-Table Syntax (MySQL)
    1942        "cluster": False,  # Clickhouse
    1943    }
    1944
    1945    def delete(
    1946        self,
    1947        table: ExpOrStr,
    1948        dialect: DialectType = None,
    1949        copy: bool = True,
    1950        **opts,
    1951    ) -> Delete:
    1952        """
    1953        Create a DELETE expression or replace the table on an existing DELETE expression.
    1954
    1955        Example:
    1956            >>> delete("tbl").sql()
    1957            'DELETE FROM tbl'
    1958
    1959        Args:
    1960            table: the table from which to delete.
    1961            dialect: the dialect used to parse the input expression.
    1962            copy: if `False`, modify this expression instance in-place.
    1963            opts: other options to use to parse the input expressions.
    1964
    1965        Returns:
    1966            Delete: the modified expression.
    1967        """
    1968        return _apply_builder(
    1969            expression=table,
    1970            instance=self,
    1971            arg="this",
    1972            dialect=dialect,
    1973            into=Table,
    1974            copy=copy,
    1975            **opts,
    1976        )
    1977
    1978    def where(
    1979        self,
    1980        *expressions: t.Optional[ExpOrStr],
    1981        append: bool = True,
    1982        dialect: DialectType = None,
    1983        copy: bool = True,
    1984        **opts,
    1985    ) -> Delete:
    1986        """
    1987        Append to or set the WHERE expressions.
    1988
    1989        Example:
    1990            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1991            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1992
    1993        Args:
    1994            *expressions: the SQL code strings to parse.
    1995                If an `Expression` instance is passed, it will be used as-is.
    1996                Multiple expressions are combined with an AND operator.
    1997            append: if `True`, AND the new expressions to any existing expression.
    1998                Otherwise, this resets the expression.
    1999            dialect: the dialect used to parse the input expressions.
    2000            copy: if `False`, modify this expression instance in-place.
    2001            opts: other options to use to parse the input expressions.
    2002
    2003        Returns:
    2004            Delete: the modified expression.
    2005        """
    2006        return _apply_conjunction_builder(
    2007            *expressions,
    2008            instance=self,
    2009            arg="where",
    2010            append=append,
    2011            into=Where,
    2012            dialect=dialect,
    2013            copy=copy,
    2014            **opts,
    2015        )

arg_types = {'with': False, 'this': False, 'using': False, 'where': False, 'returning': False, 'limit': False, 'tables': False, 'cluster': False}
def delete( self, table: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Delete: View Source

    1945    def delete(
    1946        self,
    1947        table: ExpOrStr,
    1948        dialect: DialectType = None,
    1949        copy: bool = True,
    1950        **opts,
    1951    ) -> Delete:
    1952        """
    1953        Create a DELETE expression or replace the table on an existing DELETE expression.
    1954
    1955        Example:
    1956            >>> delete("tbl").sql()
    1957            'DELETE FROM tbl'
    1958
    1959        Args:
    1960            table: the table from which to delete.
    1961            dialect: the dialect used to parse the input expression.
    1962            copy: if `False`, modify this expression instance in-place.
    1963            opts: other options to use to parse the input expressions.
    1964
    1965        Returns:
    1966            Delete: the modified expression.
    1967        """
    1968        return _apply_builder(
    1969            expression=table,
    1970            instance=self,
    1971            arg="this",
    1972            dialect=dialect,
    1973            into=Table,
    1974            copy=copy,
    1975            **opts,
    1976        )

Create a DELETE expression or replace the table on an existing DELETE expression.

###### Example:

>     >>> delete("tbl").sql()
>     'DELETE FROM tbl'

###### Arguments:

- table: the table from which to delete.
- 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:

> Delete: the modified expression.

def where( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Delete: View Source

    1978    def where(
    1979        self,
    1980        *expressions: t.Optional[ExpOrStr],
    1981        append: bool = True,
    1982        dialect: DialectType = None,
    1983        copy: bool = True,
    1984        **opts,
    1985    ) -> Delete:
    1986        """
    1987        Append to or set the WHERE expressions.
    1988
    1989        Example:
    1990            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1991            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1992
    1993        Args:
    1994            *expressions: the SQL code strings to parse.
    1995                If an `Expression` instance is passed, it will be used as-is.
    1996                Multiple expressions are combined with an AND operator.
    1997            append: if `True`, AND the new expressions to any existing expression.
    1998                Otherwise, this resets the expression.
    1999            dialect: the dialect used to parse the input expressions.
    2000            copy: if `False`, modify this expression instance in-place.
    2001            opts: other options to use to parse the input expressions.
    2002
    2003        Returns:
    2004            Delete: the modified expression.
    2005        """
    2006        return _apply_conjunction_builder(
    2007            *expressions,
    2008            instance=self,
    2009            arg="where",
    2010            append=append,
    2011            into=Where,
    2012            dialect=dialect,
    2013            copy=copy,
    2014            **opts,
    2015        )

Append to or set the WHERE expressions.

###### Example:

>     >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
>     "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator.
- append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> Delete: the modified expression.

key = 'delete'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class Drop(Expression): View Source

    2018class Drop(Expression):
    2019    arg_types = {
    2020        "this": False,
    2021        "kind": False,
    2022        "expressions": False,
    2023        "exists": False,
    2024        "temporary": False,
    2025        "materialized": False,
    2026        "cascade": False,
    2027        "constraints": False,
    2028        "purge": False,
    2029        "cluster": False,
    2030        "concurrently": False,
    2031    }
    2032
    2033    @property
    2034    def kind(self) -> t.Optional[str]:
    2035        kind = self.args.get("kind")
    2036        return kind and kind.upper()

arg_types = {'this': False, 'kind': False, 'expressions': False, 'exists': False, 'temporary': False, 'materialized': False, 'cascade': False, 'constraints': False, 'purge': False, 'cluster': False, 'concurrently': False}
kind: Optional[str] View Source

    2033    @property
    2034    def kind(self) -> t.Optional[str]:
    2035        kind = self.args.get("kind")
    2036        return kind and kind.upper()

key = 'drop'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Filter(Expression): View Source

    2039class Filter(Expression):
    2040    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'filter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Check(Expression): View Source

    2043class Check(Expression):
    2044    pass

key = 'check'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Changes(Expression): View Source

    2047class Changes(Expression):
    2048    arg_types = {"information": True, "at_before": False, "end": False}

arg_types = {'information': True, 'at_before': False, 'end': False}
key = 'changes'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Connect(Expression): View Source

    2052class Connect(Expression):
    2053    arg_types = {"start": False, "connect": True, "nocycle": False}

arg_types = {'start': False, 'connect': True, 'nocycle': False}
key = 'connect'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CopyParameter(Expression): View Source

    2056class CopyParameter(Expression):
    2057    arg_types = {"this": True, "expression": False, "expressions": False}

arg_types = {'this': True, 'expression': False, 'expressions': False}
key = 'copyparameter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Copy(DML): View Source

    2060class Copy(DML):
    2061    arg_types = {
    2062        "this": True,
    2063        "kind": True,
    2064        "files": True,
    2065        "credentials": False,
    2066        "format": False,
    2067        "params": False,
    2068    }

arg_types = {'this': True, 'kind': True, 'files': True, 'credentials': False, 'format': False, 'params': False}
key = 'copy'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class Credentials(Expression): View Source

    2071class Credentials(Expression):
    2072    arg_types = {
    2073        "credentials": False,
    2074        "encryption": False,
    2075        "storage": False,
    2076        "iam_role": False,
    2077        "region": False,
    2078    }

arg_types = {'credentials': False, 'encryption': False, 'storage': False, 'iam_role': False, 'region': False}
key = 'credentials'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Prior(Expression): View Source

    2081class Prior(Expression):
    2082    pass

key = 'prior'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Directory(Expression): View Source

    2085class Directory(Expression):
    2086    # https://spark.apache.org/docs/3.0.0-preview/sql-ref-syntax-dml-insert-overwrite-directory-hive.html
    2087    arg_types = {"this": True, "local": False, "row_format": False}

arg_types = {'this': True, 'local': False, 'row_format': False}
key = 'directory'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ForeignKey(Expression): View Source

    2090class ForeignKey(Expression):
    2091    arg_types = {
    2092        "expressions": True,
    2093        "reference": False,
    2094        "delete": False,
    2095        "update": False,
    2096    }

arg_types = {'expressions': True, 'reference': False, 'delete': False, 'update': False}
key = 'foreignkey'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnPrefix(Expression): View Source

    2099class ColumnPrefix(Expression):
    2100    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'columnprefix'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PrimaryKey(Expression): View Source

    2103class PrimaryKey(Expression):
    2104    arg_types = {"expressions": True, "options": False}

arg_types = {'expressions': True, 'options': False}
key = 'primarykey'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Into(Expression): View Source

    2109class Into(Expression):
    2110    arg_types = {
    2111        "this": False,
    2112        "temporary": False,
    2113        "unlogged": False,
    2114        "bulk_collect": False,
    2115        "expressions": False,
    2116    }

arg_types = {'this': False, 'temporary': False, 'unlogged': False, 'bulk_collect': False, 'expressions': False}
key = 'into'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class From(Expression): View Source

    2119class From(Expression):
    2120    @property
    2121    def name(self) -> str:
    2122        return self.this.name
    2123
    2124    @property
    2125    def alias_or_name(self) -> str:
    2126        return self.this.alias_or_name

name: str View Source

    2120    @property
    2121    def name(self) -> str:
    2122        return self.this.name

alias_or_name: str View Source

    2124    @property
    2125    def alias_or_name(self) -> str:
    2126        return self.this.alias_or_name

key = 'from'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Having(Expression): View Source

    2129class Having(Expression):
    2130    pass

key = 'having'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Hint(Expression): View Source

    2133class Hint(Expression):
    2134    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'hint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JoinHint(Expression): View Source

    2137class JoinHint(Expression):
    2138    arg_types = {"this": True, "expressions": True}

arg_types = {'this': True, 'expressions': True}
key = 'joinhint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Identifier(Expression): View Source

    2141class Identifier(Expression):
    2142    arg_types = {"this": True, "quoted": False, "global": False, "temporary": False}
    2143
    2144    @property
    2145    def quoted(self) -> bool:
    2146        return bool(self.args.get("quoted"))
    2147
    2148    @property
    2149    def hashable_args(self) -> t.Any:
    2150        return (self.this, self.quoted)
    2151
    2152    @property
    2153    def output_name(self) -> str:
    2154        return self.name

arg_types = {'this': True, 'quoted': False, 'global': False, 'temporary': False}
quoted: bool View Source

    2144    @property
    2145    def quoted(self) -> bool:
    2146        return bool(self.args.get("quoted"))

hashable_args: Any View Source

    2148    @property
    2149    def hashable_args(self) -> t.Any:
    2150        return (self.this, self.quoted)

output_name: str View Source

    2152    @property
    2153    def output_name(self) -> str:
    2154        return self.name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'identifier'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Opclass(Expression): View Source

    2158class Opclass(Expression):
    2159    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'opclass'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Index(Expression): View Source

    2162class Index(Expression):
    2163    arg_types = {
    2164        "this": False,
    2165        "table": False,
    2166        "unique": False,
    2167        "primary": False,
    2168        "amp": False,  # teradata
    2169        "params": False,
    2170    }

arg_types = {'this': False, 'table': False, 'unique': False, 'primary': False, 'amp': False, 'params': False}
key = 'index'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexParameters(Expression): View Source

    2173class IndexParameters(Expression):
    2174    arg_types = {
    2175        "using": False,
    2176        "include": False,
    2177        "columns": False,
    2178        "with_storage": False,
    2179        "partition_by": False,
    2180        "tablespace": False,
    2181        "where": False,
    2182        "on": False,
    2183    }

arg_types = {'using': False, 'include': False, 'columns': False, 'with_storage': False, 'partition_by': False, 'tablespace': False, 'where': False, 'on': False}
key = 'indexparameters'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Insert(DDL, DML): View Source

    2186class Insert(DDL, DML):
    2187    arg_types = {
    2188        "hint": False,
    2189        "with": False,
    2190        "is_function": False,
    2191        "this": False,
    2192        "expression": False,
    2193        "conflict": False,
    2194        "returning": False,
    2195        "overwrite": False,
    2196        "exists": False,
    2197        "alternative": False,
    2198        "where": False,
    2199        "ignore": False,
    2200        "by_name": False,
    2201        "stored": False,
    2202        "partition": False,
    2203        "settings": False,
    2204        "source": False,
    2205    }
    2206
    2207    def with_(
    2208        self,
    2209        alias: ExpOrStr,
    2210        as_: ExpOrStr,
    2211        recursive: t.Optional[bool] = None,
    2212        materialized: t.Optional[bool] = None,
    2213        append: bool = True,
    2214        dialect: DialectType = None,
    2215        copy: bool = True,
    2216        **opts,
    2217    ) -> Insert:
    2218        """
    2219        Append to or set the common table expressions.
    2220
    2221        Example:
    2222            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    2223            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    2224
    2225        Args:
    2226            alias: the SQL code string to parse as the table name.
    2227                If an `Expression` instance is passed, this is used as-is.
    2228            as_: the SQL code string to parse as the table expression.
    2229                If an `Expression` instance is passed, it will be used as-is.
    2230            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2231            materialized: set the MATERIALIZED part of the expression.
    2232            append: if `True`, add to any existing expressions.
    2233                Otherwise, this resets the expressions.
    2234            dialect: the dialect used to parse the input expression.
    2235            copy: if `False`, modify this expression instance in-place.
    2236            opts: other options to use to parse the input expressions.
    2237
    2238        Returns:
    2239            The modified expression.
    2240        """
    2241        return _apply_cte_builder(
    2242            self,
    2243            alias,
    2244            as_,
    2245            recursive=recursive,
    2246            materialized=materialized,
    2247            append=append,
    2248            dialect=dialect,
    2249            copy=copy,
    2250            **opts,
    2251        )

arg_types = {'hint': False, 'with': False, 'is_function': False, 'this': False, 'expression': False, 'conflict': False, 'returning': False, 'overwrite': False, 'exists': False, 'alternative': False, 'where': False, 'ignore': False, 'by_name': False, 'stored': False, 'partition': False, 'settings': False, 'source': False}
def with_( self, alias: Union[str, Expression], as_: Union[str, Expression], recursive: Optional[bool] = None, materialized: Optional[bool] = None, append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Insert: View Source

    2207    def with_(
    2208        self,
    2209        alias: ExpOrStr,
    2210        as_: ExpOrStr,
    2211        recursive: t.Optional[bool] = None,
    2212        materialized: t.Optional[bool] = None,
    2213        append: bool = True,
    2214        dialect: DialectType = None,
    2215        copy: bool = True,
    2216        **opts,
    2217    ) -> Insert:
    2218        """
    2219        Append to or set the common table expressions.
    2220
    2221        Example:
    2222            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    2223            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    2224
    2225        Args:
    2226            alias: the SQL code string to parse as the table name.
    2227                If an `Expression` instance is passed, this is used as-is.
    2228            as_: the SQL code string to parse as the table expression.
    2229                If an `Expression` instance is passed, it will be used as-is.
    2230            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2231            materialized: set the MATERIALIZED part of the expression.
    2232            append: if `True`, add to any existing expressions.
    2233                Otherwise, this resets the expressions.
    2234            dialect: the dialect used to parse the input expression.
    2235            copy: if `False`, modify this expression instance in-place.
    2236            opts: other options to use to parse the input expressions.
    2237
    2238        Returns:
    2239            The modified expression.
    2240        """
    2241        return _apply_cte_builder(
    2242            self,
    2243            alias,
    2244            as_,
    2245            recursive=recursive,
    2246            materialized=materialized,
    2247            append=append,
    2248            dialect=dialect,
    2249            copy=copy,
    2250            **opts,
    2251        )

Append to or set the common table expressions.

###### Example:

>     >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
>     'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'

###### Arguments:

- alias: the SQL code string to parse as the table name. If an `Expression` instance is passed, this is used as-is.
- as_: the SQL code string to parse as the table expression. If an `Expression` instance is passed, it will be used as-is.
- recursive: set the RECURSIVE part of the expression. Defaults to `False`.
- materialized: set the MATERIALIZED part of the expression.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- 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 expression.

key = 'insert'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DDL
  ctes
  selects
  named_selects
DML
  returning

class ConditionalInsert(Expression): View Source

    2254class ConditionalInsert(Expression):
    2255    arg_types = {"this": True, "expression": False, "else_": False}

arg_types = {'this': True, 'expression': False, 'else_': False}
key = 'conditionalinsert'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MultitableInserts(Expression): View Source

    2258class MultitableInserts(Expression):
    2259    arg_types = {"expressions": True, "kind": True, "source": True}

arg_types = {'expressions': True, 'kind': True, 'source': True}
key = 'multitableinserts'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnConflict(Expression): View Source

    2262class OnConflict(Expression):
    2263    arg_types = {
    2264        "duplicate": False,
    2265        "expressions": False,
    2266        "action": False,
    2267        "conflict_keys": False,
    2268        "constraint": False,
    2269    }

arg_types = {'duplicate': False, 'expressions': False, 'action': False, 'conflict_keys': False, 'constraint': False}
key = 'onconflict'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnCondition(Expression): View Source

    2272class OnCondition(Expression):
    2273    arg_types = {"error": False, "empty": False, "null": False}

arg_types = {'error': False, 'empty': False, 'null': False}
key = 'oncondition'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Returning(Expression): View Source

    2276class Returning(Expression):
    2277    arg_types = {"expressions": True, "into": False}

arg_types = {'expressions': True, 'into': False}
key = 'returning'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Introducer(Expression): View Source

    2281class Introducer(Expression):
    2282    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'introducer'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class National(Expression): View Source

    2286class National(Expression):
    2287    pass

key = 'national'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LoadData(Expression): View Source

    2290class LoadData(Expression):
    2291    arg_types = {
    2292        "this": True,
    2293        "local": False,
    2294        "overwrite": False,
    2295        "inpath": True,
    2296        "partition": False,
    2297        "input_format": False,
    2298        "serde": False,
    2299    }

arg_types = {'this': True, 'local': False, 'overwrite': False, 'inpath': True, 'partition': False, 'input_format': False, 'serde': False}
key = 'loaddata'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Partition(Expression): View Source

    2302class Partition(Expression):
    2303    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'partition'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionRange(Expression): View Source

    2306class PartitionRange(Expression):
    2307    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'partitionrange'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionId(Expression): View Source

    2311class PartitionId(Expression):
    2312    pass

key = 'partitionid'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Fetch(Expression): View Source

    2315class Fetch(Expression):
    2316    arg_types = {
    2317        "direction": False,
    2318        "count": False,
    2319        "percent": False,
    2320        "with_ties": False,
    2321    }

arg_types = {'direction': False, 'count': False, 'percent': False, 'with_ties': False}
key = 'fetch'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Grant(Expression): View Source

    2324class Grant(Expression):
    2325    arg_types = {
    2326        "privileges": True,
    2327        "kind": False,
    2328        "securable": True,
    2329        "principals": True,
    2330        "grant_option": False,
    2331    }

arg_types = {'privileges': True, 'kind': False, 'securable': True, 'principals': True, 'grant_option': False}
key = 'grant'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Group(Expression): View Source

    2334class Group(Expression):
    2335    arg_types = {
    2336        "expressions": False,
    2337        "grouping_sets": False,
    2338        "cube": False,
    2339        "rollup": False,
    2340        "totals": False,
    2341        "all": False,
    2342    }

arg_types = {'expressions': False, 'grouping_sets': False, 'cube': False, 'rollup': False, 'totals': False, 'all': False}
key = 'group'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Cube(Expression): View Source

    2345class Cube(Expression):
    2346    arg_types = {"expressions": False}

arg_types = {'expressions': False}
key = 'cube'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Rollup(Expression): View Source

    2349class Rollup(Expression):
    2350    arg_types = {"expressions": False}

arg_types = {'expressions': False}
key = 'rollup'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GroupingSets(Expression): View Source

    2353class GroupingSets(Expression):
    2354    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'groupingsets'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Lambda(Expression): View Source

    2357class Lambda(Expression):
    2358    arg_types = {"this": True, "expressions": True}

arg_types = {'this': True, 'expressions': True}
key = 'lambda'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Limit(Expression): View Source

    2361class Limit(Expression):
    2362    arg_types = {"this": False, "expression": True, "offset": False, "expressions": False}

arg_types = {'this': False, 'expression': True, 'offset': False, 'expressions': False}
key = 'limit'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Literal(Condition): View Source

    2365class Literal(Condition):
    2366    arg_types = {"this": True, "is_string": True}
    2367
    2368    @property
    2369    def hashable_args(self) -> t.Any:
    2370        return (self.this, self.args.get("is_string"))
    2371
    2372    @classmethod
    2373    def number(cls, number) -> Literal:
    2374        return cls(this=str(number), is_string=False)
    2375
    2376    @classmethod
    2377    def string(cls, string) -> Literal:
    2378        return cls(this=str(string), is_string=True)
    2379
    2380    @property
    2381    def output_name(self) -> str:
    2382        return self.name
    2383
    2384    def to_py(self) -> int | str | Decimal:
    2385        if self.is_number:
    2386            try:
    2387                return int(self.this)
    2388            except ValueError:
    2389                return Decimal(self.this)
    2390        return self.this

arg_types = {'this': True, 'is_string': True}
hashable_args: Any View Source

    2368    @property
    2369    def hashable_args(self) -> t.Any:
    2370        return (self.this, self.args.get("is_string"))

@classmethod
def number(cls, number) -> Literal: View Source

    2372    @classmethod
    2373    def number(cls, number) -> Literal:
    2374        return cls(this=str(number), is_string=False)

@classmethod
def string(cls, string) -> Literal: View Source

    2376    @classmethod
    2377    def string(cls, string) -> Literal:
    2378        return cls(this=str(string), is_string=True)

output_name: str View Source

    2380    @property
    2381    def output_name(self) -> str:
    2382        return self.name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

def to_py(self) -> int | str | decimal.Decimal: View Source

    2384    def to_py(self) -> int | str | Decimal:
    2385        if self.is_number:
    2386            try:
    2387                return int(self.this)
    2388            except ValueError:
    2389                return Decimal(self.this)
    2390        return self.this

Returns a Python object equivalent of the SQL node.

key = 'literal'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Join(Expression): View Source

    2393class Join(Expression):
    2394    arg_types = {
    2395        "this": True,
    2396        "on": False,
    2397        "side": False,
    2398        "kind": False,
    2399        "using": False,
    2400        "method": False,
    2401        "global": False,
    2402        "hint": False,
    2403        "match_condition": False,  # Snowflake
    2404        "expressions": False,
    2405    }
    2406
    2407    @property
    2408    def method(self) -> str:
    2409        return self.text("method").upper()
    2410
    2411    @property
    2412    def kind(self) -> str:
    2413        return self.text("kind").upper()
    2414
    2415    @property
    2416    def side(self) -> str:
    2417        return self.text("side").upper()
    2418
    2419    @property
    2420    def hint(self) -> str:
    2421        return self.text("hint").upper()
    2422
    2423    @property
    2424    def alias_or_name(self) -> str:
    2425        return self.this.alias_or_name
    2426
    2427    def on(
    2428        self,
    2429        *expressions: t.Optional[ExpOrStr],
    2430        append: bool = True,
    2431        dialect: DialectType = None,
    2432        copy: bool = True,
    2433        **opts,
    2434    ) -> Join:
    2435        """
    2436        Append to or set the ON expressions.
    2437
    2438        Example:
    2439            >>> import sqlglot
    2440            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    2441            'JOIN x ON y = 1'
    2442
    2443        Args:
    2444            *expressions: the SQL code strings to parse.
    2445                If an `Expression` instance is passed, it will be used as-is.
    2446                Multiple expressions are combined with an AND operator.
    2447            append: if `True`, AND the new expressions to any existing expression.
    2448                Otherwise, this resets the expression.
    2449            dialect: the dialect used to parse the input expressions.
    2450            copy: if `False`, modify this expression instance in-place.
    2451            opts: other options to use to parse the input expressions.
    2452
    2453        Returns:
    2454            The modified Join expression.
    2455        """
    2456        join = _apply_conjunction_builder(
    2457            *expressions,
    2458            instance=self,
    2459            arg="on",
    2460            append=append,
    2461            dialect=dialect,
    2462            copy=copy,
    2463            **opts,
    2464        )
    2465
    2466        if join.kind == "CROSS":
    2467            join.set("kind", None)
    2468
    2469        return join
    2470
    2471    def using(
    2472        self,
    2473        *expressions: t.Optional[ExpOrStr],
    2474        append: bool = True,
    2475        dialect: DialectType = None,
    2476        copy: bool = True,
    2477        **opts,
    2478    ) -> Join:
    2479        """
    2480        Append to or set the USING expressions.
    2481
    2482        Example:
    2483            >>> import sqlglot
    2484            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    2485            'JOIN x USING (foo, bla)'
    2486
    2487        Args:
    2488            *expressions: the SQL code strings to parse.
    2489                If an `Expression` instance is passed, it will be used as-is.
    2490            append: if `True`, concatenate the new expressions to the existing "using" list.
    2491                Otherwise, this resets the expression.
    2492            dialect: the dialect used to parse the input expressions.
    2493            copy: if `False`, modify this expression instance in-place.
    2494            opts: other options to use to parse the input expressions.
    2495
    2496        Returns:
    2497            The modified Join expression.
    2498        """
    2499        join = _apply_list_builder(
    2500            *expressions,
    2501            instance=self,
    2502            arg="using",
    2503            append=append,
    2504            dialect=dialect,
    2505            copy=copy,
    2506            **opts,
    2507        )
    2508
    2509        if join.kind == "CROSS":
    2510            join.set("kind", None)
    2511
    2512        return join

arg_types = {'this': True, 'on': False, 'side': False, 'kind': False, 'using': False, 'method': False, 'global': False, 'hint': False, 'match_condition': False, 'expressions': False}
method: str View Source

    2407    @property
    2408    def method(self) -> str:
    2409        return self.text("method").upper()

kind: str View Source

    2411    @property
    2412    def kind(self) -> str:
    2413        return self.text("kind").upper()

side: str View Source

    2415    @property
    2416    def side(self) -> str:
    2417        return self.text("side").upper()

hint: str View Source

    2419    @property
    2420    def hint(self) -> str:
    2421        return self.text("hint").upper()

alias_or_name: str View Source

    2423    @property
    2424    def alias_or_name(self) -> str:
    2425        return self.this.alias_or_name

def on( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Join: View Source

    2427    def on(
    2428        self,
    2429        *expressions: t.Optional[ExpOrStr],
    2430        append: bool = True,
    2431        dialect: DialectType = None,
    2432        copy: bool = True,
    2433        **opts,
    2434    ) -> Join:
    2435        """
    2436        Append to or set the ON expressions.
    2437
    2438        Example:
    2439            >>> import sqlglot
    2440            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    2441            'JOIN x ON y = 1'
    2442
    2443        Args:
    2444            *expressions: the SQL code strings to parse.
    2445                If an `Expression` instance is passed, it will be used as-is.
    2446                Multiple expressions are combined with an AND operator.
    2447            append: if `True`, AND the new expressions to any existing expression.
    2448                Otherwise, this resets the expression.
    2449            dialect: the dialect used to parse the input expressions.
    2450            copy: if `False`, modify this expression instance in-place.
    2451            opts: other options to use to parse the input expressions.
    2452
    2453        Returns:
    2454            The modified Join expression.
    2455        """
    2456        join = _apply_conjunction_builder(
    2457            *expressions,
    2458            instance=self,
    2459            arg="on",
    2460            append=append,
    2461            dialect=dialect,
    2462            copy=copy,
    2463            **opts,
    2464        )
    2465
    2466        if join.kind == "CROSS":
    2467            join.set("kind", None)
    2468
    2469        return join

Append to or set the ON expressions.

###### Example:

>     >>> import sqlglot
>     >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
>     'JOIN x ON y = 1'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator.
- append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Join expression.

def using( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Join: View Source

    2471    def using(
    2472        self,
    2473        *expressions: t.Optional[ExpOrStr],
    2474        append: bool = True,
    2475        dialect: DialectType = None,
    2476        copy: bool = True,
    2477        **opts,
    2478    ) -> Join:
    2479        """
    2480        Append to or set the USING expressions.
    2481
    2482        Example:
    2483            >>> import sqlglot
    2484            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    2485            'JOIN x USING (foo, bla)'
    2486
    2487        Args:
    2488            *expressions: the SQL code strings to parse.
    2489                If an `Expression` instance is passed, it will be used as-is.
    2490            append: if `True`, concatenate the new expressions to the existing "using" list.
    2491                Otherwise, this resets the expression.
    2492            dialect: the dialect used to parse the input expressions.
    2493            copy: if `False`, modify this expression instance in-place.
    2494            opts: other options to use to parse the input expressions.
    2495
    2496        Returns:
    2497            The modified Join expression.
    2498        """
    2499        join = _apply_list_builder(
    2500            *expressions,
    2501            instance=self,
    2502            arg="using",
    2503            append=append,
    2504            dialect=dialect,
    2505            copy=copy,
    2506            **opts,
    2507        )
    2508
    2509        if join.kind == "CROSS":
    2510            join.set("kind", None)
    2511
    2512        return join

Append to or set the USING expressions.

###### Example:

>     >>> import sqlglot
>     >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
>     'JOIN x USING (foo, bla)'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, concatenate the new expressions to the existing "using" list. Otherwise, this resets the expression.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Join expression.

key = 'join'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Lateral(UDTF): View Source

    2515class Lateral(UDTF):
    2516    arg_types = {
    2517        "this": True,
    2518        "view": False,
    2519        "outer": False,
    2520        "alias": False,
    2521        "cross_apply": False,  # True -> CROSS APPLY, False -> OUTER APPLY
    2522    }

arg_types = {'this': True, 'view': False, 'outer': False, 'alias': False, 'cross_apply': False}
key = 'lateral'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
UDTF
  selects
DerivedTable
  named_selects

class MatchRecognizeMeasure(Expression): View Source

    2525class MatchRecognizeMeasure(Expression):
    2526    arg_types = {
    2527        "this": True,
    2528        "window_frame": False,
    2529    }

arg_types = {'this': True, 'window_frame': False}
key = 'matchrecognizemeasure'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MatchRecognize(Expression): View Source

    2532class MatchRecognize(Expression):
    2533    arg_types = {
    2534        "partition_by": False,
    2535        "order": False,
    2536        "measures": False,
    2537        "rows": False,
    2538        "after": False,
    2539        "pattern": False,
    2540        "define": False,
    2541        "alias": False,
    2542    }

arg_types = {'partition_by': False, 'order': False, 'measures': False, 'rows': False, 'after': False, 'pattern': False, 'define': False, 'alias': False}
key = 'matchrecognize'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Final(Expression): View Source

    2547class Final(Expression):
    2548    pass

key = 'final'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Offset(Expression): View Source

    2551class Offset(Expression):
    2552    arg_types = {"this": False, "expression": True, "expressions": False}

arg_types = {'this': False, 'expression': True, 'expressions': False}
key = 'offset'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Order(Expression): View Source

    2555class Order(Expression):
    2556    arg_types = {"this": False, "expressions": True, "siblings": False}

arg_types = {'this': False, 'expressions': True, 'siblings': False}
key = 'order'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithFill(Expression): View Source

    2560class WithFill(Expression):
    2561    arg_types = {
    2562        "from": False,
    2563        "to": False,
    2564        "step": False,
    2565        "interpolate": False,
    2566    }

arg_types = {'from': False, 'to': False, 'step': False, 'interpolate': False}
key = 'withfill'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Cluster(Order): View Source

    2571class Cluster(Order):
    2572    pass

key = 'cluster'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Order
  arg_types

class Distribute(Order): View Source

    2575class Distribute(Order):
    2576    pass

key = 'distribute'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Order
  arg_types

class Sort(Order): View Source

    2579class Sort(Order):
    2580    pass

key = 'sort'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Order
  arg_types

class Ordered(Expression): View Source

    2583class Ordered(Expression):
    2584    arg_types = {"this": True, "desc": False, "nulls_first": True, "with_fill": False}

arg_types = {'this': True, 'desc': False, 'nulls_first': True, 'with_fill': False}
key = 'ordered'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Property(Expression): View Source

    2587class Property(Expression):
    2588    arg_types = {"this": True, "value": True}

arg_types = {'this': True, 'value': True}
key = 'property'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GrantPrivilege(Expression): View Source

    2591class GrantPrivilege(Expression):
    2592    arg_types = {"this": True, "expressions": False}

arg_types = {'this': True, 'expressions': False}
key = 'grantprivilege'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GrantPrincipal(Expression): View Source

    2595class GrantPrincipal(Expression):
    2596    arg_types = {"this": True, "kind": False}

arg_types = {'this': True, 'kind': False}
key = 'grantprincipal'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AllowedValuesProperty(Expression): View Source

    2599class AllowedValuesProperty(Expression):
    2600    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'allowedvaluesproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlgorithmProperty(Property): View Source

    2603class AlgorithmProperty(Property):
    2604    arg_types = {"this": True}

arg_types = {'this': True}
key = 'algorithmproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AutoIncrementProperty(Property): View Source

    2607class AutoIncrementProperty(Property):
    2608    arg_types = {"this": True}

arg_types = {'this': True}
key = 'autoincrementproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AutoRefreshProperty(Property): View Source

    2612class AutoRefreshProperty(Property):
    2613    arg_types = {"this": True}

arg_types = {'this': True}
key = 'autorefreshproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BackupProperty(Property): View Source

    2616class BackupProperty(Property):
    2617    arg_types = {"this": True}

arg_types = {'this': True}
key = 'backupproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BlockCompressionProperty(Property): View Source

    2620class BlockCompressionProperty(Property):
    2621    arg_types = {
    2622        "autotemp": False,
    2623        "always": False,
    2624        "default": False,
    2625        "manual": False,
    2626        "never": False,
    2627    }

arg_types = {'autotemp': False, 'always': False, 'default': False, 'manual': False, 'never': False}
key = 'blockcompressionproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CharacterSetProperty(Property): View Source

    2630class CharacterSetProperty(Property):
    2631    arg_types = {"this": True, "default": True}

arg_types = {'this': True, 'default': True}
key = 'charactersetproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ChecksumProperty(Property): View Source

    2634class ChecksumProperty(Property):
    2635    arg_types = {"on": False, "default": False}

arg_types = {'on': False, 'default': False}
key = 'checksumproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CollateProperty(Property): View Source

    2638class CollateProperty(Property):
    2639    arg_types = {"this": True, "default": False}

arg_types = {'this': True, 'default': False}
key = 'collateproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CopyGrantsProperty(Property): View Source

    2642class CopyGrantsProperty(Property):
    2643    arg_types = {}

arg_types = {}
key = 'copygrantsproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataBlocksizeProperty(Property): View Source

    2646class DataBlocksizeProperty(Property):
    2647    arg_types = {
    2648        "size": False,
    2649        "units": False,
    2650        "minimum": False,
    2651        "maximum": False,
    2652        "default": False,
    2653    }

arg_types = {'size': False, 'units': False, 'minimum': False, 'maximum': False, 'default': False}
key = 'datablocksizeproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataDeletionProperty(Property): View Source

    2656class DataDeletionProperty(Property):
    2657    arg_types = {"on": True, "filter_col": False, "retention_period": False}

arg_types = {'on': True, 'filter_col': False, 'retention_period': False}
key = 'datadeletionproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DefinerProperty(Property): View Source

    2660class DefinerProperty(Property):
    2661    arg_types = {"this": True}

arg_types = {'this': True}
key = 'definerproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DistKeyProperty(Property): View Source

    2664class DistKeyProperty(Property):
    2665    arg_types = {"this": True}

arg_types = {'this': True}
key = 'distkeyproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DistributedByProperty(Property): View Source

    2670class DistributedByProperty(Property):
    2671    arg_types = {"expressions": False, "kind": True, "buckets": False, "order": False}

arg_types = {'expressions': False, 'kind': True, 'buckets': False, 'order': False}
key = 'distributedbyproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DistStyleProperty(Property): View Source

    2674class DistStyleProperty(Property):
    2675    arg_types = {"this": True}

arg_types = {'this': True}
key = 'diststyleproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DuplicateKeyProperty(Property): View Source

    2678class DuplicateKeyProperty(Property):
    2679    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'duplicatekeyproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EngineProperty(Property): View Source

    2682class EngineProperty(Property):
    2683    arg_types = {"this": True}

arg_types = {'this': True}
key = 'engineproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HeapProperty(Property): View Source

    2686class HeapProperty(Property):
    2687    arg_types = {}

arg_types = {}
key = 'heapproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ToTableProperty(Property): View Source

    2690class ToTableProperty(Property):
    2691    arg_types = {"this": True}

arg_types = {'this': True}
key = 'totableproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ExecuteAsProperty(Property): View Source

    2694class ExecuteAsProperty(Property):
    2695    arg_types = {"this": True}

arg_types = {'this': True}
key = 'executeasproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ExternalProperty(Property): View Source

    2698class ExternalProperty(Property):
    2699    arg_types = {"this": False}

arg_types = {'this': False}
key = 'externalproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FallbackProperty(Property): View Source

    2702class FallbackProperty(Property):
    2703    arg_types = {"no": True, "protection": False}

arg_types = {'no': True, 'protection': False}
key = 'fallbackproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FileFormatProperty(Property): View Source

    2706class FileFormatProperty(Property):
    2707    arg_types = {"this": True}

arg_types = {'this': True}
key = 'fileformatproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FreespaceProperty(Property): View Source

    2710class FreespaceProperty(Property):
    2711    arg_types = {"this": True, "percent": False}

arg_types = {'this': True, 'percent': False}
key = 'freespaceproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GlobalProperty(Property): View Source

    2714class GlobalProperty(Property):
    2715    arg_types = {}

arg_types = {}
key = 'globalproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IcebergProperty(Property): View Source

    2718class IcebergProperty(Property):
    2719    arg_types = {}

arg_types = {}
key = 'icebergproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InheritsProperty(Property): View Source

    2722class InheritsProperty(Property):
    2723    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'inheritsproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InputModelProperty(Property): View Source

    2726class InputModelProperty(Property):
    2727    arg_types = {"this": True}

arg_types = {'this': True}
key = 'inputmodelproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OutputModelProperty(Property): View Source

    2730class OutputModelProperty(Property):
    2731    arg_types = {"this": True}

arg_types = {'this': True}
key = 'outputmodelproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IsolatedLoadingProperty(Property): View Source

    2734class IsolatedLoadingProperty(Property):
    2735    arg_types = {"no": False, "concurrent": False, "target": False}

arg_types = {'no': False, 'concurrent': False, 'target': False}
key = 'isolatedloadingproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JournalProperty(Property): View Source

    2738class JournalProperty(Property):
    2739    arg_types = {
    2740        "no": False,
    2741        "dual": False,
    2742        "before": False,
    2743        "local": False,
    2744        "after": False,
    2745    }

arg_types = {'no': False, 'dual': False, 'before': False, 'local': False, 'after': False}
key = 'journalproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LanguageProperty(Property): View Source

    2748class LanguageProperty(Property):
    2749    arg_types = {"this": True}

arg_types = {'this': True}
key = 'languageproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ClusteredByProperty(Property): View Source

    2753class ClusteredByProperty(Property):
    2754    arg_types = {"expressions": True, "sorted_by": False, "buckets": True}

arg_types = {'expressions': True, 'sorted_by': False, 'buckets': True}
key = 'clusteredbyproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DictProperty(Property): View Source

    2757class DictProperty(Property):
    2758    arg_types = {"this": True, "kind": True, "settings": False}

arg_types = {'this': True, 'kind': True, 'settings': False}
key = 'dictproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DictSubProperty(Property): View Source

    2761class DictSubProperty(Property):
    2762    pass

key = 'dictsubproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Property
  arg_types

class DictRange(Property): View Source

    2765class DictRange(Property):
    2766    arg_types = {"this": True, "min": True, "max": True}

arg_types = {'this': True, 'min': True, 'max': True}
key = 'dictrange'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DynamicProperty(Property): View Source

    2769class DynamicProperty(Property):
    2770    arg_types = {}

arg_types = {}
key = 'dynamicproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnCluster(Property): View Source

    2775class OnCluster(Property):
    2776    arg_types = {"this": True}

arg_types = {'this': True}
key = 'oncluster'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EmptyProperty(Property): View Source

    2780class EmptyProperty(Property):
    2781    arg_types = {}

arg_types = {}
key = 'emptyproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LikeProperty(Property): View Source

    2784class LikeProperty(Property):
    2785    arg_types = {"this": True, "expressions": False}

arg_types = {'this': True, 'expressions': False}
key = 'likeproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LocationProperty(Property): View Source

    2788class LocationProperty(Property):
    2789    arg_types = {"this": True}

arg_types = {'this': True}
key = 'locationproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LockProperty(Property): View Source

    2792class LockProperty(Property):
    2793    arg_types = {"this": True}

arg_types = {'this': True}
key = 'lockproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LockingProperty(Property): View Source

    2796class LockingProperty(Property):
    2797    arg_types = {
    2798        "this": False,
    2799        "kind": True,
    2800        "for_or_in": False,
    2801        "lock_type": True,
    2802        "override": False,
    2803    }

arg_types = {'this': False, 'kind': True, 'for_or_in': False, 'lock_type': True, 'override': False}
key = 'lockingproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LogProperty(Property): View Source

    2806class LogProperty(Property):
    2807    arg_types = {"no": True}

arg_types = {'no': True}
key = 'logproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MaterializedProperty(Property): View Source

    2810class MaterializedProperty(Property):
    2811    arg_types = {"this": False}

arg_types = {'this': False}
key = 'materializedproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MergeBlockRatioProperty(Property): View Source

    2814class MergeBlockRatioProperty(Property):
    2815    arg_types = {"this": False, "no": False, "default": False, "percent": False}

arg_types = {'this': False, 'no': False, 'default': False, 'percent': False}
key = 'mergeblockratioproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NoPrimaryIndexProperty(Property): View Source

    2818class NoPrimaryIndexProperty(Property):
    2819    arg_types = {}

arg_types = {}
key = 'noprimaryindexproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnProperty(Property): View Source

    2822class OnProperty(Property):
    2823    arg_types = {"this": True}

arg_types = {'this': True}
key = 'onproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnCommitProperty(Property): View Source

    2826class OnCommitProperty(Property):
    2827    arg_types = {"delete": False}

arg_types = {'delete': False}
key = 'oncommitproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionedByProperty(Property): View Source

    2830class PartitionedByProperty(Property):
    2831    arg_types = {"this": True}

arg_types = {'this': True}
key = 'partitionedbyproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionBoundSpec(Expression): View Source

    2835class PartitionBoundSpec(Expression):
    2836    # this -> IN / MODULUS, expression -> REMAINDER, from_expressions -> FROM (...), to_expressions -> TO (...)
    2837    arg_types = {
    2838        "this": False,
    2839        "expression": False,
    2840        "from_expressions": False,
    2841        "to_expressions": False,
    2842    }

arg_types = {'this': False, 'expression': False, 'from_expressions': False, 'to_expressions': False}
key = 'partitionboundspec'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionedOfProperty(Property): View Source

    2845class PartitionedOfProperty(Property):
    2846    # this -> parent_table (schema), expression -> FOR VALUES ... / DEFAULT
    2847    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'partitionedofproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StreamingTableProperty(Property): View Source

    2850class StreamingTableProperty(Property):
    2851    arg_types = {}

arg_types = {}
key = 'streamingtableproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RemoteWithConnectionModelProperty(Property): View Source

    2854class RemoteWithConnectionModelProperty(Property):
    2855    arg_types = {"this": True}

arg_types = {'this': True}
key = 'remotewithconnectionmodelproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ReturnsProperty(Property): View Source

    2858class ReturnsProperty(Property):
    2859    arg_types = {"this": False, "is_table": False, "table": False, "null": False}

arg_types = {'this': False, 'is_table': False, 'table': False, 'null': False}
key = 'returnsproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StrictProperty(Property): View Source

    2862class StrictProperty(Property):
    2863    arg_types = {}

arg_types = {}
key = 'strictproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RowFormatProperty(Property): View Source

    2866class RowFormatProperty(Property):
    2867    arg_types = {"this": True}

arg_types = {'this': True}
key = 'rowformatproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RowFormatDelimitedProperty(Property): View Source

    2870class RowFormatDelimitedProperty(Property):
    2871    # https://cwiki.apache.org/confluence/display/hive/languagemanual+dml
    2872    arg_types = {
    2873        "fields": False,
    2874        "escaped": False,
    2875        "collection_items": False,
    2876        "map_keys": False,
    2877        "lines": False,
    2878        "null": False,
    2879        "serde": False,
    2880    }

arg_types = {'fields': False, 'escaped': False, 'collection_items': False, 'map_keys': False, 'lines': False, 'null': False, 'serde': False}
key = 'rowformatdelimitedproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RowFormatSerdeProperty(Property): View Source

    2883class RowFormatSerdeProperty(Property):
    2884    arg_types = {"this": True, "serde_properties": False}

arg_types = {'this': True, 'serde_properties': False}
key = 'rowformatserdeproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class QueryTransform(Expression): View Source

    2888class QueryTransform(Expression):
    2889    arg_types = {
    2890        "expressions": True,
    2891        "command_script": True,
    2892        "schema": False,
    2893        "row_format_before": False,
    2894        "record_writer": False,
    2895        "row_format_after": False,
    2896        "record_reader": False,
    2897    }

arg_types = {'expressions': True, 'command_script': True, 'schema': False, 'row_format_before': False, 'record_writer': False, 'row_format_after': False, 'record_reader': False}
key = 'querytransform'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SampleProperty(Property): View Source

    2900class SampleProperty(Property):
    2901    arg_types = {"this": True}

arg_types = {'this': True}
key = 'sampleproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SecurityProperty(Property): View Source

    2905class SecurityProperty(Property):
    2906    arg_types = {"this": True}

arg_types = {'this': True}
key = 'securityproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SchemaCommentProperty(Property): View Source

    2909class SchemaCommentProperty(Property):
    2910    arg_types = {"this": True}

arg_types = {'this': True}
key = 'schemacommentproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SerdeProperties(Property): View Source

    2913class SerdeProperties(Property):
    2914    arg_types = {"expressions": True, "with": False}

arg_types = {'expressions': True, 'with': False}
key = 'serdeproperties'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetProperty(Property): View Source

    2917class SetProperty(Property):
    2918    arg_types = {"multi": True}

arg_types = {'multi': True}
key = 'setproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SharingProperty(Property): View Source

    2921class SharingProperty(Property):
    2922    arg_types = {"this": False}

arg_types = {'this': False}
key = 'sharingproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetConfigProperty(Property): View Source

    2925class SetConfigProperty(Property):
    2926    arg_types = {"this": True}

arg_types = {'this': True}
key = 'setconfigproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SettingsProperty(Property): View Source

    2929class SettingsProperty(Property):
    2930    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'settingsproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SortKeyProperty(Property): View Source

    2933class SortKeyProperty(Property):
    2934    arg_types = {"this": True, "compound": False}

arg_types = {'this': True, 'compound': False}
key = 'sortkeyproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SqlReadWriteProperty(Property): View Source

    2937class SqlReadWriteProperty(Property):
    2938    arg_types = {"this": True}

arg_types = {'this': True}
key = 'sqlreadwriteproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SqlSecurityProperty(Property): View Source

    2941class SqlSecurityProperty(Property):
    2942    arg_types = {"definer": True}

arg_types = {'definer': True}
key = 'sqlsecurityproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StabilityProperty(Property): View Source

    2945class StabilityProperty(Property):
    2946    arg_types = {"this": True}

arg_types = {'this': True}
key = 'stabilityproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TemporaryProperty(Property): View Source

    2949class TemporaryProperty(Property):
    2950    arg_types = {"this": False}

arg_types = {'this': False}
key = 'temporaryproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SecureProperty(Property): View Source

    2953class SecureProperty(Property):
    2954    arg_types = {}

arg_types = {}
key = 'secureproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TransformModelProperty(Property): View Source

    2957class TransformModelProperty(Property):
    2958    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'transformmodelproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TransientProperty(Property): View Source

    2961class TransientProperty(Property):
    2962    arg_types = {"this": False}

arg_types = {'this': False}
key = 'transientproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UnloggedProperty(Property): View Source

    2965class UnloggedProperty(Property):
    2966    arg_types = {}

arg_types = {}
key = 'unloggedproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ViewAttributeProperty(Property): View Source

    2970class ViewAttributeProperty(Property):
    2971    arg_types = {"this": True}

arg_types = {'this': True}
key = 'viewattributeproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class VolatileProperty(Property): View Source

    2974class VolatileProperty(Property):
    2975    arg_types = {"this": False}

arg_types = {'this': False}
key = 'volatileproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithDataProperty(Property): View Source

    2978class WithDataProperty(Property):
    2979    arg_types = {"no": True, "statistics": False}

arg_types = {'no': True, 'statistics': False}
key = 'withdataproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithJournalTableProperty(Property): View Source

    2982class WithJournalTableProperty(Property):
    2983    arg_types = {"this": True}

arg_types = {'this': True}
key = 'withjournaltableproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithSchemaBindingProperty(Property): View Source

    2986class WithSchemaBindingProperty(Property):
    2987    arg_types = {"this": True}

arg_types = {'this': True}
key = 'withschemabindingproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithSystemVersioningProperty(Property): View Source

    2990class WithSystemVersioningProperty(Property):
    2991    arg_types = {
    2992        "on": False,
    2993        "this": False,
    2994        "data_consistency": False,
    2995        "retention_period": False,
    2996        "with": True,
    2997    }

arg_types = {'on': False, 'this': False, 'data_consistency': False, 'retention_period': False, 'with': True}
key = 'withsystemversioningproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Properties(Expression): View Source

    3000class Properties(Expression):
    3001    arg_types = {"expressions": True}
    3002
    3003    NAME_TO_PROPERTY = {
    3004        "ALGORITHM": AlgorithmProperty,
    3005        "AUTO_INCREMENT": AutoIncrementProperty,
    3006        "CHARACTER SET": CharacterSetProperty,
    3007        "CLUSTERED_BY": ClusteredByProperty,
    3008        "COLLATE": CollateProperty,
    3009        "COMMENT": SchemaCommentProperty,
    3010        "DEFINER": DefinerProperty,
    3011        "DISTKEY": DistKeyProperty,
    3012        "DISTRIBUTED_BY": DistributedByProperty,
    3013        "DISTSTYLE": DistStyleProperty,
    3014        "ENGINE": EngineProperty,
    3015        "EXECUTE AS": ExecuteAsProperty,
    3016        "FORMAT": FileFormatProperty,
    3017        "LANGUAGE": LanguageProperty,
    3018        "LOCATION": LocationProperty,
    3019        "LOCK": LockProperty,
    3020        "PARTITIONED_BY": PartitionedByProperty,
    3021        "RETURNS": ReturnsProperty,
    3022        "ROW_FORMAT": RowFormatProperty,
    3023        "SORTKEY": SortKeyProperty,
    3024    }
    3025
    3026    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    3027
    3028    # CREATE property locations
    3029    # Form: schema specified
    3030    #   create [POST_CREATE]
    3031    #     table a [POST_NAME]
    3032    #     (b int) [POST_SCHEMA]
    3033    #     with ([POST_WITH])
    3034    #     index (b) [POST_INDEX]
    3035    #
    3036    # Form: alias selection
    3037    #   create [POST_CREATE]
    3038    #     table a [POST_NAME]
    3039    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    3040    #     index (c) [POST_INDEX]
    3041    class Location(AutoName):
    3042        POST_CREATE = auto()
    3043        POST_NAME = auto()
    3044        POST_SCHEMA = auto()
    3045        POST_WITH = auto()
    3046        POST_ALIAS = auto()
    3047        POST_EXPRESSION = auto()
    3048        POST_INDEX = auto()
    3049        UNSUPPORTED = auto()
    3050
    3051    @classmethod
    3052    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3053        expressions = []
    3054        for key, value in properties_dict.items():
    3055            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3056            if property_cls:
    3057                expressions.append(property_cls(this=convert(value)))
    3058            else:
    3059                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3060
    3061        return cls(expressions=expressions)

arg_types = {'expressions': True}
NAME_TO_PROPERTY = {'ALGORITHM': <class 'AlgorithmProperty'>, 'AUTO_INCREMENT': <class 'AutoIncrementProperty'>, 'CHARACTER SET': <class 'CharacterSetProperty'>, 'CLUSTERED_BY': <class 'ClusteredByProperty'>, 'COLLATE': <class 'CollateProperty'>, 'COMMENT': <class 'SchemaCommentProperty'>, 'DEFINER': <class 'DefinerProperty'>, 'DISTKEY': <class 'DistKeyProperty'>, 'DISTRIBUTED_BY': <class 'DistributedByProperty'>, 'DISTSTYLE': <class 'DistStyleProperty'>, 'ENGINE': <class 'EngineProperty'>, 'EXECUTE AS': <class 'ExecuteAsProperty'>, 'FORMAT': <class 'FileFormatProperty'>, 'LANGUAGE': <class 'LanguageProperty'>, 'LOCATION': <class 'LocationProperty'>, 'LOCK': <class 'LockProperty'>, 'PARTITIONED_BY': <class 'PartitionedByProperty'>, 'RETURNS': <class 'ReturnsProperty'>, 'ROW_FORMAT': <class 'RowFormatProperty'>, 'SORTKEY': <class 'SortKeyProperty'>}
PROPERTY_TO_NAME = {<class 'AlgorithmProperty'>: 'ALGORITHM', <class 'AutoIncrementProperty'>: 'AUTO_INCREMENT', <class 'CharacterSetProperty'>: 'CHARACTER SET', <class 'ClusteredByProperty'>: 'CLUSTERED_BY', <class 'CollateProperty'>: 'COLLATE', <class 'SchemaCommentProperty'>: 'COMMENT', <class 'DefinerProperty'>: 'DEFINER', <class 'DistKeyProperty'>: 'DISTKEY', <class 'DistributedByProperty'>: 'DISTRIBUTED_BY', <class 'DistStyleProperty'>: 'DISTSTYLE', <class 'EngineProperty'>: 'ENGINE', <class 'ExecuteAsProperty'>: 'EXECUTE AS', <class 'FileFormatProperty'>: 'FORMAT', <class 'LanguageProperty'>: 'LANGUAGE', <class 'LocationProperty'>: 'LOCATION', <class 'LockProperty'>: 'LOCK', <class 'PartitionedByProperty'>: 'PARTITIONED_BY', <class 'ReturnsProperty'>: 'RETURNS', <class 'RowFormatProperty'>: 'ROW_FORMAT', <class 'SortKeyProperty'>: 'SORTKEY'}
@classmethod
def from_dict(cls, properties_dict: Dict) -> Properties: View Source

    3051    @classmethod
    3052    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3053        expressions = []
    3054        for key, value in properties_dict.items():
    3055            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3056            if property_cls:
    3057                expressions.append(property_cls(this=convert(value)))
    3058            else:
    3059                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3060
    3061        return cls(expressions=expressions)

key = 'properties'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Properties.Location(sqlglot.helper.AutoName): View Source

    3041    class Location(AutoName):
    3042        POST_CREATE = auto()
    3043        POST_NAME = auto()
    3044        POST_SCHEMA = auto()
    3045        POST_WITH = auto()
    3046        POST_ALIAS = auto()
    3047        POST_EXPRESSION = auto()
    3048        POST_INDEX = auto()
    3049        UNSUPPORTED = auto()

An enumeration.

POST_CREATE = <Location.POST_CREATE: 'POST_CREATE'>
POST_NAME = <Location.POST_NAME: 'POST_NAME'>
POST_SCHEMA = <Location.POST_SCHEMA: 'POST_SCHEMA'>
POST_WITH = <Location.POST_WITH: 'POST_WITH'>
POST_ALIAS = <Location.POST_ALIAS: 'POST_ALIAS'>
POST_EXPRESSION = <Location.POST_EXPRESSION: 'POST_EXPRESSION'>
POST_INDEX = <Location.POST_INDEX: 'POST_INDEX'>
UNSUPPORTED = <Location.UNSUPPORTED: 'UNSUPPORTED'>
class Qualify(Expression): View Source

    3064class Qualify(Expression):
    3065    pass

key = 'qualify'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InputOutputFormat(Expression): View Source

    3068class InputOutputFormat(Expression):
    3069    arg_types = {"input_format": False, "output_format": False}

arg_types = {'input_format': False, 'output_format': False}
key = 'inputoutputformat'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Return(Expression): View Source

    3073class Return(Expression):
    3074    pass

key = 'return'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Reference(Expression): View Source

    3077class Reference(Expression):
    3078    arg_types = {"this": True, "expressions": False, "options": False}

arg_types = {'this': True, 'expressions': False, 'options': False}
key = 'reference'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Tuple(Expression): View Source

    3081class Tuple(Expression):
    3082    arg_types = {"expressions": False}
    3083
    3084    def isin(
    3085        self,
    3086        *expressions: t.Any,
    3087        query: t.Optional[ExpOrStr] = None,
    3088        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3089        copy: bool = True,
    3090        **opts,
    3091    ) -> In:
    3092        return In(
    3093            this=maybe_copy(self, copy),
    3094            expressions=[convert(e, copy=copy) for e in expressions],
    3095            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3096            unnest=(
    3097                Unnest(
    3098                    expressions=[
    3099                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3100                        for e in ensure_list(unnest)
    3101                    ]
    3102                )
    3103                if unnest
    3104                else None
    3105            ),
    3106        )

arg_types = {'expressions': False}
def isin( self, *expressions: Any, query: Union[str, Expression, NoneType] = None, unnest: Union[str, Expression, NoneType, Collection[Union[str, Expression]]] = None, copy: bool = True, **opts) -> In: View Source

    3084    def isin(
    3085        self,
    3086        *expressions: t.Any,
    3087        query: t.Optional[ExpOrStr] = None,
    3088        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3089        copy: bool = True,
    3090        **opts,
    3091    ) -> In:
    3092        return In(
    3093            this=maybe_copy(self, copy),
    3094            expressions=[convert(e, copy=copy) for e in expressions],
    3095            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3096            unnest=(
    3097                Unnest(
    3098                    expressions=[
    3099                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3100                        for e in ensure_list(unnest)
    3101                    ]
    3102                )
    3103                if unnest
    3104                else None
    3105            ),
    3106        )

key = 'tuple'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

QUERY_MODIFIERS = {'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'prewhere': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False, 'options': False}
class QueryOption(Expression): View Source

    3137class QueryOption(Expression):
    3138    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'queryoption'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithTableHint(Expression): View Source

    3142class WithTableHint(Expression):
    3143    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'withtablehint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexTableHint(Expression): View Source

    3147class IndexTableHint(Expression):
    3148    arg_types = {"this": True, "expressions": False, "target": False}

arg_types = {'this': True, 'expressions': False, 'target': False}
key = 'indextablehint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HistoricalData(Expression): View Source

    3152class HistoricalData(Expression):
    3153    arg_types = {"this": True, "kind": True, "expression": True}

arg_types = {'this': True, 'kind': True, 'expression': True}
key = 'historicaldata'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Table(Expression): View Source

    3156class Table(Expression):
    3157    arg_types = {
    3158        "this": False,
    3159        "alias": False,
    3160        "db": False,
    3161        "catalog": False,
    3162        "laterals": False,
    3163        "joins": False,
    3164        "pivots": False,
    3165        "hints": False,
    3166        "system_time": False,
    3167        "version": False,
    3168        "format": False,
    3169        "pattern": False,
    3170        "ordinality": False,
    3171        "when": False,
    3172        "only": False,
    3173        "partition": False,
    3174        "changes": False,
    3175        "rows_from": False,
    3176        "sample": False,
    3177    }
    3178
    3179    @property
    3180    def name(self) -> str:
    3181        if isinstance(self.this, Func):
    3182            return ""
    3183        return self.this.name
    3184
    3185    @property
    3186    def db(self) -> str:
    3187        return self.text("db")
    3188
    3189    @property
    3190    def catalog(self) -> str:
    3191        return self.text("catalog")
    3192
    3193    @property
    3194    def selects(self) -> t.List[Expression]:
    3195        return []
    3196
    3197    @property
    3198    def named_selects(self) -> t.List[str]:
    3199        return []
    3200
    3201    @property
    3202    def parts(self) -> t.List[Expression]:
    3203        """Return the parts of a table in order catalog, db, table."""
    3204        parts: t.List[Expression] = []
    3205
    3206        for arg in ("catalog", "db", "this"):
    3207            part = self.args.get(arg)
    3208
    3209            if isinstance(part, Dot):
    3210                parts.extend(part.flatten())
    3211            elif isinstance(part, Expression):
    3212                parts.append(part)
    3213
    3214        return parts
    3215
    3216    def to_column(self, copy: bool = True) -> Alias | Column | Dot:
    3217        parts = self.parts
    3218        col = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3219        alias = self.args.get("alias")
    3220        if alias:
    3221            col = alias_(col, alias.this, copy=copy)
    3222        return col

arg_types = {'this': False, 'alias': False, 'db': False, 'catalog': False, 'laterals': False, 'joins': False, 'pivots': False, 'hints': False, 'system_time': False, 'version': False, 'format': False, 'pattern': False, 'ordinality': False, 'when': False, 'only': False, 'partition': False, 'changes': False, 'rows_from': False, 'sample': False}
name: str View Source

    3179    @property
    3180    def name(self) -> str:
    3181        if isinstance(self.this, Func):
    3182            return ""
    3183        return self.this.name

db: str View Source

    3185    @property
    3186    def db(self) -> str:
    3187        return self.text("db")

catalog: str View Source

    3189    @property
    3190    def catalog(self) -> str:
    3191        return self.text("catalog")

selects: List[Expression] View Source

    3193    @property
    3194    def selects(self) -> t.List[Expression]:
    3195        return []

named_selects: List[str] View Source

    3197    @property
    3198    def named_selects(self) -> t.List[str]:
    3199        return []

parts: List[Expression] View Source

    3201    @property
    3202    def parts(self) -> t.List[Expression]:
    3203        """Return the parts of a table in order catalog, db, table."""
    3204        parts: t.List[Expression] = []
    3205
    3206        for arg in ("catalog", "db", "this"):
    3207            part = self.args.get(arg)
    3208
    3209            if isinstance(part, Dot):
    3210                parts.extend(part.flatten())
    3211            elif isinstance(part, Expression):
    3212                parts.append(part)
    3213
    3214        return parts

Return the parts of a table in order catalog, db, table.

def to_column( self, copy: bool = True) -> Alias | Column | Dot: View Source

    3216    def to_column(self, copy: bool = True) -> Alias | Column | Dot:
    3217        parts = self.parts
    3218        col = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3219        alias = self.args.get("alias")
    3220        if alias:
    3221            col = alias_(col, alias.this, copy=copy)
    3222        return col

key = 'table'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetOperation(Query): View Source

    3225class SetOperation(Query):
    3226    arg_types = {
    3227        "with": False,
    3228        "this": True,
    3229        "expression": True,
    3230        "distinct": False,
    3231        "by_name": False,
    3232        **QUERY_MODIFIERS,
    3233    }
    3234
    3235    def select(
    3236        self: S,
    3237        *expressions: t.Optional[ExpOrStr],
    3238        append: bool = True,
    3239        dialect: DialectType = None,
    3240        copy: bool = True,
    3241        **opts,
    3242    ) -> S:
    3243        this = maybe_copy(self, copy)
    3244        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3245        this.expression.unnest().select(
    3246            *expressions, append=append, dialect=dialect, copy=False, **opts
    3247        )
    3248        return this
    3249
    3250    @property
    3251    def named_selects(self) -> t.List[str]:
    3252        return self.this.unnest().named_selects
    3253
    3254    @property
    3255    def is_star(self) -> bool:
    3256        return self.this.is_star or self.expression.is_star
    3257
    3258    @property
    3259    def selects(self) -> t.List[Expression]:
    3260        return self.this.unnest().selects
    3261
    3262    @property
    3263    def left(self) -> Query:
    3264        return self.this
    3265
    3266    @property
    3267    def right(self) -> Query:
    3268        return self.expression

arg_types = {'with': False, 'this': True, 'expression': True, 'distinct': False, 'by_name': False, 'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'prewhere': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False, 'options': False}
def select( self: ~S, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~S: View Source

    3235    def select(
    3236        self: S,
    3237        *expressions: t.Optional[ExpOrStr],
    3238        append: bool = True,
    3239        dialect: DialectType = None,
    3240        copy: bool = True,
    3241        **opts,
    3242    ) -> S:
    3243        this = maybe_copy(self, copy)
    3244        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3245        this.expression.unnest().select(
    3246            *expressions, append=append, dialect=dialect, copy=False, **opts
    3247        )
    3248        return this

Append to or set the SELECT expressions.

###### Example:

>     >>> Select().select("x", "y").sql()
>     'SELECT x, y'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Query expression.

named_selects: List[str] View Source

    3250    @property
    3251    def named_selects(self) -> t.List[str]:
    3252        return self.this.unnest().named_selects

Returns the output names of the query's projections.

is_star: bool View Source

    3254    @property
    3255    def is_star(self) -> bool:
    3256        return self.this.is_star or self.expression.is_star

Checks whether an expression is a star.

selects: List[Expression] View Source

    3258    @property
    3259    def selects(self) -> t.List[Expression]:
    3260        return self.this.unnest().selects

Returns the query's projections.

left: Query View Source

    3262    @property
    3263    def left(self) -> Query:
    3264        return self.this

right: Query View Source

    3266    @property
    3267    def right(self) -> Query:
    3268        return self.expression

key = 'setoperation'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Query
  subquery
  limit
  offset
  order_by
  ctes
  with_
  union
  intersect
  except_

class Union(SetOperation): View Source

    3271class Union(SetOperation):
    3272    pass

key = 'union'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
SetOperation
  arg_types
  select
  named_selects
  is_star
  selects
  left
  right
Query
  subquery
  limit
  offset
  order_by
  ctes
  with_
  union
  intersect
  except_

class Except(SetOperation): View Source

    3275class Except(SetOperation):
    3276    pass

key = 'except'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
SetOperation
  arg_types
  select
  named_selects
  is_star
  selects
  left
  right
Query
  subquery
  limit
  offset
  order_by
  ctes
  with_
  union
  intersect
  except_

class Intersect(SetOperation): View Source

    3279class Intersect(SetOperation):
    3280    pass

key = 'intersect'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
SetOperation
  arg_types
  select
  named_selects
  is_star
  selects
  left
  right
Query
  subquery
  limit
  offset
  order_by
  ctes
  with_
  union
  intersect
  except_

class Update(DML): View Source

    3283class Update(DML):
    3284    arg_types = {
    3285        "with": False,
    3286        "this": False,
    3287        "expressions": True,
    3288        "from": False,
    3289        "where": False,
    3290        "returning": False,
    3291        "order": False,
    3292        "limit": False,
    3293    }
    3294
    3295    def table(
    3296        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3297    ) -> Update:
    3298        """
    3299        Set the table to update.
    3300
    3301        Example:
    3302            >>> Update().table("my_table").set_("x = 1").sql()
    3303            'UPDATE my_table SET x = 1'
    3304
    3305        Args:
    3306            expression : the SQL code strings to parse.
    3307                If a `Table` instance is passed, this is used as-is.
    3308                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3309            dialect: the dialect used to parse the input expression.
    3310            copy: if `False`, modify this expression instance in-place.
    3311            opts: other options to use to parse the input expressions.
    3312
    3313        Returns:
    3314            The modified Update expression.
    3315        """
    3316        return _apply_builder(
    3317            expression=expression,
    3318            instance=self,
    3319            arg="this",
    3320            into=Table,
    3321            prefix=None,
    3322            dialect=dialect,
    3323            copy=copy,
    3324            **opts,
    3325        )
    3326
    3327    def set_(
    3328        self,
    3329        *expressions: ExpOrStr,
    3330        append: bool = True,
    3331        dialect: DialectType = None,
    3332        copy: bool = True,
    3333        **opts,
    3334    ) -> Update:
    3335        """
    3336        Append to or set the SET expressions.
    3337
    3338        Example:
    3339            >>> Update().table("my_table").set_("x = 1").sql()
    3340            'UPDATE my_table SET x = 1'
    3341
    3342        Args:
    3343            *expressions: the SQL code strings to parse.
    3344                If `Expression` instance(s) are passed, they will be used as-is.
    3345                Multiple expressions are combined with a comma.
    3346            append: if `True`, add the new expressions to any existing SET expressions.
    3347                Otherwise, this resets the expressions.
    3348            dialect: the dialect used to parse the input expressions.
    3349            copy: if `False`, modify this expression instance in-place.
    3350            opts: other options to use to parse the input expressions.
    3351        """
    3352        return _apply_list_builder(
    3353            *expressions,
    3354            instance=self,
    3355            arg="expressions",
    3356            append=append,
    3357            into=Expression,
    3358            prefix=None,
    3359            dialect=dialect,
    3360            copy=copy,
    3361            **opts,
    3362        )
    3363
    3364    def where(
    3365        self,
    3366        *expressions: t.Optional[ExpOrStr],
    3367        append: bool = True,
    3368        dialect: DialectType = None,
    3369        copy: bool = True,
    3370        **opts,
    3371    ) -> Select:
    3372        """
    3373        Append to or set the WHERE expressions.
    3374
    3375        Example:
    3376            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3377            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3378
    3379        Args:
    3380            *expressions: the SQL code strings to parse.
    3381                If an `Expression` instance is passed, it will be used as-is.
    3382                Multiple expressions are combined with an AND operator.
    3383            append: if `True`, AND the new expressions to any existing expression.
    3384                Otherwise, this resets the expression.
    3385            dialect: the dialect used to parse the input expressions.
    3386            copy: if `False`, modify this expression instance in-place.
    3387            opts: other options to use to parse the input expressions.
    3388
    3389        Returns:
    3390            Select: the modified expression.
    3391        """
    3392        return _apply_conjunction_builder(
    3393            *expressions,
    3394            instance=self,
    3395            arg="where",
    3396            append=append,
    3397            into=Where,
    3398            dialect=dialect,
    3399            copy=copy,
    3400            **opts,
    3401        )
    3402
    3403    def from_(
    3404        self,
    3405        expression: t.Optional[ExpOrStr] = None,
    3406        dialect: DialectType = None,
    3407        copy: bool = True,
    3408        **opts,
    3409    ) -> Update:
    3410        """
    3411        Set the FROM expression.
    3412
    3413        Example:
    3414            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3415            'UPDATE my_table SET x = 1 FROM baz'
    3416
    3417        Args:
    3418            expression : the SQL code strings to parse.
    3419                If a `From` instance is passed, this is used as-is.
    3420                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3421                If nothing is passed in then a from is not applied to the expression
    3422            dialect: the dialect used to parse the input expression.
    3423            copy: if `False`, modify this expression instance in-place.
    3424            opts: other options to use to parse the input expressions.
    3425
    3426        Returns:
    3427            The modified Update expression.
    3428        """
    3429        if not expression:
    3430            return maybe_copy(self, copy)
    3431
    3432        return _apply_builder(
    3433            expression=expression,
    3434            instance=self,
    3435            arg="from",
    3436            into=From,
    3437            prefix="FROM",
    3438            dialect=dialect,
    3439            copy=copy,
    3440            **opts,
    3441        )
    3442
    3443    def with_(
    3444        self,
    3445        alias: ExpOrStr,
    3446        as_: ExpOrStr,
    3447        recursive: t.Optional[bool] = None,
    3448        materialized: t.Optional[bool] = None,
    3449        append: bool = True,
    3450        dialect: DialectType = None,
    3451        copy: bool = True,
    3452        **opts,
    3453    ) -> Update:
    3454        """
    3455        Append to or set the common table expressions.
    3456
    3457        Example:
    3458            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3459            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3460
    3461        Args:
    3462            alias: the SQL code string to parse as the table name.
    3463                If an `Expression` instance is passed, this is used as-is.
    3464            as_: the SQL code string to parse as the table expression.
    3465                If an `Expression` instance is passed, it will be used as-is.
    3466            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3467            materialized: set the MATERIALIZED part of the expression.
    3468            append: if `True`, add to any existing expressions.
    3469                Otherwise, this resets the expressions.
    3470            dialect: the dialect used to parse the input expression.
    3471            copy: if `False`, modify this expression instance in-place.
    3472            opts: other options to use to parse the input expressions.
    3473
    3474        Returns:
    3475            The modified expression.
    3476        """
    3477        return _apply_cte_builder(
    3478            self,
    3479            alias,
    3480            as_,
    3481            recursive=recursive,
    3482            materialized=materialized,
    3483            append=append,
    3484            dialect=dialect,
    3485            copy=copy,
    3486            **opts,
    3487        )

arg_types = {'with': False, 'this': False, 'expressions': True, 'from': False, 'where': False, 'returning': False, 'order': False, 'limit': False}
def table( self, expression: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3295    def table(
    3296        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3297    ) -> Update:
    3298        """
    3299        Set the table to update.
    3300
    3301        Example:
    3302            >>> Update().table("my_table").set_("x = 1").sql()
    3303            'UPDATE my_table SET x = 1'
    3304
    3305        Args:
    3306            expression : the SQL code strings to parse.
    3307                If a `Table` instance is passed, this is used as-is.
    3308                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3309            dialect: the dialect used to parse the input expression.
    3310            copy: if `False`, modify this expression instance in-place.
    3311            opts: other options to use to parse the input expressions.
    3312
    3313        Returns:
    3314            The modified Update expression.
    3315        """
    3316        return _apply_builder(
    3317            expression=expression,
    3318            instance=self,
    3319            arg="this",
    3320            into=Table,
    3321            prefix=None,
    3322            dialect=dialect,
    3323            copy=copy,
    3324            **opts,
    3325        )

Set the table to update.

###### Example:

>     >>> Update().table("my_table").set_("x = 1").sql()
>     'UPDATE my_table SET x = 1'

###### Arguments:

- expression : the SQL code strings to parse. If a `Table` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Table`.
- 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 Update expression.

def set_( self, *expressions: Union[str, Expression], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3327    def set_(
    3328        self,
    3329        *expressions: ExpOrStr,
    3330        append: bool = True,
    3331        dialect: DialectType = None,
    3332        copy: bool = True,
    3333        **opts,
    3334    ) -> Update:
    3335        """
    3336        Append to or set the SET expressions.
    3337
    3338        Example:
    3339            >>> Update().table("my_table").set_("x = 1").sql()
    3340            'UPDATE my_table SET x = 1'
    3341
    3342        Args:
    3343            *expressions: the SQL code strings to parse.
    3344                If `Expression` instance(s) are passed, they will be used as-is.
    3345                Multiple expressions are combined with a comma.
    3346            append: if `True`, add the new expressions to any existing SET expressions.
    3347                Otherwise, this resets the expressions.
    3348            dialect: the dialect used to parse the input expressions.
    3349            copy: if `False`, modify this expression instance in-place.
    3350            opts: other options to use to parse the input expressions.
    3351        """
    3352        return _apply_list_builder(
    3353            *expressions,
    3354            instance=self,
    3355            arg="expressions",
    3356            append=append,
    3357            into=Expression,
    3358            prefix=None,
    3359            dialect=dialect,
    3360            copy=copy,
    3361            **opts,
    3362        )

Append to or set the SET expressions.

###### Example:

>     >>> Update().table("my_table").set_("x = 1").sql()
>     'UPDATE my_table SET x = 1'

###### Arguments:

- *expressions: the SQL code strings to parse. If `Expression` instance(s) are passed, they will be used as-is. Multiple expressions are combined with a comma.
- append: if `True`, add the new expressions to any existing SET expressions. Otherwise, this resets the expressions.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

def where( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3364    def where(
    3365        self,
    3366        *expressions: t.Optional[ExpOrStr],
    3367        append: bool = True,
    3368        dialect: DialectType = None,
    3369        copy: bool = True,
    3370        **opts,
    3371    ) -> Select:
    3372        """
    3373        Append to or set the WHERE expressions.
    3374
    3375        Example:
    3376            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3377            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3378
    3379        Args:
    3380            *expressions: the SQL code strings to parse.
    3381                If an `Expression` instance is passed, it will be used as-is.
    3382                Multiple expressions are combined with an AND operator.
    3383            append: if `True`, AND the new expressions to any existing expression.
    3384                Otherwise, this resets the expression.
    3385            dialect: the dialect used to parse the input expressions.
    3386            copy: if `False`, modify this expression instance in-place.
    3387            opts: other options to use to parse the input expressions.
    3388
    3389        Returns:
    3390            Select: the modified expression.
    3391        """
    3392        return _apply_conjunction_builder(
    3393            *expressions,
    3394            instance=self,
    3395            arg="where",
    3396            append=append,
    3397            into=Where,
    3398            dialect=dialect,
    3399            copy=copy,
    3400            **opts,
    3401        )

Append to or set the WHERE expressions.

###### Example:

>     >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
>     "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator.
- append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> Select: the modified expression.

def from_( self, expression: Union[str, Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3403    def from_(
    3404        self,
    3405        expression: t.Optional[ExpOrStr] = None,
    3406        dialect: DialectType = None,
    3407        copy: bool = True,
    3408        **opts,
    3409    ) -> Update:
    3410        """
    3411        Set the FROM expression.
    3412
    3413        Example:
    3414            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3415            'UPDATE my_table SET x = 1 FROM baz'
    3416
    3417        Args:
    3418            expression : the SQL code strings to parse.
    3419                If a `From` instance is passed, this is used as-is.
    3420                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3421                If nothing is passed in then a from is not applied to the expression
    3422            dialect: the dialect used to parse the input expression.
    3423            copy: if `False`, modify this expression instance in-place.
    3424            opts: other options to use to parse the input expressions.
    3425
    3426        Returns:
    3427            The modified Update expression.
    3428        """
    3429        if not expression:
    3430            return maybe_copy(self, copy)
    3431
    3432        return _apply_builder(
    3433            expression=expression,
    3434            instance=self,
    3435            arg="from",
    3436            into=From,
    3437            prefix="FROM",
    3438            dialect=dialect,
    3439            copy=copy,
    3440            **opts,
    3441        )

Set the FROM expression.

###### Example:

>     >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
>     'UPDATE my_table SET x = 1 FROM baz'

###### Arguments:

- expression : the SQL code strings to parse. If a `From` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `From`. If nothing is passed in then a from is not applied to the 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 Update expression.

def with_( self, alias: Union[str, Expression], as_: Union[str, Expression], recursive: Optional[bool] = None, materialized: Optional[bool] = None, append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3443    def with_(
    3444        self,
    3445        alias: ExpOrStr,
    3446        as_: ExpOrStr,
    3447        recursive: t.Optional[bool] = None,
    3448        materialized: t.Optional[bool] = None,
    3449        append: bool = True,
    3450        dialect: DialectType = None,
    3451        copy: bool = True,
    3452        **opts,
    3453    ) -> Update:
    3454        """
    3455        Append to or set the common table expressions.
    3456
    3457        Example:
    3458            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3459            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3460
    3461        Args:
    3462            alias: the SQL code string to parse as the table name.
    3463                If an `Expression` instance is passed, this is used as-is.
    3464            as_: the SQL code string to parse as the table expression.
    3465                If an `Expression` instance is passed, it will be used as-is.
    3466            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3467            materialized: set the MATERIALIZED part of the expression.
    3468            append: if `True`, add to any existing expressions.
    3469                Otherwise, this resets the expressions.
    3470            dialect: the dialect used to parse the input expression.
    3471            copy: if `False`, modify this expression instance in-place.
    3472            opts: other options to use to parse the input expressions.
    3473
    3474        Returns:
    3475            The modified expression.
    3476        """
    3477        return _apply_cte_builder(
    3478            self,
    3479            alias,
    3480            as_,
    3481            recursive=recursive,
    3482            materialized=materialized,
    3483            append=append,
    3484            dialect=dialect,
    3485            copy=copy,
    3486            **opts,
    3487        )

Append to or set the common table expressions.

###### Example:

>     >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
>     'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'

###### Arguments:

- alias: the SQL code string to parse as the table name. If an `Expression` instance is passed, this is used as-is.
- as_: the SQL code string to parse as the table expression. If an `Expression` instance is passed, it will be used as-is.
- recursive: set the RECURSIVE part of the expression. Defaults to `False`.
- materialized: set the MATERIALIZED part of the expression.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- 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 expression.

key = 'update'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class Values(UDTF): View Source

    3490class Values(UDTF):
    3491    arg_types = {"expressions": True, "alias": False}

arg_types = {'expressions': True, 'alias': False}
key = 'values'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
UDTF
  selects
DerivedTable
  named_selects

class Var(Expression): View Source

    3494class Var(Expression):
    3495    pass

key = 'var'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Version(Expression): View Source

    3498class Version(Expression):
    3499    """
    3500    Time travel, iceberg, bigquery etc
    3501    https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots
    3502    https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html
    3503    https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of
    3504    https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16
    3505    this is either TIMESTAMP or VERSION
    3506    kind is ("AS OF", "BETWEEN")
    3507    """
    3508
    3509    arg_types = {"this": True, "kind": True, "expression": False}

Time travel, iceberg, bigquery etc https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16 this is either TIMESTAMP or VERSION kind is ("AS OF", "BETWEEN")

arg_types = {'this': True, 'kind': True, 'expression': False}
key = 'version'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Schema(Expression): View Source

    3512class Schema(Expression):
    3513    arg_types = {"this": False, "expressions": False}

arg_types = {'this': False, 'expressions': False}
key = 'schema'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Lock(Expression): View Source

    3518class Lock(Expression):
    3519    arg_types = {"update": True, "expressions": False, "wait": False}

arg_types = {'update': True, 'expressions': False, 'wait': False}
key = 'lock'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Select(Query): View Source

    3522class Select(Query):
    3523    arg_types = {
    3524        "with": False,
    3525        "kind": False,
    3526        "expressions": False,
    3527        "hint": False,
    3528        "distinct": False,
    3529        "into": False,
    3530        "from": False,
    3531        "operation_modifiers": False,
    3532        **QUERY_MODIFIERS,
    3533    }
    3534
    3535    def from_(
    3536        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3537    ) -> Select:
    3538        """
    3539        Set the FROM expression.
    3540
    3541        Example:
    3542            >>> Select().from_("tbl").select("x").sql()
    3543            'SELECT x FROM tbl'
    3544
    3545        Args:
    3546            expression : the SQL code strings to parse.
    3547                If a `From` instance is passed, this is used as-is.
    3548                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3549            dialect: the dialect used to parse the input expression.
    3550            copy: if `False`, modify this expression instance in-place.
    3551            opts: other options to use to parse the input expressions.
    3552
    3553        Returns:
    3554            The modified Select expression.
    3555        """
    3556        return _apply_builder(
    3557            expression=expression,
    3558            instance=self,
    3559            arg="from",
    3560            into=From,
    3561            prefix="FROM",
    3562            dialect=dialect,
    3563            copy=copy,
    3564            **opts,
    3565        )
    3566
    3567    def group_by(
    3568        self,
    3569        *expressions: t.Optional[ExpOrStr],
    3570        append: bool = True,
    3571        dialect: DialectType = None,
    3572        copy: bool = True,
    3573        **opts,
    3574    ) -> Select:
    3575        """
    3576        Set the GROUP BY expression.
    3577
    3578        Example:
    3579            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3580            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3581
    3582        Args:
    3583            *expressions: the SQL code strings to parse.
    3584                If a `Group` instance is passed, this is used as-is.
    3585                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3586                If nothing is passed in then a group by is not applied to the expression
    3587            append: if `True`, add to any existing expressions.
    3588                Otherwise, this flattens all the `Group` expression into a single expression.
    3589            dialect: the dialect used to parse the input expression.
    3590            copy: if `False`, modify this expression instance in-place.
    3591            opts: other options to use to parse the input expressions.
    3592
    3593        Returns:
    3594            The modified Select expression.
    3595        """
    3596        if not expressions:
    3597            return self if not copy else self.copy()
    3598
    3599        return _apply_child_list_builder(
    3600            *expressions,
    3601            instance=self,
    3602            arg="group",
    3603            append=append,
    3604            copy=copy,
    3605            prefix="GROUP BY",
    3606            into=Group,
    3607            dialect=dialect,
    3608            **opts,
    3609        )
    3610
    3611    def sort_by(
    3612        self,
    3613        *expressions: t.Optional[ExpOrStr],
    3614        append: bool = True,
    3615        dialect: DialectType = None,
    3616        copy: bool = True,
    3617        **opts,
    3618    ) -> Select:
    3619        """
    3620        Set the SORT BY expression.
    3621
    3622        Example:
    3623            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3624            'SELECT x FROM tbl SORT BY x DESC'
    3625
    3626        Args:
    3627            *expressions: the SQL code strings to parse.
    3628                If a `Group` instance is passed, this is used as-is.
    3629                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3630            append: if `True`, add to any existing expressions.
    3631                Otherwise, this flattens all the `Order` expression into a single expression.
    3632            dialect: the dialect used to parse the input expression.
    3633            copy: if `False`, modify this expression instance in-place.
    3634            opts: other options to use to parse the input expressions.
    3635
    3636        Returns:
    3637            The modified Select expression.
    3638        """
    3639        return _apply_child_list_builder(
    3640            *expressions,
    3641            instance=self,
    3642            arg="sort",
    3643            append=append,
    3644            copy=copy,
    3645            prefix="SORT BY",
    3646            into=Sort,
    3647            dialect=dialect,
    3648            **opts,
    3649        )
    3650
    3651    def cluster_by(
    3652        self,
    3653        *expressions: t.Optional[ExpOrStr],
    3654        append: bool = True,
    3655        dialect: DialectType = None,
    3656        copy: bool = True,
    3657        **opts,
    3658    ) -> Select:
    3659        """
    3660        Set the CLUSTER BY expression.
    3661
    3662        Example:
    3663            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3664            'SELECT x FROM tbl CLUSTER BY x DESC'
    3665
    3666        Args:
    3667            *expressions: the SQL code strings to parse.
    3668                If a `Group` instance is passed, this is used as-is.
    3669                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3670            append: if `True`, add to any existing expressions.
    3671                Otherwise, this flattens all the `Order` expression into a single expression.
    3672            dialect: the dialect used to parse the input expression.
    3673            copy: if `False`, modify this expression instance in-place.
    3674            opts: other options to use to parse the input expressions.
    3675
    3676        Returns:
    3677            The modified Select expression.
    3678        """
    3679        return _apply_child_list_builder(
    3680            *expressions,
    3681            instance=self,
    3682            arg="cluster",
    3683            append=append,
    3684            copy=copy,
    3685            prefix="CLUSTER BY",
    3686            into=Cluster,
    3687            dialect=dialect,
    3688            **opts,
    3689        )
    3690
    3691    def select(
    3692        self,
    3693        *expressions: t.Optional[ExpOrStr],
    3694        append: bool = True,
    3695        dialect: DialectType = None,
    3696        copy: bool = True,
    3697        **opts,
    3698    ) -> Select:
    3699        return _apply_list_builder(
    3700            *expressions,
    3701            instance=self,
    3702            arg="expressions",
    3703            append=append,
    3704            dialect=dialect,
    3705            into=Expression,
    3706            copy=copy,
    3707            **opts,
    3708        )
    3709
    3710    def lateral(
    3711        self,
    3712        *expressions: t.Optional[ExpOrStr],
    3713        append: bool = True,
    3714        dialect: DialectType = None,
    3715        copy: bool = True,
    3716        **opts,
    3717    ) -> Select:
    3718        """
    3719        Append to or set the LATERAL expressions.
    3720
    3721        Example:
    3722            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3723            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3724
    3725        Args:
    3726            *expressions: the SQL code strings to parse.
    3727                If an `Expression` instance is passed, it will be used as-is.
    3728            append: if `True`, add to any existing expressions.
    3729                Otherwise, this resets the expressions.
    3730            dialect: the dialect used to parse the input expressions.
    3731            copy: if `False`, modify this expression instance in-place.
    3732            opts: other options to use to parse the input expressions.
    3733
    3734        Returns:
    3735            The modified Select expression.
    3736        """
    3737        return _apply_list_builder(
    3738            *expressions,
    3739            instance=self,
    3740            arg="laterals",
    3741            append=append,
    3742            into=Lateral,
    3743            prefix="LATERAL VIEW",
    3744            dialect=dialect,
    3745            copy=copy,
    3746            **opts,
    3747        )
    3748
    3749    def join(
    3750        self,
    3751        expression: ExpOrStr,
    3752        on: t.Optional[ExpOrStr] = None,
    3753        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3754        append: bool = True,
    3755        join_type: t.Optional[str] = None,
    3756        join_alias: t.Optional[Identifier | str] = None,
    3757        dialect: DialectType = None,
    3758        copy: bool = True,
    3759        **opts,
    3760    ) -> Select:
    3761        """
    3762        Append to or set the JOIN expressions.
    3763
    3764        Example:
    3765            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3766            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3767
    3768            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3769            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3770
    3771            Use `join_type` to change the type of join:
    3772
    3773            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3774            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3775
    3776        Args:
    3777            expression: the SQL code string to parse.
    3778                If an `Expression` instance is passed, it will be used as-is.
    3779            on: optionally specify the join "on" criteria as a SQL string.
    3780                If an `Expression` instance is passed, it will be used as-is.
    3781            using: optionally specify the join "using" criteria as a SQL string.
    3782                If an `Expression` instance is passed, it will be used as-is.
    3783            append: if `True`, add to any existing expressions.
    3784                Otherwise, this resets the expressions.
    3785            join_type: if set, alter the parsed join type.
    3786            join_alias: an optional alias for the joined source.
    3787            dialect: the dialect used to parse the input expressions.
    3788            copy: if `False`, modify this expression instance in-place.
    3789            opts: other options to use to parse the input expressions.
    3790
    3791        Returns:
    3792            Select: the modified expression.
    3793        """
    3794        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3795
    3796        try:
    3797            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3798        except ParseError:
    3799            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3800
    3801        join = expression if isinstance(expression, Join) else Join(this=expression)
    3802
    3803        if isinstance(join.this, Select):
    3804            join.this.replace(join.this.subquery())
    3805
    3806        if join_type:
    3807            method: t.Optional[Token]
    3808            side: t.Optional[Token]
    3809            kind: t.Optional[Token]
    3810
    3811            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3812
    3813            if method:
    3814                join.set("method", method.text)
    3815            if side:
    3816                join.set("side", side.text)
    3817            if kind:
    3818                join.set("kind", kind.text)
    3819
    3820        if on:
    3821            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3822            join.set("on", on)
    3823
    3824        if using:
    3825            join = _apply_list_builder(
    3826                *ensure_list(using),
    3827                instance=join,
    3828                arg="using",
    3829                append=append,
    3830                copy=copy,
    3831                into=Identifier,
    3832                **opts,
    3833            )
    3834
    3835        if join_alias:
    3836            join.set("this", alias_(join.this, join_alias, table=True))
    3837
    3838        return _apply_list_builder(
    3839            join,
    3840            instance=self,
    3841            arg="joins",
    3842            append=append,
    3843            copy=copy,
    3844            **opts,
    3845        )
    3846
    3847    def where(
    3848        self,
    3849        *expressions: t.Optional[ExpOrStr],
    3850        append: bool = True,
    3851        dialect: DialectType = None,
    3852        copy: bool = True,
    3853        **opts,
    3854    ) -> Select:
    3855        """
    3856        Append to or set the WHERE expressions.
    3857
    3858        Example:
    3859            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3860            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3861
    3862        Args:
    3863            *expressions: the SQL code strings to parse.
    3864                If an `Expression` instance is passed, it will be used as-is.
    3865                Multiple expressions are combined with an AND operator.
    3866            append: if `True`, AND the new expressions to any existing expression.
    3867                Otherwise, this resets the expression.
    3868            dialect: the dialect used to parse the input expressions.
    3869            copy: if `False`, modify this expression instance in-place.
    3870            opts: other options to use to parse the input expressions.
    3871
    3872        Returns:
    3873            Select: the modified expression.
    3874        """
    3875        return _apply_conjunction_builder(
    3876            *expressions,
    3877            instance=self,
    3878            arg="where",
    3879            append=append,
    3880            into=Where,
    3881            dialect=dialect,
    3882            copy=copy,
    3883            **opts,
    3884        )
    3885
    3886    def having(
    3887        self,
    3888        *expressions: t.Optional[ExpOrStr],
    3889        append: bool = True,
    3890        dialect: DialectType = None,
    3891        copy: bool = True,
    3892        **opts,
    3893    ) -> Select:
    3894        """
    3895        Append to or set the HAVING expressions.
    3896
    3897        Example:
    3898            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3899            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3900
    3901        Args:
    3902            *expressions: the SQL code strings to parse.
    3903                If an `Expression` instance is passed, it will be used as-is.
    3904                Multiple expressions are combined with an AND operator.
    3905            append: if `True`, AND the new expressions to any existing expression.
    3906                Otherwise, this resets the expression.
    3907            dialect: the dialect used to parse the input expressions.
    3908            copy: if `False`, modify this expression instance in-place.
    3909            opts: other options to use to parse the input expressions.
    3910
    3911        Returns:
    3912            The modified Select expression.
    3913        """
    3914        return _apply_conjunction_builder(
    3915            *expressions,
    3916            instance=self,
    3917            arg="having",
    3918            append=append,
    3919            into=Having,
    3920            dialect=dialect,
    3921            copy=copy,
    3922            **opts,
    3923        )
    3924
    3925    def window(
    3926        self,
    3927        *expressions: t.Optional[ExpOrStr],
    3928        append: bool = True,
    3929        dialect: DialectType = None,
    3930        copy: bool = True,
    3931        **opts,
    3932    ) -> Select:
    3933        return _apply_list_builder(
    3934            *expressions,
    3935            instance=self,
    3936            arg="windows",
    3937            append=append,
    3938            into=Window,
    3939            dialect=dialect,
    3940            copy=copy,
    3941            **opts,
    3942        )
    3943
    3944    def qualify(
    3945        self,
    3946        *expressions: t.Optional[ExpOrStr],
    3947        append: bool = True,
    3948        dialect: DialectType = None,
    3949        copy: bool = True,
    3950        **opts,
    3951    ) -> Select:
    3952        return _apply_conjunction_builder(
    3953            *expressions,
    3954            instance=self,
    3955            arg="qualify",
    3956            append=append,
    3957            into=Qualify,
    3958            dialect=dialect,
    3959            copy=copy,
    3960            **opts,
    3961        )
    3962
    3963    def distinct(
    3964        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3965    ) -> Select:
    3966        """
    3967        Set the OFFSET expression.
    3968
    3969        Example:
    3970            >>> Select().from_("tbl").select("x").distinct().sql()
    3971            'SELECT DISTINCT x FROM tbl'
    3972
    3973        Args:
    3974            ons: the expressions to distinct on
    3975            distinct: whether the Select should be distinct
    3976            copy: if `False`, modify this expression instance in-place.
    3977
    3978        Returns:
    3979            Select: the modified expression.
    3980        """
    3981        instance = maybe_copy(self, copy)
    3982        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3983        instance.set("distinct", Distinct(on=on) if distinct else None)
    3984        return instance
    3985
    3986    def ctas(
    3987        self,
    3988        table: ExpOrStr,
    3989        properties: t.Optional[t.Dict] = None,
    3990        dialect: DialectType = None,
    3991        copy: bool = True,
    3992        **opts,
    3993    ) -> Create:
    3994        """
    3995        Convert this expression to a CREATE TABLE AS statement.
    3996
    3997        Example:
    3998            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3999            'CREATE TABLE x AS SELECT * FROM tbl'
    4000
    4001        Args:
    4002            table: the SQL code string to parse as the table name.
    4003                If another `Expression` instance is passed, it will be used as-is.
    4004            properties: an optional mapping of table properties
    4005            dialect: the dialect used to parse the input table.
    4006            copy: if `False`, modify this expression instance in-place.
    4007            opts: other options to use to parse the input table.
    4008
    4009        Returns:
    4010            The new Create expression.
    4011        """
    4012        instance = maybe_copy(self, copy)
    4013        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4014
    4015        properties_expression = None
    4016        if properties:
    4017            properties_expression = Properties.from_dict(properties)
    4018
    4019        return Create(
    4020            this=table_expression,
    4021            kind="TABLE",
    4022            expression=instance,
    4023            properties=properties_expression,
    4024        )
    4025
    4026    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4027        """
    4028        Set the locking read mode for this expression.
    4029
    4030        Examples:
    4031            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4032            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4033
    4034            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4035            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4036
    4037        Args:
    4038            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4039            copy: if `False`, modify this expression instance in-place.
    4040
    4041        Returns:
    4042            The modified expression.
    4043        """
    4044        inst = maybe_copy(self, copy)
    4045        inst.set("locks", [Lock(update=update)])
    4046
    4047        return inst
    4048
    4049    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4050        """
    4051        Set hints for this expression.
    4052
    4053        Examples:
    4054            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4055            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4056
    4057        Args:
    4058            hints: The SQL code strings to parse as the hints.
    4059                If an `Expression` instance is passed, it will be used as-is.
    4060            dialect: The dialect used to parse the hints.
    4061            copy: If `False`, modify this expression instance in-place.
    4062
    4063        Returns:
    4064            The modified expression.
    4065        """
    4066        inst = maybe_copy(self, copy)
    4067        inst.set(
    4068            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4069        )
    4070
    4071        return inst
    4072
    4073    @property
    4074    def named_selects(self) -> t.List[str]:
    4075        return [e.output_name for e in self.expressions if e.alias_or_name]
    4076
    4077    @property
    4078    def is_star(self) -> bool:
    4079        return any(expression.is_star for expression in self.expressions)
    4080
    4081    @property
    4082    def selects(self) -> t.List[Expression]:
    4083        return self.expressions

arg_types = {'with': False, 'kind': False, 'expressions': False, 'hint': False, 'distinct': False, 'into': False, 'from': False, 'operation_modifiers': False, 'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'prewhere': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False, 'options': False}
def from_( self, expression: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3535    def from_(
    3536        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3537    ) -> Select:
    3538        """
    3539        Set the FROM expression.
    3540
    3541        Example:
    3542            >>> Select().from_("tbl").select("x").sql()
    3543            'SELECT x FROM tbl'
    3544
    3545        Args:
    3546            expression : the SQL code strings to parse.
    3547                If a `From` instance is passed, this is used as-is.
    3548                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3549            dialect: the dialect used to parse the input expression.
    3550            copy: if `False`, modify this expression instance in-place.
    3551            opts: other options to use to parse the input expressions.
    3552
    3553        Returns:
    3554            The modified Select expression.
    3555        """
    3556        return _apply_builder(
    3557            expression=expression,
    3558            instance=self,
    3559            arg="from",
    3560            into=From,
    3561            prefix="FROM",
    3562            dialect=dialect,
    3563            copy=copy,
    3564            **opts,
    3565        )

Set the FROM expression.

###### Example:

>     >>> Select().from_("tbl").select("x").sql()
>     'SELECT x FROM tbl'

###### Arguments:

- expression : the SQL code strings to parse. If a `From` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `From`.
- 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.

def group_by( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3567    def group_by(
    3568        self,
    3569        *expressions: t.Optional[ExpOrStr],
    3570        append: bool = True,
    3571        dialect: DialectType = None,
    3572        copy: bool = True,
    3573        **opts,
    3574    ) -> Select:
    3575        """
    3576        Set the GROUP BY expression.
    3577
    3578        Example:
    3579            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3580            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3581
    3582        Args:
    3583            *expressions: the SQL code strings to parse.
    3584                If a `Group` instance is passed, this is used as-is.
    3585                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3586                If nothing is passed in then a group by is not applied to the expression
    3587            append: if `True`, add to any existing expressions.
    3588                Otherwise, this flattens all the `Group` expression into a single expression.
    3589            dialect: the dialect used to parse the input expression.
    3590            copy: if `False`, modify this expression instance in-place.
    3591            opts: other options to use to parse the input expressions.
    3592
    3593        Returns:
    3594            The modified Select expression.
    3595        """
    3596        if not expressions:
    3597            return self if not copy else self.copy()
    3598
    3599        return _apply_child_list_builder(
    3600            *expressions,
    3601            instance=self,
    3602            arg="group",
    3603            append=append,
    3604            copy=copy,
    3605            prefix="GROUP BY",
    3606            into=Group,
    3607            dialect=dialect,
    3608            **opts,
    3609        )

Set the GROUP BY expression.

###### Example:

>     >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
>     'SELECT x, COUNT(1) FROM tbl GROUP BY x'

###### Arguments:

- *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Group`. If nothing is passed in then a group by is not applied to the expression
- append: if `True`, add to any existing expressions. Otherwise, this flattens all the `Group` 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.

def sort_by( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3611    def sort_by(
    3612        self,
    3613        *expressions: t.Optional[ExpOrStr],
    3614        append: bool = True,
    3615        dialect: DialectType = None,
    3616        copy: bool = True,
    3617        **opts,
    3618    ) -> Select:
    3619        """
    3620        Set the SORT BY expression.
    3621
    3622        Example:
    3623            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3624            'SELECT x FROM tbl SORT BY x DESC'
    3625
    3626        Args:
    3627            *expressions: the SQL code strings to parse.
    3628                If a `Group` instance is passed, this is used as-is.
    3629                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3630            append: if `True`, add to any existing expressions.
    3631                Otherwise, this flattens all the `Order` expression into a single expression.
    3632            dialect: the dialect used to parse the input expression.
    3633            copy: if `False`, modify this expression instance in-place.
    3634            opts: other options to use to parse the input expressions.
    3635
    3636        Returns:
    3637            The modified Select expression.
    3638        """
    3639        return _apply_child_list_builder(
    3640            *expressions,
    3641            instance=self,
    3642            arg="sort",
    3643            append=append,
    3644            copy=copy,
    3645            prefix="SORT BY",
    3646            into=Sort,
    3647            dialect=dialect,
    3648            **opts,
    3649        )

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'

###### Arguments:

- *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` 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.

def cluster_by( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3651    def cluster_by(
    3652        self,
    3653        *expressions: t.Optional[ExpOrStr],
    3654        append: bool = True,
    3655        dialect: DialectType = None,
    3656        copy: bool = True,
    3657        **opts,
    3658    ) -> Select:
    3659        """
    3660        Set the CLUSTER BY expression.
    3661
    3662        Example:
    3663            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3664            'SELECT x FROM tbl CLUSTER BY x DESC'
    3665
    3666        Args:
    3667            *expressions: the SQL code strings to parse.
    3668                If a `Group` instance is passed, this is used as-is.
    3669                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3670            append: if `True`, add to any existing expressions.
    3671                Otherwise, this flattens all the `Order` expression into a single expression.
    3672            dialect: the dialect used to parse the input expression.
    3673            copy: if `False`, modify this expression instance in-place.
    3674            opts: other options to use to parse the input expressions.
    3675
    3676        Returns:
    3677            The modified Select expression.
    3678        """
    3679        return _apply_child_list_builder(
    3680            *expressions,
    3681            instance=self,
    3682            arg="cluster",
    3683            append=append,
    3684            copy=copy,
    3685            prefix="CLUSTER BY",
    3686            into=Cluster,
    3687            dialect=dialect,
    3688            **opts,
    3689        )

Set the CLUSTER BY expression.

###### Example:

>     >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
>     'SELECT x FROM tbl CLUSTER BY x DESC'

###### Arguments:

- *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
- 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.

def select( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3691    def select(
    3692        self,
    3693        *expressions: t.Optional[ExpOrStr],
    3694        append: bool = True,
    3695        dialect: DialectType = None,
    3696        copy: bool = True,
    3697        **opts,
    3698    ) -> Select:
    3699        return _apply_list_builder(
    3700            *expressions,
    3701            instance=self,
    3702            arg="expressions",
    3703            append=append,
    3704            dialect=dialect,
    3705            into=Expression,
    3706            copy=copy,
    3707            **opts,
    3708        )

Append to or set the SELECT expressions.

###### Example:

>     >>> Select().select("x", "y").sql()
>     'SELECT x, y'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Query expression.

def lateral( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3710    def lateral(
    3711        self,
    3712        *expressions: t.Optional[ExpOrStr],
    3713        append: bool = True,
    3714        dialect: DialectType = None,
    3715        copy: bool = True,
    3716        **opts,
    3717    ) -> Select:
    3718        """
    3719        Append to or set the LATERAL expressions.
    3720
    3721        Example:
    3722            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3723            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3724
    3725        Args:
    3726            *expressions: the SQL code strings to parse.
    3727                If an `Expression` instance is passed, it will be used as-is.
    3728            append: if `True`, add to any existing expressions.
    3729                Otherwise, this resets the expressions.
    3730            dialect: the dialect used to parse the input expressions.
    3731            copy: if `False`, modify this expression instance in-place.
    3732            opts: other options to use to parse the input expressions.
    3733
    3734        Returns:
    3735            The modified Select expression.
    3736        """
    3737        return _apply_list_builder(
    3738            *expressions,
    3739            instance=self,
    3740            arg="laterals",
    3741            append=append,
    3742            into=Lateral,
    3743            prefix="LATERAL VIEW",
    3744            dialect=dialect,
    3745            copy=copy,
    3746            **opts,
    3747        )

Append to or set the LATERAL expressions.

###### Example:

>     >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
>     'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Select expression.

def join( self, expression: Union[str, Expression], on: Union[str, Expression, NoneType] = None, using: Union[str, Expression, Collection[Union[str, Expression]], NoneType] = None, append: bool = True, join_type: Optional[str] = None, join_alias: Union[Identifier, str, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3749    def join(
    3750        self,
    3751        expression: ExpOrStr,
    3752        on: t.Optional[ExpOrStr] = None,
    3753        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3754        append: bool = True,
    3755        join_type: t.Optional[str] = None,
    3756        join_alias: t.Optional[Identifier | str] = None,
    3757        dialect: DialectType = None,
    3758        copy: bool = True,
    3759        **opts,
    3760    ) -> Select:
    3761        """
    3762        Append to or set the JOIN expressions.
    3763
    3764        Example:
    3765            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3766            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3767
    3768            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3769            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3770
    3771            Use `join_type` to change the type of join:
    3772
    3773            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3774            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3775
    3776        Args:
    3777            expression: the SQL code string to parse.
    3778                If an `Expression` instance is passed, it will be used as-is.
    3779            on: optionally specify the join "on" criteria as a SQL string.
    3780                If an `Expression` instance is passed, it will be used as-is.
    3781            using: optionally specify the join "using" criteria as a SQL string.
    3782                If an `Expression` instance is passed, it will be used as-is.
    3783            append: if `True`, add to any existing expressions.
    3784                Otherwise, this resets the expressions.
    3785            join_type: if set, alter the parsed join type.
    3786            join_alias: an optional alias for the joined source.
    3787            dialect: the dialect used to parse the input expressions.
    3788            copy: if `False`, modify this expression instance in-place.
    3789            opts: other options to use to parse the input expressions.
    3790
    3791        Returns:
    3792            Select: the modified expression.
    3793        """
    3794        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3795
    3796        try:
    3797            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3798        except ParseError:
    3799            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3800
    3801        join = expression if isinstance(expression, Join) else Join(this=expression)
    3802
    3803        if isinstance(join.this, Select):
    3804            join.this.replace(join.this.subquery())
    3805
    3806        if join_type:
    3807            method: t.Optional[Token]
    3808            side: t.Optional[Token]
    3809            kind: t.Optional[Token]
    3810
    3811            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3812
    3813            if method:
    3814                join.set("method", method.text)
    3815            if side:
    3816                join.set("side", side.text)
    3817            if kind:
    3818                join.set("kind", kind.text)
    3819
    3820        if on:
    3821            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3822            join.set("on", on)
    3823
    3824        if using:
    3825            join = _apply_list_builder(
    3826                *ensure_list(using),
    3827                instance=join,
    3828                arg="using",
    3829                append=append,
    3830                copy=copy,
    3831                into=Identifier,
    3832                **opts,
    3833            )
    3834
    3835        if join_alias:
    3836            join.set("this", alias_(join.this, join_alias, table=True))
    3837
    3838        return _apply_list_builder(
    3839            join,
    3840            instance=self,
    3841            arg="joins",
    3842            append=append,
    3843            copy=copy,
    3844            **opts,
    3845        )

Append to or set the JOIN expressions.

###### Example:

>     >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
>     'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'

>     >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
>     'SELECT 1 FROM a JOIN b USING (x, y, z)'

> Use `join_type` to change the type of join:

>     >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
>     'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'

###### Arguments:

- expression: the SQL code string to parse. If an `Expression` instance is passed, it will be used as-is.
- on: optionally specify the join "on" criteria as a SQL string. If an `Expression` instance is passed, it will be used as-is.
- using: optionally specify the join "using" criteria as a SQL string. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- join_type: if set, alter the parsed join type.
- join_alias: an optional alias for the joined source.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> Select: the modified expression.

def where( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3847    def where(
    3848        self,
    3849        *expressions: t.Optional[ExpOrStr],
    3850        append: bool = True,
    3851        dialect: DialectType = None,
    3852        copy: bool = True,
    3853        **opts,
    3854    ) -> Select:
    3855        """
    3856        Append to or set the WHERE expressions.
    3857
    3858        Example:
    3859            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3860            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3861
    3862        Args:
    3863            *expressions: the SQL code strings to parse.
    3864                If an `Expression` instance is passed, it will be used as-is.
    3865                Multiple expressions are combined with an AND operator.
    3866            append: if `True`, AND the new expressions to any existing expression.
    3867                Otherwise, this resets the expression.
    3868            dialect: the dialect used to parse the input expressions.
    3869            copy: if `False`, modify this expression instance in-place.
    3870            opts: other options to use to parse the input expressions.
    3871
    3872        Returns:
    3873            Select: the modified expression.
    3874        """
    3875        return _apply_conjunction_builder(
    3876            *expressions,
    3877            instance=self,
    3878            arg="where",
    3879            append=append,
    3880            into=Where,
    3881            dialect=dialect,
    3882            copy=copy,
    3883            **opts,
    3884        )

Append to or set the WHERE expressions.

###### Example:

>     >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
>     "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator.
- append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> Select: the modified expression.

def having( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3886    def having(
    3887        self,
    3888        *expressions: t.Optional[ExpOrStr],
    3889        append: bool = True,
    3890        dialect: DialectType = None,
    3891        copy: bool = True,
    3892        **opts,
    3893    ) -> Select:
    3894        """
    3895        Append to or set the HAVING expressions.
    3896
    3897        Example:
    3898            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3899            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3900
    3901        Args:
    3902            *expressions: the SQL code strings to parse.
    3903                If an `Expression` instance is passed, it will be used as-is.
    3904                Multiple expressions are combined with an AND operator.
    3905            append: if `True`, AND the new expressions to any existing expression.
    3906                Otherwise, this resets the expression.
    3907            dialect: the dialect used to parse the input expressions.
    3908            copy: if `False`, modify this expression instance in-place.
    3909            opts: other options to use to parse the input expressions.
    3910
    3911        Returns:
    3912            The modified Select expression.
    3913        """
    3914        return _apply_conjunction_builder(
    3915            *expressions,
    3916            instance=self,
    3917            arg="having",
    3918            append=append,
    3919            into=Having,
    3920            dialect=dialect,
    3921            copy=copy,
    3922            **opts,
    3923        )

Append to or set the HAVING expressions.

###### Example:

>     >>> 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'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator.
- append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Select expression.

def window( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3925    def window(
    3926        self,
    3927        *expressions: t.Optional[ExpOrStr],
    3928        append: bool = True,
    3929        dialect: DialectType = None,
    3930        copy: bool = True,
    3931        **opts,
    3932    ) -> Select:
    3933        return _apply_list_builder(
    3934            *expressions,
    3935            instance=self,
    3936            arg="windows",
    3937            append=append,
    3938            into=Window,
    3939            dialect=dialect,
    3940            copy=copy,
    3941            **opts,
    3942        )

def qualify( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3944    def qualify(
    3945        self,
    3946        *expressions: t.Optional[ExpOrStr],
    3947        append: bool = True,
    3948        dialect: DialectType = None,
    3949        copy: bool = True,
    3950        **opts,
    3951    ) -> Select:
    3952        return _apply_conjunction_builder(
    3953            *expressions,
    3954            instance=self,
    3955            arg="qualify",
    3956            append=append,
    3957            into=Qualify,
    3958            dialect=dialect,
    3959            copy=copy,
    3960            **opts,
    3961        )

def distinct( self, *ons: Union[str, Expression, NoneType], distinct: bool = True, copy: bool = True) -> Select: View Source

    3963    def distinct(
    3964        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3965    ) -> Select:
    3966        """
    3967        Set the OFFSET expression.
    3968
    3969        Example:
    3970            >>> Select().from_("tbl").select("x").distinct().sql()
    3971            'SELECT DISTINCT x FROM tbl'
    3972
    3973        Args:
    3974            ons: the expressions to distinct on
    3975            distinct: whether the Select should be distinct
    3976            copy: if `False`, modify this expression instance in-place.
    3977
    3978        Returns:
    3979            Select: the modified expression.
    3980        """
    3981        instance = maybe_copy(self, copy)
    3982        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3983        instance.set("distinct", Distinct(on=on) if distinct else None)
    3984        return instance

Set the OFFSET expression.

###### Example:

>     >>> Select().from_("tbl").select("x").distinct().sql()
>     'SELECT DISTINCT x FROM tbl'

###### Arguments:

- ons: the expressions to distinct on
- distinct: whether the Select should be distinct
- copy: if `False`, modify this expression instance in-place.

###### Returns:

> Select: the modified expression.

def ctas( self, table: Union[str, Expression], properties: Optional[Dict] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Create: View Source

    3986    def ctas(
    3987        self,
    3988        table: ExpOrStr,
    3989        properties: t.Optional[t.Dict] = None,
    3990        dialect: DialectType = None,
    3991        copy: bool = True,
    3992        **opts,
    3993    ) -> Create:
    3994        """
    3995        Convert this expression to a CREATE TABLE AS statement.
    3996
    3997        Example:
    3998            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3999            'CREATE TABLE x AS SELECT * FROM tbl'
    4000
    4001        Args:
    4002            table: the SQL code string to parse as the table name.
    4003                If another `Expression` instance is passed, it will be used as-is.
    4004            properties: an optional mapping of table properties
    4005            dialect: the dialect used to parse the input table.
    4006            copy: if `False`, modify this expression instance in-place.
    4007            opts: other options to use to parse the input table.
    4008
    4009        Returns:
    4010            The new Create expression.
    4011        """
    4012        instance = maybe_copy(self, copy)
    4013        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4014
    4015        properties_expression = None
    4016        if properties:
    4017            properties_expression = Properties.from_dict(properties)
    4018
    4019        return Create(
    4020            this=table_expression,
    4021            kind="TABLE",
    4022            expression=instance,
    4023            properties=properties_expression,
    4024        )

Convert this expression to a CREATE TABLE AS statement.

###### Example:

>     >>> Select().select("*").from_("tbl").ctas("x").sql()
>     'CREATE TABLE x AS SELECT * FROM tbl'

###### Arguments:

- table: the SQL code string to parse as the table name. If another `Expression` instance is passed, it will be used as-is.
- properties: an optional mapping of table properties
- dialect: the dialect used to parse the input table.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input table.

###### Returns:

> The new Create expression.

def lock( self, update: bool = True, copy: bool = True) -> Select: View Source

    4026    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4027        """
    4028        Set the locking read mode for this expression.
    4029
    4030        Examples:
    4031            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4032            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4033
    4034            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4035            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4036
    4037        Args:
    4038            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4039            copy: if `False`, modify this expression instance in-place.
    4040
    4041        Returns:
    4042            The modified expression.
    4043        """
    4044        inst = maybe_copy(self, copy)
    4045        inst.set("locks", [Lock(update=update)])
    4046
    4047        return inst

Set the locking read mode for this expression.

###### Examples:

>     >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
>     "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"

>     >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
>     "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"

###### Arguments:

- update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
- copy: if `False`, modify this expression instance in-place.

###### Returns:

> The modified expression.

def hint( self, *hints: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True) -> Select: View Source

    4049    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4050        """
    4051        Set hints for this expression.
    4052
    4053        Examples:
    4054            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4055            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4056
    4057        Args:
    4058            hints: The SQL code strings to parse as the hints.
    4059                If an `Expression` instance is passed, it will be used as-is.
    4060            dialect: The dialect used to parse the hints.
    4061            copy: If `False`, modify this expression instance in-place.
    4062
    4063        Returns:
    4064            The modified expression.
    4065        """
    4066        inst = maybe_copy(self, copy)
    4067        inst.set(
    4068            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4069        )
    4070
    4071        return inst

Set hints for this expression.

###### Examples:

>     >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
>     'SELECT /*+ BROADCAST(y) */ x FROM tbl'

###### Arguments:

- hints: The SQL code strings to parse as the hints. If an `Expression` instance is passed, it will be used as-is.
- dialect: The dialect used to parse the hints.
- copy: If `False`, modify this expression instance in-place.

###### Returns:

> The modified expression.

named_selects: List[str] View Source

    4073    @property
    4074    def named_selects(self) -> t.List[str]:
    4075        return [e.output_name for e in self.expressions if e.alias_or_name]

Returns the output names of the query's projections.

is_star: bool View Source

    4077    @property
    4078    def is_star(self) -> bool:
    4079        return any(expression.is_star for expression in self.expressions)

Checks whether an expression is a star.

selects: List[Expression] View Source

    4081    @property
    4082    def selects(self) -> t.List[Expression]:
    4083        return self.expressions

Returns the query's projections.

key = 'select'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Query
  subquery
  limit
  offset
  order_by
  ctes
  with_
  union
  intersect
  except_

UNWRAPPED_QUERIES = (<class 'Select'>, <class 'SetOperation'>)
class Subquery(DerivedTable, Query): View Source

    4089class Subquery(DerivedTable, Query):
    4090    arg_types = {
    4091        "this": True,
    4092        "alias": False,
    4093        "with": False,
    4094        **QUERY_MODIFIERS,
    4095    }
    4096
    4097    def unnest(self):
    4098        """Returns the first non subquery."""
    4099        expression = self
    4100        while isinstance(expression, Subquery):
    4101            expression = expression.this
    4102        return expression
    4103
    4104    def unwrap(self) -> Subquery:
    4105        expression = self
    4106        while expression.same_parent and expression.is_wrapper:
    4107            expression = t.cast(Subquery, expression.parent)
    4108        return expression
    4109
    4110    def select(
    4111        self,
    4112        *expressions: t.Optional[ExpOrStr],
    4113        append: bool = True,
    4114        dialect: DialectType = None,
    4115        copy: bool = True,
    4116        **opts,
    4117    ) -> Subquery:
    4118        this = maybe_copy(self, copy)
    4119        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4120        return this
    4121
    4122    @property
    4123    def is_wrapper(self) -> bool:
    4124        """
    4125        Whether this Subquery acts as a simple wrapper around another expression.
    4126
    4127        SELECT * FROM (((SELECT * FROM t)))
    4128                      ^
    4129                      This corresponds to a "wrapper" Subquery node
    4130        """
    4131        return all(v is None for k, v in self.args.items() if k != "this")
    4132
    4133    @property
    4134    def is_star(self) -> bool:
    4135        return self.this.is_star
    4136
    4137    @property
    4138    def output_name(self) -> str:
    4139        return self.alias

arg_types = {'this': True, 'alias': False, 'with': False, 'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'prewhere': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False, 'options': False}
def unnest(self): View Source

    4097    def unnest(self):
    4098        """Returns the first non subquery."""
    4099        expression = self
    4100        while isinstance(expression, Subquery):
    4101            expression = expression.this
    4102        return expression

Returns the first non subquery.

def unwrap(self) -> Subquery: View Source

    4104    def unwrap(self) -> Subquery:
    4105        expression = self
    4106        while expression.same_parent and expression.is_wrapper:
    4107            expression = t.cast(Subquery, expression.parent)
    4108        return expression

def select( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Subquery: View Source

    4110    def select(
    4111        self,
    4112        *expressions: t.Optional[ExpOrStr],
    4113        append: bool = True,
    4114        dialect: DialectType = None,
    4115        copy: bool = True,
    4116        **opts,
    4117    ) -> Subquery:
    4118        this = maybe_copy(self, copy)
    4119        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4120        return this

Append to or set the SELECT expressions.

###### Example:

>     >>> Select().select("x", "y").sql()
>     'SELECT x, y'

###### Arguments:

- *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> The modified Query expression.

is_wrapper: bool View Source

    4122    @property
    4123    def is_wrapper(self) -> bool:
    4124        """
    4125        Whether this Subquery acts as a simple wrapper around another expression.
    4126
    4127        SELECT * FROM (((SELECT * FROM t)))
    4128                      ^
    4129                      This corresponds to a "wrapper" Subquery node
    4130        """
    4131        return all(v is None for k, v in self.args.items() if k != "this")

Whether this Subquery acts as a simple wrapper around another expression.

SELECT * FROM (((SELECT * FROM t))) ^ This corresponds to a "wrapper" Subquery node

is_star: bool View Source

    4133    @property
    4134    def is_star(self) -> bool:
    4135        return self.this.is_star

Checks whether an expression is a star.

output_name: str View Source

    4137    @property
    4138    def output_name(self) -> str:
    4139        return self.alias

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'subquery'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DerivedTable
  selects
  named_selects
Query
  subquery
  limit
  offset
  order_by
  ctes
  with_
  union
  intersect
  except_

class TableSample(Expression): View Source

    4142class TableSample(Expression):
    4143    arg_types = {
    4144        "expressions": False,
    4145        "method": False,
    4146        "bucket_numerator": False,
    4147        "bucket_denominator": False,
    4148        "bucket_field": False,
    4149        "percent": False,
    4150        "rows": False,
    4151        "size": False,
    4152        "seed": False,
    4153    }

arg_types = {'expressions': False, 'method': False, 'bucket_numerator': False, 'bucket_denominator': False, 'bucket_field': False, 'percent': False, 'rows': False, 'size': False, 'seed': False}
key = 'tablesample'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Tag(Expression): View Source

    4156class Tag(Expression):
    4157    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    4158
    4159    arg_types = {
    4160        "this": False,
    4161        "prefix": False,
    4162        "postfix": False,
    4163    }

Tags are used for generating arbitrary sql like SELECT x.

arg_types = {'this': False, 'prefix': False, 'postfix': False}
key = 'tag'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Pivot(Expression): View Source

    4168class Pivot(Expression):
    4169    arg_types = {
    4170        "this": False,
    4171        "alias": False,
    4172        "expressions": False,
    4173        "field": False,
    4174        "unpivot": False,
    4175        "using": False,
    4176        "group": False,
    4177        "columns": False,
    4178        "include_nulls": False,
    4179        "default_on_null": False,
    4180    }
    4181
    4182    @property
    4183    def unpivot(self) -> bool:
    4184        return bool(self.args.get("unpivot"))

arg_types = {'this': False, 'alias': False, 'expressions': False, 'field': False, 'unpivot': False, 'using': False, 'group': False, 'columns': False, 'include_nulls': False, 'default_on_null': False}
unpivot: bool View Source

    4182    @property
    4183    def unpivot(self) -> bool:
    4184        return bool(self.args.get("unpivot"))

key = 'pivot'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Window(Condition): View Source

    4187class Window(Condition):
    4188    arg_types = {
    4189        "this": True,
    4190        "partition_by": False,
    4191        "order": False,
    4192        "spec": False,
    4193        "alias": False,
    4194        "over": False,
    4195        "first": False,
    4196    }

arg_types = {'this': True, 'partition_by': False, 'order': False, 'spec': False, 'alias': False, 'over': False, 'first': False}
key = 'window'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WindowSpec(Expression): View Source

    4199class WindowSpec(Expression):
    4200    arg_types = {
    4201        "kind": False,
    4202        "start": False,
    4203        "start_side": False,
    4204        "end": False,
    4205        "end_side": False,
    4206    }

arg_types = {'kind': False, 'start': False, 'start_side': False, 'end': False, 'end_side': False}
key = 'windowspec'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PreWhere(Expression): View Source

    4209class PreWhere(Expression):
    4210    pass

key = 'prewhere'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Where(Expression): View Source

    4213class Where(Expression):
    4214    pass

key = 'where'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Star(Expression): View Source

    4217class Star(Expression):
    4218    arg_types = {"except": False, "replace": False, "rename": False}
    4219
    4220    @property
    4221    def name(self) -> str:
    4222        return "*"
    4223
    4224    @property
    4225    def output_name(self) -> str:
    4226        return self.name

arg_types = {'except': False, 'replace': False, 'rename': False}
name: str View Source

    4220    @property
    4221    def name(self) -> str:
    4222        return "*"

output_name: str View Source

    4224    @property
    4225    def output_name(self) -> str:
    4226        return self.name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'star'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Parameter(Condition): View Source

    4229class Parameter(Condition):
    4230    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'parameter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SessionParameter(Condition): View Source

    4233class SessionParameter(Condition):
    4234    arg_types = {"this": True, "kind": False}

arg_types = {'this': True, 'kind': False}
key = 'sessionparameter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Placeholder(Condition): View Source

    4237class Placeholder(Condition):
    4238    arg_types = {"this": False, "kind": False}
    4239
    4240    @property
    4241    def name(self) -> str:
    4242        return self.this or "?"

arg_types = {'this': False, 'kind': False}
name: str View Source

    4240    @property
    4241    def name(self) -> str:
    4242        return self.this or "?"

key = 'placeholder'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Null(Condition): View Source

    4245class Null(Condition):
    4246    arg_types: t.Dict[str, t.Any] = {}
    4247
    4248    @property
    4249    def name(self) -> str:
    4250        return "NULL"
    4251
    4252    def to_py(self) -> Lit[None]:
    4253        return None

arg_types: Dict[str, Any] = {}
name: str View Source

    4248    @property
    4249    def name(self) -> str:
    4250        return "NULL"

def to_py(self) -> Literal[None]: View Source

    4252    def to_py(self) -> Lit[None]:
    4253        return None

Returns a Python object equivalent of the SQL node.

key = 'null'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Boolean(Condition): View Source

    4256class Boolean(Condition):
    4257    def to_py(self) -> bool:
    4258        return self.this

def to_py(self) -> bool: View Source

    4257    def to_py(self) -> bool:
    4258        return self.this

Returns a Python object equivalent of the SQL node.

key = 'boolean'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataTypeParam(Expression): View Source

    4261class DataTypeParam(Expression):
    4262    arg_types = {"this": True, "expression": False}
    4263
    4264    @property
    4265    def name(self) -> str:
    4266        return self.this.name

arg_types = {'this': True, 'expression': False}
name: str View Source

    4264    @property
    4265    def name(self) -> str:
    4266        return self.this.name

key = 'datatypeparam'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataType(Expression): View Source

    4271class DataType(Expression):
    4272    arg_types = {
    4273        "this": True,
    4274        "expressions": False,
    4275        "nested": False,
    4276        "values": False,
    4277        "prefix": False,
    4278        "kind": False,
    4279        "nullable": False,
    4280    }
    4281
    4282    class Type(AutoName):
    4283        ARRAY = auto()
    4284        AGGREGATEFUNCTION = auto()
    4285        SIMPLEAGGREGATEFUNCTION = auto()
    4286        BIGDECIMAL = auto()
    4287        BIGINT = auto()
    4288        BIGSERIAL = auto()
    4289        BINARY = auto()
    4290        BIT = auto()
    4291        BOOLEAN = auto()
    4292        BPCHAR = auto()
    4293        CHAR = auto()
    4294        DATE = auto()
    4295        DATE32 = auto()
    4296        DATEMULTIRANGE = auto()
    4297        DATERANGE = auto()
    4298        DATETIME = auto()
    4299        DATETIME64 = auto()
    4300        DECIMAL = auto()
    4301        DECIMAL32 = auto()
    4302        DECIMAL64 = auto()
    4303        DECIMAL128 = auto()
    4304        DOUBLE = auto()
    4305        ENUM = auto()
    4306        ENUM8 = auto()
    4307        ENUM16 = auto()
    4308        FIXEDSTRING = auto()
    4309        FLOAT = auto()
    4310        GEOGRAPHY = auto()
    4311        GEOMETRY = auto()
    4312        HLLSKETCH = auto()
    4313        HSTORE = auto()
    4314        IMAGE = auto()
    4315        INET = auto()
    4316        INT = auto()
    4317        INT128 = auto()
    4318        INT256 = auto()
    4319        INT4MULTIRANGE = auto()
    4320        INT4RANGE = auto()
    4321        INT8MULTIRANGE = auto()
    4322        INT8RANGE = auto()
    4323        INTERVAL = auto()
    4324        IPADDRESS = auto()
    4325        IPPREFIX = auto()
    4326        IPV4 = auto()
    4327        IPV6 = auto()
    4328        JSON = auto()
    4329        JSONB = auto()
    4330        LIST = auto()
    4331        LONGBLOB = auto()
    4332        LONGTEXT = auto()
    4333        LOWCARDINALITY = auto()
    4334        MAP = auto()
    4335        MEDIUMBLOB = auto()
    4336        MEDIUMINT = auto()
    4337        MEDIUMTEXT = auto()
    4338        MONEY = auto()
    4339        NAME = auto()
    4340        NCHAR = auto()
    4341        NESTED = auto()
    4342        NULL = auto()
    4343        NUMMULTIRANGE = auto()
    4344        NUMRANGE = auto()
    4345        NVARCHAR = auto()
    4346        OBJECT = auto()
    4347        RANGE = auto()
    4348        ROWVERSION = auto()
    4349        SERIAL = auto()
    4350        SET = auto()
    4351        SMALLINT = auto()
    4352        SMALLMONEY = auto()
    4353        SMALLSERIAL = auto()
    4354        STRUCT = auto()
    4355        SUPER = auto()
    4356        TEXT = auto()
    4357        TINYBLOB = auto()
    4358        TINYTEXT = auto()
    4359        TIME = auto()
    4360        TIMETZ = auto()
    4361        TIMESTAMP = auto()
    4362        TIMESTAMPNTZ = auto()
    4363        TIMESTAMPLTZ = auto()
    4364        TIMESTAMPTZ = auto()
    4365        TIMESTAMP_S = auto()
    4366        TIMESTAMP_MS = auto()
    4367        TIMESTAMP_NS = auto()
    4368        TINYINT = auto()
    4369        TSMULTIRANGE = auto()
    4370        TSRANGE = auto()
    4371        TSTZMULTIRANGE = auto()
    4372        TSTZRANGE = auto()
    4373        UBIGINT = auto()
    4374        UINT = auto()
    4375        UINT128 = auto()
    4376        UINT256 = auto()
    4377        UMEDIUMINT = auto()
    4378        UDECIMAL = auto()
    4379        UNION = auto()
    4380        UNIQUEIDENTIFIER = auto()
    4381        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4382        USERDEFINED = "USER-DEFINED"
    4383        USMALLINT = auto()
    4384        UTINYINT = auto()
    4385        UUID = auto()
    4386        VARBINARY = auto()
    4387        VARCHAR = auto()
    4388        VARIANT = auto()
    4389        VECTOR = auto()
    4390        XML = auto()
    4391        YEAR = auto()
    4392        TDIGEST = auto()
    4393
    4394    STRUCT_TYPES = {
    4395        Type.NESTED,
    4396        Type.OBJECT,
    4397        Type.STRUCT,
    4398        Type.UNION,
    4399    }
    4400
    4401    ARRAY_TYPES = {
    4402        Type.ARRAY,
    4403        Type.LIST,
    4404    }
    4405
    4406    NESTED_TYPES = {
    4407        *STRUCT_TYPES,
    4408        *ARRAY_TYPES,
    4409        Type.MAP,
    4410    }
    4411
    4412    TEXT_TYPES = {
    4413        Type.CHAR,
    4414        Type.NCHAR,
    4415        Type.NVARCHAR,
    4416        Type.TEXT,
    4417        Type.VARCHAR,
    4418        Type.NAME,
    4419    }
    4420
    4421    SIGNED_INTEGER_TYPES = {
    4422        Type.BIGINT,
    4423        Type.INT,
    4424        Type.INT128,
    4425        Type.INT256,
    4426        Type.MEDIUMINT,
    4427        Type.SMALLINT,
    4428        Type.TINYINT,
    4429    }
    4430
    4431    UNSIGNED_INTEGER_TYPES = {
    4432        Type.UBIGINT,
    4433        Type.UINT,
    4434        Type.UINT128,
    4435        Type.UINT256,
    4436        Type.UMEDIUMINT,
    4437        Type.USMALLINT,
    4438        Type.UTINYINT,
    4439    }
    4440
    4441    INTEGER_TYPES = {
    4442        *SIGNED_INTEGER_TYPES,
    4443        *UNSIGNED_INTEGER_TYPES,
    4444        Type.BIT,
    4445    }
    4446
    4447    FLOAT_TYPES = {
    4448        Type.DOUBLE,
    4449        Type.FLOAT,
    4450    }
    4451
    4452    REAL_TYPES = {
    4453        *FLOAT_TYPES,
    4454        Type.BIGDECIMAL,
    4455        Type.DECIMAL,
    4456        Type.DECIMAL32,
    4457        Type.DECIMAL64,
    4458        Type.DECIMAL128,
    4459        Type.MONEY,
    4460        Type.SMALLMONEY,
    4461        Type.UDECIMAL,
    4462    }
    4463
    4464    NUMERIC_TYPES = {
    4465        *INTEGER_TYPES,
    4466        *REAL_TYPES,
    4467    }
    4468
    4469    TEMPORAL_TYPES = {
    4470        Type.DATE,
    4471        Type.DATE32,
    4472        Type.DATETIME,
    4473        Type.DATETIME64,
    4474        Type.TIME,
    4475        Type.TIMESTAMP,
    4476        Type.TIMESTAMPNTZ,
    4477        Type.TIMESTAMPLTZ,
    4478        Type.TIMESTAMPTZ,
    4479        Type.TIMESTAMP_MS,
    4480        Type.TIMESTAMP_NS,
    4481        Type.TIMESTAMP_S,
    4482        Type.TIMETZ,
    4483    }
    4484
    4485    @classmethod
    4486    def build(
    4487        cls,
    4488        dtype: DATA_TYPE,
    4489        dialect: DialectType = None,
    4490        udt: bool = False,
    4491        copy: bool = True,
    4492        **kwargs,
    4493    ) -> DataType:
    4494        """
    4495        Constructs a DataType object.
    4496
    4497        Args:
    4498            dtype: the data type of interest.
    4499            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4500            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4501                DataType, thus creating a user-defined type.
    4502            copy: whether to copy the data type.
    4503            kwargs: additional arguments to pass in the constructor of DataType.
    4504
    4505        Returns:
    4506            The constructed DataType object.
    4507        """
    4508        from sqlglot import parse_one
    4509
    4510        if isinstance(dtype, str):
    4511            if dtype.upper() == "UNKNOWN":
    4512                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4513
    4514            try:
    4515                data_type_exp = parse_one(
    4516                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4517                )
    4518            except ParseError:
    4519                if udt:
    4520                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4521                raise
    4522        elif isinstance(dtype, DataType.Type):
    4523            data_type_exp = DataType(this=dtype)
    4524        elif isinstance(dtype, DataType):
    4525            return maybe_copy(dtype, copy)
    4526        else:
    4527            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4528
    4529        return DataType(**{**data_type_exp.args, **kwargs})
    4530
    4531    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4532        """
    4533        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4534        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4535
    4536        Args:
    4537            dtypes: the data types to compare this DataType to.
    4538            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4539                If false, it means that NULLABLE<INT> is equivalent to INT.
    4540
    4541        Returns:
    4542            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4543        """
    4544        self_is_nullable = self.args.get("nullable")
    4545        for dtype in dtypes:
    4546            other_type = DataType.build(dtype, copy=False, udt=True)
    4547            other_is_nullable = other_type.args.get("nullable")
    4548            if (
    4549                other_type.expressions
    4550                or (check_nullable and (self_is_nullable or other_is_nullable))
    4551                or self.this == DataType.Type.USERDEFINED
    4552                or other_type.this == DataType.Type.USERDEFINED
    4553            ):
    4554                matches = self == other_type
    4555            else:
    4556                matches = self.this == other_type.this
    4557
    4558            if matches:
    4559                return True
    4560        return False

arg_types = {'this': True, 'expressions': False, 'nested': False, 'values': False, 'prefix': False, 'kind': False, 'nullable': False}
STRUCT_TYPES = {<Type.OBJECT: 'OBJECT'>, <Type.NESTED: 'NESTED'>, <Type.UNION: 'UNION'>, <Type.STRUCT: 'STRUCT'>}
ARRAY_TYPES = {<Type.LIST: 'LIST'>, <Type.ARRAY: 'ARRAY'>}
NESTED_TYPES = {<Type.LIST: 'LIST'>, <Type.UNION: 'UNION'>, <Type.MAP: 'MAP'>, <Type.OBJECT: 'OBJECT'>, <Type.NESTED: 'NESTED'>, <Type.ARRAY: 'ARRAY'>, <Type.STRUCT: 'STRUCT'>}
TEXT_TYPES = {<Type.CHAR: 'CHAR'>, <Type.NAME: 'NAME'>, <Type.NCHAR: 'NCHAR'>, <Type.NVARCHAR: 'NVARCHAR'>, <Type.TEXT: 'TEXT'>, <Type.VARCHAR: 'VARCHAR'>}
SIGNED_INTEGER_TYPES = {<Type.INT128: 'INT128'>, <Type.BIGINT: 'BIGINT'>, <Type.INT256: 'INT256'>, <Type.TINYINT: 'TINYINT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.INT: 'INT'>, <Type.MEDIUMINT: 'MEDIUMINT'>}
UNSIGNED_INTEGER_TYPES = {<Type.USMALLINT: 'USMALLINT'>, <Type.UTINYINT: 'UTINYINT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.UBIGINT: 'UBIGINT'>, <Type.UINT256: 'UINT256'>, <Type.UINT: 'UINT'>, <Type.UINT128: 'UINT128'>}
INTEGER_TYPES = {<Type.USMALLINT: 'USMALLINT'>, <Type.UTINYINT: 'UTINYINT'>, <Type.INT128: 'INT128'>, <Type.BIGINT: 'BIGINT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.UBIGINT: 'UBIGINT'>, <Type.TINYINT: 'TINYINT'>, <Type.INT256: 'INT256'>, <Type.UINT256: 'UINT256'>, <Type.UINT: 'UINT'>, <Type.UINT128: 'UINT128'>, <Type.SMALLINT: 'SMALLINT'>, <Type.BIT: 'BIT'>, <Type.INT: 'INT'>, <Type.MEDIUMINT: 'MEDIUMINT'>}
FLOAT_TYPES = {<Type.DOUBLE: 'DOUBLE'>, <Type.FLOAT: 'FLOAT'>}
REAL_TYPES = {<Type.DECIMAL128: 'DECIMAL128'>, <Type.UDECIMAL: 'UDECIMAL'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL: 'DECIMAL'>, <Type.SMALLMONEY: 'SMALLMONEY'>, <Type.DECIMAL64: 'DECIMAL64'>, <Type.DECIMAL32: 'DECIMAL32'>, <Type.BIGDECIMAL: 'BIGDECIMAL'>, <Type.FLOAT: 'FLOAT'>, <Type.MONEY: 'MONEY'>}
NUMERIC_TYPES = {<Type.DECIMAL128: 'DECIMAL128'>, <Type.UDECIMAL: 'UDECIMAL'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL: 'DECIMAL'>, <Type.BIGINT: 'BIGINT'>, <Type.UBIGINT: 'UBIGINT'>, <Type.TINYINT: 'TINYINT'>, <Type.DECIMAL64: 'DECIMAL64'>, <Type.DECIMAL32: 'DECIMAL32'>, <Type.BIGDECIMAL: 'BIGDECIMAL'>, <Type.UINT256: 'UINT256'>, <Type.UINT: 'UINT'>, <Type.UINT128: 'UINT128'>, <Type.SMALLINT: 'SMALLINT'>, <Type.INT128: 'INT128'>, <Type.INT: 'INT'>, <Type.USMALLINT: 'USMALLINT'>, <Type.UTINYINT: 'UTINYINT'>, <Type.SMALLMONEY: 'SMALLMONEY'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.INT256: 'INT256'>, <Type.FLOAT: 'FLOAT'>, <Type.MONEY: 'MONEY'>, <Type.BIT: 'BIT'>, <Type.MEDIUMINT: 'MEDIUMINT'>}
TEMPORAL_TYPES = {<Type.DATETIME: 'DATETIME'>, <Type.DATETIME64: 'DATETIME64'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <Type.DATE32: 'DATE32'>, <Type.TIME: 'TIME'>, <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <Type.TIMESTAMP_S: 'TIMESTAMP_S'>, <Type.TIMETZ: 'TIMETZ'>, <Type.DATE: 'DATE'>, <Type.TIMESTAMP: 'TIMESTAMP'>, <Type.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <Type.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>}
@classmethod
def build( cls, dtype: Union[str, DataType, DataType.Type], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, udt: bool = False, copy: bool = True, **kwargs) -> DataType: View Source

    4485    @classmethod
    4486    def build(
    4487        cls,
    4488        dtype: DATA_TYPE,
    4489        dialect: DialectType = None,
    4490        udt: bool = False,
    4491        copy: bool = True,
    4492        **kwargs,
    4493    ) -> DataType:
    4494        """
    4495        Constructs a DataType object.
    4496
    4497        Args:
    4498            dtype: the data type of interest.
    4499            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4500            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4501                DataType, thus creating a user-defined type.
    4502            copy: whether to copy the data type.
    4503            kwargs: additional arguments to pass in the constructor of DataType.
    4504
    4505        Returns:
    4506            The constructed DataType object.
    4507        """
    4508        from sqlglot import parse_one
    4509
    4510        if isinstance(dtype, str):
    4511            if dtype.upper() == "UNKNOWN":
    4512                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4513
    4514            try:
    4515                data_type_exp = parse_one(
    4516                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4517                )
    4518            except ParseError:
    4519                if udt:
    4520                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4521                raise
    4522        elif isinstance(dtype, DataType.Type):
    4523            data_type_exp = DataType(this=dtype)
    4524        elif isinstance(dtype, DataType):
    4525            return maybe_copy(dtype, copy)
    4526        else:
    4527            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4528
    4529        return DataType(**{**data_type_exp.args, **kwargs})

Constructs a DataType object.

###### Arguments:

- dtype: the data type of interest.
- dialect: the dialect to use for parsing `dtype`, in case it's a string.
- udt: when set to True, `dtype` will be used as-is if it can't be parsed into a DataType, thus creating a user-defined type.
- copy: whether to copy the data type.
- kwargs: additional arguments to pass in the constructor of DataType.

###### Returns:

> The constructed DataType object.

def is_type( self, *dtypes: Union[str, DataType, DataType.Type], check_nullable: bool = False) -> bool: View Source

    4531    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4532        """
    4533        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4534        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4535
    4536        Args:
    4537            dtypes: the data types to compare this DataType to.
    4538            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4539                If false, it means that NULLABLE<INT> is equivalent to INT.
    4540
    4541        Returns:
    4542            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4543        """
    4544        self_is_nullable = self.args.get("nullable")
    4545        for dtype in dtypes:
    4546            other_type = DataType.build(dtype, copy=False, udt=True)
    4547            other_is_nullable = other_type.args.get("nullable")
    4548            if (
    4549                other_type.expressions
    4550                or (check_nullable and (self_is_nullable or other_is_nullable))
    4551                or self.this == DataType.Type.USERDEFINED
    4552                or other_type.this == DataType.Type.USERDEFINED
    4553            ):
    4554                matches = self == other_type
    4555            else:
    4556                matches = self.this == other_type.this
    4557
    4558            if matches:
    4559                return True
    4560        return False

Checks whether this DataType matches one of the provided data types. Nested types or precision will be compared using "structural equivalence" semantics, so e.g. array != array.

###### Arguments:

- dtypes: the data types to compare this DataType to.
- check_nullable: whether to take the NULLABLE type constructor into account for the comparison. If false, it means that NULLABLE is equivalent to INT.

###### Returns:

> True, if and only if there is a type in `dtypes` which is equal to this DataType.

key = 'datatype'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataType.Type(sqlglot.helper.AutoName): View Source

    4282    class Type(AutoName):
    4283        ARRAY = auto()
    4284        AGGREGATEFUNCTION = auto()
    4285        SIMPLEAGGREGATEFUNCTION = auto()
    4286        BIGDECIMAL = auto()
    4287        BIGINT = auto()
    4288        BIGSERIAL = auto()
    4289        BINARY = auto()
    4290        BIT = auto()
    4291        BOOLEAN = auto()
    4292        BPCHAR = auto()
    4293        CHAR = auto()
    4294        DATE = auto()
    4295        DATE32 = auto()
    4296        DATEMULTIRANGE = auto()
    4297        DATERANGE = auto()
    4298        DATETIME = auto()
    4299        DATETIME64 = auto()
    4300        DECIMAL = auto()
    4301        DECIMAL32 = auto()
    4302        DECIMAL64 = auto()
    4303        DECIMAL128 = auto()
    4304        DOUBLE = auto()
    4305        ENUM = auto()
    4306        ENUM8 = auto()
    4307        ENUM16 = auto()
    4308        FIXEDSTRING = auto()
    4309        FLOAT = auto()
    4310        GEOGRAPHY = auto()
    4311        GEOMETRY = auto()
    4312        HLLSKETCH = auto()
    4313        HSTORE = auto()
    4314        IMAGE = auto()
    4315        INET = auto()
    4316        INT = auto()
    4317        INT128 = auto()
    4318        INT256 = auto()
    4319        INT4MULTIRANGE = auto()
    4320        INT4RANGE = auto()
    4321        INT8MULTIRANGE = auto()
    4322        INT8RANGE = auto()
    4323        INTERVAL = auto()
    4324        IPADDRESS = auto()
    4325        IPPREFIX = auto()
    4326        IPV4 = auto()
    4327        IPV6 = auto()
    4328        JSON = auto()
    4329        JSONB = auto()
    4330        LIST = auto()
    4331        LONGBLOB = auto()
    4332        LONGTEXT = auto()
    4333        LOWCARDINALITY = auto()
    4334        MAP = auto()
    4335        MEDIUMBLOB = auto()
    4336        MEDIUMINT = auto()
    4337        MEDIUMTEXT = auto()
    4338        MONEY = auto()
    4339        NAME = auto()
    4340        NCHAR = auto()
    4341        NESTED = auto()
    4342        NULL = auto()
    4343        NUMMULTIRANGE = auto()
    4344        NUMRANGE = auto()
    4345        NVARCHAR = auto()
    4346        OBJECT = auto()
    4347        RANGE = auto()
    4348        ROWVERSION = auto()
    4349        SERIAL = auto()
    4350        SET = auto()
    4351        SMALLINT = auto()
    4352        SMALLMONEY = auto()
    4353        SMALLSERIAL = auto()
    4354        STRUCT = auto()
    4355        SUPER = auto()
    4356        TEXT = auto()
    4357        TINYBLOB = auto()
    4358        TINYTEXT = auto()
    4359        TIME = auto()
    4360        TIMETZ = auto()
    4361        TIMESTAMP = auto()
    4362        TIMESTAMPNTZ = auto()
    4363        TIMESTAMPLTZ = auto()
    4364        TIMESTAMPTZ = auto()
    4365        TIMESTAMP_S = auto()
    4366        TIMESTAMP_MS = auto()
    4367        TIMESTAMP_NS = auto()
    4368        TINYINT = auto()
    4369        TSMULTIRANGE = auto()
    4370        TSRANGE = auto()
    4371        TSTZMULTIRANGE = auto()
    4372        TSTZRANGE = auto()
    4373        UBIGINT = auto()
    4374        UINT = auto()
    4375        UINT128 = auto()
    4376        UINT256 = auto()
    4377        UMEDIUMINT = auto()
    4378        UDECIMAL = auto()
    4379        UNION = auto()
    4380        UNIQUEIDENTIFIER = auto()
    4381        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4382        USERDEFINED = "USER-DEFINED"
    4383        USMALLINT = auto()
    4384        UTINYINT = auto()
    4385        UUID = auto()
    4386        VARBINARY = auto()
    4387        VARCHAR = auto()
    4388        VARIANT = auto()
    4389        VECTOR = auto()
    4390        XML = auto()
    4391        YEAR = auto()
    4392        TDIGEST = auto()

An enumeration.

ARRAY = <Type.ARRAY: 'ARRAY'>
AGGREGATEFUNCTION = <Type.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>
SIMPLEAGGREGATEFUNCTION = <Type.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>
BIGDECIMAL = <Type.BIGDECIMAL: 'BIGDECIMAL'>
BIGINT = <Type.BIGINT: 'BIGINT'>
BIGSERIAL = <Type.BIGSERIAL: 'BIGSERIAL'>
BINARY = <Type.BINARY: 'BINARY'>
BIT = <Type.BIT: 'BIT'>
BOOLEAN = <Type.BOOLEAN: 'BOOLEAN'>
BPCHAR = <Type.BPCHAR: 'BPCHAR'>
CHAR = <Type.CHAR: 'CHAR'>
DATE = <Type.DATE: 'DATE'>
DATE32 = <Type.DATE32: 'DATE32'>
DATEMULTIRANGE = <Type.DATEMULTIRANGE: 'DATEMULTIRANGE'>
DATERANGE = <Type.DATERANGE: 'DATERANGE'>
DATETIME = <Type.DATETIME: 'DATETIME'>
DATETIME64 = <Type.DATETIME64: 'DATETIME64'>
DECIMAL = <Type.DECIMAL: 'DECIMAL'>
DECIMAL32 = <Type.DECIMAL32: 'DECIMAL32'>
DECIMAL64 = <Type.DECIMAL64: 'DECIMAL64'>
DECIMAL128 = <Type.DECIMAL128: 'DECIMAL128'>
DOUBLE = <Type.DOUBLE: 'DOUBLE'>
ENUM = <Type.ENUM: 'ENUM'>
ENUM8 = <Type.ENUM8: 'ENUM8'>
ENUM16 = <Type.ENUM16: 'ENUM16'>
FIXEDSTRING = <Type.FIXEDSTRING: 'FIXEDSTRING'>
FLOAT = <Type.FLOAT: 'FLOAT'>
GEOGRAPHY = <Type.GEOGRAPHY: 'GEOGRAPHY'>
GEOMETRY = <Type.GEOMETRY: 'GEOMETRY'>
HLLSKETCH = <Type.HLLSKETCH: 'HLLSKETCH'>
HSTORE = <Type.HSTORE: 'HSTORE'>
IMAGE = <Type.IMAGE: 'IMAGE'>
INET = <Type.INET: 'INET'>
INT = <Type.INT: 'INT'>
INT128 = <Type.INT128: 'INT128'>
INT256 = <Type.INT256: 'INT256'>
INT4MULTIRANGE = <Type.INT4MULTIRANGE: 'INT4MULTIRANGE'>
INT4RANGE = <Type.INT4RANGE: 'INT4RANGE'>
INT8MULTIRANGE = <Type.INT8MULTIRANGE: 'INT8MULTIRANGE'>
INT8RANGE = <Type.INT8RANGE: 'INT8RANGE'>
INTERVAL = <Type.INTERVAL: 'INTERVAL'>
IPADDRESS = <Type.IPADDRESS: 'IPADDRESS'>
IPPREFIX = <Type.IPPREFIX: 'IPPREFIX'>
IPV4 = <Type.IPV4: 'IPV4'>
IPV6 = <Type.IPV6: 'IPV6'>
JSON = <Type.JSON: 'JSON'>
JSONB = <Type.JSONB: 'JSONB'>
LIST = <Type.LIST: 'LIST'>
LONGBLOB = <Type.LONGBLOB: 'LONGBLOB'>
LONGTEXT = <Type.LONGTEXT: 'LONGTEXT'>
LOWCARDINALITY = <Type.LOWCARDINALITY: 'LOWCARDINALITY'>
MAP = <Type.MAP: 'MAP'>
MEDIUMBLOB = <Type.MEDIUMBLOB: 'MEDIUMBLOB'>
MEDIUMINT = <Type.MEDIUMINT: 'MEDIUMINT'>
MEDIUMTEXT = <Type.MEDIUMTEXT: 'MEDIUMTEXT'>
MONEY = <Type.MONEY: 'MONEY'>
NAME = <Type.NAME: 'NAME'>
NCHAR = <Type.NCHAR: 'NCHAR'>
NESTED = <Type.NESTED: 'NESTED'>
NULL = <Type.NULL: 'NULL'>
NUMMULTIRANGE = <Type.NUMMULTIRANGE: 'NUMMULTIRANGE'>
NUMRANGE = <Type.NUMRANGE: 'NUMRANGE'>
NVARCHAR = <Type.NVARCHAR: 'NVARCHAR'>
OBJECT = <Type.OBJECT: 'OBJECT'>
RANGE = <Type.RANGE: 'RANGE'>
ROWVERSION = <Type.ROWVERSION: 'ROWVERSION'>
SERIAL = <Type.SERIAL: 'SERIAL'>
SET = <Type.SET: 'SET'>
SMALLINT = <Type.SMALLINT: 'SMALLINT'>
SMALLMONEY = <Type.SMALLMONEY: 'SMALLMONEY'>
SMALLSERIAL = <Type.SMALLSERIAL: 'SMALLSERIAL'>
STRUCT = <Type.STRUCT: 'STRUCT'>
SUPER = <Type.SUPER: 'SUPER'>
TEXT = <Type.TEXT: 'TEXT'>
TINYBLOB = <Type.TINYBLOB: 'TINYBLOB'>
TINYTEXT = <Type.TINYTEXT: 'TINYTEXT'>
TIME = <Type.TIME: 'TIME'>
TIMETZ = <Type.TIMETZ: 'TIMETZ'>
TIMESTAMP = <Type.TIMESTAMP: 'TIMESTAMP'>
TIMESTAMPNTZ = <Type.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>
TIMESTAMPLTZ = <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>
TIMESTAMPTZ = <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>
TIMESTAMP_S = <Type.TIMESTAMP_S: 'TIMESTAMP_S'>
TIMESTAMP_MS = <Type.TIMESTAMP_MS: 'TIMESTAMP_MS'>
TIMESTAMP_NS = <Type.TIMESTAMP_NS: 'TIMESTAMP_NS'>
TINYINT = <Type.TINYINT: 'TINYINT'>
TSMULTIRANGE = <Type.TSMULTIRANGE: 'TSMULTIRANGE'>
TSRANGE = <Type.TSRANGE: 'TSRANGE'>
TSTZMULTIRANGE = <Type.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>
TSTZRANGE = <Type.TSTZRANGE: 'TSTZRANGE'>
UBIGINT = <Type.UBIGINT: 'UBIGINT'>
UINT = <Type.UINT: 'UINT'>
UINT128 = <Type.UINT128: 'UINT128'>
UINT256 = <Type.UINT256: 'UINT256'>
UMEDIUMINT = <Type.UMEDIUMINT: 'UMEDIUMINT'>
UDECIMAL = <Type.UDECIMAL: 'UDECIMAL'>
UNION = <Type.UNION: 'UNION'>
UNIQUEIDENTIFIER = <Type.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>
UNKNOWN = <Type.UNKNOWN: 'UNKNOWN'>
USERDEFINED = <Type.USERDEFINED: 'USER-DEFINED'>
USMALLINT = <Type.USMALLINT: 'USMALLINT'>
UTINYINT = <Type.UTINYINT: 'UTINYINT'>
UUID = <Type.UUID: 'UUID'>
VARBINARY = <Type.VARBINARY: 'VARBINARY'>
VARCHAR = <Type.VARCHAR: 'VARCHAR'>
VARIANT = <Type.VARIANT: 'VARIANT'>
VECTOR = <Type.VECTOR: 'VECTOR'>
XML = <Type.XML: 'XML'>
YEAR = <Type.YEAR: 'YEAR'>
TDIGEST = <Type.TDIGEST: 'TDIGEST'>
DATA_TYPE = typing.Union[str, DataType, DataType.Type]
class PseudoType(DataType): View Source

    4567class PseudoType(DataType):
    4568    arg_types = {"this": True}

arg_types = {'this': True}
key = 'pseudotype'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DataType
  Type
  STRUCT_TYPES
  ARRAY_TYPES
  NESTED_TYPES
  TEXT_TYPES
  SIGNED_INTEGER_TYPES
  UNSIGNED_INTEGER_TYPES
  INTEGER_TYPES
  FLOAT_TYPES
  REAL_TYPES
  NUMERIC_TYPES
  TEMPORAL_TYPES
  build
  is_type

class ObjectIdentifier(DataType): View Source

    4572class ObjectIdentifier(DataType):
    4573    arg_types = {"this": True}

arg_types = {'this': True}
key = 'objectidentifier'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DataType
  Type
  STRUCT_TYPES
  ARRAY_TYPES
  NESTED_TYPES
  TEXT_TYPES
  SIGNED_INTEGER_TYPES
  UNSIGNED_INTEGER_TYPES
  INTEGER_TYPES
  FLOAT_TYPES
  REAL_TYPES
  NUMERIC_TYPES
  TEMPORAL_TYPES
  build
  is_type

class SubqueryPredicate(Predicate): View Source

    4577class SubqueryPredicate(Predicate):
    4578    pass

key = 'subquerypredicate'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class All(SubqueryPredicate): View Source

    4581class All(SubqueryPredicate):
    4582    pass

key = 'all'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Any(SubqueryPredicate): View Source

    4585class Any(SubqueryPredicate):
    4586    pass

key = 'any'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Exists(SubqueryPredicate): View Source

    4589class Exists(SubqueryPredicate):
    4590    pass

key = 'exists'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Command(Expression): View Source

    4595class Command(Expression):
    4596    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'command'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Transaction(Expression): View Source

    4599class Transaction(Expression):
    4600    arg_types = {"this": False, "modes": False, "mark": False}

arg_types = {'this': False, 'modes': False, 'mark': False}
key = 'transaction'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Commit(Expression): View Source

    4603class Commit(Expression):
    4604    arg_types = {"chain": False, "this": False, "durability": False}

arg_types = {'chain': False, 'this': False, 'durability': False}
key = 'commit'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Rollback(Expression): View Source

    4607class Rollback(Expression):
    4608    arg_types = {"savepoint": False, "this": False}

arg_types = {'savepoint': False, 'this': False}
key = 'rollback'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Alter(Expression): View Source

    4611class Alter(Expression):
    4612    arg_types = {
    4613        "this": True,
    4614        "kind": True,
    4615        "actions": True,
    4616        "exists": False,
    4617        "only": False,
    4618        "options": False,
    4619        "cluster": False,
    4620        "not_valid": False,
    4621    }
    4622
    4623    @property
    4624    def kind(self) -> t.Optional[str]:
    4625        kind = self.args.get("kind")
    4626        return kind and kind.upper()
    4627
    4628    @property
    4629    def actions(self) -> t.List[Expression]:
    4630        return self.args.get("actions") or []

arg_types = {'this': True, 'kind': True, 'actions': True, 'exists': False, 'only': False, 'options': False, 'cluster': False, 'not_valid': False}
kind: Optional[str] View Source

    4623    @property
    4624    def kind(self) -> t.Optional[str]:
    4625        kind = self.args.get("kind")
    4626        return kind and kind.upper()

actions: List[Expression] View Source

    4628    @property
    4629    def actions(self) -> t.List[Expression]:
    4630        return self.args.get("actions") or []

key = 'alter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AddConstraint(Expression): View Source

    4633class AddConstraint(Expression):
    4634    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'addconstraint'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DropPartition(Expression): View Source

    4637class DropPartition(Expression):
    4638    arg_types = {"expressions": True, "exists": False}

arg_types = {'expressions': True, 'exists': False}
key = 'droppartition'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ReplacePartition(Expression): View Source

    4642class ReplacePartition(Expression):
    4643    arg_types = {"expression": True, "source": True}

arg_types = {'expression': True, 'source': True}
key = 'replacepartition'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Binary(Condition): View Source

    4647class Binary(Condition):
    4648    arg_types = {"this": True, "expression": True}
    4649
    4650    @property
    4651    def left(self) -> Expression:
    4652        return self.this
    4653
    4654    @property
    4655    def right(self) -> Expression:
    4656        return self.expression

arg_types = {'this': True, 'expression': True}
left: Expression View Source

    4650    @property
    4651    def left(self) -> Expression:
    4652        return self.this

right: Expression View Source

    4654    @property
    4655    def right(self) -> Expression:
    4656        return self.expression

key = 'binary'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Add(Binary): View Source

    4659class Add(Binary):
    4660    pass

key = 'add'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Connector(Binary): View Source

    4663class Connector(Binary):
    4664    pass

key = 'connector'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class And(Connector): View Source

    4667class And(Connector):
    4668    pass

key = 'and'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Or(Connector): View Source

    4671class Or(Connector):
    4672    pass

key = 'or'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseAnd(Binary): View Source

    4675class BitwiseAnd(Binary):
    4676    pass

key = 'bitwiseand'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseLeftShift(Binary): View Source

    4679class BitwiseLeftShift(Binary):
    4680    pass

key = 'bitwiseleftshift'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseOr(Binary): View Source

    4683class BitwiseOr(Binary):
    4684    pass

key = 'bitwiseor'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseRightShift(Binary): View Source

    4687class BitwiseRightShift(Binary):
    4688    pass

key = 'bitwiserightshift'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseXor(Binary): View Source

    4691class BitwiseXor(Binary):
    4692    pass

key = 'bitwisexor'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Div(Binary): View Source

    4695class Div(Binary):
    4696    arg_types = {"this": True, "expression": True, "typed": False, "safe": False}

arg_types = {'this': True, 'expression': True, 'typed': False, 'safe': False}
key = 'div'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class Overlaps(Binary): View Source

    4699class Overlaps(Binary):
    4700    pass

key = 'overlaps'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Dot(Binary): View Source

    4703class Dot(Binary):
    4704    @property
    4705    def is_star(self) -> bool:
    4706        return self.expression.is_star
    4707
    4708    @property
    4709    def name(self) -> str:
    4710        return self.expression.name
    4711
    4712    @property
    4713    def output_name(self) -> str:
    4714        return self.name
    4715
    4716    @classmethod
    4717    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    4718        """Build a Dot object with a sequence of expressions."""
    4719        if len(expressions) < 2:
    4720            raise ValueError("Dot requires >= 2 expressions.")
    4721
    4722        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))
    4723
    4724    @property
    4725    def parts(self) -> t.List[Expression]:
    4726        """Return the parts of a table / column in order catalog, db, table."""
    4727        this, *parts = self.flatten()
    4728
    4729        parts.reverse()
    4730
    4731        for arg in COLUMN_PARTS:
    4732            part = this.args.get(arg)
    4733
    4734            if isinstance(part, Expression):
    4735                parts.append(part)
    4736
    4737        parts.reverse()
    4738        return parts

is_star: bool View Source

    4704    @property
    4705    def is_star(self) -> bool:
    4706        return self.expression.is_star

Checks whether an expression is a star.

name: str View Source

    4708    @property
    4709    def name(self) -> str:
    4710        return self.expression.name

output_name: str View Source

    4712    @property
    4713    def output_name(self) -> str:
    4714        return self.name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

@classmethod
def build( self, expressions: Sequence[Expression]) -> Dot: View Source

    4716    @classmethod
    4717    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    4718        """Build a Dot object with a sequence of expressions."""
    4719        if len(expressions) < 2:
    4720            raise ValueError("Dot requires >= 2 expressions.")
    4721
    4722        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))

Build a Dot object with a sequence of expressions.

parts: List[Expression] View Source

    4724    @property
    4725    def parts(self) -> t.List[Expression]:
    4726        """Return the parts of a table / column in order catalog, db, table."""
    4727        this, *parts = self.flatten()
    4728
    4729        parts.reverse()
    4730
    4731        for arg in COLUMN_PARTS:
    4732            part = this.args.get(arg)
    4733
    4734            if isinstance(part, Expression):
    4735                parts.append(part)
    4736
    4737        parts.reverse()
    4738        return parts

Return the parts of a table / column in order catalog, db, table.

key = 'dot'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  alias
  alias_column_names
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class DPipe(Binary): View Source

    4741class DPipe(Binary):
    4742    arg_types = {"this": True, "expression": True, "safe": False}

arg_types = {'this': True, 'expression': True, 'safe': False}
key = 'dpipe'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class EQ(Binary, Predicate): View Source

    4745class EQ(Binary, Predicate):
    4746    pass

key = 'eq'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class NullSafeEQ(Binary, Predicate): View Source

    4749class NullSafeEQ(Binary, Predicate):
    4750    pass

key = 'nullsafeeq'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class NullSafeNEQ(Binary, Predicate): View Source

    4753class NullSafeNEQ(Binary, Predicate):
    4754    pass

key = 'nullsafeneq'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class PropertyEQ(Binary): View Source

    4758class PropertyEQ(Binary):
    4759    pass

key = 'propertyeq'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Distance(Binary): View Source

    4762class Distance(Binary):
    4763    pass

key = 'distance'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Escape(Binary): View Source

    4766class Escape(Binary):
    4767    pass

key = 'escape'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Glob(Binary, Predicate): View Source

    4770class Glob(Binary, Predicate):
    4771    pass

key = 'glob'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class GT(Binary, Predicate): View Source

    4774class GT(Binary, Predicate):
    4775    pass

key = 'gt'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class GTE(Binary, Predicate): View Source

    4778class GTE(Binary, Predicate):
    4779    pass

key = 'gte'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class ILike(Binary, Predicate): View Source

    4782class ILike(Binary, Predicate):
    4783    pass

key = 'ilike'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class ILikeAny(Binary, Predicate): View Source

    4786class ILikeAny(Binary, Predicate):
    4787    pass

key = 'ilikeany'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class IntDiv(Binary): View Source

    4790class IntDiv(Binary):
    4791    pass

key = 'intdiv'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Is(Binary, Predicate): View Source

    4794class Is(Binary, Predicate):
    4795    pass

key = 'is'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Kwarg(Binary): View Source

    4798class Kwarg(Binary):
    4799    """Kwarg in special functions like func(kwarg => y)."""

Kwarg in special functions like func(kwarg => y).

key = 'kwarg'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Like(Binary, Predicate): View Source

    4802class Like(Binary, Predicate):
    4803    pass

key = 'like'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class LikeAny(Binary, Predicate): View Source

    4806class LikeAny(Binary, Predicate):
    4807    pass

key = 'likeany'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class LT(Binary, Predicate): View Source

    4810class LT(Binary, Predicate):
    4811    pass

key = 'lt'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class LTE(Binary, Predicate): View Source

    4814class LTE(Binary, Predicate):
    4815    pass

key = 'lte'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Mod(Binary): View Source

    4818class Mod(Binary):
    4819    pass

key = 'mod'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Mul(Binary): View Source

    4822class Mul(Binary):
    4823    pass

key = 'mul'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class NEQ(Binary, Predicate): View Source

    4826class NEQ(Binary, Predicate):
    4827    pass

key = 'neq'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Operator(Binary): View Source

    4831class Operator(Binary):
    4832    arg_types = {"this": True, "operator": True, "expression": True}

arg_types = {'this': True, 'operator': True, 'expression': True}
key = 'operator'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class SimilarTo(Binary, Predicate): View Source

    4835class SimilarTo(Binary, Predicate):
    4836    pass

key = 'similarto'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Slice(Binary): View Source

    4839class Slice(Binary):
    4840    arg_types = {"this": False, "expression": False}

arg_types = {'this': False, 'expression': False}
key = 'slice'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class Sub(Binary): View Source

    4843class Sub(Binary):
    4844    pass

key = 'sub'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Unary(Condition): View Source

    4849class Unary(Condition):
    4850    pass

key = 'unary'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BitwiseNot(Unary): View Source

    4853class BitwiseNot(Unary):
    4854    pass

key = 'bitwisenot'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Not(Unary): View Source

    4857class Not(Unary):
    4858    pass

key = 'not'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Paren(Unary): View Source

    4861class Paren(Unary):
    4862    @property
    4863    def output_name(self) -> str:
    4864        return self.this.name

output_name: str View Source

    4862    @property
    4863    def output_name(self) -> str:
    4864        return self.this.name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'paren'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Neg(Unary): View Source

    4867class Neg(Unary):
    4868    def to_py(self) -> int | Decimal:
    4869        if self.is_number:
    4870            return self.this.to_py() * -1
    4871        return super().to_py()

def to_py(self) -> int | decimal.Decimal: View Source

    4868    def to_py(self) -> int | Decimal:
    4869        if self.is_number:
    4870            return self.this.to_py() * -1
    4871        return super().to_py()

Returns a Python object equivalent of the SQL node.

key = 'neg'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Alias(Expression): View Source

    4874class Alias(Expression):
    4875    arg_types = {"this": True, "alias": False}
    4876
    4877    @property
    4878    def output_name(self) -> str:
    4879        return self.alias

arg_types = {'this': True, 'alias': False}
output_name: str View Source

    4877    @property
    4878    def output_name(self) -> str:
    4879        return self.alias

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'alias'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PivotAlias(Alias): View Source

    4884class PivotAlias(Alias):
    4885    pass

key = 'pivotalias'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Alias
  arg_types
  output_name

class PivotAny(Expression): View Source

    4890class PivotAny(Expression):
    4891    arg_types = {"this": False}

arg_types = {'this': False}
key = 'pivotany'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Aliases(Expression): View Source

    4894class Aliases(Expression):
    4895    arg_types = {"this": True, "expressions": True}
    4896
    4897    @property
    4898    def aliases(self):
    4899        return self.expressions

arg_types = {'this': True, 'expressions': True}
aliases View Source

    4897    @property
    4898    def aliases(self):
    4899        return self.expressions

key = 'aliases'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AtIndex(Expression): View Source

    4903class AtIndex(Expression):
    4904    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'atindex'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AtTimeZone(Expression): View Source

    4907class AtTimeZone(Expression):
    4908    arg_types = {"this": True, "zone": True}

arg_types = {'this': True, 'zone': True}
key = 'attimezone'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FromTimeZone(Expression): View Source

    4911class FromTimeZone(Expression):
    4912    arg_types = {"this": True, "zone": True}

arg_types = {'this': True, 'zone': True}
key = 'fromtimezone'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Between(Predicate): View Source

    4915class Between(Predicate):
    4916    arg_types = {"this": True, "low": True, "high": True}

arg_types = {'this': True, 'low': True, 'high': True}
key = 'between'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Bracket(Condition): View Source

    4919class Bracket(Condition):
    4920    # https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#array_subscript_operator
    4921    arg_types = {
    4922        "this": True,
    4923        "expressions": True,
    4924        "offset": False,
    4925        "safe": False,
    4926        "returns_list_for_maps": False,
    4927    }
    4928
    4929    @property
    4930    def output_name(self) -> str:
    4931        if len(self.expressions) == 1:
    4932            return self.expressions[0].output_name
    4933
    4934        return super().output_name

arg_types = {'this': True, 'expressions': True, 'offset': False, 'safe': False, 'returns_list_for_maps': False}
output_name: str View Source

    4929    @property
    4930    def output_name(self) -> str:
    4931        if len(self.expressions) == 1:
    4932            return self.expressions[0].output_name
    4933
    4934        return super().output_name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'bracket'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Distinct(Expression): View Source

    4937class Distinct(Expression):
    4938    arg_types = {"expressions": False, "on": False}

arg_types = {'expressions': False, 'on': False}
key = 'distinct'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class In(Predicate): View Source

    4941class In(Predicate):
    4942    arg_types = {
    4943        "this": True,
    4944        "expressions": False,
    4945        "query": False,
    4946        "unnest": False,
    4947        "field": False,
    4948        "is_global": False,
    4949    }

arg_types = {'this': True, 'expressions': False, 'query': False, 'unnest': False, 'field': False, 'is_global': False}
key = 'in'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ForIn(Expression): View Source

    4953class ForIn(Expression):
    4954    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'forin'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeUnit(Expression): View Source

    4957class TimeUnit(Expression):
    4958    """Automatically converts unit arg into a var."""
    4959
    4960    arg_types = {"unit": False}
    4961
    4962    UNABBREVIATED_UNIT_NAME = {
    4963        "D": "DAY",
    4964        "H": "HOUR",
    4965        "M": "MINUTE",
    4966        "MS": "MILLISECOND",
    4967        "NS": "NANOSECOND",
    4968        "Q": "QUARTER",
    4969        "S": "SECOND",
    4970        "US": "MICROSECOND",
    4971        "W": "WEEK",
    4972        "Y": "YEAR",
    4973    }
    4974
    4975    VAR_LIKE = (Column, Literal, Var)
    4976
    4977    def __init__(self, **args):
    4978        unit = args.get("unit")
    4979        if isinstance(unit, self.VAR_LIKE):
    4980            args["unit"] = Var(
    4981                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    4982            )
    4983        elif isinstance(unit, Week):
    4984            unit.set("this", Var(this=unit.this.name.upper()))
    4985
    4986        super().__init__(**args)
    4987
    4988    @property
    4989    def unit(self) -> t.Optional[Var | IntervalSpan]:
    4990        return self.args.get("unit")

Automatically converts unit arg into a var.

TimeUnit(**args) View Source

    4977    def __init__(self, **args):
    4978        unit = args.get("unit")
    4979        if isinstance(unit, self.VAR_LIKE):
    4980            args["unit"] = Var(
    4981                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    4982            )
    4983        elif isinstance(unit, Week):
    4984            unit.set("this", Var(this=unit.this.name.upper()))
    4985
    4986        super().__init__(**args)

arg_types = {'unit': False}
UNABBREVIATED_UNIT_NAME = {'D': 'DAY', 'H': 'HOUR', 'M': 'MINUTE', 'MS': 'MILLISECOND', 'NS': 'NANOSECOND', 'Q': 'QUARTER', 'S': 'SECOND', 'US': 'MICROSECOND', 'W': 'WEEK', 'Y': 'YEAR'}
VAR_LIKE = (<class 'Column'>, <class 'Literal'>, <class 'Var'>)
unit: Union[Var, IntervalSpan, NoneType] View Source

    4988    @property
    4989    def unit(self) -> t.Optional[Var | IntervalSpan]:
    4990        return self.args.get("unit")

key = 'timeunit'

##### Inherited Members

Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IntervalOp(TimeUnit): View Source

    4993class IntervalOp(TimeUnit):
    4994    arg_types = {"unit": False, "expression": True}
    4995
    4996    def interval(self):
    4997        return Interval(
    4998            this=self.expression.copy(),
    4999            unit=self.unit.copy() if self.unit else None,
    5000        )

arg_types = {'unit': False, 'expression': True}
def interval(self): View Source

    4996    def interval(self):
    4997        return Interval(
    4998            this=self.expression.copy(),
    4999            unit=self.unit.copy() if self.unit else None,
    5000        )

key = 'intervalop'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IntervalSpan(DataType): View Source

    5006class IntervalSpan(DataType):
    5007    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'intervalspan'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DataType
  Type
  STRUCT_TYPES
  ARRAY_TYPES
  NESTED_TYPES
  TEXT_TYPES
  SIGNED_INTEGER_TYPES
  UNSIGNED_INTEGER_TYPES
  INTEGER_TYPES
  FLOAT_TYPES
  REAL_TYPES
  NUMERIC_TYPES
  TEMPORAL_TYPES
  build
  is_type

class Interval(TimeUnit): View Source

    5010class Interval(TimeUnit):
    5011    arg_types = {"this": False, "unit": False}

arg_types = {'this': False, 'unit': False}
key = 'interval'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IgnoreNulls(Expression): View Source

    5014class IgnoreNulls(Expression):
    5015    pass

key = 'ignorenulls'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RespectNulls(Expression): View Source

    5018class RespectNulls(Expression):
    5019    pass

key = 'respectnulls'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HavingMax(Expression): View Source

    5023class HavingMax(Expression):
    5024    arg_types = {"this": True, "expression": True, "max": True}

arg_types = {'this': True, 'expression': True, 'max': True}
key = 'havingmax'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Func(Condition): View Source

    5028class Func(Condition):
    5029    """
    5030    The base class for all function expressions.
    5031
    5032    Attributes:
    5033        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    5034            treated as a variable length argument and the argument's value will be stored as a list.
    5035        _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this
    5036            function expression. These values are used to map this node to a name during parsing as
    5037            well as to provide the function's name during SQL string generation. By default the SQL
    5038            name is set to the expression's class name transformed to snake case.
    5039    """
    5040
    5041    is_var_len_args = False
    5042
    5043    @classmethod
    5044    def from_arg_list(cls, args):
    5045        if cls.is_var_len_args:
    5046            all_arg_keys = list(cls.arg_types)
    5047            # If this function supports variable length argument treat the last argument as such.
    5048            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5049            num_non_var = len(non_var_len_arg_keys)
    5050
    5051            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5052            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5053        else:
    5054            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5055
    5056        return cls(**args_dict)
    5057
    5058    @classmethod
    5059    def sql_names(cls):
    5060        if cls is Func:
    5061            raise NotImplementedError(
    5062                "SQL name is only supported by concrete function implementations"
    5063            )
    5064        if "_sql_names" not in cls.__dict__:
    5065            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5066        return cls._sql_names
    5067
    5068    @classmethod
    5069    def sql_name(cls):
    5070        return cls.sql_names()[0]
    5071
    5072    @classmethod
    5073    def default_parser_mappings(cls):
    5074        return {name: cls.from_arg_list for name in cls.sql_names()}

The base class for all function expressions.

###### Attributes:

- is_var_len_args (bool): if set to True the last argument defined in arg_types will be treated as a variable length argument and the argument's value will be stored as a list.
- _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this function expression. These values are used to map this node to a name during parsing as well as to provide the function's name during SQL string generation. By default the SQL name is set to the expression's class name transformed to snake case.

is_var_len_args = False
@classmethod
def from_arg_list(cls, args): View Source

    5043    @classmethod
    5044    def from_arg_list(cls, args):
    5045        if cls.is_var_len_args:
    5046            all_arg_keys = list(cls.arg_types)
    5047            # If this function supports variable length argument treat the last argument as such.
    5048            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5049            num_non_var = len(non_var_len_arg_keys)
    5050
    5051            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5052            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5053        else:
    5054            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5055
    5056        return cls(**args_dict)

@classmethod
def sql_names(cls): View Source

    5058    @classmethod
    5059    def sql_names(cls):
    5060        if cls is Func:
    5061            raise NotImplementedError(
    5062                "SQL name is only supported by concrete function implementations"
    5063            )
    5064        if "_sql_names" not in cls.__dict__:
    5065            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5066        return cls._sql_names

@classmethod
def sql_name(cls): View Source

    5068    @classmethod
    5069    def sql_name(cls):
    5070        return cls.sql_names()[0]

@classmethod
def default_parser_mappings(cls): View Source

    5072    @classmethod
    5073    def default_parser_mappings(cls):
    5074        return {name: cls.from_arg_list for name in cls.sql_names()}

key = 'func'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AggFunc(Func): View Source

    5077class AggFunc(Func):
    5078    pass

key = 'aggfunc'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ParameterizedAgg(AggFunc): View Source

    5081class ParameterizedAgg(AggFunc):
    5082    arg_types = {"this": True, "expressions": True, "params": True}

arg_types = {'this': True, 'expressions': True, 'params': True}
key = 'parameterizedagg'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Abs(Func): View Source

    5085class Abs(Func):
    5086    pass

key = 'abs'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArgMax(AggFunc): View Source

    5089class ArgMax(AggFunc):
    5090    arg_types = {"this": True, "expression": True, "count": False}
    5091    _sql_names = ["ARG_MAX", "ARGMAX", "MAX_BY"]

arg_types = {'this': True, 'expression': True, 'count': False}
key = 'argmax'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArgMin(AggFunc): View Source

    5094class ArgMin(AggFunc):
    5095    arg_types = {"this": True, "expression": True, "count": False}
    5096    _sql_names = ["ARG_MIN", "ARGMIN", "MIN_BY"]

arg_types = {'this': True, 'expression': True, 'count': False}
key = 'argmin'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ApproxTopK(AggFunc): View Source

    5099class ApproxTopK(AggFunc):
    5100    arg_types = {"this": True, "expression": False, "counters": False}

arg_types = {'this': True, 'expression': False, 'counters': False}
key = 'approxtopk'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Flatten(Func): View Source

    5103class Flatten(Func):
    5104    pass

key = 'flatten'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Transform(Func): View Source

    5108class Transform(Func):
    5109    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'transform'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Anonymous(Func): View Source

    5112class Anonymous(Func):
    5113    arg_types = {"this": True, "expressions": False}
    5114    is_var_len_args = True
    5115
    5116    @property
    5117    def name(self) -> str:
    5118        return self.this if isinstance(self.this, str) else self.this.name

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
name: str View Source

    5116    @property
    5117    def name(self) -> str:
    5118        return self.this if isinstance(self.this, str) else self.this.name

key = 'anonymous'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class AnonymousAggFunc(AggFunc): View Source

    5121class AnonymousAggFunc(AggFunc):
    5122    arg_types = {"this": True, "expressions": False}
    5123    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'anonymousaggfunc'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CombinedAggFunc(AnonymousAggFunc): View Source

    5127class CombinedAggFunc(AnonymousAggFunc):
    5128    arg_types = {"this": True, "expressions": False, "parts": True}

arg_types = {'this': True, 'expressions': False, 'parts': True}
key = 'combinedaggfunc'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
AnonymousAggFunc
  is_var_len_args
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CombinedParameterizedAgg(ParameterizedAgg): View Source

    5131class CombinedParameterizedAgg(ParameterizedAgg):
    5132    arg_types = {"this": True, "expressions": True, "params": True, "parts": True}

arg_types = {'this': True, 'expressions': True, 'params': True, 'parts': True}
key = 'combinedparameterizedagg'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Hll(AggFunc): View Source

    5137class Hll(AggFunc):
    5138    arg_types = {"this": True, "expressions": False}
    5139    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'hll'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ApproxDistinct(AggFunc): View Source

    5142class ApproxDistinct(AggFunc):
    5143    arg_types = {"this": True, "accuracy": False}
    5144    _sql_names = ["APPROX_DISTINCT", "APPROX_COUNT_DISTINCT"]

arg_types = {'this': True, 'accuracy': False}
key = 'approxdistinct'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Apply(Func): View Source

    5147class Apply(Func):
    5148    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'apply'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Array(Func): View Source

    5151class Array(Func):
    5152    arg_types = {"expressions": False, "bracket_notation": False}
    5153    is_var_len_args = True

arg_types = {'expressions': False, 'bracket_notation': False}
is_var_len_args = True
key = 'array'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ToArray(Func): View Source

    5157class ToArray(Func):
    5158    pass

key = 'toarray'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class List(Func): View Source

    5162class List(Func):
    5163    arg_types = {"expressions": False}
    5164    is_var_len_args = True

arg_types = {'expressions': False}
is_var_len_args = True
key = 'list'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Pad(Func): View Source

    5168class Pad(Func):
    5169    arg_types = {"this": True, "expression": True, "fill_pattern": False, "is_left": True}

arg_types = {'this': True, 'expression': True, 'fill_pattern': False, 'is_left': True}
key = 'pad'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ToChar(Func): View Source

    5174class ToChar(Func):
    5175    arg_types = {"this": True, "format": False, "nlsparam": False}

arg_types = {'this': True, 'format': False, 'nlsparam': False}
key = 'tochar'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ToNumber(Func): View Source

    5180class ToNumber(Func):
    5181    arg_types = {
    5182        "this": True,
    5183        "format": False,
    5184        "nlsparam": False,
    5185        "precision": False,
    5186        "scale": False,
    5187    }

arg_types = {'this': True, 'format': False, 'nlsparam': False, 'precision': False, 'scale': False}
key = 'tonumber'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Columns(Func): View Source

    5190class Columns(Func):
    5191    arg_types = {"this": True, "unpack": False}

arg_types = {'this': True, 'unpack': False}
key = 'columns'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Convert(Func): View Source

    5195class Convert(Func):
    5196    arg_types = {"this": True, "expression": True, "style": False}

arg_types = {'this': True, 'expression': True, 'style': False}
key = 'convert'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ConvertTimezone(Func): View Source

    5199class ConvertTimezone(Func):
    5200    arg_types = {"source_tz": False, "target_tz": True, "timestamp": True}

arg_types = {'source_tz': False, 'target_tz': True, 'timestamp': True}
key = 'converttimezone'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class GenerateSeries(Func): View Source

    5203class GenerateSeries(Func):
    5204    arg_types = {"start": True, "end": True, "step": False, "is_end_exclusive": False}

arg_types = {'start': True, 'end': True, 'step': False, 'is_end_exclusive': False}
key = 'generateseries'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ExplodingGenerateSeries(GenerateSeries): View Source

    5210class ExplodingGenerateSeries(GenerateSeries):
    5211    pass

key = 'explodinggenerateseries'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
GenerateSeries
  arg_types
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayAgg(AggFunc): View Source

    5214class ArrayAgg(AggFunc):
    5215    arg_types = {"this": True, "nulls_excluded": False}

arg_types = {'this': True, 'nulls_excluded': False}
key = 'arrayagg'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayUniqueAgg(AggFunc): View Source

    5218class ArrayUniqueAgg(AggFunc):
    5219    pass

key = 'arrayuniqueagg'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayAll(Func): View Source

    5222class ArrayAll(Func):
    5223    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'arrayall'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayAny(Func): View Source

    5227class ArrayAny(Func):
    5228    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'arrayany'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayConcat(Func): View Source

    5231class ArrayConcat(Func):
    5232    _sql_names = ["ARRAY_CONCAT", "ARRAY_CAT"]
    5233    arg_types = {"this": True, "expressions": False}
    5234    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'arrayconcat'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayConstructCompact(Func): View Source

    5237class ArrayConstructCompact(Func):
    5238    arg_types = {"expressions": True}
    5239    is_var_len_args = True

arg_types = {'expressions': True}
is_var_len_args = True
key = 'arrayconstructcompact'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayContains(Binary, Func): View Source

    5242class ArrayContains(Binary, Func):
    5243    _sql_names = ["ARRAY_CONTAINS", "ARRAY_HAS"]

key = 'arraycontains'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayContainsAll(Binary, Func): View Source

    5246class ArrayContainsAll(Binary, Func):
    5247    _sql_names = ["ARRAY_CONTAINS_ALL", "ARRAY_HAS_ALL"]

key = 'arraycontainsall'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayFilter(Func): View Source

    5250class ArrayFilter(Func):
    5251    arg_types = {"this": True, "expression": True}
    5252    _sql_names = ["FILTER", "ARRAY_FILTER"]

arg_types = {'this': True, 'expression': True}
key = 'arrayfilter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayToString(Func): View Source

    5255class ArrayToString(Func):
    5256    arg_types = {"this": True, "expression": True, "null": False}
    5257    _sql_names = ["ARRAY_TO_STRING", "ARRAY_JOIN"]

arg_types = {'this': True, 'expression': True, 'null': False}
key = 'arraytostring'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StringToArray(Func): View Source

    5260class StringToArray(Func):
    5261    arg_types = {"this": True, "expression": True, "null": False}
    5262    _sql_names = ["STRING_TO_ARRAY", "SPLIT_BY_STRING"]

arg_types = {'this': True, 'expression': True, 'null': False}
key = 'stringtoarray'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayOverlaps(Binary, Func): View Source

    5265class ArrayOverlaps(Binary, Func):
    5266    pass

key = 'arrayoverlaps'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArraySize(Func): View Source

    5269class ArraySize(Func):
    5270    arg_types = {"this": True, "expression": False}
    5271    _sql_names = ["ARRAY_SIZE", "ARRAY_LENGTH"]

arg_types = {'this': True, 'expression': False}
key = 'arraysize'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArraySort(Func): View Source

    5274class ArraySort(Func):
    5275    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'arraysort'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArraySum(Func): View Source

    5278class ArraySum(Func):
    5279    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'arraysum'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayUnionAgg(AggFunc): View Source

    5282class ArrayUnionAgg(AggFunc):
    5283    pass

key = 'arrayunionagg'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Avg(AggFunc): View Source

    5286class Avg(AggFunc):
    5287    pass

key = 'avg'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class AnyValue(AggFunc): View Source

    5290class AnyValue(AggFunc):
    5291    pass

key = 'anyvalue'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Lag(AggFunc): View Source

    5294class Lag(AggFunc):
    5295    arg_types = {"this": True, "offset": False, "default": False}

arg_types = {'this': True, 'offset': False, 'default': False}
key = 'lag'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Lead(AggFunc): View Source

    5298class Lead(AggFunc):
    5299    arg_types = {"this": True, "offset": False, "default": False}

arg_types = {'this': True, 'offset': False, 'default': False}
key = 'lead'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class First(AggFunc): View Source

    5304class First(AggFunc):
    5305    pass

key = 'first'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Last(AggFunc): View Source

    5308class Last(AggFunc):
    5309    pass

key = 'last'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class FirstValue(AggFunc): View Source

    5312class FirstValue(AggFunc):
    5313    pass

key = 'firstvalue'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class LastValue(AggFunc): View Source

    5316class LastValue(AggFunc):
    5317    pass

key = 'lastvalue'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class NthValue(AggFunc): View Source

    5320class NthValue(AggFunc):
    5321    arg_types = {"this": True, "offset": True}

arg_types = {'this': True, 'offset': True}
key = 'nthvalue'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Case(Func): View Source

    5324class Case(Func):
    5325    arg_types = {"this": False, "ifs": True, "default": False}
    5326
    5327    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5328        instance = maybe_copy(self, copy)
    5329        instance.append(
    5330            "ifs",
    5331            If(
    5332                this=maybe_parse(condition, copy=copy, **opts),
    5333                true=maybe_parse(then, copy=copy, **opts),
    5334            ),
    5335        )
    5336        return instance
    5337
    5338    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5339        instance = maybe_copy(self, copy)
    5340        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5341        return instance

arg_types = {'this': False, 'ifs': True, 'default': False}
def when( self, condition: Union[str, Expression], then: Union[str, Expression], copy: bool = True, **opts) -> Case: View Source

    5327    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5328        instance = maybe_copy(self, copy)
    5329        instance.append(
    5330            "ifs",
    5331            If(
    5332                this=maybe_parse(condition, copy=copy, **opts),
    5333                true=maybe_parse(then, copy=copy, **opts),
    5334            ),
    5335        )
    5336        return instance

def else_( self, condition: Union[str, Expression], copy: bool = True, **opts) -> Case: View Source

    5338    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5339        instance = maybe_copy(self, copy)
    5340        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5341        return instance

key = 'case'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Cast(Func): View Source

    5344class Cast(Func):
    5345    arg_types = {
    5346        "this": True,
    5347        "to": True,
    5348        "format": False,
    5349        "safe": False,
    5350        "action": False,
    5351    }
    5352
    5353    @property
    5354    def name(self) -> str:
    5355        return self.this.name
    5356
    5357    @property
    5358    def to(self) -> DataType:
    5359        return self.args["to"]
    5360
    5361    @property
    5362    def output_name(self) -> str:
    5363        return self.name
    5364
    5365    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5366        """
    5367        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5368        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5369        array<int> != array<float>.
    5370
    5371        Args:
    5372            dtypes: the data types to compare this Cast's DataType to.
    5373
    5374        Returns:
    5375            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5376        """
    5377        return self.to.is_type(*dtypes)

arg_types = {'this': True, 'to': True, 'format': False, 'safe': False, 'action': False}
name: str View Source

    5353    @property
    5354    def name(self) -> str:
    5355        return self.this.name

to: DataType View Source

    5357    @property
    5358    def to(self) -> DataType:
    5359        return self.args["to"]

output_name: str View Source

    5361    @property
    5362    def output_name(self) -> str:
    5363        return self.name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

def is_type( self, *dtypes: Union[str, DataType, DataType.Type]) -> bool: View Source

    5365    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5366        """
    5367        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5368        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5369        array<int> != array<float>.
    5370
    5371        Args:
    5372            dtypes: the data types to compare this Cast's DataType to.
    5373
    5374        Returns:
    5375            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5376        """
    5377        return self.to.is_type(*dtypes)

Checks whether this Cast's DataType matches one of the provided data types. Nested types like arrays or structs will be compared using "structural equivalence" semantics, so e.g. array != array.

###### Arguments:

- dtypes: the data types to compare this Cast's DataType to.

###### Returns:

> True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.

key = 'cast'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TryCast(Cast): View Source

    5380class TryCast(Cast):
    5381    pass

key = 'trycast'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Cast
  arg_types
  name
  to
  output_name
  is_type
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Try(Func): View Source

    5384class Try(Func):
    5385    pass

key = 'try'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CastToStrType(Func): View Source

    5388class CastToStrType(Func):
    5389    arg_types = {"this": True, "to": True}

arg_types = {'this': True, 'to': True}
key = 'casttostrtype'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Collate(Binary, Func): View Source

    5392class Collate(Binary, Func):
    5393    pass

key = 'collate'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Ceil(Func): View Source

    5396class Ceil(Func):
    5397    arg_types = {"this": True, "decimals": False}
    5398    _sql_names = ["CEIL", "CEILING"]

arg_types = {'this': True, 'decimals': False}
key = 'ceil'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Coalesce(Func): View Source

    5401class Coalesce(Func):
    5402    arg_types = {"this": True, "expressions": False, "is_nvl": False}
    5403    is_var_len_args = True
    5404    _sql_names = ["COALESCE", "IFNULL", "NVL"]

arg_types = {'this': True, 'expressions': False, 'is_nvl': False}
is_var_len_args = True
key = 'coalesce'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Chr(Func): View Source

    5407class Chr(Func):
    5408    arg_types = {"expressions": True, "charset": False}
    5409    is_var_len_args = True
    5410    _sql_names = ["CHR", "CHAR"]

arg_types = {'expressions': True, 'charset': False}
is_var_len_args = True
key = 'chr'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Concat(Func): View Source

    5413class Concat(Func):
    5414    arg_types = {"expressions": True, "safe": False, "coalesce": False}
    5415    is_var_len_args = True

arg_types = {'expressions': True, 'safe': False, 'coalesce': False}
is_var_len_args = True
key = 'concat'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ConcatWs(Concat): View Source

    5418class ConcatWs(Concat):
    5419    _sql_names = ["CONCAT_WS"]

key = 'concatws'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Concat
  arg_types
  is_var_len_args
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ConnectByRoot(Func): View Source

    5423class ConnectByRoot(Func):
    5424    pass

key = 'connectbyroot'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Count(AggFunc): View Source

    5427class Count(AggFunc):
    5428    arg_types = {"this": False, "expressions": False, "big_int": False}
    5429    is_var_len_args = True

arg_types = {'this': False, 'expressions': False, 'big_int': False}
is_var_len_args = True
key = 'count'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CountIf(AggFunc): View Source

    5432class CountIf(AggFunc):
    5433    _sql_names = ["COUNT_IF", "COUNTIF"]

key = 'countif'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Cbrt(Func): View Source

    5437class Cbrt(Func):
    5438    pass

key = 'cbrt'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CurrentDate(Func): View Source

    5441class CurrentDate(Func):
    5442    arg_types = {"this": False}

arg_types = {'this': False}
key = 'currentdate'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CurrentDatetime(Func): View Source

    5445class CurrentDatetime(Func):
    5446    arg_types = {"this": False}

arg_types = {'this': False}
key = 'currentdatetime'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CurrentTime(Func): View Source

    5449class CurrentTime(Func):
    5450    arg_types = {"this": False}

arg_types = {'this': False}
key = 'currenttime'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CurrentTimestamp(Func): View Source

    5453class CurrentTimestamp(Func):
    5454    arg_types = {"this": False, "sysdate": False}

arg_types = {'this': False, 'sysdate': False}
key = 'currenttimestamp'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CurrentUser(Func): View Source

    5457class CurrentUser(Func):
    5458    arg_types = {"this": False}

arg_types = {'this': False}
key = 'currentuser'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DateAdd(Func, IntervalOp): View Source

    5461class DateAdd(Func, IntervalOp):
    5462    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'dateadd'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateSub(Func, IntervalOp): View Source

    5465class DateSub(Func, IntervalOp):
    5466    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'datesub'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateDiff(Func, TimeUnit): View Source

    5469class DateDiff(Func, TimeUnit):
    5470    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    5471    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'datediff'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateTrunc(Func): View Source

    5474class DateTrunc(Func):
    5475    arg_types = {"unit": True, "this": True, "zone": False}
    5476
    5477    def __init__(self, **args):
    5478        unit = args.get("unit")
    5479        if isinstance(unit, TimeUnit.VAR_LIKE):
    5480            args["unit"] = Literal.string(
    5481                (TimeUnit.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5482            )
    5483        elif isinstance(unit, Week):
    5484            unit.set("this", Literal.string(unit.this.name.upper()))
    5485
    5486        super().__init__(**args)
    5487
    5488    @property
    5489    def unit(self) -> Expression:
    5490        return self.args["unit"]

DateTrunc(**args) View Source

    5477    def __init__(self, **args):
    5478        unit = args.get("unit")
    5479        if isinstance(unit, TimeUnit.VAR_LIKE):
    5480            args["unit"] = Literal.string(
    5481                (TimeUnit.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5482            )
    5483        elif isinstance(unit, Week):
    5484            unit.set("this", Literal.string(unit.this.name.upper()))
    5485
    5486        super().__init__(**args)

arg_types = {'unit': True, 'this': True, 'zone': False}
unit: Expression View Source

    5488    @property
    5489    def unit(self) -> Expression:
    5490        return self.args["unit"]

key = 'datetrunc'

##### Inherited Members

Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Datetime(Func): View Source

    5495class Datetime(Func):
    5496    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'datetime'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DatetimeAdd(Func, IntervalOp): View Source

    5499class DatetimeAdd(Func, IntervalOp):
    5500    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'datetimeadd'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DatetimeSub(Func, IntervalOp): View Source

    5503class DatetimeSub(Func, IntervalOp):
    5504    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'datetimesub'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DatetimeDiff(Func, TimeUnit): View Source

    5507class DatetimeDiff(Func, TimeUnit):
    5508    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'datetimediff'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DatetimeTrunc(Func, TimeUnit): View Source

    5511class DatetimeTrunc(Func, TimeUnit):
    5512    arg_types = {"this": True, "unit": True, "zone": False}

arg_types = {'this': True, 'unit': True, 'zone': False}
key = 'datetimetrunc'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DayOfWeek(Func): View Source

    5515class DayOfWeek(Func):
    5516    _sql_names = ["DAY_OF_WEEK", "DAYOFWEEK"]

key = 'dayofweek'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DayOfWeekIso(Func): View Source

    5521class DayOfWeekIso(Func):
    5522    _sql_names = ["DAYOFWEEK_ISO", "ISODOW"]

key = 'dayofweekiso'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DayOfMonth(Func): View Source

    5525class DayOfMonth(Func):
    5526    _sql_names = ["DAY_OF_MONTH", "DAYOFMONTH"]

key = 'dayofmonth'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DayOfYear(Func): View Source

    5529class DayOfYear(Func):
    5530    _sql_names = ["DAY_OF_YEAR", "DAYOFYEAR"]

key = 'dayofyear'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ToDays(Func): View Source

    5533class ToDays(Func):
    5534    pass

key = 'todays'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class WeekOfYear(Func): View Source

    5537class WeekOfYear(Func):
    5538    _sql_names = ["WEEK_OF_YEAR", "WEEKOFYEAR"]

key = 'weekofyear'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class MonthsBetween(Func): View Source

    5541class MonthsBetween(Func):
    5542    arg_types = {"this": True, "expression": True, "roundoff": False}

arg_types = {'this': True, 'expression': True, 'roundoff': False}
key = 'monthsbetween'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class LastDay(Func, TimeUnit): View Source

    5545class LastDay(Func, TimeUnit):
    5546    _sql_names = ["LAST_DAY", "LAST_DAY_OF_MONTH"]
    5547    arg_types = {"this": True, "unit": False}

arg_types = {'this': True, 'unit': False}
key = 'lastday'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Extract(Func): View Source

    5550class Extract(Func):
    5551    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'extract'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Timestamp(Func): View Source

    5554class Timestamp(Func):
    5555    arg_types = {"this": False, "zone": False, "with_tz": False}

arg_types = {'this': False, 'zone': False, 'with_tz': False}
key = 'timestamp'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimestampAdd(Func, TimeUnit): View Source

    5558class TimestampAdd(Func, TimeUnit):
    5559    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'timestampadd'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimestampSub(Func, TimeUnit): View Source

    5562class TimestampSub(Func, TimeUnit):
    5563    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'timestampsub'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimestampDiff(Func, TimeUnit): View Source

    5566class TimestampDiff(Func, TimeUnit):
    5567    _sql_names = ["TIMESTAMPDIFF", "TIMESTAMP_DIFF"]
    5568    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'timestampdiff'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimestampTrunc(Func, TimeUnit): View Source

    5571class TimestampTrunc(Func, TimeUnit):
    5572    arg_types = {"this": True, "unit": True, "zone": False}

arg_types = {'this': True, 'unit': True, 'zone': False}
key = 'timestamptrunc'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeAdd(Func, TimeUnit): View Source

    5575class TimeAdd(Func, TimeUnit):
    5576    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'timeadd'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeSub(Func, TimeUnit): View Source

    5579class TimeSub(Func, TimeUnit):
    5580    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'timesub'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeDiff(Func, TimeUnit): View Source

    5583class TimeDiff(Func, TimeUnit):
    5584    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'timediff'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeTrunc(Func, TimeUnit): View Source

    5587class TimeTrunc(Func, TimeUnit):
    5588    arg_types = {"this": True, "unit": True, "zone": False}

arg_types = {'this': True, 'unit': True, 'zone': False}
key = 'timetrunc'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateFromParts(Func): View Source

    5591class DateFromParts(Func):
    5592    _sql_names = ["DATE_FROM_PARTS", "DATEFROMPARTS"]
    5593    arg_types = {"year": True, "month": True, "day": True}

arg_types = {'year': True, 'month': True, 'day': True}
key = 'datefromparts'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimeFromParts(Func): View Source

    5596class TimeFromParts(Func):
    5597    _sql_names = ["TIME_FROM_PARTS", "TIMEFROMPARTS"]
    5598    arg_types = {
    5599        "hour": True,
    5600        "min": True,
    5601        "sec": True,
    5602        "nano": False,
    5603        "fractions": False,
    5604        "precision": False,
    5605    }

arg_types = {'hour': True, 'min': True, 'sec': True, 'nano': False, 'fractions': False, 'precision': False}
key = 'timefromparts'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DateStrToDate(Func): View Source

    5608class DateStrToDate(Func):
    5609    pass

key = 'datestrtodate'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DateToDateStr(Func): View Source

    5612class DateToDateStr(Func):
    5613    pass

key = 'datetodatestr'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DateToDi(Func): View Source

    5616class DateToDi(Func):
    5617    pass

key = 'datetodi'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Date(Func): View Source

    5621class Date(Func):
    5622    arg_types = {"this": False, "zone": False, "expressions": False}
    5623    is_var_len_args = True

arg_types = {'this': False, 'zone': False, 'expressions': False}
is_var_len_args = True
key = 'date'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Day(Func): View Source

    5626class Day(Func):
    5627    pass

key = 'day'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Decode(Func): View Source

    5630class Decode(Func):
    5631    arg_types = {"this": True, "charset": True, "replace": False}

arg_types = {'this': True, 'charset': True, 'replace': False}
key = 'decode'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class DiToDate(Func): View Source

    5634class DiToDate(Func):
    5635    pass

key = 'ditodate'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Encode(Func): View Source

    5638class Encode(Func):
    5639    arg_types = {"this": True, "charset": True}

arg_types = {'this': True, 'charset': True}
key = 'encode'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Exp(Func): View Source

    5642class Exp(Func):
    5643    pass

key = 'exp'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Explode(Func, UDTF): View Source

    5647class Explode(Func, UDTF):
    5648    arg_types = {"this": True, "expressions": False}
    5649    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'explode'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
UDTF
  selects
DerivedTable
  named_selects

class Inline(Func): View Source

    5653class Inline(Func):
    5654    pass

key = 'inline'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ExplodeOuter(Explode): View Source

    5657class ExplodeOuter(Explode):
    5658    pass

key = 'explodeouter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Explode
  arg_types
  is_var_len_args
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
UDTF
  selects
DerivedTable
  named_selects

class Posexplode(Explode): View Source

    5661class Posexplode(Explode):
    5662    pass

key = 'posexplode'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Explode
  arg_types
  is_var_len_args
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
UDTF
  selects
DerivedTable
  named_selects

class PosexplodeOuter(Posexplode, ExplodeOuter): View Source

    5665class PosexplodeOuter(Posexplode, ExplodeOuter):
    5666    pass

key = 'posexplodeouter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Explode
  arg_types
  is_var_len_args
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
UDTF
  selects
DerivedTable
  named_selects

class Unnest(Func, UDTF): View Source

    5669class Unnest(Func, UDTF):
    5670    arg_types = {
    5671        "expressions": True,
    5672        "alias": False,
    5673        "offset": False,
    5674        "explode_array": False,
    5675    }
    5676
    5677    @property
    5678    def selects(self) -> t.List[Expression]:
    5679        columns = super().selects
    5680        offset = self.args.get("offset")
    5681        if offset:
    5682            columns = columns + [to_identifier("offset") if offset is True else offset]
    5683        return columns

arg_types = {'expressions': True, 'alias': False, 'offset': False, 'explode_array': False}
selects: List[Expression] View Source

    5677    @property
    5678    def selects(self) -> t.List[Expression]:
    5679        columns = super().selects
    5680        offset = self.args.get("offset")
    5681        if offset:
    5682            columns = columns + [to_identifier("offset") if offset is True else offset]
    5683        return columns

key = 'unnest'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
DerivedTable
  named_selects

class Floor(Func): View Source

    5686class Floor(Func):
    5687    arg_types = {"this": True, "decimals": False}

arg_types = {'this': True, 'decimals': False}
key = 'floor'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class FromBase64(Func): View Source

    5690class FromBase64(Func):
    5691    pass

key = 'frombase64'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ToBase64(Func): View Source

    5694class ToBase64(Func):
    5695    pass

key = 'tobase64'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class FromISO8601Timestamp(Func): View Source

    5699class FromISO8601Timestamp(Func):
    5700    _sql_names = ["FROM_ISO8601_TIMESTAMP"]

key = 'fromiso8601timestamp'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class GapFill(Func): View Source

    5703class GapFill(Func):
    5704    arg_types = {
    5705        "this": True,
    5706        "ts_column": True,
    5707        "bucket_width": True,
    5708        "partitioning_columns": False,
    5709        "value_columns": False,
    5710        "origin": False,
    5711        "ignore_nulls": False,
    5712    }

arg_types = {'this': True, 'ts_column': True, 'bucket_width': True, 'partitioning_columns': False, 'value_columns': False, 'origin': False, 'ignore_nulls': False}
key = 'gapfill'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class GenerateDateArray(Func): View Source

    5716class GenerateDateArray(Func):
    5717    arg_types = {"start": True, "end": True, "step": False}

arg_types = {'start': True, 'end': True, 'step': False}
key = 'generatedatearray'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class GenerateTimestampArray(Func): View Source

    5721class GenerateTimestampArray(Func):
    5722    arg_types = {"start": True, "end": True, "step": True}

arg_types = {'start': True, 'end': True, 'step': True}
key = 'generatetimestamparray'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Greatest(Func): View Source

    5725class Greatest(Func):
    5726    arg_types = {"this": True, "expressions": False}
    5727    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'greatest'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class GroupConcat(AggFunc): View Source

    5730class GroupConcat(AggFunc):
    5731    arg_types = {"this": True, "separator": False}

arg_types = {'this': True, 'separator': False}
key = 'groupconcat'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Hex(Func): View Source

    5734class Hex(Func):
    5735    pass

key = 'hex'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class LowerHex(Hex): View Source

    5738class LowerHex(Hex):
    5739    pass

key = 'lowerhex'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Xor(Connector, Func): View Source

    5742class Xor(Connector, Func):
    5743    arg_types = {"this": False, "expression": False, "expressions": False}

arg_types = {'this': False, 'expression': False, 'expressions': False}
key = 'xor'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class If(Func): View Source

    5746class If(Func):
    5747    arg_types = {"this": True, "true": True, "false": False}
    5748    _sql_names = ["IF", "IIF"]

arg_types = {'this': True, 'true': True, 'false': False}
key = 'if'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Nullif(Func): View Source

    5751class Nullif(Func):
    5752    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'nullif'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Initcap(Func): View Source

    5755class Initcap(Func):
    5756    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'initcap'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class IsNan(Func): View Source

    5759class IsNan(Func):
    5760    _sql_names = ["IS_NAN", "ISNAN"]

key = 'isnan'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class IsInf(Func): View Source

    5763class IsInf(Func):
    5764    _sql_names = ["IS_INF", "ISINF"]

key = 'isinf'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSON(Expression): View Source

    5768class JSON(Expression):
    5769    arg_types = {"this": False, "with": False, "unique": False}

arg_types = {'this': False, 'with': False, 'unique': False}
key = 'json'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPath(Expression): View Source

    5772class JSONPath(Expression):
    5773    arg_types = {"expressions": True, "escape": False}
    5774
    5775    @property
    5776    def output_name(self) -> str:
    5777        last_segment = self.expressions[-1].this
    5778        return last_segment if isinstance(last_segment, str) else ""

arg_types = {'expressions': True, 'escape': False}
output_name: str View Source

    5775    @property
    5776    def output_name(self) -> str:
    5777        last_segment = self.expressions[-1].this
    5778        return last_segment if isinstance(last_segment, str) else ""

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'jsonpath'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathPart(Expression): View Source

    5781class JSONPathPart(Expression):
    5782    arg_types = {}

arg_types = {}
key = 'jsonpathpart'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathFilter(JSONPathPart): View Source

    5785class JSONPathFilter(JSONPathPart):
    5786    arg_types = {"this": True}

arg_types = {'this': True}
key = 'jsonpathfilter'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathKey(JSONPathPart): View Source

    5789class JSONPathKey(JSONPathPart):
    5790    arg_types = {"this": True}

arg_types = {'this': True}
key = 'jsonpathkey'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathRecursive(JSONPathPart): View Source

    5793class JSONPathRecursive(JSONPathPart):
    5794    arg_types = {"this": False}

arg_types = {'this': False}
key = 'jsonpathrecursive'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathRoot(JSONPathPart): View Source

    5797class JSONPathRoot(JSONPathPart):
    5798    pass

key = 'jsonpathroot'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
JSONPathPart
  arg_types

class JSONPathScript(JSONPathPart): View Source

    5801class JSONPathScript(JSONPathPart):
    5802    arg_types = {"this": True}

arg_types = {'this': True}
key = 'jsonpathscript'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathSlice(JSONPathPart): View Source

    5805class JSONPathSlice(JSONPathPart):
    5806    arg_types = {"start": False, "end": False, "step": False}

arg_types = {'start': False, 'end': False, 'step': False}
key = 'jsonpathslice'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathSelector(JSONPathPart): View Source

    5809class JSONPathSelector(JSONPathPart):
    5810    arg_types = {"this": True}

arg_types = {'this': True}
key = 'jsonpathselector'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathSubscript(JSONPathPart): View Source

    5813class JSONPathSubscript(JSONPathPart):
    5814    arg_types = {"this": True}

arg_types = {'this': True}
key = 'jsonpathsubscript'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathUnion(JSONPathPart): View Source

    5817class JSONPathUnion(JSONPathPart):
    5818    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'jsonpathunion'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathWildcard(JSONPathPart): View Source

    5821class JSONPathWildcard(JSONPathPart):
    5822    pass

key = 'jsonpathwildcard'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
JSONPathPart
  arg_types

class FormatJson(Expression): View Source

    5825class FormatJson(Expression):
    5826    pass

key = 'formatjson'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONKeyValue(Expression): View Source

    5829class JSONKeyValue(Expression):
    5830    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'jsonkeyvalue'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONObject(Func): View Source

    5833class JSONObject(Func):
    5834    arg_types = {
    5835        "expressions": False,
    5836        "null_handling": False,
    5837        "unique_keys": False,
    5838        "return_type": False,
    5839        "encoding": False,
    5840    }

arg_types = {'expressions': False, 'null_handling': False, 'unique_keys': False, 'return_type': False, 'encoding': False}
key = 'jsonobject'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONObjectAgg(AggFunc): View Source

    5843class JSONObjectAgg(AggFunc):
    5844    arg_types = {
    5845        "expressions": False,
    5846        "null_handling": False,
    5847        "unique_keys": False,
    5848        "return_type": False,
    5849        "encoding": False,
    5850    }

arg_types = {'expressions': False, 'null_handling': False, 'unique_keys': False, 'return_type': False, 'encoding': False}
key = 'jsonobjectagg'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONArray(Func): View Source

    5854class JSONArray(Func):
    5855    arg_types = {
    5856        "expressions": True,
    5857        "null_handling": False,
    5858        "return_type": False,
    5859        "strict": False,
    5860    }

arg_types = {'expressions': True, 'null_handling': False, 'return_type': False, 'strict': False}
key = 'jsonarray'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONArrayAgg(Func): View Source

    5864class JSONArrayAgg(Func):
    5865    arg_types = {
    5866        "this": True,
    5867        "order": False,
    5868        "null_handling": False,
    5869        "return_type": False,
    5870        "strict": False,
    5871    }

arg_types = {'this': True, 'order': False, 'null_handling': False, 'return_type': False, 'strict': False}
key = 'jsonarrayagg'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONExists(Func): View Source

    5874class JSONExists(Func):
    5875    arg_types = {"this": True, "path": True, "passing": False, "on_condition": False}

arg_types = {'this': True, 'path': True, 'passing': False, 'on_condition': False}
key = 'jsonexists'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONColumnDef(Expression): View Source

    5880class JSONColumnDef(Expression):
    5881    arg_types = {"this": False, "kind": False, "path": False, "nested_schema": False}

arg_types = {'this': False, 'kind': False, 'path': False, 'nested_schema': False}
key = 'jsoncolumndef'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONSchema(Expression): View Source

    5884class JSONSchema(Expression):
    5885    arg_types = {"expressions": True}

arg_types = {'expressions': True}
key = 'jsonschema'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONValue(Expression): View Source

    5889class JSONValue(Expression):
    5890    arg_types = {
    5891        "this": True,
    5892        "path": True,
    5893        "returning": False,
    5894        "on_condition": False,
    5895    }

arg_types = {'this': True, 'path': True, 'returning': False, 'on_condition': False}
key = 'jsonvalue'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONTable(Func): View Source

    5899class JSONTable(Func):
    5900    arg_types = {
    5901        "this": True,
    5902        "schema": True,
    5903        "path": False,
    5904        "error_handling": False,
    5905        "empty_handling": False,
    5906    }

arg_types = {'this': True, 'schema': True, 'path': False, 'error_handling': False, 'empty_handling': False}
key = 'jsontable'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ObjectInsert(Func): View Source

    5910class ObjectInsert(Func):
    5911    arg_types = {
    5912        "this": True,
    5913        "key": True,
    5914        "value": True,
    5915        "update_flag": False,
    5916    }

arg_types = {'this': True, 'key': True, 'value': True, 'update_flag': False}
key = 'objectinsert'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class OpenJSONColumnDef(Expression): View Source

    5919class OpenJSONColumnDef(Expression):
    5920    arg_types = {"this": True, "kind": True, "path": False, "as_json": False}

arg_types = {'this': True, 'kind': True, 'path': False, 'as_json': False}
key = 'openjsoncolumndef'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OpenJSON(Func): View Source

    5923class OpenJSON(Func):
    5924    arg_types = {"this": True, "path": False, "expressions": False}

arg_types = {'this': True, 'path': False, 'expressions': False}
key = 'openjson'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONBContains(Binary, Func): View Source

    5927class JSONBContains(Binary, Func):
    5928    _sql_names = ["JSONB_CONTAINS"]

key = 'jsonbcontains'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONExtract(Binary, Func): View Source

    5931class JSONExtract(Binary, Func):
    5932    arg_types = {
    5933        "this": True,
    5934        "expression": True,
    5935        "only_json_types": False,
    5936        "expressions": False,
    5937        "variant_extract": False,
    5938        "json_query": False,
    5939        "option": False,
    5940    }
    5941    _sql_names = ["JSON_EXTRACT"]
    5942    is_var_len_args = True
    5943
    5944    @property
    5945    def output_name(self) -> str:
    5946        return self.expression.output_name if not self.expressions else ""

arg_types = {'this': True, 'expression': True, 'only_json_types': False, 'expressions': False, 'variant_extract': False, 'json_query': False, 'option': False}
is_var_len_args = True
output_name: str View Source

    5944    @property
    5945    def output_name(self) -> str:
    5946        return self.expression.output_name if not self.expressions else ""

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'jsonextract'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONExtractScalar(Binary, Func): View Source

    5949class JSONExtractScalar(Binary, Func):
    5950    arg_types = {"this": True, "expression": True, "only_json_types": False, "expressions": False}
    5951    _sql_names = ["JSON_EXTRACT_SCALAR"]
    5952    is_var_len_args = True
    5953
    5954    @property
    5955    def output_name(self) -> str:
    5956        return self.expression.output_name

arg_types = {'this': True, 'expression': True, 'only_json_types': False, 'expressions': False}
is_var_len_args = True
output_name: str View Source

    5954    @property
    5955    def output_name(self) -> str:
    5956        return self.expression.output_name

Name of the output column if this expression is a selection.

If the Expression has no output name, an empty string is returned.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("SELECT a")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'jsonextractscalar'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONBExtract(Binary, Func): View Source

    5959class JSONBExtract(Binary, Func):
    5960    _sql_names = ["JSONB_EXTRACT"]

key = 'jsonbextract'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONBExtractScalar(Binary, Func): View Source

    5963class JSONBExtractScalar(Binary, Func):
    5964    _sql_names = ["JSONB_EXTRACT_SCALAR"]

key = 'jsonbextractscalar'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONFormat(Func): View Source

    5967class JSONFormat(Func):
    5968    arg_types = {"this": False, "options": False}
    5969    _sql_names = ["JSON_FORMAT"]

arg_types = {'this': False, 'options': False}
key = 'jsonformat'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONArrayContains(Binary, Predicate, Func): View Source

    5973class JSONArrayContains(Binary, Predicate, Func):
    5974    _sql_names = ["JSON_ARRAY_CONTAINS"]

key = 'jsonarraycontains'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ParseJSON(Func): View Source

    5977class ParseJSON(Func):
    5978    # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
    5979    # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
    5980    _sql_names = ["PARSE_JSON", "JSON_PARSE"]
    5981    arg_types = {"this": True, "expression": False, "safe": False}

arg_types = {'this': True, 'expression': False, 'safe': False}
key = 'parsejson'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Least(Func): View Source

    5984class Least(Func):
    5985    arg_types = {"this": True, "expressions": False}
    5986    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'least'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Left(Func): View Source

    5989class Left(Func):
    5990    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'left'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Right(Func): View Source

    5993class Right(Func):
    5994    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'right'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Length(Func): View Source

    5997class Length(Func):
    5998    arg_types = {"this": True, "binary": False}
    5999    _sql_names = ["LENGTH", "LEN"]

arg_types = {'this': True, 'binary': False}
key = 'length'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Levenshtein(Func): View Source

    6002class Levenshtein(Func):
    6003    arg_types = {
    6004        "this": True,
    6005        "expression": False,
    6006        "ins_cost": False,
    6007        "del_cost": False,
    6008        "sub_cost": False,
    6009    }

arg_types = {'this': True, 'expression': False, 'ins_cost': False, 'del_cost': False, 'sub_cost': False}
key = 'levenshtein'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Ln(Func): View Source

    6012class Ln(Func):
    6013    pass

key = 'ln'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Log(Func): View Source

    6016class Log(Func):
    6017    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'log'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class LogicalOr(AggFunc): View Source

    6020class LogicalOr(AggFunc):
    6021    _sql_names = ["LOGICAL_OR", "BOOL_OR", "BOOLOR_AGG"]

key = 'logicalor'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class LogicalAnd(AggFunc): View Source

    6024class LogicalAnd(AggFunc):
    6025    _sql_names = ["LOGICAL_AND", "BOOL_AND", "BOOLAND_AGG"]

key = 'logicaland'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Lower(Func): View Source

    6028class Lower(Func):
    6029    _sql_names = ["LOWER", "LCASE"]

key = 'lower'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Map(Func): View Source

    6032class Map(Func):
    6033    arg_types = {"keys": False, "values": False}
    6034
    6035    @property
    6036    def keys(self) -> t.List[Expression]:
    6037        keys = self.args.get("keys")
    6038        return keys.expressions if keys else []
    6039
    6040    @property
    6041    def values(self) -> t.List[Expression]:
    6042        values = self.args.get("values")
    6043        return values.expressions if values else []

arg_types = {'keys': False, 'values': False}
keys: List[Expression] View Source

    6035    @property
    6036    def keys(self) -> t.List[Expression]:
    6037        keys = self.args.get("keys")
    6038        return keys.expressions if keys else []

values: List[Expression] View Source

    6040    @property
    6041    def values(self) -> t.List[Expression]:
    6042        values = self.args.get("values")
    6043        return values.expressions if values else []

key = 'map'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ToMap(Func): View Source

    6047class ToMap(Func):
    6048    pass

key = 'tomap'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class MapFromEntries(Func): View Source

    6051class MapFromEntries(Func):
    6052    pass

key = 'mapfromentries'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ScopeResolution(Expression): View Source

    6056class ScopeResolution(Expression):
    6057    arg_types = {"this": False, "expression": True}

arg_types = {'this': False, 'expression': True}
key = 'scoperesolution'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Stream(Expression): View Source

    6060class Stream(Expression):
    6061    pass

key = 'stream'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StarMap(Func): View Source

    6064class StarMap(Func):
    6065    pass

key = 'starmap'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class VarMap(Func): View Source

    6068class VarMap(Func):
    6069    arg_types = {"keys": True, "values": True}
    6070    is_var_len_args = True
    6071
    6072    @property
    6073    def keys(self) -> t.List[Expression]:
    6074        return self.args["keys"].expressions
    6075
    6076    @property
    6077    def values(self) -> t.List[Expression]:
    6078        return self.args["values"].expressions

arg_types = {'keys': True, 'values': True}
is_var_len_args = True
keys: List[Expression] View Source

    6072    @property
    6073    def keys(self) -> t.List[Expression]:
    6074        return self.args["keys"].expressions

values: List[Expression] View Source

    6076    @property
    6077    def values(self) -> t.List[Expression]:
    6078        return self.args["values"].expressions

key = 'varmap'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class MatchAgainst(Func): View Source

    6082class MatchAgainst(Func):
    6083    arg_types = {"this": True, "expressions": True, "modifier": False}

arg_types = {'this': True, 'expressions': True, 'modifier': False}
key = 'matchagainst'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Max(AggFunc): View Source

    6086class Max(AggFunc):
    6087    arg_types = {"this": True, "expressions": False}
    6088    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'max'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class MD5(Func): View Source

    6091class MD5(Func):
    6092    _sql_names = ["MD5"]

key = 'md5'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class MD5Digest(Func): View Source

    6096class MD5Digest(Func):
    6097    _sql_names = ["MD5_DIGEST"]

key = 'md5digest'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Min(AggFunc): View Source

    6100class Min(AggFunc):
    6101    arg_types = {"this": True, "expressions": False}
    6102    is_var_len_args = True

arg_types = {'this': True, 'expressions': False}
is_var_len_args = True
key = 'min'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Month(Func): View Source

    6105class Month(Func):
    6106    pass

key = 'month'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class AddMonths(Func): View Source

    6109class AddMonths(Func):
    6110    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'addmonths'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Nvl2(Func): View Source

    6113class Nvl2(Func):
    6114    arg_types = {"this": True, "true": True, "false": False}

arg_types = {'this': True, 'true': True, 'false': False}
key = 'nvl2'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Normalize(Func): View Source

    6117class Normalize(Func):
    6118    arg_types = {"this": True, "form": False}

arg_types = {'this': True, 'form': False}
key = 'normalize'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Overlay(Func): View Source

    6121class Overlay(Func):
    6122    arg_types = {"this": True, "expression": True, "from": True, "for": False}

arg_types = {'this': True, 'expression': True, 'from': True, 'for': False}
key = 'overlay'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Predict(Func): View Source

    6126class Predict(Func):
    6127    arg_types = {"this": True, "expression": True, "params_struct": False}

arg_types = {'this': True, 'expression': True, 'params_struct': False}
key = 'predict'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Pow(Binary, Func): View Source

    6130class Pow(Binary, Func):
    6131    _sql_names = ["POWER", "POW"]

key = 'pow'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class PercentileCont(AggFunc): View Source

    6134class PercentileCont(AggFunc):
    6135    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'percentilecont'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class PercentileDisc(AggFunc): View Source

    6138class PercentileDisc(AggFunc):
    6139    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'percentiledisc'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Quantile(AggFunc): View Source

    6142class Quantile(AggFunc):
    6143    arg_types = {"this": True, "quantile": True}

arg_types = {'this': True, 'quantile': True}
key = 'quantile'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ApproxQuantile(Quantile): View Source

    6146class ApproxQuantile(Quantile):
    6147    arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}

arg_types = {'this': True, 'quantile': True, 'accuracy': False, 'weight': False}
key = 'approxquantile'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Quarter(Func): View Source

    6150class Quarter(Func):
    6151    pass

key = 'quarter'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Rand(Func): View Source

    6156class Rand(Func):
    6157    _sql_names = ["RAND", "RANDOM"]
    6158    arg_types = {"this": False, "lower": False, "upper": False}

arg_types = {'this': False, 'lower': False, 'upper': False}
key = 'rand'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Randn(Func): View Source

    6161class Randn(Func):
    6162    arg_types = {"this": False}

arg_types = {'this': False}
key = 'randn'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RangeN(Func): View Source

    6165class RangeN(Func):
    6166    arg_types = {"this": True, "expressions": True, "each": False}

arg_types = {'this': True, 'expressions': True, 'each': False}
key = 'rangen'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ReadCSV(Func): View Source

    6169class ReadCSV(Func):
    6170    _sql_names = ["READ_CSV"]
    6171    is_var_len_args = True
    6172    arg_types = {"this": True, "expressions": False}

is_var_len_args = True
arg_types = {'this': True, 'expressions': False}
key = 'readcsv'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Reduce(Func): View Source

    6175class Reduce(Func):
    6176    arg_types = {"this": True, "initial": True, "merge": True, "finish": False}

arg_types = {'this': True, 'initial': True, 'merge': True, 'finish': False}
key = 'reduce'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RegexpExtract(Func): View Source

    6179class RegexpExtract(Func):
    6180    arg_types = {
    6181        "this": True,
    6182        "expression": True,
    6183        "position": False,
    6184        "occurrence": False,
    6185        "parameters": False,
    6186        "group": False,
    6187    }

arg_types = {'this': True, 'expression': True, 'position': False, 'occurrence': False, 'parameters': False, 'group': False}
key = 'regexpextract'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RegexpReplace(Func): View Source

    6190class RegexpReplace(Func):
    6191    arg_types = {
    6192        "this": True,
    6193        "expression": True,
    6194        "replacement": False,
    6195        "position": False,
    6196        "occurrence": False,
    6197        "modifiers": False,
    6198    }

arg_types = {'this': True, 'expression': True, 'replacement': False, 'position': False, 'occurrence': False, 'modifiers': False}
key = 'regexpreplace'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RegexpLike(Binary, Func): View Source

    6201class RegexpLike(Binary, Func):
    6202    arg_types = {"this": True, "expression": True, "flag": False}

arg_types = {'this': True, 'expression': True, 'flag': False}
key = 'regexplike'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RegexpILike(Binary, Func): View Source

    6205class RegexpILike(Binary, Func):
    6206    arg_types = {"this": True, "expression": True, "flag": False}

arg_types = {'this': True, 'expression': True, 'flag': False}
key = 'regexpilike'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RegexpSplit(Func): View Source

    6211class RegexpSplit(Func):
    6212    arg_types = {"this": True, "expression": True, "limit": False}

arg_types = {'this': True, 'expression': True, 'limit': False}
key = 'regexpsplit'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Repeat(Func): View Source

    6215class Repeat(Func):
    6216    arg_types = {"this": True, "times": True}

arg_types = {'this': True, 'times': True}
key = 'repeat'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Round(Func): View Source

    6221class Round(Func):
    6222    arg_types = {"this": True, "decimals": False, "truncate": False}

arg_types = {'this': True, 'decimals': False, 'truncate': False}
key = 'round'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RowNumber(Func): View Source

    6225class RowNumber(Func):
    6226    arg_types: t.Dict[str, t.Any] = {}

arg_types: Dict[str, Any] = {}
key = 'rownumber'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class SafeDivide(Func): View Source

    6229class SafeDivide(Func):
    6230    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'safedivide'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class SHA(Func): View Source

    6233class SHA(Func):
    6234    _sql_names = ["SHA", "SHA1"]

key = 'sha'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class SHA2(Func): View Source

    6237class SHA2(Func):
    6238    _sql_names = ["SHA2"]
    6239    arg_types = {"this": True, "length": False}

arg_types = {'this': True, 'length': False}
key = 'sha2'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Sign(Func): View Source

    6242class Sign(Func):
    6243    _sql_names = ["SIGN", "SIGNUM"]

key = 'sign'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class SortArray(Func): View Source

    6246class SortArray(Func):
    6247    arg_types = {"this": True, "asc": False}

arg_types = {'this': True, 'asc': False}
key = 'sortarray'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Split(Func): View Source

    6250class Split(Func):
    6251    arg_types = {"this": True, "expression": True, "limit": False}

arg_types = {'this': True, 'expression': True, 'limit': False}
key = 'split'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class SplitPart(Func): View Source

    6255class SplitPart(Func):
    6256    arg_types = {"this": True, "delimiter": True, "part_index": True}

arg_types = {'this': True, 'delimiter': True, 'part_index': True}
key = 'splitpart'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Substring(Func): View Source

    6261class Substring(Func):
    6262    _sql_names = ["SUBSTRING", "SUBSTR"]
    6263    arg_types = {"this": True, "start": False, "length": False}

arg_types = {'this': True, 'start': False, 'length': False}
key = 'substring'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StandardHash(Func): View Source

    6266class StandardHash(Func):
    6267    arg_types = {"this": True, "expression": False}

arg_types = {'this': True, 'expression': False}
key = 'standardhash'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StartsWith(Func): View Source

    6270class StartsWith(Func):
    6271    _sql_names = ["STARTS_WITH", "STARTSWITH"]
    6272    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'startswith'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StrPosition(Func): View Source

    6275class StrPosition(Func):
    6276    arg_types = {
    6277        "this": True,
    6278        "substr": True,
    6279        "position": False,
    6280        "instance": False,
    6281    }

arg_types = {'this': True, 'substr': True, 'position': False, 'instance': False}
key = 'strposition'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StrToDate(Func): View Source

    6284class StrToDate(Func):
    6285    arg_types = {"this": True, "format": False, "safe": False}

arg_types = {'this': True, 'format': False, 'safe': False}
key = 'strtodate'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StrToTime(Func): View Source

    6288class StrToTime(Func):
    6289    arg_types = {"this": True, "format": True, "zone": False, "safe": False}

arg_types = {'this': True, 'format': True, 'zone': False, 'safe': False}
key = 'strtotime'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StrToUnix(Func): View Source

    6294class StrToUnix(Func):
    6295    arg_types = {"this": False, "format": False}

arg_types = {'this': False, 'format': False}
key = 'strtounix'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StrToMap(Func): View Source

    6300class StrToMap(Func):
    6301    arg_types = {
    6302        "this": True,
    6303        "pair_delim": False,
    6304        "key_value_delim": False,
    6305        "duplicate_resolution_callback": False,
    6306    }

arg_types = {'this': True, 'pair_delim': False, 'key_value_delim': False, 'duplicate_resolution_callback': False}
key = 'strtomap'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class NumberToStr(Func): View Source

    6309class NumberToStr(Func):
    6310    arg_types = {"this": True, "format": True, "culture": False}

arg_types = {'this': True, 'format': True, 'culture': False}
key = 'numbertostr'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class FromBase(Func): View Source

    6313class FromBase(Func):
    6314    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'frombase'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Struct(Func): View Source

    6317class Struct(Func):
    6318    arg_types = {"expressions": False}
    6319    is_var_len_args = True

arg_types = {'expressions': False}
is_var_len_args = True
key = 'struct'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StructExtract(Func): View Source

    6322class StructExtract(Func):
    6323    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}
key = 'structextract'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Stuff(Func): View Source

    6328class Stuff(Func):
    6329    _sql_names = ["STUFF", "INSERT"]
    6330    arg_types = {"this": True, "start": True, "length": True, "expression": True}

arg_types = {'this': True, 'start': True, 'length': True, 'expression': True}
key = 'stuff'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Sum(AggFunc): View Source

    6333class Sum(AggFunc):
    6334    pass

key = 'sum'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Sqrt(Func): View Source

    6337class Sqrt(Func):
    6338    pass

key = 'sqrt'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Stddev(AggFunc): View Source

    6341class Stddev(AggFunc):
    6342    _sql_names = ["STDDEV", "STDEV"]

key = 'stddev'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StddevPop(AggFunc): View Source

    6345class StddevPop(AggFunc):
    6346    pass

key = 'stddevpop'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StddevSamp(AggFunc): View Source

    6349class StddevSamp(AggFunc):
    6350    pass

key = 'stddevsamp'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Time(Func): View Source

    6354class Time(Func):
    6355    arg_types = {"this": False, "zone": False}

arg_types = {'this': False, 'zone': False}
key = 'time'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimeToStr(Func): View Source

    6358class TimeToStr(Func):
    6359    arg_types = {"this": True, "format": True, "culture": False, "zone": False}

arg_types = {'this': True, 'format': True, 'culture': False, 'zone': False}
key = 'timetostr'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimeToTimeStr(Func): View Source

    6362class TimeToTimeStr(Func):
    6363    pass

key = 'timetotimestr'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimeToUnix(Func): View Source

    6366class TimeToUnix(Func):
    6367    pass

key = 'timetounix'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimeStrToDate(Func): View Source

    6370class TimeStrToDate(Func):
    6371    pass

key = 'timestrtodate'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimeStrToTime(Func): View Source

    6374class TimeStrToTime(Func):
    6375    arg_types = {"this": True, "zone": False}

arg_types = {'this': True, 'zone': False}
key = 'timestrtotime'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimeStrToUnix(Func): View Source

    6378class TimeStrToUnix(Func):
    6379    pass

key = 'timestrtounix'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Trim(Func): View Source

    6382class Trim(Func):
    6383    arg_types = {
    6384        "this": True,
    6385        "expression": False,
    6386        "position": False,
    6387        "collation": False,
    6388    }

arg_types = {'this': True, 'expression': False, 'position': False, 'collation': False}
key = 'trim'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TsOrDsAdd(Func, TimeUnit): View Source

    6391class TsOrDsAdd(Func, TimeUnit):
    6392    # return_type is used to correctly cast the arguments of this expression when transpiling it
    6393    arg_types = {"this": True, "expression": True, "unit": False, "return_type": False}
    6394
    6395    @property
    6396    def return_type(self) -> DataType:
    6397        return DataType.build(self.args.get("return_type") or DataType.Type.DATE)

arg_types = {'this': True, 'expression': True, 'unit': False, 'return_type': False}
return_type: DataType View Source

    6395    @property
    6396    def return_type(self) -> DataType:
    6397        return DataType.build(self.args.get("return_type") or DataType.Type.DATE)

key = 'tsordsadd'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TsOrDsDiff(Func, TimeUnit): View Source

    6400class TsOrDsDiff(Func, TimeUnit):
    6401    arg_types = {"this": True, "expression": True, "unit": False}

arg_types = {'this': True, 'expression': True, 'unit': False}
key = 'tsordsdiff'

##### Inherited Members

TimeUnit
  TimeUnit
  UNABBREVIATED_UNIT_NAME
  VAR_LIKE
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TsOrDsToDateStr(Func): View Source

    6404class TsOrDsToDateStr(Func):
    6405    pass

key = 'tsordstodatestr'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TsOrDsToDate(Func): View Source

    6408class TsOrDsToDate(Func):
    6409    arg_types = {"this": True, "format": False, "safe": False}

arg_types = {'this': True, 'format': False, 'safe': False}
key = 'tsordstodate'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TsOrDsToTime(Func): View Source

    6412class TsOrDsToTime(Func):
    6413    pass

key = 'tsordstotime'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TsOrDsToTimestamp(Func): View Source

    6416class TsOrDsToTimestamp(Func):
    6417    pass

key = 'tsordstotimestamp'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TsOrDiToDi(Func): View Source

    6420class TsOrDiToDi(Func):
    6421    pass

key = 'tsorditodi'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Unhex(Func): View Source

    6424class Unhex(Func):
    6425    pass

key = 'unhex'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class UnixDate(Func): View Source

    6429class UnixDate(Func):
    6430    pass

key = 'unixdate'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class UnixToStr(Func): View Source

    6433class UnixToStr(Func):
    6434    arg_types = {"this": True, "format": False}

arg_types = {'this': True, 'format': False}
key = 'unixtostr'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class UnixToTime(Func): View Source

    6439class UnixToTime(Func):
    6440    arg_types = {
    6441        "this": True,
    6442        "scale": False,
    6443        "zone": False,
    6444        "hours": False,
    6445        "minutes": False,
    6446        "format": False,
    6447    }
    6448
    6449    SECONDS = Literal.number(0)
    6450    DECIS = Literal.number(1)
    6451    CENTIS = Literal.number(2)
    6452    MILLIS = Literal.number(3)
    6453    DECIMILLIS = Literal.number(4)
    6454    CENTIMILLIS = Literal.number(5)
    6455    MICROS = Literal.number(6)
    6456    DECIMICROS = Literal.number(7)
    6457    CENTIMICROS = Literal.number(8)
    6458    NANOS = Literal.number(9)

arg_types = {'this': True, 'scale': False, 'zone': False, 'hours': False, 'minutes': False, 'format': False}
SECONDS = Literal(this=0, is_string=False)
DECIS = Literal(this=1, is_string=False)
CENTIS = Literal(this=2, is_string=False)
MILLIS = Literal(this=3, is_string=False)
DECIMILLIS = Literal(this=4, is_string=False)
CENTIMILLIS = Literal(this=5, is_string=False)
MICROS = Literal(this=6, is_string=False)
DECIMICROS = Literal(this=7, is_string=False)
CENTIMICROS = Literal(this=8, is_string=False)
NANOS = Literal(this=9, is_string=False)
key = 'unixtotime'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class UnixToTimeStr(Func): View Source

    6461class UnixToTimeStr(Func):
    6462    pass

key = 'unixtotimestr'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Uuid(Func): View Source

    6465class Uuid(Func):
    6466    _sql_names = ["UUID", "GEN_RANDOM_UUID", "GENERATE_UUID", "UUID_STRING"]
    6467
    6468    arg_types = {"this": False, "name": False}

arg_types = {'this': False, 'name': False}
key = 'uuid'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TimestampFromParts(Func): View Source

    6471class TimestampFromParts(Func):
    6472    _sql_names = ["TIMESTAMP_FROM_PARTS", "TIMESTAMPFROMPARTS"]
    6473    arg_types = {
    6474        "year": True,
    6475        "month": True,
    6476        "day": True,
    6477        "hour": True,
    6478        "min": True,
    6479        "sec": True,
    6480        "nano": False,
    6481        "zone": False,
    6482        "milli": False,
    6483    }

arg_types = {'year': True, 'month': True, 'day': True, 'hour': True, 'min': True, 'sec': True, 'nano': False, 'zone': False, 'milli': False}
key = 'timestampfromparts'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Upper(Func): View Source

    6486class Upper(Func):
    6487    _sql_names = ["UPPER", "UCASE"]

key = 'upper'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Corr(Binary, AggFunc): View Source

    6490class Corr(Binary, AggFunc):
    6491    pass

key = 'corr'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Variance(AggFunc): View Source

    6494class Variance(AggFunc):
    6495    _sql_names = ["VARIANCE", "VARIANCE_SAMP", "VAR_SAMP"]

key = 'variance'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class VariancePop(AggFunc): View Source

    6498class VariancePop(AggFunc):
    6499    _sql_names = ["VARIANCE_POP", "VAR_POP"]

key = 'variancepop'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CovarSamp(Binary, AggFunc): View Source

    6502class CovarSamp(Binary, AggFunc):
    6503    pass

key = 'covarsamp'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CovarPop(Binary, AggFunc): View Source

    6506class CovarPop(Binary, AggFunc):
    6507    pass

key = 'covarpop'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Week(Func): View Source

    6510class Week(Func):
    6511    arg_types = {"this": True, "mode": False}

arg_types = {'this': True, 'mode': False}
key = 'week'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class XMLTable(Func): View Source

    6514class XMLTable(Func):
    6515    arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}

arg_types = {'this': True, 'passing': False, 'columns': False, 'by_ref': False}
key = 'xmltable'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Year(Func): View Source

    6518class Year(Func):
    6519    pass

key = 'year'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Use(Expression): View Source

    6522class Use(Expression):
    6523    arg_types = {"this": True, "kind": False}

arg_types = {'this': True, 'kind': False}
key = 'use'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Merge(DML): View Source

    6526class Merge(DML):
    6527    arg_types = {
    6528        "this": True,
    6529        "using": True,
    6530        "on": True,
    6531        "expressions": True,
    6532        "with": False,
    6533        "returning": False,
    6534    }

arg_types = {'this': True, 'using': True, 'on': True, 'expressions': True, 'with': False, 'returning': False}
key = 'merge'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class When(Func): View Source

    6537class When(Func):
    6538    arg_types = {"matched": True, "source": False, "condition": False, "then": True}

arg_types = {'matched': True, 'source': False, 'condition': False, 'then': True}
key = 'when'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class NextValueFor(Func): View Source

    6543class NextValueFor(Func):
    6544    arg_types = {"this": True, "order": False}

arg_types = {'this': True, 'order': False}
key = 'nextvaluefor'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Semicolon(Expression): View Source

    6549class Semicolon(Expression):
    6550    arg_types = {}

arg_types = {}
key = 'semicolon'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  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
  copy
  add_comments
  pop_comments
  append
  set
  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
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

ALL_FUNCTIONS = [<class 'Abs'>, <class 'AddMonths'>, <class 'AnonymousAggFunc'>, <class 'AnyValue'>, <class 'Apply'>, <class 'ApproxDistinct'>, <class 'ApproxQuantile'>, <class 'ApproxTopK'>, <class 'ArgMax'>, <class 'ArgMin'>, <class 'Array'>, <class 'ArrayAgg'>, <class 'ArrayAll'>, <class 'ArrayAny'>, <class 'ArrayConcat'>, <class 'ArrayConstructCompact'>, <class 'ArrayContains'>, <class 'ArrayContainsAll'>, <class 'ArrayFilter'>, <class 'ArrayOverlaps'>, <class 'ArraySize'>, <class 'ArraySort'>, <class 'ArraySum'>, <class 'ArrayToString'>, <class 'ArrayUnionAgg'>, <class 'ArrayUniqueAgg'>, <class 'Avg'>, <class 'Case'>, <class 'Cast'>, <class 'CastToStrType'>, <class 'Cbrt'>, <class 'Ceil'>, <class 'Chr'>, <class 'Coalesce'>, <class 'Collate'>, <class 'Columns'>, <class 'CombinedAggFunc'>, <class 'CombinedParameterizedAgg'>, <class 'Concat'>, <class 'ConcatWs'>, <class 'ConnectByRoot'>, <class 'Convert'>, <class 'ConvertTimezone'>, <class 'Corr'>, <class 'Count'>, <class 'CountIf'>, <class 'CovarPop'>, <class 'CovarSamp'>, <class 'CurrentDate'>, <class 'CurrentDatetime'>, <class 'CurrentTime'>, <class 'CurrentTimestamp'>, <class 'CurrentUser'>, <class 'Date'>, <class 'DateAdd'>, <class 'DateDiff'>, <class 'DateFromParts'>, <class 'DateStrToDate'>, <class 'DateSub'>, <class 'DateToDateStr'>, <class 'DateToDi'>, <class 'DateTrunc'>, <class 'Datetime'>, <class 'DatetimeAdd'>, <class 'DatetimeDiff'>, <class 'DatetimeSub'>, <class 'DatetimeTrunc'>, <class 'Day'>, <class 'DayOfMonth'>, <class 'DayOfWeek'>, <class 'DayOfWeekIso'>, <class 'DayOfYear'>, <class 'Decode'>, <class 'DiToDate'>, <class 'Encode'>, <class 'Exp'>, <class 'Explode'>, <class 'ExplodeOuter'>, <class 'ExplodingGenerateSeries'>, <class 'Extract'>, <class 'First'>, <class 'FirstValue'>, <class 'Flatten'>, <class 'Floor'>, <class 'FromBase'>, <class 'FromBase64'>, <class 'FromISO8601Timestamp'>, <class 'GapFill'>, <class 'GenerateDateArray'>, <class 'GenerateSeries'>, <class 'GenerateTimestampArray'>, <class 'Greatest'>, <class 'GroupConcat'>, <class 'Hex'>, <class 'Hll'>, <class 'If'>, <class 'Initcap'>, <class 'Inline'>, <class 'IsInf'>, <class 'IsNan'>, <class 'JSONArray'>, <class 'JSONArrayAgg'>, <class 'JSONArrayContains'>, <class 'JSONBContains'>, <class 'JSONBExtract'>, <class 'JSONBExtractScalar'>, <class 'JSONExists'>, <class 'JSONExtract'>, <class 'JSONExtractScalar'>, <class 'JSONFormat'>, <class 'JSONObject'>, <class 'JSONObjectAgg'>, <class 'JSONTable'>, <class 'Lag'>, <class 'Last'>, <class 'LastDay'>, <class 'LastValue'>, <class 'Lead'>, <class 'Least'>, <class 'Left'>, <class 'Length'>, <class 'Levenshtein'>, <class 'List'>, <class 'Ln'>, <class 'Log'>, <class 'LogicalAnd'>, <class 'LogicalOr'>, <class 'Lower'>, <class 'LowerHex'>, <class 'MD5'>, <class 'MD5Digest'>, <class 'Map'>, <class 'MapFromEntries'>, <class 'MatchAgainst'>, <class 'Max'>, <class 'Min'>, <class 'Month'>, <class 'MonthsBetween'>, <class 'NextValueFor'>, <class 'Normalize'>, <class 'NthValue'>, <class 'Nullif'>, <class 'NumberToStr'>, <class 'Nvl2'>, <class 'ObjectInsert'>, <class 'OpenJSON'>, <class 'Overlay'>, <class 'Pad'>, <class 'ParameterizedAgg'>, <class 'ParseJSON'>, <class 'PercentileCont'>, <class 'PercentileDisc'>, <class 'Posexplode'>, <class 'PosexplodeOuter'>, <class 'Pow'>, <class 'Predict'>, <class 'Quantile'>, <class 'Quarter'>, <class 'Rand'>, <class 'Randn'>, <class 'RangeN'>, <class 'ReadCSV'>, <class 'Reduce'>, <class 'RegexpExtract'>, <class 'RegexpILike'>, <class 'RegexpLike'>, <class 'RegexpReplace'>, <class 'RegexpSplit'>, <class 'Repeat'>, <class 'Right'>, <class 'Round'>, <class 'RowNumber'>, <class 'SHA'>, <class 'SHA2'>, <class 'SafeDivide'>, <class 'Sign'>, <class 'SortArray'>, <class 'Split'>, <class 'SplitPart'>, <class 'Sqrt'>, <class 'StandardHash'>, <class 'StarMap'>, <class 'StartsWith'>, <class 'Stddev'>, <class 'StddevPop'>, <class 'StddevSamp'>, <class 'StrPosition'>, <class 'StrToDate'>, <class 'StrToMap'>, <class 'StrToTime'>, <class 'StrToUnix'>, <class 'StringToArray'>, <class 'Struct'>, <class 'StructExtract'>, <class 'Stuff'>, <class 'Substring'>, <class 'Sum'>, <class 'Time'>, <class 'TimeAdd'>, <class 'TimeDiff'>, <class 'TimeFromParts'>, <class 'TimeStrToDate'>, <class 'TimeStrToTime'>, <class 'TimeStrToUnix'>, <class 'TimeSub'>, <class 'TimeToStr'>, <class 'TimeToTimeStr'>, <class 'TimeToUnix'>, <class 'TimeTrunc'>, <class 'Timestamp'>, <class 'TimestampAdd'>, <class 'TimestampDiff'>, <class 'TimestampFromParts'>, <class 'TimestampSub'>, <class 'TimestampTrunc'>, <class 'ToArray'>, <class 'ToBase64'>, <class 'ToChar'>, <class 'ToDays'>, <class 'ToMap'>, <class 'ToNumber'>, <class 'Transform'>, <class 'Trim'>, <class 'Try'>, <class 'TryCast'>, <class 'TsOrDiToDi'>, <class 'TsOrDsAdd'>, <class 'TsOrDsDiff'>, <class 'TsOrDsToDate'>, <class 'TsOrDsToDateStr'>, <class 'TsOrDsToTime'>, <class 'TsOrDsToTimestamp'>, <class 'Unhex'>, <class 'UnixDate'>, <class 'UnixToStr'>, <class 'UnixToTime'>, <class 'UnixToTimeStr'>, <class 'Unnest'>, <class 'Upper'>, <class 'Uuid'>, <class 'VarMap'>, <class 'Variance'>, <class 'VariancePop'>, <class 'Week'>, <class 'WeekOfYear'>, <class 'When'>, <class 'XMLTable'>, <class 'Xor'>, <class 'Year'>]
FUNCTION_BY_NAME = {'ABS': <class 'Abs'>, 'ADD_MONTHS': <class 'AddMonths'>, 'ANONYMOUS_AGG_FUNC': <class 'AnonymousAggFunc'>, 'ANY_VALUE': <class 'AnyValue'>, 'APPLY': <class 'Apply'>, 'APPROX_DISTINCT': <class 'ApproxDistinct'>, 'APPROX_COUNT_DISTINCT': <class 'ApproxDistinct'>, 'APPROX_QUANTILE': <class 'ApproxQuantile'>, 'APPROX_TOP_K': <class 'ApproxTopK'>, 'ARG_MAX': <class 'ArgMax'>, 'ARGMAX': <class 'ArgMax'>, 'MAX_BY': <class 'ArgMax'>, 'ARG_MIN': <class 'ArgMin'>, 'ARGMIN': <class 'ArgMin'>, 'MIN_BY': <class 'ArgMin'>, 'ARRAY': <class 'Array'>, 'ARRAY_AGG': <class 'ArrayAgg'>, 'ARRAY_ALL': <class 'ArrayAll'>, 'ARRAY_ANY': <class 'ArrayAny'>, 'ARRAY_CONCAT': <class 'ArrayConcat'>, 'ARRAY_CAT': <class 'ArrayConcat'>, 'ARRAY_CONSTRUCT_COMPACT': <class 'ArrayConstructCompact'>, 'ARRAY_CONTAINS': <class 'ArrayContains'>, 'ARRAY_HAS': <class 'ArrayContains'>, 'ARRAY_CONTAINS_ALL': <class 'ArrayContainsAll'>, 'ARRAY_HAS_ALL': <class 'ArrayContainsAll'>, 'FILTER': <class 'ArrayFilter'>, 'ARRAY_FILTER': <class 'ArrayFilter'>, 'ARRAY_OVERLAPS': <class 'ArrayOverlaps'>, 'ARRAY_SIZE': <class 'ArraySize'>, 'ARRAY_LENGTH': <class 'ArraySize'>, 'ARRAY_SORT': <class 'ArraySort'>, 'ARRAY_SUM': <class 'ArraySum'>, 'ARRAY_TO_STRING': <class 'ArrayToString'>, 'ARRAY_JOIN': <class 'ArrayToString'>, 'ARRAY_UNION_AGG': <class 'ArrayUnionAgg'>, 'ARRAY_UNIQUE_AGG': <class 'ArrayUniqueAgg'>, 'AVG': <class 'Avg'>, 'CASE': <class 'Case'>, 'CAST': <class 'Cast'>, 'CAST_TO_STR_TYPE': <class 'CastToStrType'>, 'CBRT': <class 'Cbrt'>, 'CEIL': <class 'Ceil'>, 'CEILING': <class 'Ceil'>, 'CHR': <class 'Chr'>, 'CHAR': <class 'Chr'>, 'COALESCE': <class 'Coalesce'>, 'IFNULL': <class 'Coalesce'>, 'NVL': <class 'Coalesce'>, 'COLLATE': <class 'Collate'>, 'COLUMNS': <class 'Columns'>, 'COMBINED_AGG_FUNC': <class 'CombinedAggFunc'>, 'COMBINED_PARAMETERIZED_AGG': <class 'CombinedParameterizedAgg'>, 'CONCAT': <class 'Concat'>, 'CONCAT_WS': <class 'ConcatWs'>, 'CONNECT_BY_ROOT': <class 'ConnectByRoot'>, 'CONVERT': <class 'Convert'>, 'CONVERT_TIMEZONE': <class 'ConvertTimezone'>, 'CORR': <class 'Corr'>, 'COUNT': <class 'Count'>, 'COUNT_IF': <class 'CountIf'>, 'COUNTIF': <class 'CountIf'>, 'COVAR_POP': <class 'CovarPop'>, 'COVAR_SAMP': <class 'CovarSamp'>, 'CURRENT_DATE': <class 'CurrentDate'>, 'CURRENT_DATETIME': <class 'CurrentDatetime'>, 'CURRENT_TIME': <class 'CurrentTime'>, 'CURRENT_TIMESTAMP': <class 'CurrentTimestamp'>, 'CURRENT_USER': <class 'CurrentUser'>, 'DATE': <class 'Date'>, 'DATE_ADD': <class 'DateAdd'>, 'DATEDIFF': <class 'DateDiff'>, 'DATE_DIFF': <class 'DateDiff'>, 'DATE_FROM_PARTS': <class 'DateFromParts'>, 'DATEFROMPARTS': <class 'DateFromParts'>, 'DATE_STR_TO_DATE': <class 'DateStrToDate'>, 'DATE_SUB': <class 'DateSub'>, 'DATE_TO_DATE_STR': <class 'DateToDateStr'>, 'DATE_TO_DI': <class 'DateToDi'>, 'DATE_TRUNC': <class 'DateTrunc'>, 'DATETIME': <class 'Datetime'>, 'DATETIME_ADD': <class 'DatetimeAdd'>, 'DATETIME_DIFF': <class 'DatetimeDiff'>, 'DATETIME_SUB': <class 'DatetimeSub'>, 'DATETIME_TRUNC': <class 'DatetimeTrunc'>, 'DAY': <class 'Day'>, 'DAY_OF_MONTH': <class 'DayOfMonth'>, 'DAYOFMONTH': <class 'DayOfMonth'>, 'DAY_OF_WEEK': <class 'DayOfWeek'>, 'DAYOFWEEK': <class 'DayOfWeek'>, 'DAYOFWEEK_ISO': <class 'DayOfWeekIso'>, 'ISODOW': <class 'DayOfWeekIso'>, 'DAY_OF_YEAR': <class 'DayOfYear'>, 'DAYOFYEAR': <class 'DayOfYear'>, 'DECODE': <class 'Decode'>, 'DI_TO_DATE': <class 'DiToDate'>, 'ENCODE': <class 'Encode'>, 'EXP': <class 'Exp'>, 'EXPLODE': <class 'Explode'>, 'EXPLODE_OUTER': <class 'ExplodeOuter'>, 'EXPLODING_GENERATE_SERIES': <class 'ExplodingGenerateSeries'>, 'EXTRACT': <class 'Extract'>, 'FIRST': <class 'First'>, 'FIRST_VALUE': <class 'FirstValue'>, 'FLATTEN': <class 'Flatten'>, 'FLOOR': <class 'Floor'>, 'FROM_BASE': <class 'FromBase'>, 'FROM_BASE64': <class 'FromBase64'>, 'FROM_ISO8601_TIMESTAMP': <class 'FromISO8601Timestamp'>, 'GAP_FILL': <class 'GapFill'>, 'GENERATE_DATE_ARRAY': <class 'GenerateDateArray'>, 'GENERATE_SERIES': <class 'GenerateSeries'>, 'GENERATE_TIMESTAMP_ARRAY': <class 'GenerateTimestampArray'>, 'GREATEST': <class 'Greatest'>, 'GROUP_CONCAT': <class 'GroupConcat'>, 'HEX': <class 'Hex'>, 'HLL': <class 'Hll'>, 'IF': <class 'If'>, 'IIF': <class 'If'>, 'INITCAP': <class 'Initcap'>, 'INLINE': <class 'Inline'>, 'IS_INF': <class 'IsInf'>, 'ISINF': <class 'IsInf'>, 'IS_NAN': <class 'IsNan'>, 'ISNAN': <class 'IsNan'>, 'J_S_O_N_ARRAY': <class 'JSONArray'>, 'J_S_O_N_ARRAY_AGG': <class 'JSONArrayAgg'>, 'JSON_ARRAY_CONTAINS': <class 'JSONArrayContains'>, 'JSONB_CONTAINS': <class 'JSONBContains'>, 'JSONB_EXTRACT': <class 'JSONBExtract'>, 'JSONB_EXTRACT_SCALAR': <class 'JSONBExtractScalar'>, 'J_S_O_N_EXISTS': <class 'JSONExists'>, 'JSON_EXTRACT': <class 'JSONExtract'>, 'JSON_EXTRACT_SCALAR': <class 'JSONExtractScalar'>, 'JSON_FORMAT': <class 'JSONFormat'>, 'J_S_O_N_OBJECT': <class 'JSONObject'>, 'J_S_O_N_OBJECT_AGG': <class 'JSONObjectAgg'>, 'J_S_O_N_TABLE': <class 'JSONTable'>, 'LAG': <class 'Lag'>, 'LAST': <class 'Last'>, 'LAST_DAY': <class 'LastDay'>, 'LAST_DAY_OF_MONTH': <class 'LastDay'>, 'LAST_VALUE': <class 'LastValue'>, 'LEAD': <class 'Lead'>, 'LEAST': <class 'Least'>, 'LEFT': <class 'Left'>, 'LENGTH': <class 'Length'>, 'LEN': <class 'Length'>, 'LEVENSHTEIN': <class 'Levenshtein'>, 'LIST': <class 'List'>, 'LN': <class 'Ln'>, 'LOG': <class 'Log'>, 'LOGICAL_AND': <class 'LogicalAnd'>, 'BOOL_AND': <class 'LogicalAnd'>, 'BOOLAND_AGG': <class 'LogicalAnd'>, 'LOGICAL_OR': <class 'LogicalOr'>, 'BOOL_OR': <class 'LogicalOr'>, 'BOOLOR_AGG': <class 'LogicalOr'>, 'LOWER': <class 'Lower'>, 'LCASE': <class 'Lower'>, 'LOWER_HEX': <class 'LowerHex'>, 'MD5': <class 'MD5'>, 'MD5_DIGEST': <class 'MD5Digest'>, 'MAP': <class 'Map'>, 'MAP_FROM_ENTRIES': <class 'MapFromEntries'>, 'MATCH_AGAINST': <class 'MatchAgainst'>, 'MAX': <class 'Max'>, 'MIN': <class 'Min'>, 'MONTH': <class 'Month'>, 'MONTHS_BETWEEN': <class 'MonthsBetween'>, 'NEXT_VALUE_FOR': <class 'NextValueFor'>, 'NORMALIZE': <class 'Normalize'>, 'NTH_VALUE': <class 'NthValue'>, 'NULLIF': <class 'Nullif'>, 'NUMBER_TO_STR': <class 'NumberToStr'>, 'NVL2': <class 'Nvl2'>, 'OBJECT_INSERT': <class 'ObjectInsert'>, 'OPEN_J_S_O_N': <class 'OpenJSON'>, 'OVERLAY': <class 'Overlay'>, 'PAD': <class 'Pad'>, 'PARAMETERIZED_AGG': <class 'ParameterizedAgg'>, 'PARSE_JSON': <class 'ParseJSON'>, 'JSON_PARSE': <class 'ParseJSON'>, 'PERCENTILE_CONT': <class 'PercentileCont'>, 'PERCENTILE_DISC': <class 'PercentileDisc'>, 'POSEXPLODE': <class 'Posexplode'>, 'POSEXPLODE_OUTER': <class 'PosexplodeOuter'>, 'POWER': <class 'Pow'>, 'POW': <class 'Pow'>, 'PREDICT': <class 'Predict'>, 'QUANTILE': <class 'Quantile'>, 'QUARTER': <class 'Quarter'>, 'RAND': <class 'Rand'>, 'RANDOM': <class 'Rand'>, 'RANDN': <class 'Randn'>, 'RANGE_N': <class 'RangeN'>, 'READ_CSV': <class 'ReadCSV'>, 'REDUCE': <class 'Reduce'>, 'REGEXP_EXTRACT': <class 'RegexpExtract'>, 'REGEXP_I_LIKE': <class 'RegexpILike'>, 'REGEXP_LIKE': <class 'RegexpLike'>, 'REGEXP_REPLACE': <class 'RegexpReplace'>, 'REGEXP_SPLIT': <class 'RegexpSplit'>, 'REPEAT': <class 'Repeat'>, 'RIGHT': <class 'Right'>, 'ROUND': <class 'Round'>, 'ROW_NUMBER': <class 'RowNumber'>, 'SHA': <class 'SHA'>, 'SHA1': <class 'SHA'>, 'SHA2': <class 'SHA2'>, 'SAFE_DIVIDE': <class 'SafeDivide'>, 'SIGN': <class 'Sign'>, 'SIGNUM': <class 'Sign'>, 'SORT_ARRAY': <class 'SortArray'>, 'SPLIT': <class 'Split'>, 'SPLIT_PART': <class 'SplitPart'>, 'SQRT': <class 'Sqrt'>, 'STANDARD_HASH': <class 'StandardHash'>, 'STAR_MAP': <class 'StarMap'>, 'STARTS_WITH': <class 'StartsWith'>, 'STARTSWITH': <class 'StartsWith'>, 'STDDEV': <class 'Stddev'>, 'STDEV': <class 'Stddev'>, 'STDDEV_POP': <class 'StddevPop'>, 'STDDEV_SAMP': <class 'StddevSamp'>, 'STR_POSITION': <class 'StrPosition'>, 'STR_TO_DATE': <class 'StrToDate'>, 'STR_TO_MAP': <class 'StrToMap'>, 'STR_TO_TIME': <class 'StrToTime'>, 'STR_TO_UNIX': <class 'StrToUnix'>, 'STRING_TO_ARRAY': <class 'StringToArray'>, 'SPLIT_BY_STRING': <class 'StringToArray'>, 'STRUCT': <class 'Struct'>, 'STRUCT_EXTRACT': <class 'StructExtract'>, 'STUFF': <class 'Stuff'>, 'INSERT': <class 'Stuff'>, 'SUBSTRING': <class 'Substring'>, 'SUBSTR': <class 'Substring'>, 'SUM': <class 'Sum'>, 'TIME': <class 'Time'>, 'TIME_ADD': <class 'TimeAdd'>, 'TIME_DIFF': <class 'TimeDiff'>, 'TIME_FROM_PARTS': <class 'TimeFromParts'>, 'TIMEFROMPARTS': <class 'TimeFromParts'>, 'TIME_STR_TO_DATE': <class 'TimeStrToDate'>, 'TIME_STR_TO_TIME': <class 'TimeStrToTime'>, 'TIME_STR_TO_UNIX': <class 'TimeStrToUnix'>, 'TIME_SUB': <class 'TimeSub'>, 'TIME_TO_STR': <class 'TimeToStr'>, 'TIME_TO_TIME_STR': <class 'TimeToTimeStr'>, 'TIME_TO_UNIX': <class 'TimeToUnix'>, 'TIME_TRUNC': <class 'TimeTrunc'>, 'TIMESTAMP': <class 'Timestamp'>, 'TIMESTAMP_ADD': <class 'TimestampAdd'>, 'TIMESTAMPDIFF': <class 'TimestampDiff'>, 'TIMESTAMP_DIFF': <class 'TimestampDiff'>, 'TIMESTAMP_FROM_PARTS': <class 'TimestampFromParts'>, 'TIMESTAMPFROMPARTS': <class 'TimestampFromParts'>, 'TIMESTAMP_SUB': <class 'TimestampSub'>, 'TIMESTAMP_TRUNC': <class 'TimestampTrunc'>, 'TO_ARRAY': <class 'ToArray'>, 'TO_BASE64': <class 'ToBase64'>, 'TO_CHAR': <class 'ToChar'>, 'TO_DAYS': <class 'ToDays'>, 'TO_MAP': <class 'ToMap'>, 'TO_NUMBER': <class 'ToNumber'>, 'TRANSFORM': <class 'Transform'>, 'TRIM': <class 'Trim'>, 'TRY': <class 'Try'>, 'TRY_CAST': <class 'TryCast'>, 'TS_OR_DI_TO_DI': <class 'TsOrDiToDi'>, 'TS_OR_DS_ADD': <class 'TsOrDsAdd'>, 'TS_OR_DS_DIFF': <class 'TsOrDsDiff'>, 'TS_OR_DS_TO_DATE': <class 'TsOrDsToDate'>, 'TS_OR_DS_TO_DATE_STR': <class 'TsOrDsToDateStr'>, 'TS_OR_DS_TO_TIME': <class 'TsOrDsToTime'>, 'TS_OR_DS_TO_TIMESTAMP': <class 'TsOrDsToTimestamp'>, 'UNHEX': <class 'Unhex'>, 'UNIX_DATE': <class 'UnixDate'>, 'UNIX_TO_STR': <class 'UnixToStr'>, 'UNIX_TO_TIME': <class 'UnixToTime'>, 'UNIX_TO_TIME_STR': <class 'UnixToTimeStr'>, 'UNNEST': <class 'Unnest'>, 'UPPER': <class 'Upper'>, 'UCASE': <class 'Upper'>, 'UUID': <class 'Uuid'>, 'GEN_RANDOM_UUID': <class 'Uuid'>, 'GENERATE_UUID': <class 'Uuid'>, 'UUID_STRING': <class 'Uuid'>, 'VAR_MAP': <class 'VarMap'>, 'VARIANCE': <class 'Variance'>, 'VARIANCE_SAMP': <class 'Variance'>, 'VAR_SAMP': <class 'Variance'>, 'VARIANCE_POP': <class 'VariancePop'>, 'VAR_POP': <class 'VariancePop'>, 'WEEK': <class 'Week'>, 'WEEK_OF_YEAR': <class 'WeekOfYear'>, 'WEEKOFYEAR': <class 'WeekOfYear'>, 'WHEN': <class 'When'>, 'X_M_L_TABLE': <class 'XMLTable'>, 'XOR': <class 'Xor'>, 'YEAR': <class 'Year'>}
JSON_PATH_PARTS = [<class 'JSONPathFilter'>, <class 'JSONPathKey'>, <class 'JSONPathRecursive'>, <class 'JSONPathRoot'>, <class 'JSONPathScript'>, <class 'JSONPathSelector'>, <class 'JSONPathSlice'>, <class 'JSONPathSubscript'>, <class 'JSONPathUnion'>, <class 'JSONPathWildcard'>]
PERCENTILES = (<class 'PercentileCont'>, <class 'PercentileDisc'>)
def maybe_parse( sql_or_expression: Union[str, Expression], *, into: Union[str, Type[Expression], Collection[Union[str, Type[Expression]]], NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, prefix: Optional[str] = None, copy: bool = False, **opts) -> Expression: View Source

    6590def maybe_parse(
    6591    sql_or_expression: ExpOrStr,
    6592    *,
    6593    into: t.Optional[IntoType] = None,
    6594    dialect: DialectType = None,
    6595    prefix: t.Optional[str] = None,
    6596    copy: bool = False,
    6597    **opts,
    6598) -> Expression:
    6599    """Gracefully handle a possible string or expression.
    6600
    6601    Example:
    6602        >>> maybe_parse("1")
    6603        Literal(this=1, is_string=False)
    6604        >>> maybe_parse(to_identifier("x"))
    6605        Identifier(this=x, quoted=False)
    6606
    6607    Args:
    6608        sql_or_expression: the SQL code string or an expression
    6609        into: the SQLGlot Expression to parse into
    6610        dialect: the dialect used to parse the input expressions (in the case that an
    6611            input expression is a SQL string).
    6612        prefix: a string to prefix the sql with before it gets parsed
    6613            (automatically includes a space)
    6614        copy: whether to copy the expression.
    6615        **opts: other options to use to parse the input expressions (again, in the case
    6616            that an input expression is a SQL string).
    6617
    6618    Returns:
    6619        Expression: the parsed or given expression.
    6620    """
    6621    if isinstance(sql_or_expression, Expression):
    6622        if copy:
    6623            return sql_or_expression.copy()
    6624        return sql_or_expression
    6625
    6626    if sql_or_expression is None:
    6627        raise ParseError("SQL cannot be None")
    6628
    6629    import sqlglot
    6630
    6631    sql = str(sql_or_expression)
    6632    if prefix:
    6633        sql = f"{prefix} {sql}"
    6634
    6635    return sqlglot.parse_one(sql, read=dialect, into=into, **opts)

Gracefully handle a possible string or expression.

###### Example:

>     >>> maybe_parse("1")
>     Literal(this=1, is_string=False)
>     >>> maybe_parse(to_identifier("x"))
>     Identifier(this=x, quoted=False)

###### Arguments:

- sql_or_expression: the SQL code string or an expression
- into: the SQLGlot Expression to parse into
- dialect: the dialect used to parse the input expressions (in the case that an input expression is a SQL string).
- prefix: a string to prefix the sql with before it gets parsed (automatically includes a space)
- copy: whether to copy the expression.
- **opts: other options to use to parse the input expressions (again, in the case that an input expression is a SQL string).

###### Returns:

> Expression: the parsed or given expression.

def maybe_copy(instance, copy=True): View Source

    6646def maybe_copy(instance, copy=True):
    6647    return instance.copy() if copy and instance else instance

def union( *expressions: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Union: View Source

    6882def union(
    6883    *expressions: ExpOrStr,
    6884    distinct: bool = True,
    6885    dialect: DialectType = None,
    6886    copy: bool = True,
    6887    **opts,
    6888) -> Union:
    6889    """
    6890    Initializes a syntax tree for the `UNION` operation.
    6891
    6892    Example:
    6893        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6894        'SELECT * FROM foo UNION SELECT * FROM bla'
    6895
    6896    Args:
    6897        expressions: the SQL code strings, corresponding to the `UNION`'s operands.
    6898            If `Expression` instances are passed, they will be used as-is.
    6899        distinct: set the DISTINCT flag if and only if this is true.
    6900        dialect: the dialect used to parse the input expression.
    6901        copy: whether to copy the expression.
    6902        opts: other options to use to parse the input expressions.
    6903
    6904    Returns:
    6905        The new Union instance.
    6906    """
    6907    assert len(expressions) >= 2, "At least two expressions are required by `union`."
    6908    return _apply_set_operation(
    6909        *expressions, set_operation=Union, distinct=distinct, dialect=dialect, copy=copy, **opts
    6910    )

Initializes a syntax tree for the `UNION` operation.

###### Example:

>     >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
>     'SELECT * FROM foo UNION SELECT * FROM bla'

###### Arguments:

- expressions: the SQL code strings, corresponding to the `UNION`'s operands. If `Expression` instances are passed, they will be used as-is.
- distinct: set the DISTINCT flag if and only if this is true.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy the expression.
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Union instance.

def intersect( *expressions: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Intersect: View Source

    6913def intersect(
    6914    *expressions: ExpOrStr,
    6915    distinct: bool = True,
    6916    dialect: DialectType = None,
    6917    copy: bool = True,
    6918    **opts,
    6919) -> Intersect:
    6920    """
    6921    Initializes a syntax tree for the `INTERSECT` operation.
    6922
    6923    Example:
    6924        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6925        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    6926
    6927    Args:
    6928        expressions: the SQL code strings, corresponding to the `INTERSECT`'s operands.
    6929            If `Expression` instances are passed, they will be used as-is.
    6930        distinct: set the DISTINCT flag if and only if this is true.
    6931        dialect: the dialect used to parse the input expression.
    6932        copy: whether to copy the expression.
    6933        opts: other options to use to parse the input expressions.
    6934
    6935    Returns:
    6936        The new Intersect instance.
    6937    """
    6938    assert len(expressions) >= 2, "At least two expressions are required by `intersect`."
    6939    return _apply_set_operation(
    6940        *expressions, set_operation=Intersect, distinct=distinct, dialect=dialect, copy=copy, **opts
    6941    )

Initializes a syntax tree for the `INTERSECT` operation.

###### Example:

>     >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
>     'SELECT * FROM foo INTERSECT SELECT * FROM bla'

###### Arguments:

- expressions: the SQL code strings, corresponding to the `INTERSECT`'s operands. If `Expression` instances are passed, they will be used as-is.
- distinct: set the DISTINCT flag if and only if this is true.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy the expression.
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Intersect instance.

def except_( *expressions: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Except: View Source

    6944def except_(
    6945    *expressions: ExpOrStr,
    6946    distinct: bool = True,
    6947    dialect: DialectType = None,
    6948    copy: bool = True,
    6949    **opts,
    6950) -> Except:
    6951    """
    6952    Initializes a syntax tree for the `EXCEPT` operation.
    6953
    6954    Example:
    6955        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6956        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    6957
    6958    Args:
    6959        expressions: the SQL code strings, corresponding to the `EXCEPT`'s operands.
    6960            If `Expression` instances are passed, they will be used as-is.
    6961        distinct: set the DISTINCT flag if and only if this is true.
    6962        dialect: the dialect used to parse the input expression.
    6963        copy: whether to copy the expression.
    6964        opts: other options to use to parse the input expressions.
    6965
    6966    Returns:
    6967        The new Except instance.
    6968    """
    6969    assert len(expressions) >= 2, "At least two expressions are required by `except_`."
    6970    return _apply_set_operation(
    6971        *expressions, set_operation=Except, distinct=distinct, dialect=dialect, copy=copy, **opts
    6972    )

Initializes a syntax tree for the `EXCEPT` operation.

###### Example:

>     >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
>     'SELECT * FROM foo EXCEPT SELECT * FROM bla'

###### Arguments:

- expressions: the SQL code strings, corresponding to the `EXCEPT`'s operands. If `Expression` instances are passed, they will be used as-is.
- distinct: set the DISTINCT flag if and only if this is true.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy the expression.
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Except instance.

def select( *expressions: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Select: View Source

    6975def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    6976    """
    6977    Initializes a syntax tree from one or multiple SELECT expressions.
    6978
    6979    Example:
    6980        >>> select("col1", "col2").from_("tbl").sql()
    6981        'SELECT col1, col2 FROM tbl'
    6982
    6983    Args:
    6984        *expressions: the SQL code string to parse as the expressions of a
    6985            SELECT statement. If an Expression instance is passed, this is used as-is.
    6986        dialect: the dialect used to parse the input expressions (in the case that an
    6987            input expression is a SQL string).
    6988        **opts: other options to use to parse the input expressions (again, in the case
    6989            that an input expression is a SQL string).
    6990
    6991    Returns:
    6992        Select: the syntax tree for the SELECT statement.
    6993    """
    6994    return Select().select(*expressions, dialect=dialect, **opts)

Initializes a syntax tree from one or multiple SELECT expressions.

###### Example:

>     >>> select("col1", "col2").from_("tbl").sql()
>     'SELECT col1, col2 FROM tbl'

###### Arguments:

- *expressions: the SQL code string to parse as the expressions of a SELECT statement. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expressions (in the case that an input expression is a SQL string).
- **opts: other options to use to parse the input expressions (again, in the case that an input expression is a SQL string).

###### Returns:

> Select: the syntax tree for the SELECT statement.

def from_( expression: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Select: View Source

    6997def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    6998    """
    6999    Initializes a syntax tree from a FROM expression.
    7000
    7001    Example:
    7002        >>> from_("tbl").select("col1", "col2").sql()
    7003        'SELECT col1, col2 FROM tbl'
    7004
    7005    Args:
    7006        *expression: the SQL code string to parse as the FROM expressions of a
    7007            SELECT statement. If an Expression instance is passed, this is used as-is.
    7008        dialect: the dialect used to parse the input expression (in the case that the
    7009            input expression is a SQL string).
    7010        **opts: other options to use to parse the input expressions (again, in the case
    7011            that the input expression is a SQL string).
    7012
    7013    Returns:
    7014        Select: the syntax tree for the SELECT statement.
    7015    """
    7016    return Select().from_(expression, dialect=dialect, **opts)

Initializes a syntax tree from a FROM expression.

###### Example:

>     >>> from_("tbl").select("col1", "col2").sql()
>     'SELECT col1, col2 FROM tbl'

###### Arguments:

- *expression: the SQL code string to parse as the FROM expressions of a SELECT statement. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression (in the case that the input expression is a SQL string).
- **opts: other options to use to parse the input expressions (again, in the case that the input expression is a SQL string).

###### Returns:

> Select: the syntax tree for the SELECT statement.

def update( table: str | Table, properties: Optional[dict] = None, where: Union[str, Expression, NoneType] = None, from_: Union[str, Expression, NoneType] = None, with_: Optional[Dict[str, Union[str, Expression]]] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Update: View Source

    7019def update(
    7020    table: str | Table,
    7021    properties: t.Optional[dict] = None,
    7022    where: t.Optional[ExpOrStr] = None,
    7023    from_: t.Optional[ExpOrStr] = None,
    7024    with_: t.Optional[t.Dict[str, ExpOrStr]] = None,
    7025    dialect: DialectType = None,
    7026    **opts,
    7027) -> Update:
    7028    """
    7029    Creates an update statement.
    7030
    7031    Example:
    7032        >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz_cte", where="baz_cte.id > 1 and my_table.id = baz_cte.id", with_={"baz_cte": "SELECT id FROM foo"}).sql()
    7033        "WITH baz_cte AS (SELECT id FROM foo) UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz_cte WHERE baz_cte.id > 1 AND my_table.id = baz_cte.id"
    7034
    7035    Args:
    7036        properties: dictionary of properties to SET which are
    7037            auto converted to sql objects eg None -> NULL
    7038        where: sql conditional parsed into a WHERE statement
    7039        from_: sql statement parsed into a FROM statement
    7040        with_: dictionary of CTE aliases / select statements to include in a WITH clause.
    7041        dialect: the dialect used to parse the input expressions.
    7042        **opts: other options to use to parse the input expressions.
    7043
    7044    Returns:
    7045        Update: the syntax tree for the UPDATE statement.
    7046    """
    7047    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    7048    if properties:
    7049        update_expr.set(
    7050            "expressions",
    7051            [
    7052                EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    7053                for k, v in properties.items()
    7054            ],
    7055        )
    7056    if from_:
    7057        update_expr.set(
    7058            "from",
    7059            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    7060        )
    7061    if isinstance(where, Condition):
    7062        where = Where(this=where)
    7063    if where:
    7064        update_expr.set(
    7065            "where",
    7066            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    7067        )
    7068    if with_:
    7069        cte_list = [
    7070            alias_(CTE(this=maybe_parse(qry, dialect=dialect, **opts)), alias, table=True)
    7071            for alias, qry in with_.items()
    7072        ]
    7073        update_expr.set(
    7074            "with",
    7075            With(expressions=cte_list),
    7076        )
    7077    return update_expr

Creates an update statement.

###### Example:

>     >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz_cte", where="baz_cte.id > 1 and my_table.id = baz_cte.id", with_={"baz_cte": "SELECT id FROM foo"}).sql()
>     "WITH baz_cte AS (SELECT id FROM foo) UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz_cte WHERE baz_cte.id > 1 AND my_table.id = baz_cte.id"

###### Arguments:

- properties: dictionary of properties to SET which are auto converted to sql objects eg None -> NULL
- where: sql conditional parsed into a WHERE statement
- from_: sql statement parsed into a FROM statement
- with_: dictionary of CTE aliases / select statements to include in a WITH clause.
- dialect: the dialect used to parse the input expressions.
- **opts: other options to use to parse the input expressions.

###### Returns:

> Update: the syntax tree for the UPDATE statement.

def delete( table: Union[str, Expression], where: Union[str, Expression, NoneType] = None, returning: Union[str, Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Delete: View Source

    7080def delete(
    7081    table: ExpOrStr,
    7082    where: t.Optional[ExpOrStr] = None,
    7083    returning: t.Optional[ExpOrStr] = None,
    7084    dialect: DialectType = None,
    7085    **opts,
    7086) -> Delete:
    7087    """
    7088    Builds a delete statement.
    7089
    7090    Example:
    7091        >>> delete("my_table", where="id > 1").sql()
    7092        'DELETE FROM my_table WHERE id > 1'
    7093
    7094    Args:
    7095        where: sql conditional parsed into a WHERE statement
    7096        returning: sql conditional parsed into a RETURNING statement
    7097        dialect: the dialect used to parse the input expressions.
    7098        **opts: other options to use to parse the input expressions.
    7099
    7100    Returns:
    7101        Delete: the syntax tree for the DELETE statement.
    7102    """
    7103    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    7104    if where:
    7105        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    7106    if returning:
    7107        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    7108    return delete_expr

Builds a delete statement.

###### Example:

>     >>> delete("my_table", where="id > 1").sql()
>     'DELETE FROM my_table WHERE id > 1'

###### Arguments:

- where: sql conditional parsed into a WHERE statement
- returning: sql conditional parsed into a RETURNING statement
- dialect: the dialect used to parse the input expressions.
- **opts: other options to use to parse the input expressions.

###### Returns:

> Delete: the syntax tree for the DELETE statement.

def insert( expression: Union[str, Expression], into: Union[str, Expression], columns: Optional[Sequence[str | Identifier]] = None, overwrite: Optional[bool] = None, returning: Union[str, Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Insert: View Source

    7111def insert(
    7112    expression: ExpOrStr,
    7113    into: ExpOrStr,
    7114    columns: t.Optional[t.Sequence[str | Identifier]] = None,
    7115    overwrite: t.Optional[bool] = None,
    7116    returning: t.Optional[ExpOrStr] = None,
    7117    dialect: DialectType = None,
    7118    copy: bool = True,
    7119    **opts,
    7120) -> Insert:
    7121    """
    7122    Builds an INSERT statement.
    7123
    7124    Example:
    7125        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    7126        'INSERT INTO tbl VALUES (1, 2, 3)'
    7127
    7128    Args:
    7129        expression: the sql string or expression of the INSERT statement
    7130        into: the tbl to insert data to.
    7131        columns: optionally the table's column names.
    7132        overwrite: whether to INSERT OVERWRITE or not.
    7133        returning: sql conditional parsed into a RETURNING statement
    7134        dialect: the dialect used to parse the input expressions.
    7135        copy: whether to copy the expression.
    7136        **opts: other options to use to parse the input expressions.
    7137
    7138    Returns:
    7139        Insert: the syntax tree for the INSERT statement.
    7140    """
    7141    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7142    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    7143
    7144    if columns:
    7145        this = Schema(this=this, expressions=[to_identifier(c, copy=copy) for c in columns])
    7146
    7147    insert = Insert(this=this, expression=expr, overwrite=overwrite)
    7148
    7149    if returning:
    7150        insert = insert.returning(returning, dialect=dialect, copy=False, **opts)
    7151
    7152    return insert

Builds an INSERT statement.

###### Example:

>     >>> insert("VALUES (1, 2, 3)", "tbl").sql()
>     'INSERT INTO tbl VALUES (1, 2, 3)'

###### Arguments:

- expression: the sql string or expression of the INSERT statement
- into: the tbl to insert data to.
- columns: optionally the table's column names.
- overwrite: whether to INSERT OVERWRITE or not.
- returning: sql conditional parsed into a RETURNING statement
- dialect: the dialect used to parse the input expressions.
- copy: whether to copy the expression.
- **opts: other options to use to parse the input expressions.

###### Returns:

> Insert: the syntax tree for the INSERT statement.

def merge( *when_exprs: Union[str, Expression], into: Union[str, Expression], using: Union[str, Expression], on: Union[str, Expression], returning: Union[str, Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Merge: View Source

    7155def merge(
    7156    *when_exprs: ExpOrStr,
    7157    into: ExpOrStr,
    7158    using: ExpOrStr,
    7159    on: ExpOrStr,
    7160    returning: t.Optional[ExpOrStr] = None,
    7161    dialect: DialectType = None,
    7162    copy: bool = True,
    7163    **opts,
    7164) -> Merge:
    7165    """
    7166    Builds a MERGE statement.
    7167
    7168    Example:
    7169        >>> merge("WHEN MATCHED THEN UPDATE SET col1 = source_table.col1",
    7170        ...       "WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)",
    7171        ...       into="my_table",
    7172        ...       using="source_table",
    7173        ...       on="my_table.id = source_table.id").sql()
    7174        'MERGE INTO my_table USING source_table ON my_table.id = source_table.id WHEN MATCHED THEN UPDATE SET col1 = source_table.col1 WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)'
    7175
    7176    Args:
    7177        *when_exprs: The WHEN clauses specifying actions for matched and unmatched rows.
    7178        into: The target table to merge data into.
    7179        using: The source table to merge data from.
    7180        on: The join condition for the merge.
    7181        returning: The columns to return from the merge.
    7182        dialect: The dialect used to parse the input expressions.
    7183        copy: Whether to copy the expression.
    7184        **opts: Other options to use to parse the input expressions.
    7185
    7186    Returns:
    7187        Merge: The syntax tree for the MERGE statement.
    7188    """
    7189    merge = Merge(
    7190        this=maybe_parse(into, dialect=dialect, copy=copy, **opts),
    7191        using=maybe_parse(using, dialect=dialect, copy=copy, **opts),
    7192        on=maybe_parse(on, dialect=dialect, copy=copy, **opts),
    7193        expressions=[
    7194            maybe_parse(when_expr, dialect=dialect, copy=copy, into=When, **opts)
    7195            for when_expr in when_exprs
    7196        ],
    7197    )
    7198    if returning:
    7199        merge = merge.returning(returning, dialect=dialect, copy=False, **opts)
    7200
    7201    return merge

Builds a MERGE statement.

###### Example:

>     >>> merge("WHEN MATCHED THEN UPDATE SET col1 = source_table.col1",
>     ...       "WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)",
>     ...       into="my_table",
>     ...       using="source_table",
>     ...       on="my_table.id = source_table.id").sql()
>     'MERGE INTO my_table USING source_table ON my_table.id = source_table.id WHEN MATCHED THEN UPDATE SET col1 = source_table.col1 WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)'

###### Arguments:

- *when_exprs: The WHEN clauses specifying actions for matched and unmatched rows.
- into: The target table to merge data into.
- using: The source table to merge data from.
- on: The join condition for the merge.
- returning: The columns to return from the merge.
- dialect: The dialect used to parse the input expressions.
- copy: Whether to copy the expression.
- **opts: Other options to use to parse the input expressions.

###### Returns:

> Merge: The syntax tree for the MERGE statement.

def condition( expression: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    7204def condition(
    7205    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    7206) -> Condition:
    7207    """
    7208    Initialize a logical condition expression.
    7209
    7210    Example:
    7211        >>> condition("x=1").sql()
    7212        'x = 1'
    7213
    7214        This is helpful for composing larger logical syntax trees:
    7215        >>> where = condition("x=1")
    7216        >>> where = where.and_("y=1")
    7217        >>> Select().from_("tbl").select("*").where(where).sql()
    7218        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    7219
    7220    Args:
    7221        *expression: the SQL code string to parse.
    7222            If an Expression instance is passed, this is used as-is.
    7223        dialect: the dialect used to parse the input expression (in the case that the
    7224            input expression is a SQL string).
    7225        copy: Whether to copy `expression` (only applies to expressions).
    7226        **opts: other options to use to parse the input expressions (again, in the case
    7227            that the input expression is a SQL string).
    7228
    7229    Returns:
    7230        The new Condition instance
    7231    """
    7232    return maybe_parse(
    7233        expression,
    7234        into=Condition,
    7235        dialect=dialect,
    7236        copy=copy,
    7237        **opts,
    7238    )

Initialize a logical condition expression.

###### Example:

>     >>> condition("x=1").sql()
>     'x = 1'

> This is helpful for composing larger logical syntax trees:

>     >>> where = condition("x=1")
>     >>> where = where.and_("y=1")
>     >>> Select().from_("tbl").select("*").where(where).sql()
>     'SELECT * FROM tbl WHERE x = 1 AND y = 1'

###### Arguments:

- *expression: the SQL code string to parse. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression (in the case that the input expression is a SQL string).
- copy: Whether to copy `expression` (only applies to expressions).
- **opts: other options to use to parse the input expressions (again, in the case that the input expression is a SQL string).

###### Returns:

> The new Condition instance

def and_( *expressions: Union[str, Expression, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    7241def and_(
    7242    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7243) -> Condition:
    7244    """
    7245    Combine multiple conditions with an AND logical operator.
    7246
    7247    Example:
    7248        >>> and_("x=1", and_("y=1", "z=1")).sql()
    7249        'x = 1 AND (y = 1 AND z = 1)'
    7250
    7251    Args:
    7252        *expressions: the SQL code strings to parse.
    7253            If an Expression instance is passed, this is used as-is.
    7254        dialect: the dialect used to parse the input expression.
    7255        copy: whether to copy `expressions` (only applies to Expressions).
    7256        **opts: other options to use to parse the input expressions.
    7257
    7258    Returns:
    7259        The new condition
    7260    """
    7261    return t.cast(Condition, _combine(expressions, And, dialect, copy=copy, **opts))

Combine multiple conditions with an AND logical operator.

###### Example:

>     >>> and_("x=1", and_("y=1", "z=1")).sql()
>     'x = 1 AND (y = 1 AND z = 1)'

###### Arguments:

- *expressions: the SQL code strings to parse. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy `expressions` (only applies to Expressions).
- **opts: other options to use to parse the input expressions.

###### Returns:

> The new condition

def or_( *expressions: Union[str, Expression, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    7264def or_(
    7265    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7266) -> Condition:
    7267    """
    7268    Combine multiple conditions with an OR logical operator.
    7269
    7270    Example:
    7271        >>> or_("x=1", or_("y=1", "z=1")).sql()
    7272        'x = 1 OR (y = 1 OR z = 1)'
    7273
    7274    Args:
    7275        *expressions: the SQL code strings to parse.
    7276            If an Expression instance is passed, this is used as-is.
    7277        dialect: the dialect used to parse the input expression.
    7278        copy: whether to copy `expressions` (only applies to Expressions).
    7279        **opts: other options to use to parse the input expressions.
    7280
    7281    Returns:
    7282        The new condition
    7283    """
    7284    return t.cast(Condition, _combine(expressions, Or, dialect, copy=copy, **opts))

Combine multiple conditions with an OR logical operator.

###### Example:

>     >>> or_("x=1", or_("y=1", "z=1")).sql()
>     'x = 1 OR (y = 1 OR z = 1)'

###### Arguments:

- *expressions: the SQL code strings to parse. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy `expressions` (only applies to Expressions).
- **opts: other options to use to parse the input expressions.

###### Returns:

> The new condition

def xor( *expressions: Union[str, Expression, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    7287def xor(
    7288    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7289) -> Condition:
    7290    """
    7291    Combine multiple conditions with an XOR logical operator.
    7292
    7293    Example:
    7294        >>> xor("x=1", xor("y=1", "z=1")).sql()
    7295        'x = 1 XOR (y = 1 XOR z = 1)'
    7296
    7297    Args:
    7298        *expressions: the SQL code strings to parse.
    7299            If an Expression instance is passed, this is used as-is.
    7300        dialect: the dialect used to parse the input expression.
    7301        copy: whether to copy `expressions` (only applies to Expressions).
    7302        **opts: other options to use to parse the input expressions.
    7303
    7304    Returns:
    7305        The new condition
    7306    """
    7307    return t.cast(Condition, _combine(expressions, Xor, dialect, copy=copy, **opts))

Combine multiple conditions with an XOR logical operator.

###### Example:

>     >>> xor("x=1", xor("y=1", "z=1")).sql()
>     'x = 1 XOR (y = 1 XOR z = 1)'

###### Arguments:

- *expressions: the SQL code strings to parse. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy `expressions` (only applies to Expressions).
- **opts: other options to use to parse the input expressions.

###### Returns:

> The new condition

def not_( expression: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Not: View Source

    7310def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    7311    """
    7312    Wrap a condition with a NOT operator.
    7313
    7314    Example:
    7315        >>> not_("this_suit='black'").sql()
    7316        "NOT this_suit = 'black'"
    7317
    7318    Args:
    7319        expression: the SQL code string to parse.
    7320            If an Expression instance is passed, this is used as-is.
    7321        dialect: the dialect used to parse the input expression.
    7322        copy: whether to copy the expression or not.
    7323        **opts: other options to use to parse the input expressions.
    7324
    7325    Returns:
    7326        The new condition.
    7327    """
    7328    this = condition(
    7329        expression,
    7330        dialect=dialect,
    7331        copy=copy,
    7332        **opts,
    7333    )
    7334    return Not(this=_wrap(this, Connector))

Wrap a condition with a NOT operator.

###### Example:

>     >>> not_("this_suit='black'").sql()
>     "NOT this_suit = 'black'"

###### Arguments:

- expression: the SQL code string to parse. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy the expression or not.
- **opts: other options to use to parse the input expressions.

###### Returns:

> The new condition.

def paren( expression: Union[str, Expression], copy: bool = True) -> Paren: View Source

    7337def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    7338    """
    7339    Wrap an expression in parentheses.
    7340
    7341    Example:
    7342        >>> paren("5 + 3").sql()
    7343        '(5 + 3)'
    7344
    7345    Args:
    7346        expression: the SQL code string to parse.
    7347            If an Expression instance is passed, this is used as-is.
    7348        copy: whether to copy the expression or not.
    7349
    7350    Returns:
    7351        The wrapped expression.
    7352    """
    7353    return Paren(this=maybe_parse(expression, copy=copy))

Wrap an expression in parentheses.

###### Example:

>     >>> paren("5 + 3").sql()
>     '(5 + 3)'

###### Arguments:

- expression: the SQL code string to parse. If an Expression instance is passed, this is used as-is.
- copy: whether to copy the expression or not.

###### Returns:

> The wrapped expression.

SAFE_IDENTIFIER_RE: Pattern[str] = re.compile('^[_a-zA-Z][\\w]*$')
def to_identifier(name, quoted=None, copy=True): View Source

    7369def to_identifier(name, quoted=None, copy=True):
    7370    """Builds an identifier.
    7371
    7372    Args:
    7373        name: The name to turn into an identifier.
    7374        quoted: Whether to force quote the identifier.
    7375        copy: Whether to copy name if it's an Identifier.
    7376
    7377    Returns:
    7378        The identifier ast node.
    7379    """
    7380
    7381    if name is None:
    7382        return None
    7383
    7384    if isinstance(name, Identifier):
    7385        identifier = maybe_copy(name, copy)
    7386    elif isinstance(name, str):
    7387        identifier = Identifier(
    7388            this=name,
    7389            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    7390        )
    7391    else:
    7392        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    7393    return identifier

Builds an identifier.

###### Arguments:

- name: The name to turn into an identifier.
- quoted: Whether to force quote the identifier.
- copy: Whether to copy name if it's an Identifier.

###### Returns:

> The identifier ast node.

def parse_identifier( name: str | Identifier, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None) -> Identifier: View Source

    7396def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Identifier:
    7397    """
    7398    Parses a given string into an identifier.
    7399
    7400    Args:
    7401        name: The name to parse into an identifier.
    7402        dialect: The dialect to parse against.
    7403
    7404    Returns:
    7405        The identifier ast node.
    7406    """
    7407    try:
    7408        expression = maybe_parse(name, dialect=dialect, into=Identifier)
    7409    except (ParseError, TokenError):
    7410        expression = to_identifier(name)
    7411
    7412    return expression

Parses a given string into an identifier.

###### Arguments:

- name: The name to parse into an identifier.
- dialect: The dialect to parse against.

###### Returns:

> The identifier ast node.

INTERVAL_STRING_RE = re.compile('\\s*([0-9]+)\\s*([a-zA-Z]+)\\s*')
def to_interval( interval: str | Literal) -> Interval: View Source

    7418def to_interval(interval: str | Literal) -> Interval:
    7419    """Builds an interval expression from a string like '1 day' or '5 months'."""
    7420    if isinstance(interval, Literal):
    7421        if not interval.is_string:
    7422            raise ValueError("Invalid interval string.")
    7423
    7424        interval = interval.this
    7425
    7426    interval_parts = INTERVAL_STRING_RE.match(interval)  # type: ignore
    7427
    7428    if not interval_parts:
    7429        raise ValueError("Invalid interval string.")
    7430
    7431    return Interval(
    7432        this=Literal.string(interval_parts.group(1)),
    7433        unit=Var(this=interval_parts.group(2).upper()),
    7434    )

Builds an interval expression from a string like '1 day' or '5 months'.

def to_table( sql_path: str | Table, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **kwargs) -> Table: View Source

    7437def to_table(
    7438    sql_path: str | Table, dialect: DialectType = None, copy: bool = True, **kwargs
    7439) -> Table:
    7440    """
    7441    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    7442    If a table is passed in then that table is returned.
    7443
    7444    Args:
    7445        sql_path: a `[catalog].[schema].[table]` string.
    7446        dialect: the source dialect according to which the table name will be parsed.
    7447        copy: Whether to copy a table if it is passed in.
    7448        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    7449
    7450    Returns:
    7451        A table expression.
    7452    """
    7453    if isinstance(sql_path, Table):
    7454        return maybe_copy(sql_path, copy=copy)
    7455
    7456    table = maybe_parse(sql_path, into=Table, dialect=dialect)
    7457
    7458    for k, v in kwargs.items():
    7459        table.set(k, v)
    7460
    7461    return table

Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional. If a table is passed in then that table is returned.

###### Arguments:

- sql_path: a `[catalog].[schema].[table]` string.
- dialect: the source dialect according to which the table name will be parsed.
- copy: Whether to copy a table if it is passed in.
- kwargs: the kwargs to instantiate the resulting `Table` expression with.

###### Returns:

> A table expression.

def to_column( sql_path: str | Column, quoted: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **kwargs) -> Column: View Source

    7464def to_column(
    7465    sql_path: str | Column,
    7466    quoted: t.Optional[bool] = None,
    7467    dialect: DialectType = None,
    7468    copy: bool = True,
    7469    **kwargs,
    7470) -> Column:
    7471    """
    7472    Create a column from a `[table].[column]` sql path. Table is optional.
    7473    If a column is passed in then that column is returned.
    7474
    7475    Args:
    7476        sql_path: a `[table].[column]` string.
    7477        quoted: Whether or not to force quote identifiers.
    7478        dialect: the source dialect according to which the column name will be parsed.
    7479        copy: Whether to copy a column if it is passed in.
    7480        kwargs: the kwargs to instantiate the resulting `Column` expression with.
    7481
    7482    Returns:
    7483        A column expression.
    7484    """
    7485    if isinstance(sql_path, Column):
    7486        return maybe_copy(sql_path, copy=copy)
    7487
    7488    try:
    7489        col = maybe_parse(sql_path, into=Column, dialect=dialect)
    7490    except ParseError:
    7491        return column(*reversed(sql_path.split(".")), quoted=quoted, **kwargs)
    7492
    7493    for k, v in kwargs.items():
    7494        col.set(k, v)
    7495
    7496    if quoted:
    7497        for i in col.find_all(Identifier):
    7498            i.set("quoted", True)
    7499
    7500    return col

Create a column from a `[table].[column]` sql path. Table is optional. If a column is passed in then that column is returned.

###### Arguments:

- sql_path: a `[table].[column]` string.
- quoted: Whether or not to force quote identifiers.
- dialect: the source dialect according to which the column name will be parsed.
- copy: Whether to copy a column if it is passed in.
- kwargs: the kwargs to instantiate the resulting `Column` expression with.

###### Returns:

> A column expression.

def alias_( expression: Union[str, Expression], alias: Union[Identifier, str, NoneType], table: Union[bool, Sequence[str | Identifier]] = False, quoted: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts): View Source

    7503def alias_(
    7504    expression: ExpOrStr,
    7505    alias: t.Optional[str | Identifier],
    7506    table: bool | t.Sequence[str | Identifier] = False,
    7507    quoted: t.Optional[bool] = None,
    7508    dialect: DialectType = None,
    7509    copy: bool = True,
    7510    **opts,
    7511):
    7512    """Create an Alias expression.
    7513
    7514    Example:
    7515        >>> alias_('foo', 'bar').sql()
    7516        'foo AS bar'
    7517
    7518        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    7519        '(SELECT 1, 2) AS bar(a, b)'
    7520
    7521    Args:
    7522        expression: the SQL code strings to parse.
    7523            If an Expression instance is passed, this is used as-is.
    7524        alias: the alias name to use. If the name has
    7525            special characters it is quoted.
    7526        table: Whether to create a table alias, can also be a list of columns.
    7527        quoted: whether to quote the alias
    7528        dialect: the dialect used to parse the input expression.
    7529        copy: Whether to copy the expression.
    7530        **opts: other options to use to parse the input expressions.
    7531
    7532    Returns:
    7533        Alias: the aliased expression
    7534    """
    7535    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7536    alias = to_identifier(alias, quoted=quoted)
    7537
    7538    if table:
    7539        table_alias = TableAlias(this=alias)
    7540        exp.set("alias", table_alias)
    7541
    7542        if not isinstance(table, bool):
    7543            for column in table:
    7544                table_alias.append("columns", to_identifier(column, quoted=quoted))
    7545
    7546        return exp
    7547
    7548    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    7549    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    7550    # for the complete Window expression.
    7551    #
    7552    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    7553
    7554    if "alias" in exp.arg_types and not isinstance(exp, Window):
    7555        exp.set("alias", alias)
    7556        return exp
    7557    return Alias(this=exp, alias=alias)

Create an Alias expression.

###### Example:

>     >>> alias_('foo', 'bar').sql()
>     'foo AS bar'

>     >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
>     '(SELECT 1, 2) AS bar(a, b)'

###### Arguments:

- expression: the SQL code strings to parse. If an Expression instance is passed, this is used as-is.
- alias: the alias name to use. If the name has special characters it is quoted.
- table: Whether to create a table alias, can also be a list of columns.
- quoted: whether to quote the alias
- dialect: the dialect used to parse the input expression.
- copy: Whether to copy the expression.
- **opts: other options to use to parse the input expressions.

###### Returns:

> Alias: the aliased expression

def subquery( expression: Union[str, Expression], alias: Union[Identifier, str, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Select: View Source

    7560def subquery(
    7561    expression: ExpOrStr,
    7562    alias: t.Optional[Identifier | str] = None,
    7563    dialect: DialectType = None,
    7564    **opts,
    7565) -> Select:
    7566    """
    7567    Build a subquery expression that's selected from.
    7568
    7569    Example:
    7570        >>> subquery('select x from tbl', 'bar').select('x').sql()
    7571        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    7572
    7573    Args:
    7574        expression: the SQL code strings to parse.
    7575            If an Expression instance is passed, this is used as-is.
    7576        alias: the alias name to use.
    7577        dialect: the dialect used to parse the input expression.
    7578        **opts: other options to use to parse the input expressions.
    7579
    7580    Returns:
    7581        A new Select instance with the subquery expression included.
    7582    """
    7583
    7584    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias, **opts)
    7585    return Select().from_(expression, dialect=dialect, **opts)

Build a subquery expression that's selected from.

###### Example:

>     >>> subquery('select x from tbl', 'bar').select('x').sql()
>     'SELECT x FROM (SELECT x FROM tbl) AS bar'

###### Arguments:

- expression: the SQL code strings to parse. If an Expression instance is passed, this is used as-is.
- alias: the alias name to use.
- dialect: the dialect used to parse the input expression.
- **opts: other options to use to parse the input expressions.

###### Returns:

> A new Select instance with the subquery expression included.

def column( col, table=None, db=None, catalog=None, *, fields=None, quoted=None, copy=True): View Source

    7616def column(
    7617    col,
    7618    table=None,
    7619    db=None,
    7620    catalog=None,
    7621    *,
    7622    fields=None,
    7623    quoted=None,
    7624    copy=True,
    7625):
    7626    """
    7627    Build a Column.
    7628
    7629    Args:
    7630        col: Column name.
    7631        table: Table name.
    7632        db: Database name.
    7633        catalog: Catalog name.
    7634        fields: Additional fields using dots.
    7635        quoted: Whether to force quotes on the column's identifiers.
    7636        copy: Whether to copy identifiers if passed in.
    7637
    7638    Returns:
    7639        The new Column instance.
    7640    """
    7641    this = Column(
    7642        this=to_identifier(col, quoted=quoted, copy=copy),
    7643        table=to_identifier(table, quoted=quoted, copy=copy),
    7644        db=to_identifier(db, quoted=quoted, copy=copy),
    7645        catalog=to_identifier(catalog, quoted=quoted, copy=copy),
    7646    )
    7647
    7648    if fields:
    7649        this = Dot.build(
    7650            (this, *(to_identifier(field, quoted=quoted, copy=copy) for field in fields))
    7651        )
    7652    return this

Build a Column.

###### Arguments:

- col: Column name.
- table: Table name.
- db: Database name.
- catalog: Catalog name.
- fields: Additional fields using dots.
- quoted: Whether to force quotes on the column's identifiers.
- copy: Whether to copy identifiers if passed in.

###### Returns:

> The new Column instance.

def cast( expression: Union[str, Expression], to: Union[str, DataType, DataType.Type], copy: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Cast: View Source

    7655def cast(
    7656    expression: ExpOrStr, to: DATA_TYPE, copy: bool = True, dialect: DialectType = None, **opts
    7657) -> Cast:
    7658    """Cast an expression to a data type.
    7659
    7660    Example:
    7661        >>> cast('x + 1', 'int').sql()
    7662        'CAST(x + 1 AS INT)'
    7663
    7664    Args:
    7665        expression: The expression to cast.
    7666        to: The datatype to cast to.
    7667        copy: Whether to copy the supplied expressions.
    7668        dialect: The target dialect. This is used to prevent a re-cast in the following scenario:
    7669            - The expression to be cast is already a exp.Cast expression
    7670            - The existing cast is to a type that is logically equivalent to new type
    7671
    7672            For example, if :expression='CAST(x as DATETIME)' and :to=Type.TIMESTAMP,
    7673            but in the target dialect DATETIME is mapped to TIMESTAMP, then we will NOT return `CAST(x (as DATETIME) as TIMESTAMP)`
    7674            and instead just return the original expression `CAST(x as DATETIME)`.
    7675
    7676            This is to prevent it being output as a double cast `CAST(x (as TIMESTAMP) as TIMESTAMP)` once the DATETIME -> TIMESTAMP
    7677            mapping is applied in the target dialect generator.
    7678
    7679    Returns:
    7680        The new Cast instance.
    7681    """
    7682    expr = maybe_parse(expression, copy=copy, dialect=dialect, **opts)
    7683    data_type = DataType.build(to, copy=copy, dialect=dialect, **opts)
    7684
    7685    # dont re-cast if the expression is already a cast to the correct type
    7686    if isinstance(expr, Cast):
    7687        from sqlglot.dialects.dialect import Dialect
    7688
    7689        target_dialect = Dialect.get_or_raise(dialect)
    7690        type_mapping = target_dialect.generator_class.TYPE_MAPPING
    7691
    7692        existing_cast_type: DataType.Type = expr.to.this
    7693        new_cast_type: DataType.Type = data_type.this
    7694        types_are_equivalent = type_mapping.get(
    7695            existing_cast_type, existing_cast_type
    7696        ) == type_mapping.get(new_cast_type, new_cast_type)
    7697        if expr.is_type(data_type) or types_are_equivalent:
    7698            return expr
    7699
    7700    expr = Cast(this=expr, to=data_type)
    7701    expr.type = data_type
    7702
    7703    return expr

Cast an expression to a data type.

###### Example:

>     >>> cast('x + 1', 'int').sql()
>     'CAST(x + 1 AS INT)'

###### Arguments:

- expression: The expression to cast.
- to: The datatype to cast to.
- copy: Whether to copy the supplied expressions.

- dialect: The target dialect. This is used to prevent a re-cast in the following scenario:

  - The expression to be cast is already a exp.Cast expression
  - The existing cast is to a type that is logically equivalent to new type

  For example, if :expression='CAST(x as DATETIME)' and :to=Type.TIMESTAMP, but in the target dialect DATETIME is mapped to TIMESTAMP, then we will NOT return `CAST(x (as DATETIME) as TIMESTAMP)` and instead just return the original expression `CAST(x as DATETIME)`.

  This is to prevent it being output as a double cast `CAST(x (as TIMESTAMP) as TIMESTAMP)` once the DATETIME -> TIMESTAMP mapping is applied in the target dialect generator.

###### Returns:

> The new Cast instance.

def table_( table: Identifier | str, db: Union[Identifier, str, NoneType] = None, catalog: Union[Identifier, str, NoneType] = None, quoted: Optional[bool] = None, alias: Union[Identifier, str, NoneType] = None) -> Table: View Source

    7706def table_(
    7707    table: Identifier | str,
    7708    db: t.Optional[Identifier | str] = None,
    7709    catalog: t.Optional[Identifier | str] = None,
    7710    quoted: t.Optional[bool] = None,
    7711    alias: t.Optional[Identifier | str] = None,
    7712) -> Table:
    7713    """Build a Table.
    7714
    7715    Args:
    7716        table: Table name.
    7717        db: Database name.
    7718        catalog: Catalog name.
    7719        quote: Whether to force quotes on the table's identifiers.
    7720        alias: Table's alias.
    7721
    7722    Returns:
    7723        The new Table instance.
    7724    """
    7725    return Table(
    7726        this=to_identifier(table, quoted=quoted) if table else None,
    7727        db=to_identifier(db, quoted=quoted) if db else None,
    7728        catalog=to_identifier(catalog, quoted=quoted) if catalog else None,
    7729        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    7730    )

Build a Table.

###### Arguments:

- table: Table name.
- db: Database name.
- catalog: Catalog name.
- quote: Whether to force quotes on the table's identifiers.
- alias: Table's alias.

###### Returns:

> The new Table instance.

def values( values: Iterable[Tuple[Any, ...]], alias: Optional[str] = None, columns: Union[Iterable[str], Dict[str, DataType], NoneType] = None) -> Values: View Source

    7733def values(
    7734    values: t.Iterable[t.Tuple[t.Any, ...]],
    7735    alias: t.Optional[str] = None,
    7736    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    7737) -> Values:
    7738    """Build VALUES statement.
    7739
    7740    Example:
    7741        >>> values([(1, '2')]).sql()
    7742        "VALUES (1, '2')"
    7743
    7744    Args:
    7745        values: values statements that will be converted to SQL
    7746        alias: optional alias
    7747        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    7748         If either are provided then an alias is also required.
    7749
    7750    Returns:
    7751        Values: the Values expression object
    7752    """
    7753    if columns and not alias:
    7754        raise ValueError("Alias is required when providing columns")
    7755
    7756    return Values(
    7757        expressions=[convert(tup) for tup in values],
    7758        alias=(
    7759            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    7760            if columns
    7761            else (TableAlias(this=to_identifier(alias)) if alias else None)
    7762        ),
    7763    )

Build VALUES statement.

###### Example:

>     >>> values([(1, '2')]).sql()
>     "VALUES (1, '2')"

###### Arguments:

- values: values statements that will be converted to SQL
- alias: optional alias
- columns: Optional list of ordered column names or ordered dictionary of column names to types. If either are provided then an alias is also required.

###### Returns:

> Values: the Values expression object

def var( name: Union[str, Expression, NoneType]) -> Var: View Source

    7766def var(name: t.Optional[ExpOrStr]) -> Var:
    7767    """Build a SQL variable.
    7768
    7769    Example:
    7770        >>> repr(var('x'))
    7771        'Var(this=x)'
    7772
    7773        >>> repr(var(column('x', table='y')))
    7774        'Var(this=x)'
    7775
    7776    Args:
    7777        name: The name of the var or an expression who's name will become the var.
    7778
    7779    Returns:
    7780        The new variable node.
    7781    """
    7782    if not name:
    7783        raise ValueError("Cannot convert empty name into var.")
    7784
    7785    if isinstance(name, Expression):
    7786        name = name.name
    7787    return Var(this=name)

Build a SQL variable.

###### Example:

>     >>> repr(var('x'))
>     'Var(this=x)'

>     >>> repr(var(column('x', table='y')))
>     'Var(this=x)'

###### Arguments:

- name: The name of the var or an expression who's name will become the var.

###### Returns:

> The new variable node.

def rename_table( old_name: str | Table, new_name: str | Table, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None) -> Alter: View Source

    7790def rename_table(
    7791    old_name: str | Table,
    7792    new_name: str | Table,
    7793    dialect: DialectType = None,
    7794) -> Alter:
    7795    """Build ALTER TABLE... RENAME... expression
    7796
    7797    Args:
    7798        old_name: The old name of the table
    7799        new_name: The new name of the table
    7800        dialect: The dialect to parse the table.
    7801
    7802    Returns:
    7803        Alter table expression
    7804    """
    7805    old_table = to_table(old_name, dialect=dialect)
    7806    new_table = to_table(new_name, dialect=dialect)
    7807    return Alter(
    7808        this=old_table,
    7809        kind="TABLE",
    7810        actions=[
    7811            AlterRename(this=new_table),
    7812        ],
    7813    )

Build ALTER TABLE... RENAME... expression

###### Arguments:

- old_name: The old name of the table
- new_name: The new name of the table
- dialect: The dialect to parse the table.

###### Returns:

> Alter table expression

def rename_column( table_name: str | Table, old_column_name: str | Column, new_column_name: str | Column, exists: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None) -> Alter: View Source

    7816def rename_column(
    7817    table_name: str | Table,
    7818    old_column_name: str | Column,
    7819    new_column_name: str | Column,
    7820    exists: t.Optional[bool] = None,
    7821    dialect: DialectType = None,
    7822) -> Alter:
    7823    """Build ALTER TABLE... RENAME COLUMN... expression
    7824
    7825    Args:
    7826        table_name: Name of the table
    7827        old_column: The old name of the column
    7828        new_column: The new name of the column
    7829        exists: Whether to add the `IF EXISTS` clause
    7830        dialect: The dialect to parse the table/column.
    7831
    7832    Returns:
    7833        Alter table expression
    7834    """
    7835    table = to_table(table_name, dialect=dialect)
    7836    old_column = to_column(old_column_name, dialect=dialect)
    7837    new_column = to_column(new_column_name, dialect=dialect)
    7838    return Alter(
    7839        this=table,
    7840        kind="TABLE",
    7841        actions=[
    7842            RenameColumn(this=old_column, to=new_column, exists=exists),
    7843        ],
    7844    )

Build ALTER TABLE... RENAME COLUMN... expression

###### Arguments:

- table_name: Name of the table
- old_column: The old name of the column
- new_column: The new name of the column
- exists: Whether to add the `IF EXISTS` clause
- dialect: The dialect to parse the table/column.

###### Returns:

> Alter table expression

def convert(value: Any, copy: bool = False) -> Expression: View Source

    7847def convert(value: t.Any, copy: bool = False) -> Expression:
    7848    """Convert a python value into an expression object.
    7849
    7850    Raises an error if a conversion is not possible.
    7851
    7852    Args:
    7853        value: A python object.
    7854        copy: Whether to copy `value` (only applies to Expressions and collections).
    7855
    7856    Returns:
    7857        The equivalent expression object.
    7858    """
    7859    if isinstance(value, Expression):
    7860        return maybe_copy(value, copy)
    7861    if isinstance(value, str):
    7862        return Literal.string(value)
    7863    if isinstance(value, bool):
    7864        return Boolean(this=value)
    7865    if value is None or (isinstance(value, float) and math.isnan(value)):
    7866        return null()
    7867    if isinstance(value, numbers.Number):
    7868        return Literal.number(value)
    7869    if isinstance(value, bytes):
    7870        return HexString(this=value.hex())
    7871    if isinstance(value, datetime.datetime):
    7872        datetime_literal = Literal.string(value.isoformat(sep=" "))
    7873
    7874        tz = None
    7875        if value.tzinfo:
    7876            # this works for zoneinfo.ZoneInfo, pytz.timezone and datetime.datetime.utc to return IANA timezone names like "America/Los_Angeles"
    7877            # instead of abbreviations like "PDT". This is for consistency with other timezone handling functions in SQLGlot
    7878            tz = Literal.string(str(value.tzinfo))
    7879
    7880        return TimeStrToTime(this=datetime_literal, zone=tz)
    7881    if isinstance(value, datetime.date):
    7882        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    7883        return DateStrToDate(this=date_literal)
    7884    if isinstance(value, tuple):
    7885        if hasattr(value, "_fields"):
    7886            return Struct(
    7887                expressions=[
    7888                    PropertyEQ(
    7889                        this=to_identifier(k), expression=convert(getattr(value, k), copy=copy)
    7890                    )
    7891                    for k in value._fields
    7892                ]
    7893            )
    7894        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    7895    if isinstance(value, list):
    7896        return Array(expressions=[convert(v, copy=copy) for v in value])
    7897    if isinstance(value, dict):
    7898        return Map(
    7899            keys=Array(expressions=[convert(k, copy=copy) for k in value]),
    7900            values=Array(expressions=[convert(v, copy=copy) for v in value.values()]),
    7901        )
    7902    if hasattr(value, "__dict__"):
    7903        return Struct(
    7904            expressions=[
    7905                PropertyEQ(this=to_identifier(k), expression=convert(v, copy=copy))
    7906                for k, v in value.__dict__.items()
    7907            ]
    7908        )
    7909    raise ValueError(f"Cannot convert {value}")

Convert a python value into an expression object.

Raises an error if a conversion is not possible.

###### Arguments:

- value: A python object.
- copy: Whether to copy `value` (only applies to Expressions and collections).

###### Returns:

> The equivalent expression object.

def replace_children( expression: Expression, fun: Callable, *args, **kwargs) -> None: View Source

    7912def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    7913    """
    7914    Replace children of an expression with the result of a lambda fun(child) -> exp.
    7915    """
    7916    for k, v in tuple(expression.args.items()):
    7917        is_list_arg = type(v) is list
    7918
    7919        child_nodes = v if is_list_arg else [v]
    7920        new_child_nodes = []
    7921
    7922        for cn in child_nodes:
    7923            if isinstance(cn, Expression):
    7924                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    7925                    new_child_nodes.append(child_node)
    7926            else:
    7927                new_child_nodes.append(cn)
    7928
    7929        expression.set(k, new_child_nodes if is_list_arg else seq_get(new_child_nodes, 0))

Replace children of an expression with the result of a lambda fun(child) -> exp.

def replace_tree( expression: Expression, fun: Callable, prune: Optional[Callable[[Expression], bool]] = None) -> Expression: View Source

    7932def replace_tree(
    7933    expression: Expression,
    7934    fun: t.Callable,
    7935    prune: t.Optional[t.Callable[[Expression], bool]] = None,
    7936) -> Expression:
    7937    """
    7938    Replace an entire tree with the result of function calls on each node.
    7939
    7940    This will be traversed in reverse dfs, so leaves first.
    7941    If new nodes are created as a result of function calls, they will also be traversed.
    7942    """
    7943    stack = list(expression.dfs(prune=prune))
    7944
    7945    while stack:
    7946        node = stack.pop()
    7947        new_node = fun(node)
    7948
    7949        if new_node is not node:
    7950            node.replace(new_node)
    7951
    7952            if isinstance(new_node, Expression):
    7953                stack.append(new_node)
    7954
    7955    return new_node

Replace an entire tree with the result of function calls on each node.

This will be traversed in reverse dfs, so leaves first. If new nodes are created as a result of function calls, they will also be traversed.

def column_table_names( expression: Expression, exclude: str = '') -> Set[str]: View Source

    7958def column_table_names(expression: Expression, exclude: str = "") -> t.Set[str]:
    7959    """
    7960    Return all table names referenced through columns in an expression.
    7961
    7962    Example:
    7963        >>> import sqlglot
    7964        >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
    7965        ['a', 'c']
    7966
    7967    Args:
    7968        expression: expression to find table names.
    7969        exclude: a table name to exclude
    7970
    7971    Returns:
    7972        A list of unique names.
    7973    """
    7974    return {
    7975        table
    7976        for table in (column.table for column in expression.find_all(Column))
    7977        if table and table != exclude
    7978    }

Return all table names referenced through columns in an expression.

###### Example:

>     >>> import sqlglot
>     >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
>     ['a', 'c']

###### Arguments:

- expression: expression to find table names.
- exclude: a table name to exclude

###### Returns:

> A list of unique names.

def table_name( table: Table | str, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, identify: bool = False) -> str: View Source

    7981def table_name(table: Table | str, dialect: DialectType = None, identify: bool = False) -> str:
    7982    """Get the full name of a table as a string.
    7983
    7984    Args:
    7985        table: Table expression node or string.
    7986        dialect: The dialect to generate the table name for.
    7987        identify: Determines when an identifier should be quoted. Possible values are:
    7988            False (default): Never quote, except in cases where it's mandatory by the dialect.
    7989            True: Always quote.
    7990
    7991    Examples:
    7992        >>> from sqlglot import exp, parse_one
    7993        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    7994        'a.b.c'
    7995
    7996    Returns:
    7997        The table name.
    7998    """
    7999
    8000    table = maybe_parse(table, into=Table, dialect=dialect)
    8001
    8002    if not table:
    8003        raise ValueError(f"Cannot parse {table}")
    8004
    8005    return ".".join(
    8006        (
    8007            part.sql(dialect=dialect, identify=True, copy=False)
    8008            if identify or not SAFE_IDENTIFIER_RE.match(part.name)
    8009            else part.name
    8010        )
    8011        for part in table.parts
    8012    )

Get the full name of a table as a string.

###### Arguments:

- table: Table expression node or string.
- dialect: The dialect to generate the table name for.
- identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True: Always quote.

###### Examples:

>     >>> from sqlglot import exp, parse_one
>     >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
>     'a.b.c'

###### Returns:

> The table name.

def normalize_table_name( table: str | Table, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True) -> str: View Source

    8015def normalize_table_name(table: str | Table, dialect: DialectType = None, copy: bool = True) -> str:
    8016    """Returns a case normalized table name without quotes.
    8017
    8018    Args:
    8019        table: the table to normalize
    8020        dialect: the dialect to use for normalization rules
    8021        copy: whether to copy the expression.
    8022
    8023    Examples:
    8024        >>> normalize_table_name("`A-B`.c", dialect="bigquery")
    8025        'A-B.c'
    8026    """
    8027    from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
    8028
    8029    return ".".join(
    8030        p.name
    8031        for p in normalize_identifiers(
    8032            to_table(table, dialect=dialect, copy=copy), dialect=dialect
    8033        ).parts
    8034    )

Returns a case normalized table name without quotes.

###### Arguments:

- table: the table to normalize
- dialect: the dialect to use for normalization rules
- copy: whether to copy the expression.

###### Examples:

>     >>> normalize_table_name("`A-B`.c", dialect="bigquery")
>     'A-B.c'

def replace_tables( expression: ~E, mapping: Dict[str, str], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True) -> ~E: View Source

    8037def replace_tables(
    8038    expression: E, mapping: t.Dict[str, str], dialect: DialectType = None, copy: bool = True
    8039) -> E:
    8040    """Replace all tables in expression according to the mapping.
    8041
    8042    Args:
    8043        expression: expression node to be transformed and replaced.
    8044        mapping: mapping of table names.
    8045        dialect: the dialect of the mapping table
    8046        copy: whether to copy the expression.
    8047
    8048    Examples:
    8049        >>> from sqlglot import exp, parse_one
    8050        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    8051        'SELECT * FROM c /* a.b */'
    8052
    8053    Returns:
    8054        The mapped expression.
    8055    """
    8056
    8057    mapping = {normalize_table_name(k, dialect=dialect): v for k, v in mapping.items()}
    8058
    8059    def _replace_tables(node: Expression) -> Expression:
    8060        if isinstance(node, Table):
    8061            original = normalize_table_name(node, dialect=dialect)
    8062            new_name = mapping.get(original)
    8063
    8064            if new_name:
    8065                table = to_table(
    8066                    new_name,
    8067                    **{k: v for k, v in node.args.items() if k not in TABLE_PARTS},
    8068                    dialect=dialect,
    8069                )
    8070                table.add_comments([original])
    8071                return table
    8072        return node
    8073
    8074    return expression.transform(_replace_tables, copy=copy)  # type: ignore

Replace all tables in expression according to the mapping.

###### Arguments:

- expression: expression node to be transformed and replaced.
- mapping: mapping of table names.
- dialect: the dialect of the mapping table
- copy: whether to copy the expression.

###### Examples:

>     >>> from sqlglot import exp, parse_one
>     >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
>     'SELECT * FROM c /* a.b */'

###### Returns:

> The mapped expression.

def replace_placeholders( expression: Expression, *args, **kwargs) -> Expression: View Source

    8077def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    8078    """Replace placeholders in an expression.
    8079
    8080    Args:
    8081        expression: expression node to be transformed and replaced.
    8082        args: positional names that will substitute unnamed placeholders in the given order.
    8083        kwargs: keyword arguments that will substitute named placeholders.
    8084
    8085    Examples:
    8086        >>> from sqlglot import exp, parse_one
    8087        >>> replace_placeholders(
    8088        ...     parse_one("select * from :tbl where ? = ?"),
    8089        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    8090        ... ).sql()
    8091        "SELECT * FROM foo WHERE str_col = 'b'"
    8092
    8093    Returns:
    8094        The mapped expression.
    8095    """
    8096
    8097    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    8098        if isinstance(node, Placeholder):
    8099            if node.this:
    8100                new_name = kwargs.get(node.this)
    8101                if new_name is not None:
    8102                    return convert(new_name)
    8103            else:
    8104                try:
    8105                    return convert(next(args))
    8106                except StopIteration:
    8107                    pass
    8108        return node
    8109
    8110    return expression.transform(_replace_placeholders, iter(args), **kwargs)

Replace placeholders in an expression.

###### Arguments:

- expression: expression node to be transformed and replaced.
- args: positional names that will substitute unnamed placeholders in the given order.
- kwargs: keyword arguments that will substitute named placeholders.

###### Examples:

>     >>> from sqlglot import exp, parse_one
>     >>> replace_placeholders(
>     ...     parse_one("select * from :tbl where ? = ?"),
>     ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
>     ... ).sql()
>     "SELECT * FROM foo WHERE str_col = 'b'"

###### Returns:

> The mapped expression.

def expand( expression: Expression, sources: Dict[str, Query], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True) -> Expression: View Source

    8113def expand(
    8114    expression: Expression,
    8115    sources: t.Dict[str, Query],
    8116    dialect: DialectType = None,
    8117    copy: bool = True,
    8118) -> Expression:
    8119    """Transforms an expression by expanding all referenced sources into subqueries.
    8120
    8121    Examples:
    8122        >>> from sqlglot import parse_one
    8123        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    8124        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    8125
    8126        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    8127        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    8128
    8129    Args:
    8130        expression: The expression to expand.
    8131        sources: A dictionary of name to Queries.
    8132        dialect: The dialect of the sources dict.
    8133        copy: Whether to copy the expression during transformation. Defaults to True.
    8134
    8135    Returns:
    8136        The transformed expression.
    8137    """
    8138    sources = {normalize_table_name(k, dialect=dialect): v for k, v in sources.items()}
    8139
    8140    def _expand(node: Expression):
    8141        if isinstance(node, Table):
    8142            name = normalize_table_name(node, dialect=dialect)
    8143            source = sources.get(name)
    8144            if source:
    8145                subquery = source.subquery(node.alias or name)
    8146                subquery.comments = [f"source: {name}"]
    8147                return subquery.transform(_expand, copy=False)
    8148        return node
    8149
    8150    return expression.transform(_expand, copy=copy)

Transforms an expression by expanding all referenced sources into subqueries.

###### Examples:

>     >>> from sqlglot import parse_one
>     >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
>     'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'

>     >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
>     'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'

###### Arguments:

- expression: The expression to expand.
- sources: A dictionary of name to Queries.
- dialect: The dialect of the sources dict.
- copy: Whether to copy the expression during transformation. Defaults to True.

###### Returns:

> The transformed expression.

def func( name: str, *args, copy: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **kwargs) -> Func: View Source

    8153def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwargs) -> Func:
    8154    """
    8155    Returns a Func expression.
    8156
    8157    Examples:
    8158        >>> func("abs", 5).sql()
    8159        'ABS(5)'
    8160
    8161        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    8162        'CAST(5 AS DOUBLE)'
    8163
    8164    Args:
    8165        name: the name of the function to build.
    8166        args: the args used to instantiate the function of interest.
    8167        copy: whether to copy the argument expressions.
    8168        dialect: the source dialect.
    8169        kwargs: the kwargs used to instantiate the function of interest.
    8170
    8171    Note:
    8172        The arguments `args` and `kwargs` are mutually exclusive.
    8173
    8174    Returns:
    8175        An instance of the function of interest, or an anonymous function, if `name` doesn't
    8176        correspond to an existing `sqlglot.expressions.Func` class.
    8177    """
    8178    if args and kwargs:
    8179        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    8180
    8181    from sqlglot.dialects.dialect import Dialect
    8182
    8183    dialect = Dialect.get_or_raise(dialect)
    8184
    8185    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect, copy=copy) for arg in args]
    8186    kwargs = {key: maybe_parse(value, dialect=dialect, copy=copy) for key, value in kwargs.items()}
    8187
    8188    constructor = dialect.parser_class.FUNCTIONS.get(name.upper())
    8189    if constructor:
    8190        if converted:
    8191            if "dialect" in constructor.__code__.co_varnames:
    8192                function = constructor(converted, dialect=dialect)
    8193            else:
    8194                function = constructor(converted)
    8195        elif constructor.__name__ == "from_arg_list":
    8196            function = constructor.__self__(**kwargs)  # type: ignore
    8197        else:
    8198            constructor = FUNCTION_BY_NAME.get(name.upper())
    8199            if constructor:
    8200                function = constructor(**kwargs)
    8201            else:
    8202                raise ValueError(
    8203                    f"Unable to convert '{name}' into a Func. Either manually construct "
    8204                    "the Func expression of interest or parse the function call."
    8205                )
    8206    else:
    8207        kwargs = kwargs or {"expressions": converted}
    8208        function = Anonymous(this=name, **kwargs)
    8209
    8210    for error_message in function.error_messages(converted):
    8211        raise ValueError(error_message)
    8212
    8213    return function

Returns a Func expression.

###### Examples:

>     >>> func("abs", 5).sql()
>     'ABS(5)'

>     >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
>     'CAST(5 AS DOUBLE)'

###### Arguments:

- name: the name of the function to build.
- args: the args used to instantiate the function of interest.
- copy: whether to copy the argument expressions.
- dialect: the source dialect.
- kwargs: the kwargs used to instantiate the function of interest.

###### Note:

> The arguments `args` and `kwargs` are mutually exclusive.

###### Returns:

> An instance of the function of interest, or an anonymous function, if `name` doesn't correspond to an existing `sqlglot.expressions.Func` class.

def case( expression: Union[str, Expression, NoneType] = None, **opts) -> Case: View Source

    8216def case(
    8217    expression: t.Optional[ExpOrStr] = None,
    8218    **opts,
    8219) -> Case:
    8220    """
    8221    Initialize a CASE statement.
    8222
    8223    Example:
    8224        case().when("a = 1", "foo").else_("bar")
    8225
    8226    Args:
    8227        expression: Optionally, the input expression (not all dialects support this)
    8228        **opts: Extra keyword arguments for parsing `expression`
    8229    """
    8230    if expression is not None:
    8231        this = maybe_parse(expression, **opts)
    8232    else:
    8233        this = None
    8234    return Case(this=this, ifs=[])

Initialize a CASE statement.

###### Example:

> case().when("a = 1", "foo").else_("bar")

###### Arguments:

- expression: Optionally, the input expression (not all dialects support this)
- **opts: Extra keyword arguments for parsing `expression`

def array( *expressions: Union[str, Expression], copy: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **kwargs) -> Array: View Source

    8237def array(
    8238    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8239) -> Array:
    8240    """
    8241    Returns an array.
    8242
    8243    Examples:
    8244        >>> array(1, 'x').sql()
    8245        'ARRAY(1, x)'
    8246
    8247    Args:
    8248        expressions: the expressions to add to the array.
    8249        copy: whether to copy the argument expressions.
    8250        dialect: the source dialect.
    8251        kwargs: the kwargs used to instantiate the function of interest.
    8252
    8253    Returns:
    8254        An array expression.
    8255    """
    8256    return Array(
    8257        expressions=[
    8258            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8259            for expression in expressions
    8260        ]
    8261    )

Returns an array.

###### Examples:

>     >>> array(1, 'x').sql()
>     'ARRAY(1, x)'

###### Arguments:

- expressions: the expressions to add to the array.
- copy: whether to copy the argument expressions.
- dialect: the source dialect.
- kwargs: the kwargs used to instantiate the function of interest.

###### Returns:

> An array expression.

def tuple_( *expressions: Union[str, Expression], copy: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **kwargs) -> Tuple: View Source

    8264def tuple_(
    8265    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8266) -> Tuple:
    8267    """
    8268    Returns an tuple.
    8269
    8270    Examples:
    8271        >>> tuple_(1, 'x').sql()
    8272        '(1, x)'
    8273
    8274    Args:
    8275        expressions: the expressions to add to the tuple.
    8276        copy: whether to copy the argument expressions.
    8277        dialect: the source dialect.
    8278        kwargs: the kwargs used to instantiate the function of interest.
    8279
    8280    Returns:
    8281        A tuple expression.
    8282    """
    8283    return Tuple(
    8284        expressions=[
    8285            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8286            for expression in expressions
    8287        ]
    8288    )

Returns an tuple.

###### Examples:

>     >>> tuple_(1, 'x').sql()
>     '(1, x)'

###### Arguments:

- expressions: the expressions to add to the tuple.
- copy: whether to copy the argument expressions.
- dialect: the source dialect.
- kwargs: the kwargs used to instantiate the function of interest.

###### Returns:

> A tuple expression.

def true() -> Boolean: View Source

    8291def true() -> Boolean:
    8292    """
    8293    Returns a true Boolean expression.
    8294    """
    8295    return Boolean(this=True)

Returns a true Boolean expression.

def false() -> Boolean: View Source

    8298def false() -> Boolean:
    8299    """
    8300    Returns a false Boolean expression.
    8301    """
    8302    return Boolean(this=False)

Returns a false Boolean expression.

def null() -> Null: View Source

    8305def null() -> Null:
    8306    """
    8307    Returns a Null expression.
    8308    """
    8309    return Null()

Returns a Null expression.

NONNULL_CONSTANTS = (<class 'Literal'>, <class 'Boolean'>)
CONSTANTS = (<class 'Literal'>, <class 'Boolean'>, <class 'Null'>)