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 WithProcedureOptions(Property):
    3000    arg_types = {"expressions": True}
    3001
    3002
    3003class Properties(Expression):
    3004    arg_types = {"expressions": True}
    3005
    3006    NAME_TO_PROPERTY = {
    3007        "ALGORITHM": AlgorithmProperty,
    3008        "AUTO_INCREMENT": AutoIncrementProperty,
    3009        "CHARACTER SET": CharacterSetProperty,
    3010        "CLUSTERED_BY": ClusteredByProperty,
    3011        "COLLATE": CollateProperty,
    3012        "COMMENT": SchemaCommentProperty,
    3013        "DEFINER": DefinerProperty,
    3014        "DISTKEY": DistKeyProperty,
    3015        "DISTRIBUTED_BY": DistributedByProperty,
    3016        "DISTSTYLE": DistStyleProperty,
    3017        "ENGINE": EngineProperty,
    3018        "EXECUTE AS": ExecuteAsProperty,
    3019        "FORMAT": FileFormatProperty,
    3020        "LANGUAGE": LanguageProperty,
    3021        "LOCATION": LocationProperty,
    3022        "LOCK": LockProperty,
    3023        "PARTITIONED_BY": PartitionedByProperty,
    3024        "RETURNS": ReturnsProperty,
    3025        "ROW_FORMAT": RowFormatProperty,
    3026        "SORTKEY": SortKeyProperty,
    3027    }
    3028
    3029    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    3030
    3031    # CREATE property locations
    3032    # Form: schema specified
    3033    #   create [POST_CREATE]
    3034    #     table a [POST_NAME]
    3035    #     (b int) [POST_SCHEMA]
    3036    #     with ([POST_WITH])
    3037    #     index (b) [POST_INDEX]
    3038    #
    3039    # Form: alias selection
    3040    #   create [POST_CREATE]
    3041    #     table a [POST_NAME]
    3042    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    3043    #     index (c) [POST_INDEX]
    3044    class Location(AutoName):
    3045        POST_CREATE = auto()
    3046        POST_NAME = auto()
    3047        POST_SCHEMA = auto()
    3048        POST_WITH = auto()
    3049        POST_ALIAS = auto()
    3050        POST_EXPRESSION = auto()
    3051        POST_INDEX = auto()
    3052        UNSUPPORTED = auto()
    3053
    3054    @classmethod
    3055    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3056        expressions = []
    3057        for key, value in properties_dict.items():
    3058            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3059            if property_cls:
    3060                expressions.append(property_cls(this=convert(value)))
    3061            else:
    3062                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3063
    3064        return cls(expressions=expressions)
    3065
    3066
    3067class Qualify(Expression):
    3068    pass
    3069
    3070
    3071class InputOutputFormat(Expression):
    3072    arg_types = {"input_format": False, "output_format": False}
    3073
    3074
    3075# https://www.ibm.com/docs/en/ias?topic=procedures-return-statement-in-sql
    3076class Return(Expression):
    3077    pass
    3078
    3079
    3080class Reference(Expression):
    3081    arg_types = {"this": True, "expressions": False, "options": False}
    3082
    3083
    3084class Tuple(Expression):
    3085    arg_types = {"expressions": False}
    3086
    3087    def isin(
    3088        self,
    3089        *expressions: t.Any,
    3090        query: t.Optional[ExpOrStr] = None,
    3091        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3092        copy: bool = True,
    3093        **opts,
    3094    ) -> In:
    3095        return In(
    3096            this=maybe_copy(self, copy),
    3097            expressions=[convert(e, copy=copy) for e in expressions],
    3098            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3099            unnest=(
    3100                Unnest(
    3101                    expressions=[
    3102                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3103                        for e in ensure_list(unnest)
    3104                    ]
    3105                )
    3106                if unnest
    3107                else None
    3108            ),
    3109        )
    3110
    3111
    3112QUERY_MODIFIERS = {
    3113    "match": False,
    3114    "laterals": False,
    3115    "joins": False,
    3116    "connect": False,
    3117    "pivots": False,
    3118    "prewhere": False,
    3119    "where": False,
    3120    "group": False,
    3121    "having": False,
    3122    "qualify": False,
    3123    "windows": False,
    3124    "distribute": False,
    3125    "sort": False,
    3126    "cluster": False,
    3127    "order": False,
    3128    "limit": False,
    3129    "offset": False,
    3130    "locks": False,
    3131    "sample": False,
    3132    "settings": False,
    3133    "format": False,
    3134    "options": False,
    3135}
    3136
    3137
    3138# https://learn.microsoft.com/en-us/sql/t-sql/queries/option-clause-transact-sql?view=sql-server-ver16
    3139# https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-query?view=sql-server-ver16
    3140class QueryOption(Expression):
    3141    arg_types = {"this": True, "expression": False}
    3142
    3143
    3144# https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver16
    3145class WithTableHint(Expression):
    3146    arg_types = {"expressions": True}
    3147
    3148
    3149# https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
    3150class IndexTableHint(Expression):
    3151    arg_types = {"this": True, "expressions": False, "target": False}
    3152
    3153
    3154# https://docs.snowflake.com/en/sql-reference/constructs/at-before
    3155class HistoricalData(Expression):
    3156    arg_types = {"this": True, "kind": True, "expression": True}
    3157
    3158
    3159class Table(Expression):
    3160    arg_types = {
    3161        "this": False,
    3162        "alias": False,
    3163        "db": False,
    3164        "catalog": False,
    3165        "laterals": False,
    3166        "joins": False,
    3167        "pivots": False,
    3168        "hints": False,
    3169        "system_time": False,
    3170        "version": False,
    3171        "format": False,
    3172        "pattern": False,
    3173        "ordinality": False,
    3174        "when": False,
    3175        "only": False,
    3176        "partition": False,
    3177        "changes": False,
    3178        "rows_from": False,
    3179        "sample": False,
    3180    }
    3181
    3182    @property
    3183    def name(self) -> str:
    3184        if isinstance(self.this, Func):
    3185            return ""
    3186        return self.this.name
    3187
    3188    @property
    3189    def db(self) -> str:
    3190        return self.text("db")
    3191
    3192    @property
    3193    def catalog(self) -> str:
    3194        return self.text("catalog")
    3195
    3196    @property
    3197    def selects(self) -> t.List[Expression]:
    3198        return []
    3199
    3200    @property
    3201    def named_selects(self) -> t.List[str]:
    3202        return []
    3203
    3204    @property
    3205    def parts(self) -> t.List[Expression]:
    3206        """Return the parts of a table in order catalog, db, table."""
    3207        parts: t.List[Expression] = []
    3208
    3209        for arg in ("catalog", "db", "this"):
    3210            part = self.args.get(arg)
    3211
    3212            if isinstance(part, Dot):
    3213                parts.extend(part.flatten())
    3214            elif isinstance(part, Expression):
    3215                parts.append(part)
    3216
    3217        return parts
    3218
    3219    def to_column(self, copy: bool = True) -> Alias | Column | Dot:
    3220        parts = self.parts
    3221        last_part = parts[-1]
    3222
    3223        if isinstance(last_part, Identifier):
    3224            col = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3225        else:
    3226            # This branch will be reached if a function or array is wrapped in a `Table`
    3227            col = last_part
    3228
    3229        alias = self.args.get("alias")
    3230        if alias:
    3231            col = alias_(col, alias.this, copy=copy)
    3232
    3233        return col
    3234
    3235
    3236class SetOperation(Query):
    3237    arg_types = {
    3238        "with": False,
    3239        "this": True,
    3240        "expression": True,
    3241        "distinct": False,
    3242        "by_name": False,
    3243        **QUERY_MODIFIERS,
    3244    }
    3245
    3246    def select(
    3247        self: S,
    3248        *expressions: t.Optional[ExpOrStr],
    3249        append: bool = True,
    3250        dialect: DialectType = None,
    3251        copy: bool = True,
    3252        **opts,
    3253    ) -> S:
    3254        this = maybe_copy(self, copy)
    3255        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3256        this.expression.unnest().select(
    3257            *expressions, append=append, dialect=dialect, copy=False, **opts
    3258        )
    3259        return this
    3260
    3261    @property
    3262    def named_selects(self) -> t.List[str]:
    3263        return self.this.unnest().named_selects
    3264
    3265    @property
    3266    def is_star(self) -> bool:
    3267        return self.this.is_star or self.expression.is_star
    3268
    3269    @property
    3270    def selects(self) -> t.List[Expression]:
    3271        return self.this.unnest().selects
    3272
    3273    @property
    3274    def left(self) -> Query:
    3275        return self.this
    3276
    3277    @property
    3278    def right(self) -> Query:
    3279        return self.expression
    3280
    3281
    3282class Union(SetOperation):
    3283    pass
    3284
    3285
    3286class Except(SetOperation):
    3287    pass
    3288
    3289
    3290class Intersect(SetOperation):
    3291    pass
    3292
    3293
    3294class Update(DML):
    3295    arg_types = {
    3296        "with": False,
    3297        "this": False,
    3298        "expressions": True,
    3299        "from": False,
    3300        "where": False,
    3301        "returning": False,
    3302        "order": False,
    3303        "limit": False,
    3304    }
    3305
    3306    def table(
    3307        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3308    ) -> Update:
    3309        """
    3310        Set the table to update.
    3311
    3312        Example:
    3313            >>> Update().table("my_table").set_("x = 1").sql()
    3314            'UPDATE my_table SET x = 1'
    3315
    3316        Args:
    3317            expression : the SQL code strings to parse.
    3318                If a `Table` instance is passed, this is used as-is.
    3319                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3320            dialect: the dialect used to parse the input expression.
    3321            copy: if `False`, modify this expression instance in-place.
    3322            opts: other options to use to parse the input expressions.
    3323
    3324        Returns:
    3325            The modified Update expression.
    3326        """
    3327        return _apply_builder(
    3328            expression=expression,
    3329            instance=self,
    3330            arg="this",
    3331            into=Table,
    3332            prefix=None,
    3333            dialect=dialect,
    3334            copy=copy,
    3335            **opts,
    3336        )
    3337
    3338    def set_(
    3339        self,
    3340        *expressions: ExpOrStr,
    3341        append: bool = True,
    3342        dialect: DialectType = None,
    3343        copy: bool = True,
    3344        **opts,
    3345    ) -> Update:
    3346        """
    3347        Append to or set the SET expressions.
    3348
    3349        Example:
    3350            >>> Update().table("my_table").set_("x = 1").sql()
    3351            'UPDATE my_table SET x = 1'
    3352
    3353        Args:
    3354            *expressions: the SQL code strings to parse.
    3355                If `Expression` instance(s) are passed, they will be used as-is.
    3356                Multiple expressions are combined with a comma.
    3357            append: if `True`, add the new expressions to any existing SET expressions.
    3358                Otherwise, this resets the expressions.
    3359            dialect: the dialect used to parse the input expressions.
    3360            copy: if `False`, modify this expression instance in-place.
    3361            opts: other options to use to parse the input expressions.
    3362        """
    3363        return _apply_list_builder(
    3364            *expressions,
    3365            instance=self,
    3366            arg="expressions",
    3367            append=append,
    3368            into=Expression,
    3369            prefix=None,
    3370            dialect=dialect,
    3371            copy=copy,
    3372            **opts,
    3373        )
    3374
    3375    def where(
    3376        self,
    3377        *expressions: t.Optional[ExpOrStr],
    3378        append: bool = True,
    3379        dialect: DialectType = None,
    3380        copy: bool = True,
    3381        **opts,
    3382    ) -> Select:
    3383        """
    3384        Append to or set the WHERE expressions.
    3385
    3386        Example:
    3387            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3388            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3389
    3390        Args:
    3391            *expressions: the SQL code strings to parse.
    3392                If an `Expression` instance is passed, it will be used as-is.
    3393                Multiple expressions are combined with an AND operator.
    3394            append: if `True`, AND the new expressions to any existing expression.
    3395                Otherwise, this resets the expression.
    3396            dialect: the dialect used to parse the input expressions.
    3397            copy: if `False`, modify this expression instance in-place.
    3398            opts: other options to use to parse the input expressions.
    3399
    3400        Returns:
    3401            Select: the modified expression.
    3402        """
    3403        return _apply_conjunction_builder(
    3404            *expressions,
    3405            instance=self,
    3406            arg="where",
    3407            append=append,
    3408            into=Where,
    3409            dialect=dialect,
    3410            copy=copy,
    3411            **opts,
    3412        )
    3413
    3414    def from_(
    3415        self,
    3416        expression: t.Optional[ExpOrStr] = None,
    3417        dialect: DialectType = None,
    3418        copy: bool = True,
    3419        **opts,
    3420    ) -> Update:
    3421        """
    3422        Set the FROM expression.
    3423
    3424        Example:
    3425            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3426            'UPDATE my_table SET x = 1 FROM baz'
    3427
    3428        Args:
    3429            expression : the SQL code strings to parse.
    3430                If a `From` instance is passed, this is used as-is.
    3431                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3432                If nothing is passed in then a from is not applied to the expression
    3433            dialect: the dialect used to parse the input expression.
    3434            copy: if `False`, modify this expression instance in-place.
    3435            opts: other options to use to parse the input expressions.
    3436
    3437        Returns:
    3438            The modified Update expression.
    3439        """
    3440        if not expression:
    3441            return maybe_copy(self, copy)
    3442
    3443        return _apply_builder(
    3444            expression=expression,
    3445            instance=self,
    3446            arg="from",
    3447            into=From,
    3448            prefix="FROM",
    3449            dialect=dialect,
    3450            copy=copy,
    3451            **opts,
    3452        )
    3453
    3454    def with_(
    3455        self,
    3456        alias: ExpOrStr,
    3457        as_: ExpOrStr,
    3458        recursive: t.Optional[bool] = None,
    3459        materialized: t.Optional[bool] = None,
    3460        append: bool = True,
    3461        dialect: DialectType = None,
    3462        copy: bool = True,
    3463        **opts,
    3464    ) -> Update:
    3465        """
    3466        Append to or set the common table expressions.
    3467
    3468        Example:
    3469            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3470            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3471
    3472        Args:
    3473            alias: the SQL code string to parse as the table name.
    3474                If an `Expression` instance is passed, this is used as-is.
    3475            as_: the SQL code string to parse as the table expression.
    3476                If an `Expression` instance is passed, it will be used as-is.
    3477            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3478            materialized: set the MATERIALIZED part of the expression.
    3479            append: if `True`, add to any existing expressions.
    3480                Otherwise, this resets the expressions.
    3481            dialect: the dialect used to parse the input expression.
    3482            copy: if `False`, modify this expression instance in-place.
    3483            opts: other options to use to parse the input expressions.
    3484
    3485        Returns:
    3486            The modified expression.
    3487        """
    3488        return _apply_cte_builder(
    3489            self,
    3490            alias,
    3491            as_,
    3492            recursive=recursive,
    3493            materialized=materialized,
    3494            append=append,
    3495            dialect=dialect,
    3496            copy=copy,
    3497            **opts,
    3498        )
    3499
    3500
    3501class Values(UDTF):
    3502    arg_types = {"expressions": True, "alias": False}
    3503
    3504
    3505class Var(Expression):
    3506    pass
    3507
    3508
    3509class Version(Expression):
    3510    """
    3511    Time travel, iceberg, bigquery etc
    3512    https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots
    3513    https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html
    3514    https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of
    3515    https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16
    3516    this is either TIMESTAMP or VERSION
    3517    kind is ("AS OF", "BETWEEN")
    3518    """
    3519
    3520    arg_types = {"this": True, "kind": True, "expression": False}
    3521
    3522
    3523class Schema(Expression):
    3524    arg_types = {"this": False, "expressions": False}
    3525
    3526
    3527# https://dev.mysql.com/doc/refman/8.0/en/select.html
    3528# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SELECT.html
    3529class Lock(Expression):
    3530    arg_types = {"update": True, "expressions": False, "wait": False}
    3531
    3532
    3533class Select(Query):
    3534    arg_types = {
    3535        "with": False,
    3536        "kind": False,
    3537        "expressions": False,
    3538        "hint": False,
    3539        "distinct": False,
    3540        "into": False,
    3541        "from": False,
    3542        "operation_modifiers": False,
    3543        **QUERY_MODIFIERS,
    3544    }
    3545
    3546    def from_(
    3547        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3548    ) -> Select:
    3549        """
    3550        Set the FROM expression.
    3551
    3552        Example:
    3553            >>> Select().from_("tbl").select("x").sql()
    3554            'SELECT x FROM tbl'
    3555
    3556        Args:
    3557            expression : the SQL code strings to parse.
    3558                If a `From` instance is passed, this is used as-is.
    3559                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3560            dialect: the dialect used to parse the input expression.
    3561            copy: if `False`, modify this expression instance in-place.
    3562            opts: other options to use to parse the input expressions.
    3563
    3564        Returns:
    3565            The modified Select expression.
    3566        """
    3567        return _apply_builder(
    3568            expression=expression,
    3569            instance=self,
    3570            arg="from",
    3571            into=From,
    3572            prefix="FROM",
    3573            dialect=dialect,
    3574            copy=copy,
    3575            **opts,
    3576        )
    3577
    3578    def group_by(
    3579        self,
    3580        *expressions: t.Optional[ExpOrStr],
    3581        append: bool = True,
    3582        dialect: DialectType = None,
    3583        copy: bool = True,
    3584        **opts,
    3585    ) -> Select:
    3586        """
    3587        Set the GROUP BY expression.
    3588
    3589        Example:
    3590            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3591            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3592
    3593        Args:
    3594            *expressions: the SQL code strings to parse.
    3595                If a `Group` instance is passed, this is used as-is.
    3596                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3597                If nothing is passed in then a group by is not applied to the expression
    3598            append: if `True`, add to any existing expressions.
    3599                Otherwise, this flattens all the `Group` expression into a single expression.
    3600            dialect: the dialect used to parse the input expression.
    3601            copy: if `False`, modify this expression instance in-place.
    3602            opts: other options to use to parse the input expressions.
    3603
    3604        Returns:
    3605            The modified Select expression.
    3606        """
    3607        if not expressions:
    3608            return self if not copy else self.copy()
    3609
    3610        return _apply_child_list_builder(
    3611            *expressions,
    3612            instance=self,
    3613            arg="group",
    3614            append=append,
    3615            copy=copy,
    3616            prefix="GROUP BY",
    3617            into=Group,
    3618            dialect=dialect,
    3619            **opts,
    3620        )
    3621
    3622    def sort_by(
    3623        self,
    3624        *expressions: t.Optional[ExpOrStr],
    3625        append: bool = True,
    3626        dialect: DialectType = None,
    3627        copy: bool = True,
    3628        **opts,
    3629    ) -> Select:
    3630        """
    3631        Set the SORT BY expression.
    3632
    3633        Example:
    3634            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3635            'SELECT x FROM tbl SORT BY x DESC'
    3636
    3637        Args:
    3638            *expressions: the SQL code strings to parse.
    3639                If a `Group` instance is passed, this is used as-is.
    3640                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3641            append: if `True`, add to any existing expressions.
    3642                Otherwise, this flattens all the `Order` expression into a single expression.
    3643            dialect: the dialect used to parse the input expression.
    3644            copy: if `False`, modify this expression instance in-place.
    3645            opts: other options to use to parse the input expressions.
    3646
    3647        Returns:
    3648            The modified Select expression.
    3649        """
    3650        return _apply_child_list_builder(
    3651            *expressions,
    3652            instance=self,
    3653            arg="sort",
    3654            append=append,
    3655            copy=copy,
    3656            prefix="SORT BY",
    3657            into=Sort,
    3658            dialect=dialect,
    3659            **opts,
    3660        )
    3661
    3662    def cluster_by(
    3663        self,
    3664        *expressions: t.Optional[ExpOrStr],
    3665        append: bool = True,
    3666        dialect: DialectType = None,
    3667        copy: bool = True,
    3668        **opts,
    3669    ) -> Select:
    3670        """
    3671        Set the CLUSTER BY expression.
    3672
    3673        Example:
    3674            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3675            'SELECT x FROM tbl CLUSTER BY x DESC'
    3676
    3677        Args:
    3678            *expressions: the SQL code strings to parse.
    3679                If a `Group` instance is passed, this is used as-is.
    3680                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3681            append: if `True`, add to any existing expressions.
    3682                Otherwise, this flattens all the `Order` expression into a single expression.
    3683            dialect: the dialect used to parse the input expression.
    3684            copy: if `False`, modify this expression instance in-place.
    3685            opts: other options to use to parse the input expressions.
    3686
    3687        Returns:
    3688            The modified Select expression.
    3689        """
    3690        return _apply_child_list_builder(
    3691            *expressions,
    3692            instance=self,
    3693            arg="cluster",
    3694            append=append,
    3695            copy=copy,
    3696            prefix="CLUSTER BY",
    3697            into=Cluster,
    3698            dialect=dialect,
    3699            **opts,
    3700        )
    3701
    3702    def select(
    3703        self,
    3704        *expressions: t.Optional[ExpOrStr],
    3705        append: bool = True,
    3706        dialect: DialectType = None,
    3707        copy: bool = True,
    3708        **opts,
    3709    ) -> Select:
    3710        return _apply_list_builder(
    3711            *expressions,
    3712            instance=self,
    3713            arg="expressions",
    3714            append=append,
    3715            dialect=dialect,
    3716            into=Expression,
    3717            copy=copy,
    3718            **opts,
    3719        )
    3720
    3721    def lateral(
    3722        self,
    3723        *expressions: t.Optional[ExpOrStr],
    3724        append: bool = True,
    3725        dialect: DialectType = None,
    3726        copy: bool = True,
    3727        **opts,
    3728    ) -> Select:
    3729        """
    3730        Append to or set the LATERAL expressions.
    3731
    3732        Example:
    3733            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3734            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3735
    3736        Args:
    3737            *expressions: the SQL code strings to parse.
    3738                If an `Expression` instance is passed, it will be used as-is.
    3739            append: if `True`, add to any existing expressions.
    3740                Otherwise, this resets the expressions.
    3741            dialect: the dialect used to parse the input expressions.
    3742            copy: if `False`, modify this expression instance in-place.
    3743            opts: other options to use to parse the input expressions.
    3744
    3745        Returns:
    3746            The modified Select expression.
    3747        """
    3748        return _apply_list_builder(
    3749            *expressions,
    3750            instance=self,
    3751            arg="laterals",
    3752            append=append,
    3753            into=Lateral,
    3754            prefix="LATERAL VIEW",
    3755            dialect=dialect,
    3756            copy=copy,
    3757            **opts,
    3758        )
    3759
    3760    def join(
    3761        self,
    3762        expression: ExpOrStr,
    3763        on: t.Optional[ExpOrStr] = None,
    3764        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3765        append: bool = True,
    3766        join_type: t.Optional[str] = None,
    3767        join_alias: t.Optional[Identifier | str] = None,
    3768        dialect: DialectType = None,
    3769        copy: bool = True,
    3770        **opts,
    3771    ) -> Select:
    3772        """
    3773        Append to or set the JOIN expressions.
    3774
    3775        Example:
    3776            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3777            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3778
    3779            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3780            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3781
    3782            Use `join_type` to change the type of join:
    3783
    3784            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3785            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3786
    3787        Args:
    3788            expression: the SQL code string to parse.
    3789                If an `Expression` instance is passed, it will be used as-is.
    3790            on: optionally specify the join "on" criteria as a SQL string.
    3791                If an `Expression` instance is passed, it will be used as-is.
    3792            using: optionally specify the join "using" criteria as a SQL string.
    3793                If an `Expression` instance is passed, it will be used as-is.
    3794            append: if `True`, add to any existing expressions.
    3795                Otherwise, this resets the expressions.
    3796            join_type: if set, alter the parsed join type.
    3797            join_alias: an optional alias for the joined source.
    3798            dialect: the dialect used to parse the input expressions.
    3799            copy: if `False`, modify this expression instance in-place.
    3800            opts: other options to use to parse the input expressions.
    3801
    3802        Returns:
    3803            Select: the modified expression.
    3804        """
    3805        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3806
    3807        try:
    3808            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3809        except ParseError:
    3810            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3811
    3812        join = expression if isinstance(expression, Join) else Join(this=expression)
    3813
    3814        if isinstance(join.this, Select):
    3815            join.this.replace(join.this.subquery())
    3816
    3817        if join_type:
    3818            method: t.Optional[Token]
    3819            side: t.Optional[Token]
    3820            kind: t.Optional[Token]
    3821
    3822            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3823
    3824            if method:
    3825                join.set("method", method.text)
    3826            if side:
    3827                join.set("side", side.text)
    3828            if kind:
    3829                join.set("kind", kind.text)
    3830
    3831        if on:
    3832            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3833            join.set("on", on)
    3834
    3835        if using:
    3836            join = _apply_list_builder(
    3837                *ensure_list(using),
    3838                instance=join,
    3839                arg="using",
    3840                append=append,
    3841                copy=copy,
    3842                into=Identifier,
    3843                **opts,
    3844            )
    3845
    3846        if join_alias:
    3847            join.set("this", alias_(join.this, join_alias, table=True))
    3848
    3849        return _apply_list_builder(
    3850            join,
    3851            instance=self,
    3852            arg="joins",
    3853            append=append,
    3854            copy=copy,
    3855            **opts,
    3856        )
    3857
    3858    def where(
    3859        self,
    3860        *expressions: t.Optional[ExpOrStr],
    3861        append: bool = True,
    3862        dialect: DialectType = None,
    3863        copy: bool = True,
    3864        **opts,
    3865    ) -> Select:
    3866        """
    3867        Append to or set the WHERE expressions.
    3868
    3869        Example:
    3870            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3871            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3872
    3873        Args:
    3874            *expressions: the SQL code strings to parse.
    3875                If an `Expression` instance is passed, it will be used as-is.
    3876                Multiple expressions are combined with an AND operator.
    3877            append: if `True`, AND the new expressions to any existing expression.
    3878                Otherwise, this resets the expression.
    3879            dialect: the dialect used to parse the input expressions.
    3880            copy: if `False`, modify this expression instance in-place.
    3881            opts: other options to use to parse the input expressions.
    3882
    3883        Returns:
    3884            Select: the modified expression.
    3885        """
    3886        return _apply_conjunction_builder(
    3887            *expressions,
    3888            instance=self,
    3889            arg="where",
    3890            append=append,
    3891            into=Where,
    3892            dialect=dialect,
    3893            copy=copy,
    3894            **opts,
    3895        )
    3896
    3897    def having(
    3898        self,
    3899        *expressions: t.Optional[ExpOrStr],
    3900        append: bool = True,
    3901        dialect: DialectType = None,
    3902        copy: bool = True,
    3903        **opts,
    3904    ) -> Select:
    3905        """
    3906        Append to or set the HAVING expressions.
    3907
    3908        Example:
    3909            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3910            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3911
    3912        Args:
    3913            *expressions: the SQL code strings to parse.
    3914                If an `Expression` instance is passed, it will be used as-is.
    3915                Multiple expressions are combined with an AND operator.
    3916            append: if `True`, AND the new expressions to any existing expression.
    3917                Otherwise, this resets the expression.
    3918            dialect: the dialect used to parse the input expressions.
    3919            copy: if `False`, modify this expression instance in-place.
    3920            opts: other options to use to parse the input expressions.
    3921
    3922        Returns:
    3923            The modified Select expression.
    3924        """
    3925        return _apply_conjunction_builder(
    3926            *expressions,
    3927            instance=self,
    3928            arg="having",
    3929            append=append,
    3930            into=Having,
    3931            dialect=dialect,
    3932            copy=copy,
    3933            **opts,
    3934        )
    3935
    3936    def window(
    3937        self,
    3938        *expressions: t.Optional[ExpOrStr],
    3939        append: bool = True,
    3940        dialect: DialectType = None,
    3941        copy: bool = True,
    3942        **opts,
    3943    ) -> Select:
    3944        return _apply_list_builder(
    3945            *expressions,
    3946            instance=self,
    3947            arg="windows",
    3948            append=append,
    3949            into=Window,
    3950            dialect=dialect,
    3951            copy=copy,
    3952            **opts,
    3953        )
    3954
    3955    def qualify(
    3956        self,
    3957        *expressions: t.Optional[ExpOrStr],
    3958        append: bool = True,
    3959        dialect: DialectType = None,
    3960        copy: bool = True,
    3961        **opts,
    3962    ) -> Select:
    3963        return _apply_conjunction_builder(
    3964            *expressions,
    3965            instance=self,
    3966            arg="qualify",
    3967            append=append,
    3968            into=Qualify,
    3969            dialect=dialect,
    3970            copy=copy,
    3971            **opts,
    3972        )
    3973
    3974    def distinct(
    3975        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3976    ) -> Select:
    3977        """
    3978        Set the OFFSET expression.
    3979
    3980        Example:
    3981            >>> Select().from_("tbl").select("x").distinct().sql()
    3982            'SELECT DISTINCT x FROM tbl'
    3983
    3984        Args:
    3985            ons: the expressions to distinct on
    3986            distinct: whether the Select should be distinct
    3987            copy: if `False`, modify this expression instance in-place.
    3988
    3989        Returns:
    3990            Select: the modified expression.
    3991        """
    3992        instance = maybe_copy(self, copy)
    3993        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3994        instance.set("distinct", Distinct(on=on) if distinct else None)
    3995        return instance
    3996
    3997    def ctas(
    3998        self,
    3999        table: ExpOrStr,
    4000        properties: t.Optional[t.Dict] = None,
    4001        dialect: DialectType = None,
    4002        copy: bool = True,
    4003        **opts,
    4004    ) -> Create:
    4005        """
    4006        Convert this expression to a CREATE TABLE AS statement.
    4007
    4008        Example:
    4009            >>> Select().select("*").from_("tbl").ctas("x").sql()
    4010            'CREATE TABLE x AS SELECT * FROM tbl'
    4011
    4012        Args:
    4013            table: the SQL code string to parse as the table name.
    4014                If another `Expression` instance is passed, it will be used as-is.
    4015            properties: an optional mapping of table properties
    4016            dialect: the dialect used to parse the input table.
    4017            copy: if `False`, modify this expression instance in-place.
    4018            opts: other options to use to parse the input table.
    4019
    4020        Returns:
    4021            The new Create expression.
    4022        """
    4023        instance = maybe_copy(self, copy)
    4024        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4025
    4026        properties_expression = None
    4027        if properties:
    4028            properties_expression = Properties.from_dict(properties)
    4029
    4030        return Create(
    4031            this=table_expression,
    4032            kind="TABLE",
    4033            expression=instance,
    4034            properties=properties_expression,
    4035        )
    4036
    4037    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4038        """
    4039        Set the locking read mode for this expression.
    4040
    4041        Examples:
    4042            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4043            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4044
    4045            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4046            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4047
    4048        Args:
    4049            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4050            copy: if `False`, modify this expression instance in-place.
    4051
    4052        Returns:
    4053            The modified expression.
    4054        """
    4055        inst = maybe_copy(self, copy)
    4056        inst.set("locks", [Lock(update=update)])
    4057
    4058        return inst
    4059
    4060    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4061        """
    4062        Set hints for this expression.
    4063
    4064        Examples:
    4065            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4066            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4067
    4068        Args:
    4069            hints: The SQL code strings to parse as the hints.
    4070                If an `Expression` instance is passed, it will be used as-is.
    4071            dialect: The dialect used to parse the hints.
    4072            copy: If `False`, modify this expression instance in-place.
    4073
    4074        Returns:
    4075            The modified expression.
    4076        """
    4077        inst = maybe_copy(self, copy)
    4078        inst.set(
    4079            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4080        )
    4081
    4082        return inst
    4083
    4084    @property
    4085    def named_selects(self) -> t.List[str]:
    4086        return [e.output_name for e in self.expressions if e.alias_or_name]
    4087
    4088    @property
    4089    def is_star(self) -> bool:
    4090        return any(expression.is_star for expression in self.expressions)
    4091
    4092    @property
    4093    def selects(self) -> t.List[Expression]:
    4094        return self.expressions
    4095
    4096
    4097UNWRAPPED_QUERIES = (Select, SetOperation)
    4098
    4099
    4100class Subquery(DerivedTable, Query):
    4101    arg_types = {
    4102        "this": True,
    4103        "alias": False,
    4104        "with": False,
    4105        **QUERY_MODIFIERS,
    4106    }
    4107
    4108    def unnest(self):
    4109        """Returns the first non subquery."""
    4110        expression = self
    4111        while isinstance(expression, Subquery):
    4112            expression = expression.this
    4113        return expression
    4114
    4115    def unwrap(self) -> Subquery:
    4116        expression = self
    4117        while expression.same_parent and expression.is_wrapper:
    4118            expression = t.cast(Subquery, expression.parent)
    4119        return expression
    4120
    4121    def select(
    4122        self,
    4123        *expressions: t.Optional[ExpOrStr],
    4124        append: bool = True,
    4125        dialect: DialectType = None,
    4126        copy: bool = True,
    4127        **opts,
    4128    ) -> Subquery:
    4129        this = maybe_copy(self, copy)
    4130        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4131        return this
    4132
    4133    @property
    4134    def is_wrapper(self) -> bool:
    4135        """
    4136        Whether this Subquery acts as a simple wrapper around another expression.
    4137
    4138        SELECT * FROM (((SELECT * FROM t)))
    4139                      ^
    4140                      This corresponds to a "wrapper" Subquery node
    4141        """
    4142        return all(v is None for k, v in self.args.items() if k != "this")
    4143
    4144    @property
    4145    def is_star(self) -> bool:
    4146        return self.this.is_star
    4147
    4148    @property
    4149    def output_name(self) -> str:
    4150        return self.alias
    4151
    4152
    4153class TableSample(Expression):
    4154    arg_types = {
    4155        "expressions": False,
    4156        "method": False,
    4157        "bucket_numerator": False,
    4158        "bucket_denominator": False,
    4159        "bucket_field": False,
    4160        "percent": False,
    4161        "rows": False,
    4162        "size": False,
    4163        "seed": False,
    4164    }
    4165
    4166
    4167class Tag(Expression):
    4168    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    4169
    4170    arg_types = {
    4171        "this": False,
    4172        "prefix": False,
    4173        "postfix": False,
    4174    }
    4175
    4176
    4177# Represents both the standard SQL PIVOT operator and DuckDB's "simplified" PIVOT syntax
    4178# https://duckdb.org/docs/sql/statements/pivot
    4179class Pivot(Expression):
    4180    arg_types = {
    4181        "this": False,
    4182        "alias": False,
    4183        "expressions": False,
    4184        "field": False,
    4185        "unpivot": False,
    4186        "using": False,
    4187        "group": False,
    4188        "columns": False,
    4189        "include_nulls": False,
    4190        "default_on_null": False,
    4191    }
    4192
    4193    @property
    4194    def unpivot(self) -> bool:
    4195        return bool(self.args.get("unpivot"))
    4196
    4197
    4198class Window(Condition):
    4199    arg_types = {
    4200        "this": True,
    4201        "partition_by": False,
    4202        "order": False,
    4203        "spec": False,
    4204        "alias": False,
    4205        "over": False,
    4206        "first": False,
    4207    }
    4208
    4209
    4210class WindowSpec(Expression):
    4211    arg_types = {
    4212        "kind": False,
    4213        "start": False,
    4214        "start_side": False,
    4215        "end": False,
    4216        "end_side": False,
    4217    }
    4218
    4219
    4220class PreWhere(Expression):
    4221    pass
    4222
    4223
    4224class Where(Expression):
    4225    pass
    4226
    4227
    4228class Star(Expression):
    4229    arg_types = {"except": False, "replace": False, "rename": False}
    4230
    4231    @property
    4232    def name(self) -> str:
    4233        return "*"
    4234
    4235    @property
    4236    def output_name(self) -> str:
    4237        return self.name
    4238
    4239
    4240class Parameter(Condition):
    4241    arg_types = {"this": True, "expression": False}
    4242
    4243
    4244class SessionParameter(Condition):
    4245    arg_types = {"this": True, "kind": False}
    4246
    4247
    4248class Placeholder(Condition):
    4249    arg_types = {"this": False, "kind": False}
    4250
    4251    @property
    4252    def name(self) -> str:
    4253        return self.this or "?"
    4254
    4255
    4256class Null(Condition):
    4257    arg_types: t.Dict[str, t.Any] = {}
    4258
    4259    @property
    4260    def name(self) -> str:
    4261        return "NULL"
    4262
    4263    def to_py(self) -> Lit[None]:
    4264        return None
    4265
    4266
    4267class Boolean(Condition):
    4268    def to_py(self) -> bool:
    4269        return self.this
    4270
    4271
    4272class DataTypeParam(Expression):
    4273    arg_types = {"this": True, "expression": False}
    4274
    4275    @property
    4276    def name(self) -> str:
    4277        return self.this.name
    4278
    4279
    4280# The `nullable` arg is helpful when transpiling types from other dialects to ClickHouse, which
    4281# assumes non-nullable types by default. Values `None` and `True` mean the type is nullable.
    4282class DataType(Expression):
    4283    arg_types = {
    4284        "this": True,
    4285        "expressions": False,
    4286        "nested": False,
    4287        "values": False,
    4288        "prefix": False,
    4289        "kind": False,
    4290        "nullable": False,
    4291    }
    4292
    4293    class Type(AutoName):
    4294        ARRAY = auto()
    4295        AGGREGATEFUNCTION = auto()
    4296        SIMPLEAGGREGATEFUNCTION = auto()
    4297        BIGDECIMAL = auto()
    4298        BIGINT = auto()
    4299        BIGSERIAL = auto()
    4300        BINARY = auto()
    4301        BIT = auto()
    4302        BOOLEAN = auto()
    4303        BPCHAR = auto()
    4304        CHAR = auto()
    4305        DATE = auto()
    4306        DATE32 = auto()
    4307        DATEMULTIRANGE = auto()
    4308        DATERANGE = auto()
    4309        DATETIME = auto()
    4310        DATETIME64 = auto()
    4311        DECIMAL = auto()
    4312        DECIMAL32 = auto()
    4313        DECIMAL64 = auto()
    4314        DECIMAL128 = auto()
    4315        DECIMAL256 = auto()
    4316        DOUBLE = auto()
    4317        ENUM = auto()
    4318        ENUM8 = auto()
    4319        ENUM16 = auto()
    4320        FIXEDSTRING = auto()
    4321        FLOAT = auto()
    4322        GEOGRAPHY = auto()
    4323        GEOMETRY = auto()
    4324        POINT = auto()
    4325        RING = auto()
    4326        LINESTRING = auto()
    4327        MULTILINESTRING = auto()
    4328        POLYGON = auto()
    4329        MULTIPOLYGON = auto()
    4330        HLLSKETCH = auto()
    4331        HSTORE = auto()
    4332        IMAGE = auto()
    4333        INET = auto()
    4334        INT = auto()
    4335        INT128 = auto()
    4336        INT256 = auto()
    4337        INT4MULTIRANGE = auto()
    4338        INT4RANGE = auto()
    4339        INT8MULTIRANGE = auto()
    4340        INT8RANGE = auto()
    4341        INTERVAL = auto()
    4342        IPADDRESS = auto()
    4343        IPPREFIX = auto()
    4344        IPV4 = auto()
    4345        IPV6 = auto()
    4346        JSON = auto()
    4347        JSONB = auto()
    4348        LIST = auto()
    4349        LONGBLOB = auto()
    4350        LONGTEXT = auto()
    4351        LOWCARDINALITY = auto()
    4352        MAP = auto()
    4353        MEDIUMBLOB = auto()
    4354        MEDIUMINT = auto()
    4355        MEDIUMTEXT = auto()
    4356        MONEY = auto()
    4357        NAME = auto()
    4358        NCHAR = auto()
    4359        NESTED = auto()
    4360        NULL = auto()
    4361        NUMMULTIRANGE = auto()
    4362        NUMRANGE = auto()
    4363        NVARCHAR = auto()
    4364        OBJECT = auto()
    4365        RANGE = auto()
    4366        ROWVERSION = auto()
    4367        SERIAL = auto()
    4368        SET = auto()
    4369        SMALLINT = auto()
    4370        SMALLMONEY = auto()
    4371        SMALLSERIAL = auto()
    4372        STRUCT = auto()
    4373        SUPER = auto()
    4374        TEXT = auto()
    4375        TINYBLOB = auto()
    4376        TINYTEXT = auto()
    4377        TIME = auto()
    4378        TIMETZ = auto()
    4379        TIMESTAMP = auto()
    4380        TIMESTAMPNTZ = auto()
    4381        TIMESTAMPLTZ = auto()
    4382        TIMESTAMPTZ = auto()
    4383        TIMESTAMP_S = auto()
    4384        TIMESTAMP_MS = auto()
    4385        TIMESTAMP_NS = auto()
    4386        TINYINT = auto()
    4387        TSMULTIRANGE = auto()
    4388        TSRANGE = auto()
    4389        TSTZMULTIRANGE = auto()
    4390        TSTZRANGE = auto()
    4391        UBIGINT = auto()
    4392        UINT = auto()
    4393        UINT128 = auto()
    4394        UINT256 = auto()
    4395        UMEDIUMINT = auto()
    4396        UDECIMAL = auto()
    4397        UNION = auto()
    4398        UNIQUEIDENTIFIER = auto()
    4399        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4400        USERDEFINED = "USER-DEFINED"
    4401        USMALLINT = auto()
    4402        UTINYINT = auto()
    4403        UUID = auto()
    4404        VARBINARY = auto()
    4405        VARCHAR = auto()
    4406        VARIANT = auto()
    4407        VECTOR = auto()
    4408        XML = auto()
    4409        YEAR = auto()
    4410        TDIGEST = auto()
    4411
    4412    STRUCT_TYPES = {
    4413        Type.NESTED,
    4414        Type.OBJECT,
    4415        Type.STRUCT,
    4416        Type.UNION,
    4417    }
    4418
    4419    ARRAY_TYPES = {
    4420        Type.ARRAY,
    4421        Type.LIST,
    4422    }
    4423
    4424    NESTED_TYPES = {
    4425        *STRUCT_TYPES,
    4426        *ARRAY_TYPES,
    4427        Type.MAP,
    4428    }
    4429
    4430    TEXT_TYPES = {
    4431        Type.CHAR,
    4432        Type.NCHAR,
    4433        Type.NVARCHAR,
    4434        Type.TEXT,
    4435        Type.VARCHAR,
    4436        Type.NAME,
    4437    }
    4438
    4439    SIGNED_INTEGER_TYPES = {
    4440        Type.BIGINT,
    4441        Type.INT,
    4442        Type.INT128,
    4443        Type.INT256,
    4444        Type.MEDIUMINT,
    4445        Type.SMALLINT,
    4446        Type.TINYINT,
    4447    }
    4448
    4449    UNSIGNED_INTEGER_TYPES = {
    4450        Type.UBIGINT,
    4451        Type.UINT,
    4452        Type.UINT128,
    4453        Type.UINT256,
    4454        Type.UMEDIUMINT,
    4455        Type.USMALLINT,
    4456        Type.UTINYINT,
    4457    }
    4458
    4459    INTEGER_TYPES = {
    4460        *SIGNED_INTEGER_TYPES,
    4461        *UNSIGNED_INTEGER_TYPES,
    4462        Type.BIT,
    4463    }
    4464
    4465    FLOAT_TYPES = {
    4466        Type.DOUBLE,
    4467        Type.FLOAT,
    4468    }
    4469
    4470    REAL_TYPES = {
    4471        *FLOAT_TYPES,
    4472        Type.BIGDECIMAL,
    4473        Type.DECIMAL,
    4474        Type.DECIMAL32,
    4475        Type.DECIMAL64,
    4476        Type.DECIMAL128,
    4477        Type.DECIMAL256,
    4478        Type.MONEY,
    4479        Type.SMALLMONEY,
    4480        Type.UDECIMAL,
    4481    }
    4482
    4483    NUMERIC_TYPES = {
    4484        *INTEGER_TYPES,
    4485        *REAL_TYPES,
    4486    }
    4487
    4488    TEMPORAL_TYPES = {
    4489        Type.DATE,
    4490        Type.DATE32,
    4491        Type.DATETIME,
    4492        Type.DATETIME64,
    4493        Type.TIME,
    4494        Type.TIMESTAMP,
    4495        Type.TIMESTAMPNTZ,
    4496        Type.TIMESTAMPLTZ,
    4497        Type.TIMESTAMPTZ,
    4498        Type.TIMESTAMP_MS,
    4499        Type.TIMESTAMP_NS,
    4500        Type.TIMESTAMP_S,
    4501        Type.TIMETZ,
    4502    }
    4503
    4504    @classmethod
    4505    def build(
    4506        cls,
    4507        dtype: DATA_TYPE,
    4508        dialect: DialectType = None,
    4509        udt: bool = False,
    4510        copy: bool = True,
    4511        **kwargs,
    4512    ) -> DataType:
    4513        """
    4514        Constructs a DataType object.
    4515
    4516        Args:
    4517            dtype: the data type of interest.
    4518            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4519            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4520                DataType, thus creating a user-defined type.
    4521            copy: whether to copy the data type.
    4522            kwargs: additional arguments to pass in the constructor of DataType.
    4523
    4524        Returns:
    4525            The constructed DataType object.
    4526        """
    4527        from sqlglot import parse_one
    4528
    4529        if isinstance(dtype, str):
    4530            if dtype.upper() == "UNKNOWN":
    4531                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4532
    4533            try:
    4534                data_type_exp = parse_one(
    4535                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4536                )
    4537            except ParseError:
    4538                if udt:
    4539                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4540                raise
    4541        elif isinstance(dtype, DataType.Type):
    4542            data_type_exp = DataType(this=dtype)
    4543        elif isinstance(dtype, DataType):
    4544            return maybe_copy(dtype, copy)
    4545        else:
    4546            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4547
    4548        return DataType(**{**data_type_exp.args, **kwargs})
    4549
    4550    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4551        """
    4552        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4553        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4554
    4555        Args:
    4556            dtypes: the data types to compare this DataType to.
    4557            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4558                If false, it means that NULLABLE<INT> is equivalent to INT.
    4559
    4560        Returns:
    4561            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4562        """
    4563        self_is_nullable = self.args.get("nullable")
    4564        for dtype in dtypes:
    4565            other_type = DataType.build(dtype, copy=False, udt=True)
    4566            other_is_nullable = other_type.args.get("nullable")
    4567            if (
    4568                other_type.expressions
    4569                or (check_nullable and (self_is_nullable or other_is_nullable))
    4570                or self.this == DataType.Type.USERDEFINED
    4571                or other_type.this == DataType.Type.USERDEFINED
    4572            ):
    4573                matches = self == other_type
    4574            else:
    4575                matches = self.this == other_type.this
    4576
    4577            if matches:
    4578                return True
    4579        return False
    4580
    4581
    4582DATA_TYPE = t.Union[str, DataType, DataType.Type]
    4583
    4584
    4585# https://www.postgresql.org/docs/15/datatype-pseudo.html
    4586class PseudoType(DataType):
    4587    arg_types = {"this": True}
    4588
    4589
    4590# https://www.postgresql.org/docs/15/datatype-oid.html
    4591class ObjectIdentifier(DataType):
    4592    arg_types = {"this": True}
    4593
    4594
    4595# WHERE x <OP> EXISTS|ALL|ANY|SOME(SELECT ...)
    4596class SubqueryPredicate(Predicate):
    4597    pass
    4598
    4599
    4600class All(SubqueryPredicate):
    4601    pass
    4602
    4603
    4604class Any(SubqueryPredicate):
    4605    pass
    4606
    4607
    4608class Exists(SubqueryPredicate):
    4609    pass
    4610
    4611
    4612# Commands to interact with the databases or engines. For most of the command
    4613# expressions we parse whatever comes after the command's name as a string.
    4614class Command(Expression):
    4615    arg_types = {"this": True, "expression": False}
    4616
    4617
    4618class Transaction(Expression):
    4619    arg_types = {"this": False, "modes": False, "mark": False}
    4620
    4621
    4622class Commit(Expression):
    4623    arg_types = {"chain": False, "this": False, "durability": False}
    4624
    4625
    4626class Rollback(Expression):
    4627    arg_types = {"savepoint": False, "this": False}
    4628
    4629
    4630class Alter(Expression):
    4631    arg_types = {
    4632        "this": True,
    4633        "kind": True,
    4634        "actions": True,
    4635        "exists": False,
    4636        "only": False,
    4637        "options": False,
    4638        "cluster": False,
    4639        "not_valid": False,
    4640    }
    4641
    4642    @property
    4643    def kind(self) -> t.Optional[str]:
    4644        kind = self.args.get("kind")
    4645        return kind and kind.upper()
    4646
    4647    @property
    4648    def actions(self) -> t.List[Expression]:
    4649        return self.args.get("actions") or []
    4650
    4651
    4652class AddConstraint(Expression):
    4653    arg_types = {"expressions": True}
    4654
    4655
    4656class DropPartition(Expression):
    4657    arg_types = {"expressions": True, "exists": False}
    4658
    4659
    4660# https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#replace-partition
    4661class ReplacePartition(Expression):
    4662    arg_types = {"expression": True, "source": True}
    4663
    4664
    4665# Binary expressions like (ADD a b)
    4666class Binary(Condition):
    4667    arg_types = {"this": True, "expression": True}
    4668
    4669    @property
    4670    def left(self) -> Expression:
    4671        return self.this
    4672
    4673    @property
    4674    def right(self) -> Expression:
    4675        return self.expression
    4676
    4677
    4678class Add(Binary):
    4679    pass
    4680
    4681
    4682class Connector(Binary):
    4683    pass
    4684
    4685
    4686class And(Connector):
    4687    pass
    4688
    4689
    4690class Or(Connector):
    4691    pass
    4692
    4693
    4694class BitwiseAnd(Binary):
    4695    pass
    4696
    4697
    4698class BitwiseLeftShift(Binary):
    4699    pass
    4700
    4701
    4702class BitwiseOr(Binary):
    4703    pass
    4704
    4705
    4706class BitwiseRightShift(Binary):
    4707    pass
    4708
    4709
    4710class BitwiseXor(Binary):
    4711    pass
    4712
    4713
    4714class Div(Binary):
    4715    arg_types = {"this": True, "expression": True, "typed": False, "safe": False}
    4716
    4717
    4718class Overlaps(Binary):
    4719    pass
    4720
    4721
    4722class Dot(Binary):
    4723    @property
    4724    def is_star(self) -> bool:
    4725        return self.expression.is_star
    4726
    4727    @property
    4728    def name(self) -> str:
    4729        return self.expression.name
    4730
    4731    @property
    4732    def output_name(self) -> str:
    4733        return self.name
    4734
    4735    @classmethod
    4736    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    4737        """Build a Dot object with a sequence of expressions."""
    4738        if len(expressions) < 2:
    4739            raise ValueError("Dot requires >= 2 expressions.")
    4740
    4741        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))
    4742
    4743    @property
    4744    def parts(self) -> t.List[Expression]:
    4745        """Return the parts of a table / column in order catalog, db, table."""
    4746        this, *parts = self.flatten()
    4747
    4748        parts.reverse()
    4749
    4750        for arg in COLUMN_PARTS:
    4751            part = this.args.get(arg)
    4752
    4753            if isinstance(part, Expression):
    4754                parts.append(part)
    4755
    4756        parts.reverse()
    4757        return parts
    4758
    4759
    4760class DPipe(Binary):
    4761    arg_types = {"this": True, "expression": True, "safe": False}
    4762
    4763
    4764class EQ(Binary, Predicate):
    4765    pass
    4766
    4767
    4768class NullSafeEQ(Binary, Predicate):
    4769    pass
    4770
    4771
    4772class NullSafeNEQ(Binary, Predicate):
    4773    pass
    4774
    4775
    4776# Represents e.g. := in DuckDB which is mostly used for setting parameters
    4777class PropertyEQ(Binary):
    4778    pass
    4779
    4780
    4781class Distance(Binary):
    4782    pass
    4783
    4784
    4785class Escape(Binary):
    4786    pass
    4787
    4788
    4789class Glob(Binary, Predicate):
    4790    pass
    4791
    4792
    4793class GT(Binary, Predicate):
    4794    pass
    4795
    4796
    4797class GTE(Binary, Predicate):
    4798    pass
    4799
    4800
    4801class ILike(Binary, Predicate):
    4802    pass
    4803
    4804
    4805class ILikeAny(Binary, Predicate):
    4806    pass
    4807
    4808
    4809class IntDiv(Binary):
    4810    pass
    4811
    4812
    4813class Is(Binary, Predicate):
    4814    pass
    4815
    4816
    4817class Kwarg(Binary):
    4818    """Kwarg in special functions like func(kwarg => y)."""
    4819
    4820
    4821class Like(Binary, Predicate):
    4822    pass
    4823
    4824
    4825class LikeAny(Binary, Predicate):
    4826    pass
    4827
    4828
    4829class LT(Binary, Predicate):
    4830    pass
    4831
    4832
    4833class LTE(Binary, Predicate):
    4834    pass
    4835
    4836
    4837class Mod(Binary):
    4838    pass
    4839
    4840
    4841class Mul(Binary):
    4842    pass
    4843
    4844
    4845class NEQ(Binary, Predicate):
    4846    pass
    4847
    4848
    4849# https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-PATH
    4850class Operator(Binary):
    4851    arg_types = {"this": True, "operator": True, "expression": True}
    4852
    4853
    4854class SimilarTo(Binary, Predicate):
    4855    pass
    4856
    4857
    4858class Slice(Binary):
    4859    arg_types = {"this": False, "expression": False}
    4860
    4861
    4862class Sub(Binary):
    4863    pass
    4864
    4865
    4866# Unary Expressions
    4867# (NOT a)
    4868class Unary(Condition):
    4869    pass
    4870
    4871
    4872class BitwiseNot(Unary):
    4873    pass
    4874
    4875
    4876class Not(Unary):
    4877    pass
    4878
    4879
    4880class Paren(Unary):
    4881    @property
    4882    def output_name(self) -> str:
    4883        return self.this.name
    4884
    4885
    4886class Neg(Unary):
    4887    def to_py(self) -> int | Decimal:
    4888        if self.is_number:
    4889            return self.this.to_py() * -1
    4890        return super().to_py()
    4891
    4892
    4893class Alias(Expression):
    4894    arg_types = {"this": True, "alias": False}
    4895
    4896    @property
    4897    def output_name(self) -> str:
    4898        return self.alias
    4899
    4900
    4901# BigQuery requires the UNPIVOT column list aliases to be either strings or ints, but
    4902# other dialects require identifiers. This enables us to transpile between them easily.
    4903class PivotAlias(Alias):
    4904    pass
    4905
    4906
    4907# Represents Snowflake's ANY [ ORDER BY ... ] syntax
    4908# https://docs.snowflake.com/en/sql-reference/constructs/pivot
    4909class PivotAny(Expression):
    4910    arg_types = {"this": False}
    4911
    4912
    4913class Aliases(Expression):
    4914    arg_types = {"this": True, "expressions": True}
    4915
    4916    @property
    4917    def aliases(self):
    4918        return self.expressions
    4919
    4920
    4921# https://docs.aws.amazon.com/redshift/latest/dg/query-super.html
    4922class AtIndex(Expression):
    4923    arg_types = {"this": True, "expression": True}
    4924
    4925
    4926class AtTimeZone(Expression):
    4927    arg_types = {"this": True, "zone": True}
    4928
    4929
    4930class FromTimeZone(Expression):
    4931    arg_types = {"this": True, "zone": True}
    4932
    4933
    4934class Between(Predicate):
    4935    arg_types = {"this": True, "low": True, "high": True}
    4936
    4937
    4938class Bracket(Condition):
    4939    # https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#array_subscript_operator
    4940    arg_types = {
    4941        "this": True,
    4942        "expressions": True,
    4943        "offset": False,
    4944        "safe": False,
    4945        "returns_list_for_maps": False,
    4946    }
    4947
    4948    @property
    4949    def output_name(self) -> str:
    4950        if len(self.expressions) == 1:
    4951            return self.expressions[0].output_name
    4952
    4953        return super().output_name
    4954
    4955
    4956class Distinct(Expression):
    4957    arg_types = {"expressions": False, "on": False}
    4958
    4959
    4960class In(Predicate):
    4961    arg_types = {
    4962        "this": True,
    4963        "expressions": False,
    4964        "query": False,
    4965        "unnest": False,
    4966        "field": False,
    4967        "is_global": False,
    4968    }
    4969
    4970
    4971# https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#for-in
    4972class ForIn(Expression):
    4973    arg_types = {"this": True, "expression": True}
    4974
    4975
    4976class TimeUnit(Expression):
    4977    """Automatically converts unit arg into a var."""
    4978
    4979    arg_types = {"unit": False}
    4980
    4981    UNABBREVIATED_UNIT_NAME = {
    4982        "D": "DAY",
    4983        "H": "HOUR",
    4984        "M": "MINUTE",
    4985        "MS": "MILLISECOND",
    4986        "NS": "NANOSECOND",
    4987        "Q": "QUARTER",
    4988        "S": "SECOND",
    4989        "US": "MICROSECOND",
    4990        "W": "WEEK",
    4991        "Y": "YEAR",
    4992    }
    4993
    4994    VAR_LIKE = (Column, Literal, Var)
    4995
    4996    def __init__(self, **args):
    4997        unit = args.get("unit")
    4998        if isinstance(unit, self.VAR_LIKE):
    4999            args["unit"] = Var(
    5000                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5001            )
    5002        elif isinstance(unit, Week):
    5003            unit.set("this", Var(this=unit.this.name.upper()))
    5004
    5005        super().__init__(**args)
    5006
    5007    @property
    5008    def unit(self) -> t.Optional[Var | IntervalSpan]:
    5009        return self.args.get("unit")
    5010
    5011
    5012class IntervalOp(TimeUnit):
    5013    arg_types = {"unit": False, "expression": True}
    5014
    5015    def interval(self):
    5016        return Interval(
    5017            this=self.expression.copy(),
    5018            unit=self.unit.copy() if self.unit else None,
    5019        )
    5020
    5021
    5022# https://www.oracletutorial.com/oracle-basics/oracle-interval/
    5023# https://trino.io/docs/current/language/types.html#interval-day-to-second
    5024# https://docs.databricks.com/en/sql/language-manual/data-types/interval-type.html
    5025class IntervalSpan(DataType):
    5026    arg_types = {"this": True, "expression": True}
    5027
    5028
    5029class Interval(TimeUnit):
    5030    arg_types = {"this": False, "unit": False}
    5031
    5032
    5033class IgnoreNulls(Expression):
    5034    pass
    5035
    5036
    5037class RespectNulls(Expression):
    5038    pass
    5039
    5040
    5041# https://cloud.google.com/bigquery/docs/reference/standard-sql/aggregate-function-calls#max_min_clause
    5042class HavingMax(Expression):
    5043    arg_types = {"this": True, "expression": True, "max": True}
    5044
    5045
    5046# Functions
    5047class Func(Condition):
    5048    """
    5049    The base class for all function expressions.
    5050
    5051    Attributes:
    5052        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    5053            treated as a variable length argument and the argument's value will be stored as a list.
    5054        _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this
    5055            function expression. These values are used to map this node to a name during parsing as
    5056            well as to provide the function's name during SQL string generation. By default the SQL
    5057            name is set to the expression's class name transformed to snake case.
    5058    """
    5059
    5060    is_var_len_args = False
    5061
    5062    @classmethod
    5063    def from_arg_list(cls, args):
    5064        if cls.is_var_len_args:
    5065            all_arg_keys = list(cls.arg_types)
    5066            # If this function supports variable length argument treat the last argument as such.
    5067            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5068            num_non_var = len(non_var_len_arg_keys)
    5069
    5070            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5071            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5072        else:
    5073            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5074
    5075        return cls(**args_dict)
    5076
    5077    @classmethod
    5078    def sql_names(cls):
    5079        if cls is Func:
    5080            raise NotImplementedError(
    5081                "SQL name is only supported by concrete function implementations"
    5082            )
    5083        if "_sql_names" not in cls.__dict__:
    5084            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5085        return cls._sql_names
    5086
    5087    @classmethod
    5088    def sql_name(cls):
    5089        return cls.sql_names()[0]
    5090
    5091    @classmethod
    5092    def default_parser_mappings(cls):
    5093        return {name: cls.from_arg_list for name in cls.sql_names()}
    5094
    5095
    5096class AggFunc(Func):
    5097    pass
    5098
    5099
    5100class ParameterizedAgg(AggFunc):
    5101    arg_types = {"this": True, "expressions": True, "params": True}
    5102
    5103
    5104class Abs(Func):
    5105    pass
    5106
    5107
    5108class ArgMax(AggFunc):
    5109    arg_types = {"this": True, "expression": True, "count": False}
    5110    _sql_names = ["ARG_MAX", "ARGMAX", "MAX_BY"]
    5111
    5112
    5113class ArgMin(AggFunc):
    5114    arg_types = {"this": True, "expression": True, "count": False}
    5115    _sql_names = ["ARG_MIN", "ARGMIN", "MIN_BY"]
    5116
    5117
    5118class ApproxTopK(AggFunc):
    5119    arg_types = {"this": True, "expression": False, "counters": False}
    5120
    5121
    5122class Flatten(Func):
    5123    pass
    5124
    5125
    5126# https://spark.apache.org/docs/latest/api/sql/index.html#transform
    5127class Transform(Func):
    5128    arg_types = {"this": True, "expression": True}
    5129
    5130
    5131class Anonymous(Func):
    5132    arg_types = {"this": True, "expressions": False}
    5133    is_var_len_args = True
    5134
    5135    @property
    5136    def name(self) -> str:
    5137        return self.this if isinstance(self.this, str) else self.this.name
    5138
    5139
    5140class AnonymousAggFunc(AggFunc):
    5141    arg_types = {"this": True, "expressions": False}
    5142    is_var_len_args = True
    5143
    5144
    5145# https://clickhouse.com/docs/en/sql-reference/aggregate-functions/combinators
    5146class CombinedAggFunc(AnonymousAggFunc):
    5147    arg_types = {"this": True, "expressions": False, "parts": True}
    5148
    5149
    5150class CombinedParameterizedAgg(ParameterizedAgg):
    5151    arg_types = {"this": True, "expressions": True, "params": True, "parts": True}
    5152
    5153
    5154# https://docs.snowflake.com/en/sql-reference/functions/hll
    5155# https://docs.aws.amazon.com/redshift/latest/dg/r_HLL_function.html
    5156class Hll(AggFunc):
    5157    arg_types = {"this": True, "expressions": False}
    5158    is_var_len_args = True
    5159
    5160
    5161class ApproxDistinct(AggFunc):
    5162    arg_types = {"this": True, "accuracy": False}
    5163    _sql_names = ["APPROX_DISTINCT", "APPROX_COUNT_DISTINCT"]
    5164
    5165
    5166class Apply(Func):
    5167    arg_types = {"this": True, "expression": True}
    5168
    5169
    5170class Array(Func):
    5171    arg_types = {"expressions": False, "bracket_notation": False}
    5172    is_var_len_args = True
    5173
    5174
    5175# https://docs.snowflake.com/en/sql-reference/functions/to_array
    5176class ToArray(Func):
    5177    pass
    5178
    5179
    5180# https://materialize.com/docs/sql/types/list/
    5181class List(Func):
    5182    arg_types = {"expressions": False}
    5183    is_var_len_args = True
    5184
    5185
    5186# String pad, kind True -> LPAD, False -> RPAD
    5187class Pad(Func):
    5188    arg_types = {"this": True, "expression": True, "fill_pattern": False, "is_left": True}
    5189
    5190
    5191# https://docs.snowflake.com/en/sql-reference/functions/to_char
    5192# https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/TO_CHAR-number.html
    5193class ToChar(Func):
    5194    arg_types = {"this": True, "format": False, "nlsparam": False}
    5195
    5196
    5197# https://docs.snowflake.com/en/sql-reference/functions/to_decimal
    5198# https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/TO_NUMBER.html
    5199class ToNumber(Func):
    5200    arg_types = {
    5201        "this": True,
    5202        "format": False,
    5203        "nlsparam": False,
    5204        "precision": False,
    5205        "scale": False,
    5206    }
    5207
    5208
    5209# https://docs.snowflake.com/en/sql-reference/functions/to_double
    5210class ToDouble(Func):
    5211    arg_types = {
    5212        "this": True,
    5213        "format": False,
    5214    }
    5215
    5216
    5217class Columns(Func):
    5218    arg_types = {"this": True, "unpack": False}
    5219
    5220
    5221# https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16#syntax
    5222class Convert(Func):
    5223    arg_types = {"this": True, "expression": True, "style": False}
    5224
    5225
    5226class ConvertTimezone(Func):
    5227    arg_types = {"source_tz": False, "target_tz": True, "timestamp": True}
    5228
    5229
    5230class GenerateSeries(Func):
    5231    arg_types = {"start": True, "end": True, "step": False, "is_end_exclusive": False}
    5232
    5233
    5234# Postgres' GENERATE_SERIES function returns a row set, i.e. it implicitly explodes when it's
    5235# used in a projection, so this expression is a helper that facilitates transpilation to other
    5236# dialects. For example, we'd generate UNNEST(GENERATE_SERIES(...)) in DuckDB
    5237class ExplodingGenerateSeries(GenerateSeries):
    5238    pass
    5239
    5240
    5241class ArrayAgg(AggFunc):
    5242    arg_types = {"this": True, "nulls_excluded": False}
    5243
    5244
    5245class ArrayUniqueAgg(AggFunc):
    5246    pass
    5247
    5248
    5249class ArrayAll(Func):
    5250    arg_types = {"this": True, "expression": True}
    5251
    5252
    5253# Represents Python's `any(f(x) for x in array)`, where `array` is `this` and `f` is `expression`
    5254class ArrayAny(Func):
    5255    arg_types = {"this": True, "expression": True}
    5256
    5257
    5258class ArrayConcat(Func):
    5259    _sql_names = ["ARRAY_CONCAT", "ARRAY_CAT"]
    5260    arg_types = {"this": True, "expressions": False}
    5261    is_var_len_args = True
    5262
    5263
    5264class ArrayConstructCompact(Func):
    5265    arg_types = {"expressions": True}
    5266    is_var_len_args = True
    5267
    5268
    5269class ArrayContains(Binary, Func):
    5270    _sql_names = ["ARRAY_CONTAINS", "ARRAY_HAS"]
    5271
    5272
    5273class ArrayContainsAll(Binary, Func):
    5274    _sql_names = ["ARRAY_CONTAINS_ALL", "ARRAY_HAS_ALL"]
    5275
    5276
    5277class ArrayFilter(Func):
    5278    arg_types = {"this": True, "expression": True}
    5279    _sql_names = ["FILTER", "ARRAY_FILTER"]
    5280
    5281
    5282class ArrayToString(Func):
    5283    arg_types = {"this": True, "expression": True, "null": False}
    5284    _sql_names = ["ARRAY_TO_STRING", "ARRAY_JOIN"]
    5285
    5286
    5287# https://cloud.google.com/bigquery/docs/reference/standard-sql/timestamp_functions#string
    5288class String(Func):
    5289    arg_types = {"this": True, "zone": False}
    5290
    5291
    5292class StringToArray(Func):
    5293    arg_types = {"this": True, "expression": True, "null": False}
    5294    _sql_names = ["STRING_TO_ARRAY", "SPLIT_BY_STRING"]
    5295
    5296
    5297class ArrayOverlaps(Binary, Func):
    5298    pass
    5299
    5300
    5301class ArraySize(Func):
    5302    arg_types = {"this": True, "expression": False}
    5303    _sql_names = ["ARRAY_SIZE", "ARRAY_LENGTH"]
    5304
    5305
    5306class ArraySort(Func):
    5307    arg_types = {"this": True, "expression": False}
    5308
    5309
    5310class ArraySum(Func):
    5311    arg_types = {"this": True, "expression": False}
    5312
    5313
    5314class ArrayUnionAgg(AggFunc):
    5315    pass
    5316
    5317
    5318class Avg(AggFunc):
    5319    pass
    5320
    5321
    5322class AnyValue(AggFunc):
    5323    pass
    5324
    5325
    5326class Lag(AggFunc):
    5327    arg_types = {"this": True, "offset": False, "default": False}
    5328
    5329
    5330class Lead(AggFunc):
    5331    arg_types = {"this": True, "offset": False, "default": False}
    5332
    5333
    5334# some dialects have a distinction between first and first_value, usually first is an aggregate func
    5335# and first_value is a window func
    5336class First(AggFunc):
    5337    pass
    5338
    5339
    5340class Last(AggFunc):
    5341    pass
    5342
    5343
    5344class FirstValue(AggFunc):
    5345    pass
    5346
    5347
    5348class LastValue(AggFunc):
    5349    pass
    5350
    5351
    5352class NthValue(AggFunc):
    5353    arg_types = {"this": True, "offset": True}
    5354
    5355
    5356class Case(Func):
    5357    arg_types = {"this": False, "ifs": True, "default": False}
    5358
    5359    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5360        instance = maybe_copy(self, copy)
    5361        instance.append(
    5362            "ifs",
    5363            If(
    5364                this=maybe_parse(condition, copy=copy, **opts),
    5365                true=maybe_parse(then, copy=copy, **opts),
    5366            ),
    5367        )
    5368        return instance
    5369
    5370    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5371        instance = maybe_copy(self, copy)
    5372        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5373        return instance
    5374
    5375
    5376class Cast(Func):
    5377    arg_types = {
    5378        "this": True,
    5379        "to": True,
    5380        "format": False,
    5381        "safe": False,
    5382        "action": False,
    5383    }
    5384
    5385    @property
    5386    def name(self) -> str:
    5387        return self.this.name
    5388
    5389    @property
    5390    def to(self) -> DataType:
    5391        return self.args["to"]
    5392
    5393    @property
    5394    def output_name(self) -> str:
    5395        return self.name
    5396
    5397    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5398        """
    5399        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5400        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5401        array<int> != array<float>.
    5402
    5403        Args:
    5404            dtypes: the data types to compare this Cast's DataType to.
    5405
    5406        Returns:
    5407            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5408        """
    5409        return self.to.is_type(*dtypes)
    5410
    5411
    5412class TryCast(Cast):
    5413    pass
    5414
    5415
    5416class Try(Func):
    5417    pass
    5418
    5419
    5420class CastToStrType(Func):
    5421    arg_types = {"this": True, "to": True}
    5422
    5423
    5424class Collate(Binary, Func):
    5425    pass
    5426
    5427
    5428class Ceil(Func):
    5429    arg_types = {"this": True, "decimals": False}
    5430    _sql_names = ["CEIL", "CEILING"]
    5431
    5432
    5433class Coalesce(Func):
    5434    arg_types = {"this": True, "expressions": False, "is_nvl": False}
    5435    is_var_len_args = True
    5436    _sql_names = ["COALESCE", "IFNULL", "NVL"]
    5437
    5438
    5439class Chr(Func):
    5440    arg_types = {"expressions": True, "charset": False}
    5441    is_var_len_args = True
    5442    _sql_names = ["CHR", "CHAR"]
    5443
    5444
    5445class Concat(Func):
    5446    arg_types = {"expressions": True, "safe": False, "coalesce": False}
    5447    is_var_len_args = True
    5448
    5449
    5450class ConcatWs(Concat):
    5451    _sql_names = ["CONCAT_WS"]
    5452
    5453
    5454# https://docs.oracle.com/cd/B13789_01/server.101/b10759/operators004.htm#i1035022
    5455class ConnectByRoot(Func):
    5456    pass
    5457
    5458
    5459class Count(AggFunc):
    5460    arg_types = {"this": False, "expressions": False, "big_int": False}
    5461    is_var_len_args = True
    5462
    5463
    5464class CountIf(AggFunc):
    5465    _sql_names = ["COUNT_IF", "COUNTIF"]
    5466
    5467
    5468# cube root
    5469class Cbrt(Func):
    5470    pass
    5471
    5472
    5473class CurrentDate(Func):
    5474    arg_types = {"this": False}
    5475
    5476
    5477class CurrentDatetime(Func):
    5478    arg_types = {"this": False}
    5479
    5480
    5481class CurrentTime(Func):
    5482    arg_types = {"this": False}
    5483
    5484
    5485class CurrentTimestamp(Func):
    5486    arg_types = {"this": False, "sysdate": False}
    5487
    5488
    5489class CurrentUser(Func):
    5490    arg_types = {"this": False}
    5491
    5492
    5493class DateAdd(Func, IntervalOp):
    5494    arg_types = {"this": True, "expression": True, "unit": False}
    5495
    5496
    5497class DateSub(Func, IntervalOp):
    5498    arg_types = {"this": True, "expression": True, "unit": False}
    5499
    5500
    5501class DateDiff(Func, TimeUnit):
    5502    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    5503    arg_types = {"this": True, "expression": True, "unit": False}
    5504
    5505
    5506class DateTrunc(Func):
    5507    arg_types = {"unit": True, "this": True, "zone": False}
    5508
    5509    def __init__(self, **args):
    5510        unit = args.get("unit")
    5511        if isinstance(unit, TimeUnit.VAR_LIKE):
    5512            args["unit"] = Literal.string(
    5513                (TimeUnit.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5514            )
    5515        elif isinstance(unit, Week):
    5516            unit.set("this", Literal.string(unit.this.name.upper()))
    5517
    5518        super().__init__(**args)
    5519
    5520    @property
    5521    def unit(self) -> Expression:
    5522        return self.args["unit"]
    5523
    5524
    5525# https://cloud.google.com/bigquery/docs/reference/standard-sql/datetime_functions#datetime
    5526# expression can either be time_expr or time_zone
    5527class Datetime(Func):
    5528    arg_types = {"this": True, "expression": False}
    5529
    5530
    5531class DatetimeAdd(Func, IntervalOp):
    5532    arg_types = {"this": True, "expression": True, "unit": False}
    5533
    5534
    5535class DatetimeSub(Func, IntervalOp):
    5536    arg_types = {"this": True, "expression": True, "unit": False}
    5537
    5538
    5539class DatetimeDiff(Func, TimeUnit):
    5540    arg_types = {"this": True, "expression": True, "unit": False}
    5541
    5542
    5543class DatetimeTrunc(Func, TimeUnit):
    5544    arg_types = {"this": True, "unit": True, "zone": False}
    5545
    5546
    5547class DayOfWeek(Func):
    5548    _sql_names = ["DAY_OF_WEEK", "DAYOFWEEK"]
    5549
    5550
    5551# https://duckdb.org/docs/sql/functions/datepart.html#part-specifiers-only-usable-as-date-part-specifiers
    5552# ISO day of week function in duckdb is ISODOW
    5553class DayOfWeekIso(Func):
    5554    _sql_names = ["DAYOFWEEK_ISO", "ISODOW"]
    5555
    5556
    5557class DayOfMonth(Func):
    5558    _sql_names = ["DAY_OF_MONTH", "DAYOFMONTH"]
    5559
    5560
    5561class DayOfYear(Func):
    5562    _sql_names = ["DAY_OF_YEAR", "DAYOFYEAR"]
    5563
    5564
    5565class ToDays(Func):
    5566    pass
    5567
    5568
    5569class WeekOfYear(Func):
    5570    _sql_names = ["WEEK_OF_YEAR", "WEEKOFYEAR"]
    5571
    5572
    5573class MonthsBetween(Func):
    5574    arg_types = {"this": True, "expression": True, "roundoff": False}
    5575
    5576
    5577class LastDay(Func, TimeUnit):
    5578    _sql_names = ["LAST_DAY", "LAST_DAY_OF_MONTH"]
    5579    arg_types = {"this": True, "unit": False}
    5580
    5581
    5582class Extract(Func):
    5583    arg_types = {"this": True, "expression": True}
    5584
    5585
    5586class Timestamp(Func):
    5587    arg_types = {"this": False, "zone": False, "with_tz": False}
    5588
    5589
    5590class TimestampAdd(Func, TimeUnit):
    5591    arg_types = {"this": True, "expression": True, "unit": False}
    5592
    5593
    5594class TimestampSub(Func, TimeUnit):
    5595    arg_types = {"this": True, "expression": True, "unit": False}
    5596
    5597
    5598class TimestampDiff(Func, TimeUnit):
    5599    _sql_names = ["TIMESTAMPDIFF", "TIMESTAMP_DIFF"]
    5600    arg_types = {"this": True, "expression": True, "unit": False}
    5601
    5602
    5603class TimestampTrunc(Func, TimeUnit):
    5604    arg_types = {"this": True, "unit": True, "zone": False}
    5605
    5606
    5607class TimeAdd(Func, TimeUnit):
    5608    arg_types = {"this": True, "expression": True, "unit": False}
    5609
    5610
    5611class TimeSub(Func, TimeUnit):
    5612    arg_types = {"this": True, "expression": True, "unit": False}
    5613
    5614
    5615class TimeDiff(Func, TimeUnit):
    5616    arg_types = {"this": True, "expression": True, "unit": False}
    5617
    5618
    5619class TimeTrunc(Func, TimeUnit):
    5620    arg_types = {"this": True, "unit": True, "zone": False}
    5621
    5622
    5623class DateFromParts(Func):
    5624    _sql_names = ["DATE_FROM_PARTS", "DATEFROMPARTS"]
    5625    arg_types = {"year": True, "month": True, "day": True}
    5626
    5627
    5628class TimeFromParts(Func):
    5629    _sql_names = ["TIME_FROM_PARTS", "TIMEFROMPARTS"]
    5630    arg_types = {
    5631        "hour": True,
    5632        "min": True,
    5633        "sec": True,
    5634        "nano": False,
    5635        "fractions": False,
    5636        "precision": False,
    5637    }
    5638
    5639
    5640class DateStrToDate(Func):
    5641    pass
    5642
    5643
    5644class DateToDateStr(Func):
    5645    pass
    5646
    5647
    5648class DateToDi(Func):
    5649    pass
    5650
    5651
    5652# https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions#date
    5653class Date(Func):
    5654    arg_types = {"this": False, "zone": False, "expressions": False}
    5655    is_var_len_args = True
    5656
    5657
    5658class Day(Func):
    5659    pass
    5660
    5661
    5662class Decode(Func):
    5663    arg_types = {"this": True, "charset": True, "replace": False}
    5664
    5665
    5666class DiToDate(Func):
    5667    pass
    5668
    5669
    5670class Encode(Func):
    5671    arg_types = {"this": True, "charset": True}
    5672
    5673
    5674class Exp(Func):
    5675    pass
    5676
    5677
    5678# https://docs.snowflake.com/en/sql-reference/functions/flatten
    5679class Explode(Func, UDTF):
    5680    arg_types = {"this": True, "expressions": False}
    5681    is_var_len_args = True
    5682
    5683
    5684# https://spark.apache.org/docs/latest/api/sql/#inline
    5685class Inline(Func):
    5686    pass
    5687
    5688
    5689class ExplodeOuter(Explode):
    5690    pass
    5691
    5692
    5693class Posexplode(Explode):
    5694    pass
    5695
    5696
    5697class PosexplodeOuter(Posexplode, ExplodeOuter):
    5698    pass
    5699
    5700
    5701class Unnest(Func, UDTF):
    5702    arg_types = {
    5703        "expressions": True,
    5704        "alias": False,
    5705        "offset": False,
    5706        "explode_array": False,
    5707    }
    5708
    5709    @property
    5710    def selects(self) -> t.List[Expression]:
    5711        columns = super().selects
    5712        offset = self.args.get("offset")
    5713        if offset:
    5714            columns = columns + [to_identifier("offset") if offset is True else offset]
    5715        return columns
    5716
    5717
    5718class Floor(Func):
    5719    arg_types = {"this": True, "decimals": False}
    5720
    5721
    5722class FromBase64(Func):
    5723    pass
    5724
    5725
    5726class ToBase64(Func):
    5727    pass
    5728
    5729
    5730# https://trino.io/docs/current/functions/datetime.html#from_iso8601_timestamp
    5731class FromISO8601Timestamp(Func):
    5732    _sql_names = ["FROM_ISO8601_TIMESTAMP"]
    5733
    5734
    5735class GapFill(Func):
    5736    arg_types = {
    5737        "this": True,
    5738        "ts_column": True,
    5739        "bucket_width": True,
    5740        "partitioning_columns": False,
    5741        "value_columns": False,
    5742        "origin": False,
    5743        "ignore_nulls": False,
    5744    }
    5745
    5746
    5747# https://cloud.google.com/bigquery/docs/reference/standard-sql/array_functions#generate_date_array
    5748class GenerateDateArray(Func):
    5749    arg_types = {"start": True, "end": True, "step": False}
    5750
    5751
    5752# https://cloud.google.com/bigquery/docs/reference/standard-sql/array_functions#generate_timestamp_array
    5753class GenerateTimestampArray(Func):
    5754    arg_types = {"start": True, "end": True, "step": True}
    5755
    5756
    5757class Greatest(Func):
    5758    arg_types = {"this": True, "expressions": False}
    5759    is_var_len_args = True
    5760
    5761
    5762class GroupConcat(AggFunc):
    5763    arg_types = {"this": True, "separator": False}
    5764
    5765
    5766class Hex(Func):
    5767    pass
    5768
    5769
    5770class LowerHex(Hex):
    5771    pass
    5772
    5773
    5774class Xor(Connector, Func):
    5775    arg_types = {"this": False, "expression": False, "expressions": False}
    5776
    5777
    5778class If(Func):
    5779    arg_types = {"this": True, "true": True, "false": False}
    5780    _sql_names = ["IF", "IIF"]
    5781
    5782
    5783class Nullif(Func):
    5784    arg_types = {"this": True, "expression": True}
    5785
    5786
    5787class Initcap(Func):
    5788    arg_types = {"this": True, "expression": False}
    5789
    5790
    5791class IsNan(Func):
    5792    _sql_names = ["IS_NAN", "ISNAN"]
    5793
    5794
    5795class IsInf(Func):
    5796    _sql_names = ["IS_INF", "ISINF"]
    5797
    5798
    5799# https://www.postgresql.org/docs/current/functions-json.html
    5800class JSON(Expression):
    5801    arg_types = {"this": False, "with": False, "unique": False}
    5802
    5803
    5804class JSONPath(Expression):
    5805    arg_types = {"expressions": True, "escape": False}
    5806
    5807    @property
    5808    def output_name(self) -> str:
    5809        last_segment = self.expressions[-1].this
    5810        return last_segment if isinstance(last_segment, str) else ""
    5811
    5812
    5813class JSONPathPart(Expression):
    5814    arg_types = {}
    5815
    5816
    5817class JSONPathFilter(JSONPathPart):
    5818    arg_types = {"this": True}
    5819
    5820
    5821class JSONPathKey(JSONPathPart):
    5822    arg_types = {"this": True}
    5823
    5824
    5825class JSONPathRecursive(JSONPathPart):
    5826    arg_types = {"this": False}
    5827
    5828
    5829class JSONPathRoot(JSONPathPart):
    5830    pass
    5831
    5832
    5833class JSONPathScript(JSONPathPart):
    5834    arg_types = {"this": True}
    5835
    5836
    5837class JSONPathSlice(JSONPathPart):
    5838    arg_types = {"start": False, "end": False, "step": False}
    5839
    5840
    5841class JSONPathSelector(JSONPathPart):
    5842    arg_types = {"this": True}
    5843
    5844
    5845class JSONPathSubscript(JSONPathPart):
    5846    arg_types = {"this": True}
    5847
    5848
    5849class JSONPathUnion(JSONPathPart):
    5850    arg_types = {"expressions": True}
    5851
    5852
    5853class JSONPathWildcard(JSONPathPart):
    5854    pass
    5855
    5856
    5857class FormatJson(Expression):
    5858    pass
    5859
    5860
    5861class JSONKeyValue(Expression):
    5862    arg_types = {"this": True, "expression": True}
    5863
    5864
    5865class JSONObject(Func):
    5866    arg_types = {
    5867        "expressions": False,
    5868        "null_handling": False,
    5869        "unique_keys": False,
    5870        "return_type": False,
    5871        "encoding": False,
    5872    }
    5873
    5874
    5875class JSONObjectAgg(AggFunc):
    5876    arg_types = {
    5877        "expressions": False,
    5878        "null_handling": False,
    5879        "unique_keys": False,
    5880        "return_type": False,
    5881        "encoding": False,
    5882    }
    5883
    5884
    5885# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_ARRAY.html
    5886class JSONArray(Func):
    5887    arg_types = {
    5888        "expressions": True,
    5889        "null_handling": False,
    5890        "return_type": False,
    5891        "strict": False,
    5892    }
    5893
    5894
    5895# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_ARRAYAGG.html
    5896class JSONArrayAgg(Func):
    5897    arg_types = {
    5898        "this": True,
    5899        "order": False,
    5900        "null_handling": False,
    5901        "return_type": False,
    5902        "strict": False,
    5903    }
    5904
    5905
    5906class JSONExists(Func):
    5907    arg_types = {"this": True, "path": True, "passing": False, "on_condition": False}
    5908
    5909
    5910# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_TABLE.html
    5911# Note: parsing of JSON column definitions is currently incomplete.
    5912class JSONColumnDef(Expression):
    5913    arg_types = {"this": False, "kind": False, "path": False, "nested_schema": False}
    5914
    5915
    5916class JSONSchema(Expression):
    5917    arg_types = {"expressions": True}
    5918
    5919
    5920# https://dev.mysql.com/doc/refman/8.4/en/json-search-functions.html#function_json-value
    5921class JSONValue(Expression):
    5922    arg_types = {
    5923        "this": True,
    5924        "path": True,
    5925        "returning": False,
    5926        "on_condition": False,
    5927    }
    5928
    5929
    5930# # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/JSON_TABLE.html
    5931class JSONTable(Func):
    5932    arg_types = {
    5933        "this": True,
    5934        "schema": True,
    5935        "path": False,
    5936        "error_handling": False,
    5937        "empty_handling": False,
    5938    }
    5939
    5940
    5941# https://docs.snowflake.com/en/sql-reference/functions/object_insert
    5942class ObjectInsert(Func):
    5943    arg_types = {
    5944        "this": True,
    5945        "key": True,
    5946        "value": True,
    5947        "update_flag": False,
    5948    }
    5949
    5950
    5951class OpenJSONColumnDef(Expression):
    5952    arg_types = {"this": True, "kind": True, "path": False, "as_json": False}
    5953
    5954
    5955class OpenJSON(Func):
    5956    arg_types = {"this": True, "path": False, "expressions": False}
    5957
    5958
    5959class JSONBContains(Binary, Func):
    5960    _sql_names = ["JSONB_CONTAINS"]
    5961
    5962
    5963class JSONExtract(Binary, Func):
    5964    arg_types = {
    5965        "this": True,
    5966        "expression": True,
    5967        "only_json_types": False,
    5968        "expressions": False,
    5969        "variant_extract": False,
    5970        "json_query": False,
    5971        "option": False,
    5972    }
    5973    _sql_names = ["JSON_EXTRACT"]
    5974    is_var_len_args = True
    5975
    5976    @property
    5977    def output_name(self) -> str:
    5978        return self.expression.output_name if not self.expressions else ""
    5979
    5980
    5981class JSONExtractScalar(Binary, Func):
    5982    arg_types = {"this": True, "expression": True, "only_json_types": False, "expressions": False}
    5983    _sql_names = ["JSON_EXTRACT_SCALAR"]
    5984    is_var_len_args = True
    5985
    5986    @property
    5987    def output_name(self) -> str:
    5988        return self.expression.output_name
    5989
    5990
    5991class JSONBExtract(Binary, Func):
    5992    _sql_names = ["JSONB_EXTRACT"]
    5993
    5994
    5995class JSONBExtractScalar(Binary, Func):
    5996    _sql_names = ["JSONB_EXTRACT_SCALAR"]
    5997
    5998
    5999class JSONFormat(Func):
    6000    arg_types = {"this": False, "options": False}
    6001    _sql_names = ["JSON_FORMAT"]
    6002
    6003
    6004# https://dev.mysql.com/doc/refman/8.0/en/json-search-functions.html#operator_member-of
    6005class JSONArrayContains(Binary, Predicate, Func):
    6006    _sql_names = ["JSON_ARRAY_CONTAINS"]
    6007
    6008
    6009class ParseJSON(Func):
    6010    # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
    6011    # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
    6012    _sql_names = ["PARSE_JSON", "JSON_PARSE"]
    6013    arg_types = {"this": True, "expression": False, "safe": False}
    6014
    6015
    6016class Least(Func):
    6017    arg_types = {"this": True, "expressions": False}
    6018    is_var_len_args = True
    6019
    6020
    6021class Left(Func):
    6022    arg_types = {"this": True, "expression": True}
    6023
    6024
    6025class Right(Func):
    6026    arg_types = {"this": True, "expression": True}
    6027
    6028
    6029class Length(Func):
    6030    arg_types = {"this": True, "binary": False}
    6031    _sql_names = ["LENGTH", "LEN"]
    6032
    6033
    6034class Levenshtein(Func):
    6035    arg_types = {
    6036        "this": True,
    6037        "expression": False,
    6038        "ins_cost": False,
    6039        "del_cost": False,
    6040        "sub_cost": False,
    6041        "max_dist": False,
    6042    }
    6043
    6044
    6045class Ln(Func):
    6046    pass
    6047
    6048
    6049class Log(Func):
    6050    arg_types = {"this": True, "expression": False}
    6051
    6052
    6053class LogicalOr(AggFunc):
    6054    _sql_names = ["LOGICAL_OR", "BOOL_OR", "BOOLOR_AGG"]
    6055
    6056
    6057class LogicalAnd(AggFunc):
    6058    _sql_names = ["LOGICAL_AND", "BOOL_AND", "BOOLAND_AGG"]
    6059
    6060
    6061class Lower(Func):
    6062    _sql_names = ["LOWER", "LCASE"]
    6063
    6064
    6065class Map(Func):
    6066    arg_types = {"keys": False, "values": False}
    6067
    6068    @property
    6069    def keys(self) -> t.List[Expression]:
    6070        keys = self.args.get("keys")
    6071        return keys.expressions if keys else []
    6072
    6073    @property
    6074    def values(self) -> t.List[Expression]:
    6075        values = self.args.get("values")
    6076        return values.expressions if values else []
    6077
    6078
    6079# Represents the MAP {...} syntax in DuckDB - basically convert a struct to a MAP
    6080class ToMap(Func):
    6081    pass
    6082
    6083
    6084class MapFromEntries(Func):
    6085    pass
    6086
    6087
    6088# https://learn.microsoft.com/en-us/sql/t-sql/language-elements/scope-resolution-operator-transact-sql?view=sql-server-ver16
    6089class ScopeResolution(Expression):
    6090    arg_types = {"this": False, "expression": True}
    6091
    6092
    6093class Stream(Expression):
    6094    pass
    6095
    6096
    6097class StarMap(Func):
    6098    pass
    6099
    6100
    6101class VarMap(Func):
    6102    arg_types = {"keys": True, "values": True}
    6103    is_var_len_args = True
    6104
    6105    @property
    6106    def keys(self) -> t.List[Expression]:
    6107        return self.args["keys"].expressions
    6108
    6109    @property
    6110    def values(self) -> t.List[Expression]:
    6111        return self.args["values"].expressions
    6112
    6113
    6114# https://dev.mysql.com/doc/refman/8.0/en/fulltext-search.html
    6115class MatchAgainst(Func):
    6116    arg_types = {"this": True, "expressions": True, "modifier": False}
    6117
    6118
    6119class Max(AggFunc):
    6120    arg_types = {"this": True, "expressions": False}
    6121    is_var_len_args = True
    6122
    6123
    6124class MD5(Func):
    6125    _sql_names = ["MD5"]
    6126
    6127
    6128# Represents the variant of the MD5 function that returns a binary value
    6129class MD5Digest(Func):
    6130    _sql_names = ["MD5_DIGEST"]
    6131
    6132
    6133class Min(AggFunc):
    6134    arg_types = {"this": True, "expressions": False}
    6135    is_var_len_args = True
    6136
    6137
    6138class Month(Func):
    6139    pass
    6140
    6141
    6142class AddMonths(Func):
    6143    arg_types = {"this": True, "expression": True}
    6144
    6145
    6146class Nvl2(Func):
    6147    arg_types = {"this": True, "true": True, "false": False}
    6148
    6149
    6150class Normalize(Func):
    6151    arg_types = {"this": True, "form": False}
    6152
    6153
    6154class Overlay(Func):
    6155    arg_types = {"this": True, "expression": True, "from": True, "for": False}
    6156
    6157
    6158# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-predict#mlpredict_function
    6159class Predict(Func):
    6160    arg_types = {"this": True, "expression": True, "params_struct": False}
    6161
    6162
    6163class Pow(Binary, Func):
    6164    _sql_names = ["POWER", "POW"]
    6165
    6166
    6167class PercentileCont(AggFunc):
    6168    arg_types = {"this": True, "expression": False}
    6169
    6170
    6171class PercentileDisc(AggFunc):
    6172    arg_types = {"this": True, "expression": False}
    6173
    6174
    6175class Quantile(AggFunc):
    6176    arg_types = {"this": True, "quantile": True}
    6177
    6178
    6179class ApproxQuantile(Quantile):
    6180    arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}
    6181
    6182
    6183class Quarter(Func):
    6184    pass
    6185
    6186
    6187# https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Functions-Expressions-and-Predicates/Arithmetic-Trigonometric-Hyperbolic-Operators/Functions/RANDOM/RANDOM-Function-Syntax
    6188# teradata lower and upper bounds
    6189class Rand(Func):
    6190    _sql_names = ["RAND", "RANDOM"]
    6191    arg_types = {"this": False, "lower": False, "upper": False}
    6192
    6193
    6194class Randn(Func):
    6195    arg_types = {"this": False}
    6196
    6197
    6198class RangeN(Func):
    6199    arg_types = {"this": True, "expressions": True, "each": False}
    6200
    6201
    6202class ReadCSV(Func):
    6203    _sql_names = ["READ_CSV"]
    6204    is_var_len_args = True
    6205    arg_types = {"this": True, "expressions": False}
    6206
    6207
    6208class Reduce(Func):
    6209    arg_types = {"this": True, "initial": True, "merge": True, "finish": False}
    6210
    6211
    6212class RegexpExtract(Func):
    6213    arg_types = {
    6214        "this": True,
    6215        "expression": True,
    6216        "position": False,
    6217        "occurrence": False,
    6218        "parameters": False,
    6219        "group": False,
    6220    }
    6221
    6222
    6223class RegexpReplace(Func):
    6224    arg_types = {
    6225        "this": True,
    6226        "expression": True,
    6227        "replacement": False,
    6228        "position": False,
    6229        "occurrence": False,
    6230        "modifiers": False,
    6231    }
    6232
    6233
    6234class RegexpLike(Binary, Func):
    6235    arg_types = {"this": True, "expression": True, "flag": False}
    6236
    6237
    6238class RegexpILike(Binary, Func):
    6239    arg_types = {"this": True, "expression": True, "flag": False}
    6240
    6241
    6242# https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.split.html
    6243# limit is the number of times a pattern is applied
    6244class RegexpSplit(Func):
    6245    arg_types = {"this": True, "expression": True, "limit": False}
    6246
    6247
    6248class Repeat(Func):
    6249    arg_types = {"this": True, "times": True}
    6250
    6251
    6252# https://learn.microsoft.com/en-us/sql/t-sql/functions/round-transact-sql?view=sql-server-ver16
    6253# tsql third argument function == trunctaion if not 0
    6254class Round(Func):
    6255    arg_types = {"this": True, "decimals": False, "truncate": False}
    6256
    6257
    6258class RowNumber(Func):
    6259    arg_types: t.Dict[str, t.Any] = {}
    6260
    6261
    6262class SafeDivide(Func):
    6263    arg_types = {"this": True, "expression": True}
    6264
    6265
    6266class SHA(Func):
    6267    _sql_names = ["SHA", "SHA1"]
    6268
    6269
    6270class SHA2(Func):
    6271    _sql_names = ["SHA2"]
    6272    arg_types = {"this": True, "length": False}
    6273
    6274
    6275class Sign(Func):
    6276    _sql_names = ["SIGN", "SIGNUM"]
    6277
    6278
    6279class SortArray(Func):
    6280    arg_types = {"this": True, "asc": False}
    6281
    6282
    6283class Split(Func):
    6284    arg_types = {"this": True, "expression": True, "limit": False}
    6285
    6286
    6287# https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.split_part.html
    6288class SplitPart(Func):
    6289    arg_types = {"this": True, "delimiter": True, "part_index": True}
    6290
    6291
    6292# Start may be omitted in the case of postgres
    6293# https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
    6294class Substring(Func):
    6295    _sql_names = ["SUBSTRING", "SUBSTR"]
    6296    arg_types = {"this": True, "start": False, "length": False}
    6297
    6298
    6299class StandardHash(Func):
    6300    arg_types = {"this": True, "expression": False}
    6301
    6302
    6303class StartsWith(Func):
    6304    _sql_names = ["STARTS_WITH", "STARTSWITH"]
    6305    arg_types = {"this": True, "expression": True}
    6306
    6307
    6308class StrPosition(Func):
    6309    arg_types = {
    6310        "this": True,
    6311        "substr": True,
    6312        "position": False,
    6313        "instance": False,
    6314    }
    6315
    6316
    6317class StrToDate(Func):
    6318    arg_types = {"this": True, "format": False, "safe": False}
    6319
    6320
    6321class StrToTime(Func):
    6322    arg_types = {"this": True, "format": True, "zone": False, "safe": False}
    6323
    6324
    6325# Spark allows unix_timestamp()
    6326# https://spark.apache.org/docs/3.1.3/api/python/reference/api/pyspark.sql.functions.unix_timestamp.html
    6327class StrToUnix(Func):
    6328    arg_types = {"this": False, "format": False}
    6329
    6330
    6331# https://prestodb.io/docs/current/functions/string.html
    6332# https://spark.apache.org/docs/latest/api/sql/index.html#str_to_map
    6333class StrToMap(Func):
    6334    arg_types = {
    6335        "this": True,
    6336        "pair_delim": False,
    6337        "key_value_delim": False,
    6338        "duplicate_resolution_callback": False,
    6339    }
    6340
    6341
    6342class NumberToStr(Func):
    6343    arg_types = {"this": True, "format": True, "culture": False}
    6344
    6345
    6346class FromBase(Func):
    6347    arg_types = {"this": True, "expression": True}
    6348
    6349
    6350class Struct(Func):
    6351    arg_types = {"expressions": False}
    6352    is_var_len_args = True
    6353
    6354
    6355class StructExtract(Func):
    6356    arg_types = {"this": True, "expression": True}
    6357
    6358
    6359# https://learn.microsoft.com/en-us/sql/t-sql/functions/stuff-transact-sql?view=sql-server-ver16
    6360# https://docs.snowflake.com/en/sql-reference/functions/insert
    6361class Stuff(Func):
    6362    _sql_names = ["STUFF", "INSERT"]
    6363    arg_types = {"this": True, "start": True, "length": True, "expression": True}
    6364
    6365
    6366class Sum(AggFunc):
    6367    pass
    6368
    6369
    6370class Sqrt(Func):
    6371    pass
    6372
    6373
    6374class Stddev(AggFunc):
    6375    _sql_names = ["STDDEV", "STDEV"]
    6376
    6377
    6378class StddevPop(AggFunc):
    6379    pass
    6380
    6381
    6382class StddevSamp(AggFunc):
    6383    pass
    6384
    6385
    6386# https://cloud.google.com/bigquery/docs/reference/standard-sql/time_functions#time
    6387class Time(Func):
    6388    arg_types = {"this": False, "zone": False}
    6389
    6390
    6391class TimeToStr(Func):
    6392    arg_types = {"this": True, "format": True, "culture": False, "zone": False}
    6393
    6394
    6395class TimeToTimeStr(Func):
    6396    pass
    6397
    6398
    6399class TimeToUnix(Func):
    6400    pass
    6401
    6402
    6403class TimeStrToDate(Func):
    6404    pass
    6405
    6406
    6407class TimeStrToTime(Func):
    6408    arg_types = {"this": True, "zone": False}
    6409
    6410
    6411class TimeStrToUnix(Func):
    6412    pass
    6413
    6414
    6415class Trim(Func):
    6416    arg_types = {
    6417        "this": True,
    6418        "expression": False,
    6419        "position": False,
    6420        "collation": False,
    6421    }
    6422
    6423
    6424class TsOrDsAdd(Func, TimeUnit):
    6425    # return_type is used to correctly cast the arguments of this expression when transpiling it
    6426    arg_types = {"this": True, "expression": True, "unit": False, "return_type": False}
    6427
    6428    @property
    6429    def return_type(self) -> DataType:
    6430        return DataType.build(self.args.get("return_type") or DataType.Type.DATE)
    6431
    6432
    6433class TsOrDsDiff(Func, TimeUnit):
    6434    arg_types = {"this": True, "expression": True, "unit": False}
    6435
    6436
    6437class TsOrDsToDateStr(Func):
    6438    pass
    6439
    6440
    6441class TsOrDsToDate(Func):
    6442    arg_types = {"this": True, "format": False, "safe": False}
    6443
    6444
    6445class TsOrDsToTime(Func):
    6446    pass
    6447
    6448
    6449class TsOrDsToTimestamp(Func):
    6450    pass
    6451
    6452
    6453class TsOrDiToDi(Func):
    6454    pass
    6455
    6456
    6457class Unhex(Func):
    6458    pass
    6459
    6460
    6461# https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions#unix_date
    6462class UnixDate(Func):
    6463    pass
    6464
    6465
    6466class UnixToStr(Func):
    6467    arg_types = {"this": True, "format": False}
    6468
    6469
    6470# https://prestodb.io/docs/current/functions/datetime.html
    6471# presto has weird zone/hours/minutes
    6472class UnixToTime(Func):
    6473    arg_types = {
    6474        "this": True,
    6475        "scale": False,
    6476        "zone": False,
    6477        "hours": False,
    6478        "minutes": False,
    6479        "format": False,
    6480    }
    6481
    6482    SECONDS = Literal.number(0)
    6483    DECIS = Literal.number(1)
    6484    CENTIS = Literal.number(2)
    6485    MILLIS = Literal.number(3)
    6486    DECIMILLIS = Literal.number(4)
    6487    CENTIMILLIS = Literal.number(5)
    6488    MICROS = Literal.number(6)
    6489    DECIMICROS = Literal.number(7)
    6490    CENTIMICROS = Literal.number(8)
    6491    NANOS = Literal.number(9)
    6492
    6493
    6494class UnixToTimeStr(Func):
    6495    pass
    6496
    6497
    6498class Uuid(Func):
    6499    _sql_names = ["UUID", "GEN_RANDOM_UUID", "GENERATE_UUID", "UUID_STRING"]
    6500
    6501    arg_types = {"this": False, "name": False}
    6502
    6503
    6504class TimestampFromParts(Func):
    6505    _sql_names = ["TIMESTAMP_FROM_PARTS", "TIMESTAMPFROMPARTS"]
    6506    arg_types = {
    6507        "year": True,
    6508        "month": True,
    6509        "day": True,
    6510        "hour": True,
    6511        "min": True,
    6512        "sec": True,
    6513        "nano": False,
    6514        "zone": False,
    6515        "milli": False,
    6516    }
    6517
    6518
    6519class Upper(Func):
    6520    _sql_names = ["UPPER", "UCASE"]
    6521
    6522
    6523class Corr(Binary, AggFunc):
    6524    pass
    6525
    6526
    6527class Variance(AggFunc):
    6528    _sql_names = ["VARIANCE", "VARIANCE_SAMP", "VAR_SAMP"]
    6529
    6530
    6531class VariancePop(AggFunc):
    6532    _sql_names = ["VARIANCE_POP", "VAR_POP"]
    6533
    6534
    6535class CovarSamp(Binary, AggFunc):
    6536    pass
    6537
    6538
    6539class CovarPop(Binary, AggFunc):
    6540    pass
    6541
    6542
    6543class Week(Func):
    6544    arg_types = {"this": True, "mode": False}
    6545
    6546
    6547class XMLTable(Func):
    6548    arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}
    6549
    6550
    6551class Year(Func):
    6552    pass
    6553
    6554
    6555class Use(Expression):
    6556    arg_types = {"this": True, "kind": False}
    6557
    6558
    6559class Merge(DML):
    6560    arg_types = {
    6561        "this": True,
    6562        "using": True,
    6563        "on": True,
    6564        "expressions": True,
    6565        "with": False,
    6566        "returning": False,
    6567    }
    6568
    6569
    6570class When(Func):
    6571    arg_types = {"matched": True, "source": False, "condition": False, "then": True}
    6572
    6573
    6574# https://docs.oracle.com/javadb/10.8.3.0/ref/rrefsqljnextvaluefor.html
    6575# https://learn.microsoft.com/en-us/sql/t-sql/functions/next-value-for-transact-sql?view=sql-server-ver16
    6576class NextValueFor(Func):
    6577    arg_types = {"this": True, "order": False}
    6578
    6579
    6580# Refers to a trailing semi-colon. This is only used to preserve trailing comments
    6581# select 1; -- my comment
    6582class Semicolon(Expression):
    6583    arg_types = {}
    6584
    6585
    6586def _norm_arg(arg):
    6587    return arg.lower() if type(arg) is str else arg
    6588
    6589
    6590ALL_FUNCTIONS = subclasses(__name__, Func, (AggFunc, Anonymous, Func))
    6591FUNCTION_BY_NAME = {name: func for func in ALL_FUNCTIONS for name in func.sql_names()}
    6592
    6593JSON_PATH_PARTS = subclasses(__name__, JSONPathPart, (JSONPathPart,))
    6594
    6595PERCENTILES = (PercentileCont, PercentileDisc)
    6596
    6597
    6598# Helpers
    6599@t.overload
    6600def maybe_parse(
    6601    sql_or_expression: ExpOrStr,
    6602    *,
    6603    into: t.Type[E],
    6604    dialect: DialectType = None,
    6605    prefix: t.Optional[str] = None,
    6606    copy: bool = False,
    6607    **opts,
    6608) -> E: ...
    6609
    6610
    6611@t.overload
    6612def maybe_parse(
    6613    sql_or_expression: str | E,
    6614    *,
    6615    into: t.Optional[IntoType] = None,
    6616    dialect: DialectType = None,
    6617    prefix: t.Optional[str] = None,
    6618    copy: bool = False,
    6619    **opts,
    6620) -> E: ...
    6621
    6622
    6623def maybe_parse(
    6624    sql_or_expression: ExpOrStr,
    6625    *,
    6626    into: t.Optional[IntoType] = None,
    6627    dialect: DialectType = None,
    6628    prefix: t.Optional[str] = None,
    6629    copy: bool = False,
    6630    **opts,
    6631) -> Expression:
    6632    """Gracefully handle a possible string or expression.
    6633
    6634    Example:
    6635        >>> maybe_parse("1")
    6636        Literal(this=1, is_string=False)
    6637        >>> maybe_parse(to_identifier("x"))
    6638        Identifier(this=x, quoted=False)
    6639
    6640    Args:
    6641        sql_or_expression: the SQL code string or an expression
    6642        into: the SQLGlot Expression to parse into
    6643        dialect: the dialect used to parse the input expressions (in the case that an
    6644            input expression is a SQL string).
    6645        prefix: a string to prefix the sql with before it gets parsed
    6646            (automatically includes a space)
    6647        copy: whether to copy the expression.
    6648        **opts: other options to use to parse the input expressions (again, in the case
    6649            that an input expression is a SQL string).
    6650
    6651    Returns:
    6652        Expression: the parsed or given expression.
    6653    """
    6654    if isinstance(sql_or_expression, Expression):
    6655        if copy:
    6656            return sql_or_expression.copy()
    6657        return sql_or_expression
    6658
    6659    if sql_or_expression is None:
    6660        raise ParseError("SQL cannot be None")
    6661
    6662    import sqlglot
    6663
    6664    sql = str(sql_or_expression)
    6665    if prefix:
    6666        sql = f"{prefix} {sql}"
    6667
    6668    return sqlglot.parse_one(sql, read=dialect, into=into, **opts)
    6669
    6670
    6671@t.overload
    6672def maybe_copy(instance: None, copy: bool = True) -> None: ...
    6673
    6674
    6675@t.overload
    6676def maybe_copy(instance: E, copy: bool = True) -> E: ...
    6677
    6678
    6679def maybe_copy(instance, copy=True):
    6680    return instance.copy() if copy and instance else instance
    6681
    6682
    6683def _to_s(node: t.Any, verbose: bool = False, level: int = 0) -> str:
    6684    """Generate a textual representation of an Expression tree"""
    6685    indent = "\n" + ("  " * (level + 1))
    6686    delim = f",{indent}"
    6687
    6688    if isinstance(node, Expression):
    6689        args = {k: v for k, v in node.args.items() if (v is not None and v != []) or verbose}
    6690
    6691        if (node.type or verbose) and not isinstance(node, DataType):
    6692            args["_type"] = node.type
    6693        if node.comments or verbose:
    6694            args["_comments"] = node.comments
    6695
    6696        if verbose:
    6697            args["_id"] = id(node)
    6698
    6699        # Inline leaves for a more compact representation
    6700        if node.is_leaf():
    6701            indent = ""
    6702            delim = ", "
    6703
    6704        items = delim.join([f"{k}={_to_s(v, verbose, level + 1)}" for k, v in args.items()])
    6705        return f"{node.__class__.__name__}({indent}{items})"
    6706
    6707    if isinstance(node, list):
    6708        items = delim.join(_to_s(i, verbose, level + 1) for i in node)
    6709        items = f"{indent}{items}" if items else ""
    6710        return f"[{items}]"
    6711
    6712    # Indent multiline strings to match the current level
    6713    return indent.join(textwrap.dedent(str(node).strip("\n")).splitlines())
    6714
    6715
    6716def _is_wrong_expression(expression, into):
    6717    return isinstance(expression, Expression) and not isinstance(expression, into)
    6718
    6719
    6720def _apply_builder(
    6721    expression,
    6722    instance,
    6723    arg,
    6724    copy=True,
    6725    prefix=None,
    6726    into=None,
    6727    dialect=None,
    6728    into_arg="this",
    6729    **opts,
    6730):
    6731    if _is_wrong_expression(expression, into):
    6732        expression = into(**{into_arg: expression})
    6733    instance = maybe_copy(instance, copy)
    6734    expression = maybe_parse(
    6735        sql_or_expression=expression,
    6736        prefix=prefix,
    6737        into=into,
    6738        dialect=dialect,
    6739        **opts,
    6740    )
    6741    instance.set(arg, expression)
    6742    return instance
    6743
    6744
    6745def _apply_child_list_builder(
    6746    *expressions,
    6747    instance,
    6748    arg,
    6749    append=True,
    6750    copy=True,
    6751    prefix=None,
    6752    into=None,
    6753    dialect=None,
    6754    properties=None,
    6755    **opts,
    6756):
    6757    instance = maybe_copy(instance, copy)
    6758    parsed = []
    6759    properties = {} if properties is None else properties
    6760
    6761    for expression in expressions:
    6762        if expression is not None:
    6763            if _is_wrong_expression(expression, into):
    6764                expression = into(expressions=[expression])
    6765
    6766            expression = maybe_parse(
    6767                expression,
    6768                into=into,
    6769                dialect=dialect,
    6770                prefix=prefix,
    6771                **opts,
    6772            )
    6773            for k, v in expression.args.items():
    6774                if k == "expressions":
    6775                    parsed.extend(v)
    6776                else:
    6777                    properties[k] = v
    6778
    6779    existing = instance.args.get(arg)
    6780    if append and existing:
    6781        parsed = existing.expressions + parsed
    6782
    6783    child = into(expressions=parsed)
    6784    for k, v in properties.items():
    6785        child.set(k, v)
    6786    instance.set(arg, child)
    6787
    6788    return instance
    6789
    6790
    6791def _apply_list_builder(
    6792    *expressions,
    6793    instance,
    6794    arg,
    6795    append=True,
    6796    copy=True,
    6797    prefix=None,
    6798    into=None,
    6799    dialect=None,
    6800    **opts,
    6801):
    6802    inst = maybe_copy(instance, copy)
    6803
    6804    expressions = [
    6805        maybe_parse(
    6806            sql_or_expression=expression,
    6807            into=into,
    6808            prefix=prefix,
    6809            dialect=dialect,
    6810            **opts,
    6811        )
    6812        for expression in expressions
    6813        if expression is not None
    6814    ]
    6815
    6816    existing_expressions = inst.args.get(arg)
    6817    if append and existing_expressions:
    6818        expressions = existing_expressions + expressions
    6819
    6820    inst.set(arg, expressions)
    6821    return inst
    6822
    6823
    6824def _apply_conjunction_builder(
    6825    *expressions,
    6826    instance,
    6827    arg,
    6828    into=None,
    6829    append=True,
    6830    copy=True,
    6831    dialect=None,
    6832    **opts,
    6833):
    6834    expressions = [exp for exp in expressions if exp is not None and exp != ""]
    6835    if not expressions:
    6836        return instance
    6837
    6838    inst = maybe_copy(instance, copy)
    6839
    6840    existing = inst.args.get(arg)
    6841    if append and existing is not None:
    6842        expressions = [existing.this if into else existing] + list(expressions)
    6843
    6844    node = and_(*expressions, dialect=dialect, copy=copy, **opts)
    6845
    6846    inst.set(arg, into(this=node) if into else node)
    6847    return inst
    6848
    6849
    6850def _apply_cte_builder(
    6851    instance: E,
    6852    alias: ExpOrStr,
    6853    as_: ExpOrStr,
    6854    recursive: t.Optional[bool] = None,
    6855    materialized: t.Optional[bool] = None,
    6856    append: bool = True,
    6857    dialect: DialectType = None,
    6858    copy: bool = True,
    6859    **opts,
    6860) -> E:
    6861    alias_expression = maybe_parse(alias, dialect=dialect, into=TableAlias, **opts)
    6862    as_expression = maybe_parse(as_, dialect=dialect, **opts)
    6863    cte = CTE(this=as_expression, alias=alias_expression, materialized=materialized)
    6864    return _apply_child_list_builder(
    6865        cte,
    6866        instance=instance,
    6867        arg="with",
    6868        append=append,
    6869        copy=copy,
    6870        into=With,
    6871        properties={"recursive": recursive or False},
    6872    )
    6873
    6874
    6875def _combine(
    6876    expressions: t.Sequence[t.Optional[ExpOrStr]],
    6877    operator: t.Type[Connector],
    6878    dialect: DialectType = None,
    6879    copy: bool = True,
    6880    **opts,
    6881) -> Expression:
    6882    conditions = [
    6883        condition(expression, dialect=dialect, copy=copy, **opts)
    6884        for expression in expressions
    6885        if expression is not None
    6886    ]
    6887
    6888    this, *rest = conditions
    6889    if rest:
    6890        this = _wrap(this, Connector)
    6891    for expression in rest:
    6892        this = operator(this=this, expression=_wrap(expression, Connector))
    6893
    6894    return this
    6895
    6896
    6897def _wrap(expression: E, kind: t.Type[Expression]) -> E | Paren:
    6898    return Paren(this=expression) if isinstance(expression, kind) else expression
    6899
    6900
    6901def _apply_set_operation(
    6902    *expressions: ExpOrStr,
    6903    set_operation: t.Type[S],
    6904    distinct: bool = True,
    6905    dialect: DialectType = None,
    6906    copy: bool = True,
    6907    **opts,
    6908) -> S:
    6909    return reduce(
    6910        lambda x, y: set_operation(this=x, expression=y, distinct=distinct),
    6911        (maybe_parse(e, dialect=dialect, copy=copy, **opts) for e in expressions),
    6912    )
    6913
    6914
    6915def union(
    6916    *expressions: ExpOrStr,
    6917    distinct: bool = True,
    6918    dialect: DialectType = None,
    6919    copy: bool = True,
    6920    **opts,
    6921) -> Union:
    6922    """
    6923    Initializes a syntax tree for the `UNION` operation.
    6924
    6925    Example:
    6926        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6927        'SELECT * FROM foo UNION SELECT * FROM bla'
    6928
    6929    Args:
    6930        expressions: the SQL code strings, corresponding to the `UNION`'s operands.
    6931            If `Expression` instances are passed, they will be used as-is.
    6932        distinct: set the DISTINCT flag if and only if this is true.
    6933        dialect: the dialect used to parse the input expression.
    6934        copy: whether to copy the expression.
    6935        opts: other options to use to parse the input expressions.
    6936
    6937    Returns:
    6938        The new Union instance.
    6939    """
    6940    assert len(expressions) >= 2, "At least two expressions are required by `union`."
    6941    return _apply_set_operation(
    6942        *expressions, set_operation=Union, distinct=distinct, dialect=dialect, copy=copy, **opts
    6943    )
    6944
    6945
    6946def intersect(
    6947    *expressions: ExpOrStr,
    6948    distinct: bool = True,
    6949    dialect: DialectType = None,
    6950    copy: bool = True,
    6951    **opts,
    6952) -> Intersect:
    6953    """
    6954    Initializes a syntax tree for the `INTERSECT` operation.
    6955
    6956    Example:
    6957        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6958        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    6959
    6960    Args:
    6961        expressions: the SQL code strings, corresponding to the `INTERSECT`'s operands.
    6962            If `Expression` instances are passed, they will be used as-is.
    6963        distinct: set the DISTINCT flag if and only if this is true.
    6964        dialect: the dialect used to parse the input expression.
    6965        copy: whether to copy the expression.
    6966        opts: other options to use to parse the input expressions.
    6967
    6968    Returns:
    6969        The new Intersect instance.
    6970    """
    6971    assert len(expressions) >= 2, "At least two expressions are required by `intersect`."
    6972    return _apply_set_operation(
    6973        *expressions, set_operation=Intersect, distinct=distinct, dialect=dialect, copy=copy, **opts
    6974    )
    6975
    6976
    6977def except_(
    6978    *expressions: ExpOrStr,
    6979    distinct: bool = True,
    6980    dialect: DialectType = None,
    6981    copy: bool = True,
    6982    **opts,
    6983) -> Except:
    6984    """
    6985    Initializes a syntax tree for the `EXCEPT` operation.
    6986
    6987    Example:
    6988        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6989        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    6990
    6991    Args:
    6992        expressions: the SQL code strings, corresponding to the `EXCEPT`'s operands.
    6993            If `Expression` instances are passed, they will be used as-is.
    6994        distinct: set the DISTINCT flag if and only if this is true.
    6995        dialect: the dialect used to parse the input expression.
    6996        copy: whether to copy the expression.
    6997        opts: other options to use to parse the input expressions.
    6998
    6999    Returns:
    7000        The new Except instance.
    7001    """
    7002    assert len(expressions) >= 2, "At least two expressions are required by `except_`."
    7003    return _apply_set_operation(
    7004        *expressions, set_operation=Except, distinct=distinct, dialect=dialect, copy=copy, **opts
    7005    )
    7006
    7007
    7008def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    7009    """
    7010    Initializes a syntax tree from one or multiple SELECT expressions.
    7011
    7012    Example:
    7013        >>> select("col1", "col2").from_("tbl").sql()
    7014        'SELECT col1, col2 FROM tbl'
    7015
    7016    Args:
    7017        *expressions: the SQL code string to parse as the expressions of a
    7018            SELECT statement. If an Expression instance is passed, this is used as-is.
    7019        dialect: the dialect used to parse the input expressions (in the case that an
    7020            input expression is a SQL string).
    7021        **opts: other options to use to parse the input expressions (again, in the case
    7022            that an input expression is a SQL string).
    7023
    7024    Returns:
    7025        Select: the syntax tree for the SELECT statement.
    7026    """
    7027    return Select().select(*expressions, dialect=dialect, **opts)
    7028
    7029
    7030def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    7031    """
    7032    Initializes a syntax tree from a FROM expression.
    7033
    7034    Example:
    7035        >>> from_("tbl").select("col1", "col2").sql()
    7036        'SELECT col1, col2 FROM tbl'
    7037
    7038    Args:
    7039        *expression: the SQL code string to parse as the FROM expressions of a
    7040            SELECT statement. If an Expression instance is passed, this is used as-is.
    7041        dialect: the dialect used to parse the input expression (in the case that the
    7042            input expression is a SQL string).
    7043        **opts: other options to use to parse the input expressions (again, in the case
    7044            that the input expression is a SQL string).
    7045
    7046    Returns:
    7047        Select: the syntax tree for the SELECT statement.
    7048    """
    7049    return Select().from_(expression, dialect=dialect, **opts)
    7050
    7051
    7052def update(
    7053    table: str | Table,
    7054    properties: t.Optional[dict] = None,
    7055    where: t.Optional[ExpOrStr] = None,
    7056    from_: t.Optional[ExpOrStr] = None,
    7057    with_: t.Optional[t.Dict[str, ExpOrStr]] = None,
    7058    dialect: DialectType = None,
    7059    **opts,
    7060) -> Update:
    7061    """
    7062    Creates an update statement.
    7063
    7064    Example:
    7065        >>> 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()
    7066        "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"
    7067
    7068    Args:
    7069        properties: dictionary of properties to SET which are
    7070            auto converted to sql objects eg None -> NULL
    7071        where: sql conditional parsed into a WHERE statement
    7072        from_: sql statement parsed into a FROM statement
    7073        with_: dictionary of CTE aliases / select statements to include in a WITH clause.
    7074        dialect: the dialect used to parse the input expressions.
    7075        **opts: other options to use to parse the input expressions.
    7076
    7077    Returns:
    7078        Update: the syntax tree for the UPDATE statement.
    7079    """
    7080    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    7081    if properties:
    7082        update_expr.set(
    7083            "expressions",
    7084            [
    7085                EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    7086                for k, v in properties.items()
    7087            ],
    7088        )
    7089    if from_:
    7090        update_expr.set(
    7091            "from",
    7092            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    7093        )
    7094    if isinstance(where, Condition):
    7095        where = Where(this=where)
    7096    if where:
    7097        update_expr.set(
    7098            "where",
    7099            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    7100        )
    7101    if with_:
    7102        cte_list = [
    7103            alias_(CTE(this=maybe_parse(qry, dialect=dialect, **opts)), alias, table=True)
    7104            for alias, qry in with_.items()
    7105        ]
    7106        update_expr.set(
    7107            "with",
    7108            With(expressions=cte_list),
    7109        )
    7110    return update_expr
    7111
    7112
    7113def delete(
    7114    table: ExpOrStr,
    7115    where: t.Optional[ExpOrStr] = None,
    7116    returning: t.Optional[ExpOrStr] = None,
    7117    dialect: DialectType = None,
    7118    **opts,
    7119) -> Delete:
    7120    """
    7121    Builds a delete statement.
    7122
    7123    Example:
    7124        >>> delete("my_table", where="id > 1").sql()
    7125        'DELETE FROM my_table WHERE id > 1'
    7126
    7127    Args:
    7128        where: sql conditional parsed into a WHERE statement
    7129        returning: sql conditional parsed into a RETURNING statement
    7130        dialect: the dialect used to parse the input expressions.
    7131        **opts: other options to use to parse the input expressions.
    7132
    7133    Returns:
    7134        Delete: the syntax tree for the DELETE statement.
    7135    """
    7136    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    7137    if where:
    7138        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    7139    if returning:
    7140        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    7141    return delete_expr
    7142
    7143
    7144def insert(
    7145    expression: ExpOrStr,
    7146    into: ExpOrStr,
    7147    columns: t.Optional[t.Sequence[str | Identifier]] = None,
    7148    overwrite: t.Optional[bool] = None,
    7149    returning: t.Optional[ExpOrStr] = None,
    7150    dialect: DialectType = None,
    7151    copy: bool = True,
    7152    **opts,
    7153) -> Insert:
    7154    """
    7155    Builds an INSERT statement.
    7156
    7157    Example:
    7158        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    7159        'INSERT INTO tbl VALUES (1, 2, 3)'
    7160
    7161    Args:
    7162        expression: the sql string or expression of the INSERT statement
    7163        into: the tbl to insert data to.
    7164        columns: optionally the table's column names.
    7165        overwrite: whether to INSERT OVERWRITE or not.
    7166        returning: sql conditional parsed into a RETURNING statement
    7167        dialect: the dialect used to parse the input expressions.
    7168        copy: whether to copy the expression.
    7169        **opts: other options to use to parse the input expressions.
    7170
    7171    Returns:
    7172        Insert: the syntax tree for the INSERT statement.
    7173    """
    7174    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7175    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    7176
    7177    if columns:
    7178        this = Schema(this=this, expressions=[to_identifier(c, copy=copy) for c in columns])
    7179
    7180    insert = Insert(this=this, expression=expr, overwrite=overwrite)
    7181
    7182    if returning:
    7183        insert = insert.returning(returning, dialect=dialect, copy=False, **opts)
    7184
    7185    return insert
    7186
    7187
    7188def merge(
    7189    *when_exprs: ExpOrStr,
    7190    into: ExpOrStr,
    7191    using: ExpOrStr,
    7192    on: ExpOrStr,
    7193    returning: t.Optional[ExpOrStr] = None,
    7194    dialect: DialectType = None,
    7195    copy: bool = True,
    7196    **opts,
    7197) -> Merge:
    7198    """
    7199    Builds a MERGE statement.
    7200
    7201    Example:
    7202        >>> merge("WHEN MATCHED THEN UPDATE SET col1 = source_table.col1",
    7203        ...       "WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)",
    7204        ...       into="my_table",
    7205        ...       using="source_table",
    7206        ...       on="my_table.id = source_table.id").sql()
    7207        '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)'
    7208
    7209    Args:
    7210        *when_exprs: The WHEN clauses specifying actions for matched and unmatched rows.
    7211        into: The target table to merge data into.
    7212        using: The source table to merge data from.
    7213        on: The join condition for the merge.
    7214        returning: The columns to return from the merge.
    7215        dialect: The dialect used to parse the input expressions.
    7216        copy: Whether to copy the expression.
    7217        **opts: Other options to use to parse the input expressions.
    7218
    7219    Returns:
    7220        Merge: The syntax tree for the MERGE statement.
    7221    """
    7222    merge = Merge(
    7223        this=maybe_parse(into, dialect=dialect, copy=copy, **opts),
    7224        using=maybe_parse(using, dialect=dialect, copy=copy, **opts),
    7225        on=maybe_parse(on, dialect=dialect, copy=copy, **opts),
    7226        expressions=[
    7227            maybe_parse(when_expr, dialect=dialect, copy=copy, into=When, **opts)
    7228            for when_expr in when_exprs
    7229        ],
    7230    )
    7231    if returning:
    7232        merge = merge.returning(returning, dialect=dialect, copy=False, **opts)
    7233
    7234    return merge
    7235
    7236
    7237def condition(
    7238    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    7239) -> Condition:
    7240    """
    7241    Initialize a logical condition expression.
    7242
    7243    Example:
    7244        >>> condition("x=1").sql()
    7245        'x = 1'
    7246
    7247        This is helpful for composing larger logical syntax trees:
    7248        >>> where = condition("x=1")
    7249        >>> where = where.and_("y=1")
    7250        >>> Select().from_("tbl").select("*").where(where).sql()
    7251        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    7252
    7253    Args:
    7254        *expression: the SQL code string to parse.
    7255            If an Expression instance is passed, this is used as-is.
    7256        dialect: the dialect used to parse the input expression (in the case that the
    7257            input expression is a SQL string).
    7258        copy: Whether to copy `expression` (only applies to expressions).
    7259        **opts: other options to use to parse the input expressions (again, in the case
    7260            that the input expression is a SQL string).
    7261
    7262    Returns:
    7263        The new Condition instance
    7264    """
    7265    return maybe_parse(
    7266        expression,
    7267        into=Condition,
    7268        dialect=dialect,
    7269        copy=copy,
    7270        **opts,
    7271    )
    7272
    7273
    7274def and_(
    7275    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7276) -> Condition:
    7277    """
    7278    Combine multiple conditions with an AND logical operator.
    7279
    7280    Example:
    7281        >>> and_("x=1", and_("y=1", "z=1")).sql()
    7282        'x = 1 AND (y = 1 AND z = 1)'
    7283
    7284    Args:
    7285        *expressions: the SQL code strings to parse.
    7286            If an Expression instance is passed, this is used as-is.
    7287        dialect: the dialect used to parse the input expression.
    7288        copy: whether to copy `expressions` (only applies to Expressions).
    7289        **opts: other options to use to parse the input expressions.
    7290
    7291    Returns:
    7292        The new condition
    7293    """
    7294    return t.cast(Condition, _combine(expressions, And, dialect, copy=copy, **opts))
    7295
    7296
    7297def or_(
    7298    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7299) -> Condition:
    7300    """
    7301    Combine multiple conditions with an OR logical operator.
    7302
    7303    Example:
    7304        >>> or_("x=1", or_("y=1", "z=1")).sql()
    7305        'x = 1 OR (y = 1 OR z = 1)'
    7306
    7307    Args:
    7308        *expressions: the SQL code strings to parse.
    7309            If an Expression instance is passed, this is used as-is.
    7310        dialect: the dialect used to parse the input expression.
    7311        copy: whether to copy `expressions` (only applies to Expressions).
    7312        **opts: other options to use to parse the input expressions.
    7313
    7314    Returns:
    7315        The new condition
    7316    """
    7317    return t.cast(Condition, _combine(expressions, Or, dialect, copy=copy, **opts))
    7318
    7319
    7320def xor(
    7321    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7322) -> Condition:
    7323    """
    7324    Combine multiple conditions with an XOR logical operator.
    7325
    7326    Example:
    7327        >>> xor("x=1", xor("y=1", "z=1")).sql()
    7328        'x = 1 XOR (y = 1 XOR z = 1)'
    7329
    7330    Args:
    7331        *expressions: the SQL code strings to parse.
    7332            If an Expression instance is passed, this is used as-is.
    7333        dialect: the dialect used to parse the input expression.
    7334        copy: whether to copy `expressions` (only applies to Expressions).
    7335        **opts: other options to use to parse the input expressions.
    7336
    7337    Returns:
    7338        The new condition
    7339    """
    7340    return t.cast(Condition, _combine(expressions, Xor, dialect, copy=copy, **opts))
    7341
    7342
    7343def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    7344    """
    7345    Wrap a condition with a NOT operator.
    7346
    7347    Example:
    7348        >>> not_("this_suit='black'").sql()
    7349        "NOT this_suit = 'black'"
    7350
    7351    Args:
    7352        expression: the SQL code string to parse.
    7353            If an Expression instance is passed, this is used as-is.
    7354        dialect: the dialect used to parse the input expression.
    7355        copy: whether to copy the expression or not.
    7356        **opts: other options to use to parse the input expressions.
    7357
    7358    Returns:
    7359        The new condition.
    7360    """
    7361    this = condition(
    7362        expression,
    7363        dialect=dialect,
    7364        copy=copy,
    7365        **opts,
    7366    )
    7367    return Not(this=_wrap(this, Connector))
    7368
    7369
    7370def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    7371    """
    7372    Wrap an expression in parentheses.
    7373
    7374    Example:
    7375        >>> paren("5 + 3").sql()
    7376        '(5 + 3)'
    7377
    7378    Args:
    7379        expression: the SQL code string to parse.
    7380            If an Expression instance is passed, this is used as-is.
    7381        copy: whether to copy the expression or not.
    7382
    7383    Returns:
    7384        The wrapped expression.
    7385    """
    7386    return Paren(this=maybe_parse(expression, copy=copy))
    7387
    7388
    7389SAFE_IDENTIFIER_RE: t.Pattern[str] = re.compile(r"^[_a-zA-Z][\w]*$")
    7390
    7391
    7392@t.overload
    7393def to_identifier(name: None, quoted: t.Optional[bool] = None, copy: bool = True) -> None: ...
    7394
    7395
    7396@t.overload
    7397def to_identifier(
    7398    name: str | Identifier, quoted: t.Optional[bool] = None, copy: bool = True
    7399) -> Identifier: ...
    7400
    7401
    7402def to_identifier(name, quoted=None, copy=True):
    7403    """Builds an identifier.
    7404
    7405    Args:
    7406        name: The name to turn into an identifier.
    7407        quoted: Whether to force quote the identifier.
    7408        copy: Whether to copy name if it's an Identifier.
    7409
    7410    Returns:
    7411        The identifier ast node.
    7412    """
    7413
    7414    if name is None:
    7415        return None
    7416
    7417    if isinstance(name, Identifier):
    7418        identifier = maybe_copy(name, copy)
    7419    elif isinstance(name, str):
    7420        identifier = Identifier(
    7421            this=name,
    7422            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    7423        )
    7424    else:
    7425        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    7426    return identifier
    7427
    7428
    7429def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Identifier:
    7430    """
    7431    Parses a given string into an identifier.
    7432
    7433    Args:
    7434        name: The name to parse into an identifier.
    7435        dialect: The dialect to parse against.
    7436
    7437    Returns:
    7438        The identifier ast node.
    7439    """
    7440    try:
    7441        expression = maybe_parse(name, dialect=dialect, into=Identifier)
    7442    except (ParseError, TokenError):
    7443        expression = to_identifier(name)
    7444
    7445    return expression
    7446
    7447
    7448INTERVAL_STRING_RE = re.compile(r"\s*([0-9]+)\s*([a-zA-Z]+)\s*")
    7449
    7450
    7451def to_interval(interval: str | Literal) -> Interval:
    7452    """Builds an interval expression from a string like '1 day' or '5 months'."""
    7453    if isinstance(interval, Literal):
    7454        if not interval.is_string:
    7455            raise ValueError("Invalid interval string.")
    7456
    7457        interval = interval.this
    7458
    7459    interval = maybe_parse(f"INTERVAL {interval}")
    7460    assert isinstance(interval, Interval)
    7461    return interval
    7462
    7463
    7464def to_table(
    7465    sql_path: str | Table, dialect: DialectType = None, copy: bool = True, **kwargs
    7466) -> Table:
    7467    """
    7468    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    7469    If a table is passed in then that table is returned.
    7470
    7471    Args:
    7472        sql_path: a `[catalog].[schema].[table]` string.
    7473        dialect: the source dialect according to which the table name will be parsed.
    7474        copy: Whether to copy a table if it is passed in.
    7475        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    7476
    7477    Returns:
    7478        A table expression.
    7479    """
    7480    if isinstance(sql_path, Table):
    7481        return maybe_copy(sql_path, copy=copy)
    7482
    7483    table = maybe_parse(sql_path, into=Table, dialect=dialect)
    7484
    7485    for k, v in kwargs.items():
    7486        table.set(k, v)
    7487
    7488    return table
    7489
    7490
    7491def to_column(
    7492    sql_path: str | Column,
    7493    quoted: t.Optional[bool] = None,
    7494    dialect: DialectType = None,
    7495    copy: bool = True,
    7496    **kwargs,
    7497) -> Column:
    7498    """
    7499    Create a column from a `[table].[column]` sql path. Table is optional.
    7500    If a column is passed in then that column is returned.
    7501
    7502    Args:
    7503        sql_path: a `[table].[column]` string.
    7504        quoted: Whether or not to force quote identifiers.
    7505        dialect: the source dialect according to which the column name will be parsed.
    7506        copy: Whether to copy a column if it is passed in.
    7507        kwargs: the kwargs to instantiate the resulting `Column` expression with.
    7508
    7509    Returns:
    7510        A column expression.
    7511    """
    7512    if isinstance(sql_path, Column):
    7513        return maybe_copy(sql_path, copy=copy)
    7514
    7515    try:
    7516        col = maybe_parse(sql_path, into=Column, dialect=dialect)
    7517    except ParseError:
    7518        return column(*reversed(sql_path.split(".")), quoted=quoted, **kwargs)
    7519
    7520    for k, v in kwargs.items():
    7521        col.set(k, v)
    7522
    7523    if quoted:
    7524        for i in col.find_all(Identifier):
    7525            i.set("quoted", True)
    7526
    7527    return col
    7528
    7529
    7530def alias_(
    7531    expression: ExpOrStr,
    7532    alias: t.Optional[str | Identifier],
    7533    table: bool | t.Sequence[str | Identifier] = False,
    7534    quoted: t.Optional[bool] = None,
    7535    dialect: DialectType = None,
    7536    copy: bool = True,
    7537    **opts,
    7538):
    7539    """Create an Alias expression.
    7540
    7541    Example:
    7542        >>> alias_('foo', 'bar').sql()
    7543        'foo AS bar'
    7544
    7545        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    7546        '(SELECT 1, 2) AS bar(a, b)'
    7547
    7548    Args:
    7549        expression: the SQL code strings to parse.
    7550            If an Expression instance is passed, this is used as-is.
    7551        alias: the alias name to use. If the name has
    7552            special characters it is quoted.
    7553        table: Whether to create a table alias, can also be a list of columns.
    7554        quoted: whether to quote the alias
    7555        dialect: the dialect used to parse the input expression.
    7556        copy: Whether to copy the expression.
    7557        **opts: other options to use to parse the input expressions.
    7558
    7559    Returns:
    7560        Alias: the aliased expression
    7561    """
    7562    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7563    alias = to_identifier(alias, quoted=quoted)
    7564
    7565    if table:
    7566        table_alias = TableAlias(this=alias)
    7567        exp.set("alias", table_alias)
    7568
    7569        if not isinstance(table, bool):
    7570            for column in table:
    7571                table_alias.append("columns", to_identifier(column, quoted=quoted))
    7572
    7573        return exp
    7574
    7575    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    7576    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    7577    # for the complete Window expression.
    7578    #
    7579    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    7580
    7581    if "alias" in exp.arg_types and not isinstance(exp, Window):
    7582        exp.set("alias", alias)
    7583        return exp
    7584    return Alias(this=exp, alias=alias)
    7585
    7586
    7587def subquery(
    7588    expression: ExpOrStr,
    7589    alias: t.Optional[Identifier | str] = None,
    7590    dialect: DialectType = None,
    7591    **opts,
    7592) -> Select:
    7593    """
    7594    Build a subquery expression that's selected from.
    7595
    7596    Example:
    7597        >>> subquery('select x from tbl', 'bar').select('x').sql()
    7598        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    7599
    7600    Args:
    7601        expression: the SQL code strings to parse.
    7602            If an Expression instance is passed, this is used as-is.
    7603        alias: the alias name to use.
    7604        dialect: the dialect used to parse the input expression.
    7605        **opts: other options to use to parse the input expressions.
    7606
    7607    Returns:
    7608        A new Select instance with the subquery expression included.
    7609    """
    7610
    7611    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias, **opts)
    7612    return Select().from_(expression, dialect=dialect, **opts)
    7613
    7614
    7615@t.overload
    7616def column(
    7617    col: str | Identifier,
    7618    table: t.Optional[str | Identifier] = None,
    7619    db: t.Optional[str | Identifier] = None,
    7620    catalog: t.Optional[str | Identifier] = None,
    7621    *,
    7622    fields: t.Collection[t.Union[str, Identifier]],
    7623    quoted: t.Optional[bool] = None,
    7624    copy: bool = True,
    7625) -> Dot:
    7626    pass
    7627
    7628
    7629@t.overload
    7630def column(
    7631    col: str | Identifier,
    7632    table: t.Optional[str | Identifier] = None,
    7633    db: t.Optional[str | Identifier] = None,
    7634    catalog: t.Optional[str | Identifier] = None,
    7635    *,
    7636    fields: Lit[None] = None,
    7637    quoted: t.Optional[bool] = None,
    7638    copy: bool = True,
    7639) -> Column:
    7640    pass
    7641
    7642
    7643def column(
    7644    col,
    7645    table=None,
    7646    db=None,
    7647    catalog=None,
    7648    *,
    7649    fields=None,
    7650    quoted=None,
    7651    copy=True,
    7652):
    7653    """
    7654    Build a Column.
    7655
    7656    Args:
    7657        col: Column name.
    7658        table: Table name.
    7659        db: Database name.
    7660        catalog: Catalog name.
    7661        fields: Additional fields using dots.
    7662        quoted: Whether to force quotes on the column's identifiers.
    7663        copy: Whether to copy identifiers if passed in.
    7664
    7665    Returns:
    7666        The new Column instance.
    7667    """
    7668    this = Column(
    7669        this=to_identifier(col, quoted=quoted, copy=copy),
    7670        table=to_identifier(table, quoted=quoted, copy=copy),
    7671        db=to_identifier(db, quoted=quoted, copy=copy),
    7672        catalog=to_identifier(catalog, quoted=quoted, copy=copy),
    7673    )
    7674
    7675    if fields:
    7676        this = Dot.build(
    7677            (this, *(to_identifier(field, quoted=quoted, copy=copy) for field in fields))
    7678        )
    7679    return this
    7680
    7681
    7682def cast(
    7683    expression: ExpOrStr, to: DATA_TYPE, copy: bool = True, dialect: DialectType = None, **opts
    7684) -> Cast:
    7685    """Cast an expression to a data type.
    7686
    7687    Example:
    7688        >>> cast('x + 1', 'int').sql()
    7689        'CAST(x + 1 AS INT)'
    7690
    7691    Args:
    7692        expression: The expression to cast.
    7693        to: The datatype to cast to.
    7694        copy: Whether to copy the supplied expressions.
    7695        dialect: The target dialect. This is used to prevent a re-cast in the following scenario:
    7696            - The expression to be cast is already a exp.Cast expression
    7697            - The existing cast is to a type that is logically equivalent to new type
    7698
    7699            For example, if :expression='CAST(x as DATETIME)' and :to=Type.TIMESTAMP,
    7700            but in the target dialect DATETIME is mapped to TIMESTAMP, then we will NOT return `CAST(x (as DATETIME) as TIMESTAMP)`
    7701            and instead just return the original expression `CAST(x as DATETIME)`.
    7702
    7703            This is to prevent it being output as a double cast `CAST(x (as TIMESTAMP) as TIMESTAMP)` once the DATETIME -> TIMESTAMP
    7704            mapping is applied in the target dialect generator.
    7705
    7706    Returns:
    7707        The new Cast instance.
    7708    """
    7709    expr = maybe_parse(expression, copy=copy, dialect=dialect, **opts)
    7710    data_type = DataType.build(to, copy=copy, dialect=dialect, **opts)
    7711
    7712    # dont re-cast if the expression is already a cast to the correct type
    7713    if isinstance(expr, Cast):
    7714        from sqlglot.dialects.dialect import Dialect
    7715
    7716        target_dialect = Dialect.get_or_raise(dialect)
    7717        type_mapping = target_dialect.generator_class.TYPE_MAPPING
    7718
    7719        existing_cast_type: DataType.Type = expr.to.this
    7720        new_cast_type: DataType.Type = data_type.this
    7721        types_are_equivalent = type_mapping.get(
    7722            existing_cast_type, existing_cast_type
    7723        ) == type_mapping.get(new_cast_type, new_cast_type)
    7724        if expr.is_type(data_type) or types_are_equivalent:
    7725            return expr
    7726
    7727    expr = Cast(this=expr, to=data_type)
    7728    expr.type = data_type
    7729
    7730    return expr
    7731
    7732
    7733def table_(
    7734    table: Identifier | str,
    7735    db: t.Optional[Identifier | str] = None,
    7736    catalog: t.Optional[Identifier | str] = None,
    7737    quoted: t.Optional[bool] = None,
    7738    alias: t.Optional[Identifier | str] = None,
    7739) -> Table:
    7740    """Build a Table.
    7741
    7742    Args:
    7743        table: Table name.
    7744        db: Database name.
    7745        catalog: Catalog name.
    7746        quote: Whether to force quotes on the table's identifiers.
    7747        alias: Table's alias.
    7748
    7749    Returns:
    7750        The new Table instance.
    7751    """
    7752    return Table(
    7753        this=to_identifier(table, quoted=quoted) if table else None,
    7754        db=to_identifier(db, quoted=quoted) if db else None,
    7755        catalog=to_identifier(catalog, quoted=quoted) if catalog else None,
    7756        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    7757    )
    7758
    7759
    7760def values(
    7761    values: t.Iterable[t.Tuple[t.Any, ...]],
    7762    alias: t.Optional[str] = None,
    7763    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    7764) -> Values:
    7765    """Build VALUES statement.
    7766
    7767    Example:
    7768        >>> values([(1, '2')]).sql()
    7769        "VALUES (1, '2')"
    7770
    7771    Args:
    7772        values: values statements that will be converted to SQL
    7773        alias: optional alias
    7774        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    7775         If either are provided then an alias is also required.
    7776
    7777    Returns:
    7778        Values: the Values expression object
    7779    """
    7780    if columns and not alias:
    7781        raise ValueError("Alias is required when providing columns")
    7782
    7783    return Values(
    7784        expressions=[convert(tup) for tup in values],
    7785        alias=(
    7786            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    7787            if columns
    7788            else (TableAlias(this=to_identifier(alias)) if alias else None)
    7789        ),
    7790    )
    7791
    7792
    7793def var(name: t.Optional[ExpOrStr]) -> Var:
    7794    """Build a SQL variable.
    7795
    7796    Example:
    7797        >>> repr(var('x'))
    7798        'Var(this=x)'
    7799
    7800        >>> repr(var(column('x', table='y')))
    7801        'Var(this=x)'
    7802
    7803    Args:
    7804        name: The name of the var or an expression who's name will become the var.
    7805
    7806    Returns:
    7807        The new variable node.
    7808    """
    7809    if not name:
    7810        raise ValueError("Cannot convert empty name into var.")
    7811
    7812    if isinstance(name, Expression):
    7813        name = name.name
    7814    return Var(this=name)
    7815
    7816
    7817def rename_table(
    7818    old_name: str | Table,
    7819    new_name: str | Table,
    7820    dialect: DialectType = None,
    7821) -> Alter:
    7822    """Build ALTER TABLE... RENAME... expression
    7823
    7824    Args:
    7825        old_name: The old name of the table
    7826        new_name: The new name of the table
    7827        dialect: The dialect to parse the table.
    7828
    7829    Returns:
    7830        Alter table expression
    7831    """
    7832    old_table = to_table(old_name, dialect=dialect)
    7833    new_table = to_table(new_name, dialect=dialect)
    7834    return Alter(
    7835        this=old_table,
    7836        kind="TABLE",
    7837        actions=[
    7838            AlterRename(this=new_table),
    7839        ],
    7840    )
    7841
    7842
    7843def rename_column(
    7844    table_name: str | Table,
    7845    old_column_name: str | Column,
    7846    new_column_name: str | Column,
    7847    exists: t.Optional[bool] = None,
    7848    dialect: DialectType = None,
    7849) -> Alter:
    7850    """Build ALTER TABLE... RENAME COLUMN... expression
    7851
    7852    Args:
    7853        table_name: Name of the table
    7854        old_column: The old name of the column
    7855        new_column: The new name of the column
    7856        exists: Whether to add the `IF EXISTS` clause
    7857        dialect: The dialect to parse the table/column.
    7858
    7859    Returns:
    7860        Alter table expression
    7861    """
    7862    table = to_table(table_name, dialect=dialect)
    7863    old_column = to_column(old_column_name, dialect=dialect)
    7864    new_column = to_column(new_column_name, dialect=dialect)
    7865    return Alter(
    7866        this=table,
    7867        kind="TABLE",
    7868        actions=[
    7869            RenameColumn(this=old_column, to=new_column, exists=exists),
    7870        ],
    7871    )
    7872
    7873
    7874def convert(value: t.Any, copy: bool = False) -> Expression:
    7875    """Convert a python value into an expression object.
    7876
    7877    Raises an error if a conversion is not possible.
    7878
    7879    Args:
    7880        value: A python object.
    7881        copy: Whether to copy `value` (only applies to Expressions and collections).
    7882
    7883    Returns:
    7884        The equivalent expression object.
    7885    """
    7886    if isinstance(value, Expression):
    7887        return maybe_copy(value, copy)
    7888    if isinstance(value, str):
    7889        return Literal.string(value)
    7890    if isinstance(value, bool):
    7891        return Boolean(this=value)
    7892    if value is None or (isinstance(value, float) and math.isnan(value)):
    7893        return null()
    7894    if isinstance(value, numbers.Number):
    7895        return Literal.number(value)
    7896    if isinstance(value, bytes):
    7897        return HexString(this=value.hex())
    7898    if isinstance(value, datetime.datetime):
    7899        datetime_literal = Literal.string(value.isoformat(sep=" "))
    7900
    7901        tz = None
    7902        if value.tzinfo:
    7903            # this works for zoneinfo.ZoneInfo, pytz.timezone and datetime.datetime.utc to return IANA timezone names like "America/Los_Angeles"
    7904            # instead of abbreviations like "PDT". This is for consistency with other timezone handling functions in SQLGlot
    7905            tz = Literal.string(str(value.tzinfo))
    7906
    7907        return TimeStrToTime(this=datetime_literal, zone=tz)
    7908    if isinstance(value, datetime.date):
    7909        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    7910        return DateStrToDate(this=date_literal)
    7911    if isinstance(value, tuple):
    7912        if hasattr(value, "_fields"):
    7913            return Struct(
    7914                expressions=[
    7915                    PropertyEQ(
    7916                        this=to_identifier(k), expression=convert(getattr(value, k), copy=copy)
    7917                    )
    7918                    for k in value._fields
    7919                ]
    7920            )
    7921        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    7922    if isinstance(value, list):
    7923        return Array(expressions=[convert(v, copy=copy) for v in value])
    7924    if isinstance(value, dict):
    7925        return Map(
    7926            keys=Array(expressions=[convert(k, copy=copy) for k in value]),
    7927            values=Array(expressions=[convert(v, copy=copy) for v in value.values()]),
    7928        )
    7929    if hasattr(value, "__dict__"):
    7930        return Struct(
    7931            expressions=[
    7932                PropertyEQ(this=to_identifier(k), expression=convert(v, copy=copy))
    7933                for k, v in value.__dict__.items()
    7934            ]
    7935        )
    7936    raise ValueError(f"Cannot convert {value}")
    7937
    7938
    7939def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    7940    """
    7941    Replace children of an expression with the result of a lambda fun(child) -> exp.
    7942    """
    7943    for k, v in tuple(expression.args.items()):
    7944        is_list_arg = type(v) is list
    7945
    7946        child_nodes = v if is_list_arg else [v]
    7947        new_child_nodes = []
    7948
    7949        for cn in child_nodes:
    7950            if isinstance(cn, Expression):
    7951                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    7952                    new_child_nodes.append(child_node)
    7953            else:
    7954                new_child_nodes.append(cn)
    7955
    7956        expression.set(k, new_child_nodes if is_list_arg else seq_get(new_child_nodes, 0))
    7957
    7958
    7959def replace_tree(
    7960    expression: Expression,
    7961    fun: t.Callable,
    7962    prune: t.Optional[t.Callable[[Expression], bool]] = None,
    7963) -> Expression:
    7964    """
    7965    Replace an entire tree with the result of function calls on each node.
    7966
    7967    This will be traversed in reverse dfs, so leaves first.
    7968    If new nodes are created as a result of function calls, they will also be traversed.
    7969    """
    7970    stack = list(expression.dfs(prune=prune))
    7971
    7972    while stack:
    7973        node = stack.pop()
    7974        new_node = fun(node)
    7975
    7976        if new_node is not node:
    7977            node.replace(new_node)
    7978
    7979            if isinstance(new_node, Expression):
    7980                stack.append(new_node)
    7981
    7982    return new_node
    7983
    7984
    7985def column_table_names(expression: Expression, exclude: str = "") -> t.Set[str]:
    7986    """
    7987    Return all table names referenced through columns in an expression.
    7988
    7989    Example:
    7990        >>> import sqlglot
    7991        >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
    7992        ['a', 'c']
    7993
    7994    Args:
    7995        expression: expression to find table names.
    7996        exclude: a table name to exclude
    7997
    7998    Returns:
    7999        A list of unique names.
    8000    """
    8001    return {
    8002        table
    8003        for table in (column.table for column in expression.find_all(Column))
    8004        if table and table != exclude
    8005    }
    8006
    8007
    8008def table_name(table: Table | str, dialect: DialectType = None, identify: bool = False) -> str:
    8009    """Get the full name of a table as a string.
    8010
    8011    Args:
    8012        table: Table expression node or string.
    8013        dialect: The dialect to generate the table name for.
    8014        identify: Determines when an identifier should be quoted. Possible values are:
    8015            False (default): Never quote, except in cases where it's mandatory by the dialect.
    8016            True: Always quote.
    8017
    8018    Examples:
    8019        >>> from sqlglot import exp, parse_one
    8020        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    8021        'a.b.c'
    8022
    8023    Returns:
    8024        The table name.
    8025    """
    8026
    8027    table = maybe_parse(table, into=Table, dialect=dialect)
    8028
    8029    if not table:
    8030        raise ValueError(f"Cannot parse {table}")
    8031
    8032    return ".".join(
    8033        (
    8034            part.sql(dialect=dialect, identify=True, copy=False)
    8035            if identify or not SAFE_IDENTIFIER_RE.match(part.name)
    8036            else part.name
    8037        )
    8038        for part in table.parts
    8039    )
    8040
    8041
    8042def normalize_table_name(table: str | Table, dialect: DialectType = None, copy: bool = True) -> str:
    8043    """Returns a case normalized table name without quotes.
    8044
    8045    Args:
    8046        table: the table to normalize
    8047        dialect: the dialect to use for normalization rules
    8048        copy: whether to copy the expression.
    8049
    8050    Examples:
    8051        >>> normalize_table_name("`A-B`.c", dialect="bigquery")
    8052        'A-B.c'
    8053    """
    8054    from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
    8055
    8056    return ".".join(
    8057        p.name
    8058        for p in normalize_identifiers(
    8059            to_table(table, dialect=dialect, copy=copy), dialect=dialect
    8060        ).parts
    8061    )
    8062
    8063
    8064def replace_tables(
    8065    expression: E, mapping: t.Dict[str, str], dialect: DialectType = None, copy: bool = True
    8066) -> E:
    8067    """Replace all tables in expression according to the mapping.
    8068
    8069    Args:
    8070        expression: expression node to be transformed and replaced.
    8071        mapping: mapping of table names.
    8072        dialect: the dialect of the mapping table
    8073        copy: whether to copy the expression.
    8074
    8075    Examples:
    8076        >>> from sqlglot import exp, parse_one
    8077        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    8078        'SELECT * FROM c /* a.b */'
    8079
    8080    Returns:
    8081        The mapped expression.
    8082    """
    8083
    8084    mapping = {normalize_table_name(k, dialect=dialect): v for k, v in mapping.items()}
    8085
    8086    def _replace_tables(node: Expression) -> Expression:
    8087        if isinstance(node, Table):
    8088            original = normalize_table_name(node, dialect=dialect)
    8089            new_name = mapping.get(original)
    8090
    8091            if new_name:
    8092                table = to_table(
    8093                    new_name,
    8094                    **{k: v for k, v in node.args.items() if k not in TABLE_PARTS},
    8095                    dialect=dialect,
    8096                )
    8097                table.add_comments([original])
    8098                return table
    8099        return node
    8100
    8101    return expression.transform(_replace_tables, copy=copy)  # type: ignore
    8102
    8103
    8104def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    8105    """Replace placeholders in an expression.
    8106
    8107    Args:
    8108        expression: expression node to be transformed and replaced.
    8109        args: positional names that will substitute unnamed placeholders in the given order.
    8110        kwargs: keyword arguments that will substitute named placeholders.
    8111
    8112    Examples:
    8113        >>> from sqlglot import exp, parse_one
    8114        >>> replace_placeholders(
    8115        ...     parse_one("select * from :tbl where ? = ?"),
    8116        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    8117        ... ).sql()
    8118        "SELECT * FROM foo WHERE str_col = 'b'"
    8119
    8120    Returns:
    8121        The mapped expression.
    8122    """
    8123
    8124    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    8125        if isinstance(node, Placeholder):
    8126            if node.this:
    8127                new_name = kwargs.get(node.this)
    8128                if new_name is not None:
    8129                    return convert(new_name)
    8130            else:
    8131                try:
    8132                    return convert(next(args))
    8133                except StopIteration:
    8134                    pass
    8135        return node
    8136
    8137    return expression.transform(_replace_placeholders, iter(args), **kwargs)
    8138
    8139
    8140def expand(
    8141    expression: Expression,
    8142    sources: t.Dict[str, Query],
    8143    dialect: DialectType = None,
    8144    copy: bool = True,
    8145) -> Expression:
    8146    """Transforms an expression by expanding all referenced sources into subqueries.
    8147
    8148    Examples:
    8149        >>> from sqlglot import parse_one
    8150        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    8151        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    8152
    8153        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    8154        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    8155
    8156    Args:
    8157        expression: The expression to expand.
    8158        sources: A dictionary of name to Queries.
    8159        dialect: The dialect of the sources dict.
    8160        copy: Whether to copy the expression during transformation. Defaults to True.
    8161
    8162    Returns:
    8163        The transformed expression.
    8164    """
    8165    sources = {normalize_table_name(k, dialect=dialect): v for k, v in sources.items()}
    8166
    8167    def _expand(node: Expression):
    8168        if isinstance(node, Table):
    8169            name = normalize_table_name(node, dialect=dialect)
    8170            source = sources.get(name)
    8171            if source:
    8172                subquery = source.subquery(node.alias or name)
    8173                subquery.comments = [f"source: {name}"]
    8174                return subquery.transform(_expand, copy=False)
    8175        return node
    8176
    8177    return expression.transform(_expand, copy=copy)
    8178
    8179
    8180def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwargs) -> Func:
    8181    """
    8182    Returns a Func expression.
    8183
    8184    Examples:
    8185        >>> func("abs", 5).sql()
    8186        'ABS(5)'
    8187
    8188        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    8189        'CAST(5 AS DOUBLE)'
    8190
    8191    Args:
    8192        name: the name of the function to build.
    8193        args: the args used to instantiate the function of interest.
    8194        copy: whether to copy the argument expressions.
    8195        dialect: the source dialect.
    8196        kwargs: the kwargs used to instantiate the function of interest.
    8197
    8198    Note:
    8199        The arguments `args` and `kwargs` are mutually exclusive.
    8200
    8201    Returns:
    8202        An instance of the function of interest, or an anonymous function, if `name` doesn't
    8203        correspond to an existing `sqlglot.expressions.Func` class.
    8204    """
    8205    if args and kwargs:
    8206        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    8207
    8208    from sqlglot.dialects.dialect import Dialect
    8209
    8210    dialect = Dialect.get_or_raise(dialect)
    8211
    8212    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect, copy=copy) for arg in args]
    8213    kwargs = {key: maybe_parse(value, dialect=dialect, copy=copy) for key, value in kwargs.items()}
    8214
    8215    constructor = dialect.parser_class.FUNCTIONS.get(name.upper())
    8216    if constructor:
    8217        if converted:
    8218            if "dialect" in constructor.__code__.co_varnames:
    8219                function = constructor(converted, dialect=dialect)
    8220            else:
    8221                function = constructor(converted)
    8222        elif constructor.__name__ == "from_arg_list":
    8223            function = constructor.__self__(**kwargs)  # type: ignore
    8224        else:
    8225            constructor = FUNCTION_BY_NAME.get(name.upper())
    8226            if constructor:
    8227                function = constructor(**kwargs)
    8228            else:
    8229                raise ValueError(
    8230                    f"Unable to convert '{name}' into a Func. Either manually construct "
    8231                    "the Func expression of interest or parse the function call."
    8232                )
    8233    else:
    8234        kwargs = kwargs or {"expressions": converted}
    8235        function = Anonymous(this=name, **kwargs)
    8236
    8237    for error_message in function.error_messages(converted):
    8238        raise ValueError(error_message)
    8239
    8240    return function
    8241
    8242
    8243def case(
    8244    expression: t.Optional[ExpOrStr] = None,
    8245    **opts,
    8246) -> Case:
    8247    """
    8248    Initialize a CASE statement.
    8249
    8250    Example:
    8251        case().when("a = 1", "foo").else_("bar")
    8252
    8253    Args:
    8254        expression: Optionally, the input expression (not all dialects support this)
    8255        **opts: Extra keyword arguments for parsing `expression`
    8256    """
    8257    if expression is not None:
    8258        this = maybe_parse(expression, **opts)
    8259    else:
    8260        this = None
    8261    return Case(this=this, ifs=[])
    8262
    8263
    8264def array(
    8265    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8266) -> Array:
    8267    """
    8268    Returns an array.
    8269
    8270    Examples:
    8271        >>> array(1, 'x').sql()
    8272        'ARRAY(1, x)'
    8273
    8274    Args:
    8275        expressions: the expressions to add to the array.
    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        An array expression.
    8282    """
    8283    return Array(
    8284        expressions=[
    8285            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8286            for expression in expressions
    8287        ]
    8288    )
    8289
    8290
    8291def tuple_(
    8292    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8293) -> Tuple:
    8294    """
    8295    Returns an tuple.
    8296
    8297    Examples:
    8298        >>> tuple_(1, 'x').sql()
    8299        '(1, x)'
    8300
    8301    Args:
    8302        expressions: the expressions to add to the tuple.
    8303        copy: whether to copy the argument expressions.
    8304        dialect: the source dialect.
    8305        kwargs: the kwargs used to instantiate the function of interest.
    8306
    8307    Returns:
    8308        A tuple expression.
    8309    """
    8310    return Tuple(
    8311        expressions=[
    8312            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8313            for expression in expressions
    8314        ]
    8315    )
    8316
    8317
    8318def true() -> Boolean:
    8319    """
    8320    Returns a true Boolean expression.
    8321    """
    8322    return Boolean(this=True)
    8323
    8324
    8325def false() -> Boolean:
    8326    """
    8327    Returns a false Boolean expression.
    8328    """
    8329    return Boolean(this=False)
    8330
    8331
    8332def null() -> Null:
    8333    """
    8334    Returns a Null expression.
    8335    """
    8336    return Null()
    8337
    8338
    8339NONNULL_CONSTANTS = (
    8340    Literal,
    8341    Boolean,
    8342)
    8343
    8344CONSTANTS = (
    8345    Literal,
    8346    Boolean,
    8347    Null,
    8348)

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 WithProcedureOptions(Property): View Source

    3000class WithProcedureOptions(Property):
    3001    arg_types = {"expressions": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  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

    3004class Properties(Expression):
    3005    arg_types = {"expressions": True}
    3006
    3007    NAME_TO_PROPERTY = {
    3008        "ALGORITHM": AlgorithmProperty,
    3009        "AUTO_INCREMENT": AutoIncrementProperty,
    3010        "CHARACTER SET": CharacterSetProperty,
    3011        "CLUSTERED_BY": ClusteredByProperty,
    3012        "COLLATE": CollateProperty,
    3013        "COMMENT": SchemaCommentProperty,
    3014        "DEFINER": DefinerProperty,
    3015        "DISTKEY": DistKeyProperty,
    3016        "DISTRIBUTED_BY": DistributedByProperty,
    3017        "DISTSTYLE": DistStyleProperty,
    3018        "ENGINE": EngineProperty,
    3019        "EXECUTE AS": ExecuteAsProperty,
    3020        "FORMAT": FileFormatProperty,
    3021        "LANGUAGE": LanguageProperty,
    3022        "LOCATION": LocationProperty,
    3023        "LOCK": LockProperty,
    3024        "PARTITIONED_BY": PartitionedByProperty,
    3025        "RETURNS": ReturnsProperty,
    3026        "ROW_FORMAT": RowFormatProperty,
    3027        "SORTKEY": SortKeyProperty,
    3028    }
    3029
    3030    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    3031
    3032    # CREATE property locations
    3033    # Form: schema specified
    3034    #   create [POST_CREATE]
    3035    #     table a [POST_NAME]
    3036    #     (b int) [POST_SCHEMA]
    3037    #     with ([POST_WITH])
    3038    #     index (b) [POST_INDEX]
    3039    #
    3040    # Form: alias selection
    3041    #   create [POST_CREATE]
    3042    #     table a [POST_NAME]
    3043    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    3044    #     index (c) [POST_INDEX]
    3045    class Location(AutoName):
    3046        POST_CREATE = auto()
    3047        POST_NAME = auto()
    3048        POST_SCHEMA = auto()
    3049        POST_WITH = auto()
    3050        POST_ALIAS = auto()
    3051        POST_EXPRESSION = auto()
    3052        POST_INDEX = auto()
    3053        UNSUPPORTED = auto()
    3054
    3055    @classmethod
    3056    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3057        expressions = []
    3058        for key, value in properties_dict.items():
    3059            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3060            if property_cls:
    3061                expressions.append(property_cls(this=convert(value)))
    3062            else:
    3063                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3064
    3065        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

    3055    @classmethod
    3056    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3057        expressions = []
    3058        for key, value in properties_dict.items():
    3059            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3060            if property_cls:
    3061                expressions.append(property_cls(this=convert(value)))
    3062            else:
    3063                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3064
    3065        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

    3045    class Location(AutoName):
    3046        POST_CREATE = auto()
    3047        POST_NAME = auto()
    3048        POST_SCHEMA = auto()
    3049        POST_WITH = auto()
    3050        POST_ALIAS = auto()
    3051        POST_EXPRESSION = auto()
    3052        POST_INDEX = auto()
    3053        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

    3068class Qualify(Expression):
    3069    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

    3072class InputOutputFormat(Expression):
    3073    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

    3077class Return(Expression):
    3078    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

    3081class Reference(Expression):
    3082    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

    3085class Tuple(Expression):
    3086    arg_types = {"expressions": False}
    3087
    3088    def isin(
    3089        self,
    3090        *expressions: t.Any,
    3091        query: t.Optional[ExpOrStr] = None,
    3092        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3093        copy: bool = True,
    3094        **opts,
    3095    ) -> In:
    3096        return In(
    3097            this=maybe_copy(self, copy),
    3098            expressions=[convert(e, copy=copy) for e in expressions],
    3099            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3100            unnest=(
    3101                Unnest(
    3102                    expressions=[
    3103                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3104                        for e in ensure_list(unnest)
    3105                    ]
    3106                )
    3107                if unnest
    3108                else None
    3109            ),
    3110        )

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

    3088    def isin(
    3089        self,
    3090        *expressions: t.Any,
    3091        query: t.Optional[ExpOrStr] = None,
    3092        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3093        copy: bool = True,
    3094        **opts,
    3095    ) -> In:
    3096        return In(
    3097            this=maybe_copy(self, copy),
    3098            expressions=[convert(e, copy=copy) for e in expressions],
    3099            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3100            unnest=(
    3101                Unnest(
    3102                    expressions=[
    3103                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3104                        for e in ensure_list(unnest)
    3105                    ]
    3106                )
    3107                if unnest
    3108                else None
    3109            ),
    3110        )

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

    3141class QueryOption(Expression):
    3142    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

    3146class WithTableHint(Expression):
    3147    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

    3151class IndexTableHint(Expression):
    3152    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

    3156class HistoricalData(Expression):
    3157    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

    3160class Table(Expression):
    3161    arg_types = {
    3162        "this": False,
    3163        "alias": False,
    3164        "db": False,
    3165        "catalog": False,
    3166        "laterals": False,
    3167        "joins": False,
    3168        "pivots": False,
    3169        "hints": False,
    3170        "system_time": False,
    3171        "version": False,
    3172        "format": False,
    3173        "pattern": False,
    3174        "ordinality": False,
    3175        "when": False,
    3176        "only": False,
    3177        "partition": False,
    3178        "changes": False,
    3179        "rows_from": False,
    3180        "sample": False,
    3181    }
    3182
    3183    @property
    3184    def name(self) -> str:
    3185        if isinstance(self.this, Func):
    3186            return ""
    3187        return self.this.name
    3188
    3189    @property
    3190    def db(self) -> str:
    3191        return self.text("db")
    3192
    3193    @property
    3194    def catalog(self) -> str:
    3195        return self.text("catalog")
    3196
    3197    @property
    3198    def selects(self) -> t.List[Expression]:
    3199        return []
    3200
    3201    @property
    3202    def named_selects(self) -> t.List[str]:
    3203        return []
    3204
    3205    @property
    3206    def parts(self) -> t.List[Expression]:
    3207        """Return the parts of a table in order catalog, db, table."""
    3208        parts: t.List[Expression] = []
    3209
    3210        for arg in ("catalog", "db", "this"):
    3211            part = self.args.get(arg)
    3212
    3213            if isinstance(part, Dot):
    3214                parts.extend(part.flatten())
    3215            elif isinstance(part, Expression):
    3216                parts.append(part)
    3217
    3218        return parts
    3219
    3220    def to_column(self, copy: bool = True) -> Alias | Column | Dot:
    3221        parts = self.parts
    3222        last_part = parts[-1]
    3223
    3224        if isinstance(last_part, Identifier):
    3225            col = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3226        else:
    3227            # This branch will be reached if a function or array is wrapped in a `Table`
    3228            col = last_part
    3229
    3230        alias = self.args.get("alias")
    3231        if alias:
    3232            col = alias_(col, alias.this, copy=copy)
    3233
    3234        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

    3183    @property
    3184    def name(self) -> str:
    3185        if isinstance(self.this, Func):
    3186            return ""
    3187        return self.this.name

db: str View Source

    3189    @property
    3190    def db(self) -> str:
    3191        return self.text("db")

catalog: str View Source

    3193    @property
    3194    def catalog(self) -> str:
    3195        return self.text("catalog")

selects: List[Expression] View Source

    3197    @property
    3198    def selects(self) -> t.List[Expression]:
    3199        return []

named_selects: List[str] View Source

    3201    @property
    3202    def named_selects(self) -> t.List[str]:
    3203        return []

parts: List[Expression] View Source

    3205    @property
    3206    def parts(self) -> t.List[Expression]:
    3207        """Return the parts of a table in order catalog, db, table."""
    3208        parts: t.List[Expression] = []
    3209
    3210        for arg in ("catalog", "db", "this"):
    3211            part = self.args.get(arg)
    3212
    3213            if isinstance(part, Dot):
    3214                parts.extend(part.flatten())
    3215            elif isinstance(part, Expression):
    3216                parts.append(part)
    3217
    3218        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

    3220    def to_column(self, copy: bool = True) -> Alias | Column | Dot:
    3221        parts = self.parts
    3222        last_part = parts[-1]
    3223
    3224        if isinstance(last_part, Identifier):
    3225            col = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3226        else:
    3227            # This branch will be reached if a function or array is wrapped in a `Table`
    3228            col = last_part
    3229
    3230        alias = self.args.get("alias")
    3231        if alias:
    3232            col = alias_(col, alias.this, copy=copy)
    3233
    3234        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

    3237class SetOperation(Query):
    3238    arg_types = {
    3239        "with": False,
    3240        "this": True,
    3241        "expression": True,
    3242        "distinct": False,
    3243        "by_name": False,
    3244        **QUERY_MODIFIERS,
    3245    }
    3246
    3247    def select(
    3248        self: S,
    3249        *expressions: t.Optional[ExpOrStr],
    3250        append: bool = True,
    3251        dialect: DialectType = None,
    3252        copy: bool = True,
    3253        **opts,
    3254    ) -> S:
    3255        this = maybe_copy(self, copy)
    3256        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3257        this.expression.unnest().select(
    3258            *expressions, append=append, dialect=dialect, copy=False, **opts
    3259        )
    3260        return this
    3261
    3262    @property
    3263    def named_selects(self) -> t.List[str]:
    3264        return self.this.unnest().named_selects
    3265
    3266    @property
    3267    def is_star(self) -> bool:
    3268        return self.this.is_star or self.expression.is_star
    3269
    3270    @property
    3271    def selects(self) -> t.List[Expression]:
    3272        return self.this.unnest().selects
    3273
    3274    @property
    3275    def left(self) -> Query:
    3276        return self.this
    3277
    3278    @property
    3279    def right(self) -> Query:
    3280        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

    3247    def select(
    3248        self: S,
    3249        *expressions: t.Optional[ExpOrStr],
    3250        append: bool = True,
    3251        dialect: DialectType = None,
    3252        copy: bool = True,
    3253        **opts,
    3254    ) -> S:
    3255        this = maybe_copy(self, copy)
    3256        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3257        this.expression.unnest().select(
    3258            *expressions, append=append, dialect=dialect, copy=False, **opts
    3259        )
    3260        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

    3262    @property
    3263    def named_selects(self) -> t.List[str]:
    3264        return self.this.unnest().named_selects

Returns the output names of the query's projections.

is_star: bool View Source

    3266    @property
    3267    def is_star(self) -> bool:
    3268        return self.this.is_star or self.expression.is_star

Checks whether an expression is a star.

selects: List[Expression] View Source

    3270    @property
    3271    def selects(self) -> t.List[Expression]:
    3272        return self.this.unnest().selects

Returns the query's projections.

left: Query View Source

    3274    @property
    3275    def left(self) -> Query:
    3276        return self.this

right: Query View Source

    3278    @property
    3279    def right(self) -> Query:
    3280        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

    3283class Union(SetOperation):
    3284    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

    3287class Except(SetOperation):
    3288    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

    3291class Intersect(SetOperation):
    3292    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

    3295class Update(DML):
    3296    arg_types = {
    3297        "with": False,
    3298        "this": False,
    3299        "expressions": True,
    3300        "from": False,
    3301        "where": False,
    3302        "returning": False,
    3303        "order": False,
    3304        "limit": False,
    3305    }
    3306
    3307    def table(
    3308        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3309    ) -> Update:
    3310        """
    3311        Set the table to update.
    3312
    3313        Example:
    3314            >>> Update().table("my_table").set_("x = 1").sql()
    3315            'UPDATE my_table SET x = 1'
    3316
    3317        Args:
    3318            expression : the SQL code strings to parse.
    3319                If a `Table` instance is passed, this is used as-is.
    3320                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3321            dialect: the dialect used to parse the input expression.
    3322            copy: if `False`, modify this expression instance in-place.
    3323            opts: other options to use to parse the input expressions.
    3324
    3325        Returns:
    3326            The modified Update expression.
    3327        """
    3328        return _apply_builder(
    3329            expression=expression,
    3330            instance=self,
    3331            arg="this",
    3332            into=Table,
    3333            prefix=None,
    3334            dialect=dialect,
    3335            copy=copy,
    3336            **opts,
    3337        )
    3338
    3339    def set_(
    3340        self,
    3341        *expressions: ExpOrStr,
    3342        append: bool = True,
    3343        dialect: DialectType = None,
    3344        copy: bool = True,
    3345        **opts,
    3346    ) -> Update:
    3347        """
    3348        Append to or set the SET expressions.
    3349
    3350        Example:
    3351            >>> Update().table("my_table").set_("x = 1").sql()
    3352            'UPDATE my_table SET x = 1'
    3353
    3354        Args:
    3355            *expressions: the SQL code strings to parse.
    3356                If `Expression` instance(s) are passed, they will be used as-is.
    3357                Multiple expressions are combined with a comma.
    3358            append: if `True`, add the new expressions to any existing SET expressions.
    3359                Otherwise, this resets the expressions.
    3360            dialect: the dialect used to parse the input expressions.
    3361            copy: if `False`, modify this expression instance in-place.
    3362            opts: other options to use to parse the input expressions.
    3363        """
    3364        return _apply_list_builder(
    3365            *expressions,
    3366            instance=self,
    3367            arg="expressions",
    3368            append=append,
    3369            into=Expression,
    3370            prefix=None,
    3371            dialect=dialect,
    3372            copy=copy,
    3373            **opts,
    3374        )
    3375
    3376    def where(
    3377        self,
    3378        *expressions: t.Optional[ExpOrStr],
    3379        append: bool = True,
    3380        dialect: DialectType = None,
    3381        copy: bool = True,
    3382        **opts,
    3383    ) -> Select:
    3384        """
    3385        Append to or set the WHERE expressions.
    3386
    3387        Example:
    3388            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3389            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3390
    3391        Args:
    3392            *expressions: the SQL code strings to parse.
    3393                If an `Expression` instance is passed, it will be used as-is.
    3394                Multiple expressions are combined with an AND operator.
    3395            append: if `True`, AND the new expressions to any existing expression.
    3396                Otherwise, this resets the expression.
    3397            dialect: the dialect used to parse the input expressions.
    3398            copy: if `False`, modify this expression instance in-place.
    3399            opts: other options to use to parse the input expressions.
    3400
    3401        Returns:
    3402            Select: the modified expression.
    3403        """
    3404        return _apply_conjunction_builder(
    3405            *expressions,
    3406            instance=self,
    3407            arg="where",
    3408            append=append,
    3409            into=Where,
    3410            dialect=dialect,
    3411            copy=copy,
    3412            **opts,
    3413        )
    3414
    3415    def from_(
    3416        self,
    3417        expression: t.Optional[ExpOrStr] = None,
    3418        dialect: DialectType = None,
    3419        copy: bool = True,
    3420        **opts,
    3421    ) -> Update:
    3422        """
    3423        Set the FROM expression.
    3424
    3425        Example:
    3426            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3427            'UPDATE my_table SET x = 1 FROM baz'
    3428
    3429        Args:
    3430            expression : the SQL code strings to parse.
    3431                If a `From` instance is passed, this is used as-is.
    3432                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3433                If nothing is passed in then a from is not applied to the expression
    3434            dialect: the dialect used to parse the input expression.
    3435            copy: if `False`, modify this expression instance in-place.
    3436            opts: other options to use to parse the input expressions.
    3437
    3438        Returns:
    3439            The modified Update expression.
    3440        """
    3441        if not expression:
    3442            return maybe_copy(self, copy)
    3443
    3444        return _apply_builder(
    3445            expression=expression,
    3446            instance=self,
    3447            arg="from",
    3448            into=From,
    3449            prefix="FROM",
    3450            dialect=dialect,
    3451            copy=copy,
    3452            **opts,
    3453        )
    3454
    3455    def with_(
    3456        self,
    3457        alias: ExpOrStr,
    3458        as_: ExpOrStr,
    3459        recursive: t.Optional[bool] = None,
    3460        materialized: t.Optional[bool] = None,
    3461        append: bool = True,
    3462        dialect: DialectType = None,
    3463        copy: bool = True,
    3464        **opts,
    3465    ) -> Update:
    3466        """
    3467        Append to or set the common table expressions.
    3468
    3469        Example:
    3470            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3471            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3472
    3473        Args:
    3474            alias: the SQL code string to parse as the table name.
    3475                If an `Expression` instance is passed, this is used as-is.
    3476            as_: the SQL code string to parse as the table expression.
    3477                If an `Expression` instance is passed, it will be used as-is.
    3478            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3479            materialized: set the MATERIALIZED part of the expression.
    3480            append: if `True`, add to any existing expressions.
    3481                Otherwise, this resets the expressions.
    3482            dialect: the dialect used to parse the input expression.
    3483            copy: if `False`, modify this expression instance in-place.
    3484            opts: other options to use to parse the input expressions.
    3485
    3486        Returns:
    3487            The modified expression.
    3488        """
    3489        return _apply_cte_builder(
    3490            self,
    3491            alias,
    3492            as_,
    3493            recursive=recursive,
    3494            materialized=materialized,
    3495            append=append,
    3496            dialect=dialect,
    3497            copy=copy,
    3498            **opts,
    3499        )

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

    3307    def table(
    3308        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3309    ) -> Update:
    3310        """
    3311        Set the table to update.
    3312
    3313        Example:
    3314            >>> Update().table("my_table").set_("x = 1").sql()
    3315            'UPDATE my_table SET x = 1'
    3316
    3317        Args:
    3318            expression : the SQL code strings to parse.
    3319                If a `Table` instance is passed, this is used as-is.
    3320                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3321            dialect: the dialect used to parse the input expression.
    3322            copy: if `False`, modify this expression instance in-place.
    3323            opts: other options to use to parse the input expressions.
    3324
    3325        Returns:
    3326            The modified Update expression.
    3327        """
    3328        return _apply_builder(
    3329            expression=expression,
    3330            instance=self,
    3331            arg="this",
    3332            into=Table,
    3333            prefix=None,
    3334            dialect=dialect,
    3335            copy=copy,
    3336            **opts,
    3337        )

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

    3339    def set_(
    3340        self,
    3341        *expressions: ExpOrStr,
    3342        append: bool = True,
    3343        dialect: DialectType = None,
    3344        copy: bool = True,
    3345        **opts,
    3346    ) -> Update:
    3347        """
    3348        Append to or set the SET expressions.
    3349
    3350        Example:
    3351            >>> Update().table("my_table").set_("x = 1").sql()
    3352            'UPDATE my_table SET x = 1'
    3353
    3354        Args:
    3355            *expressions: the SQL code strings to parse.
    3356                If `Expression` instance(s) are passed, they will be used as-is.
    3357                Multiple expressions are combined with a comma.
    3358            append: if `True`, add the new expressions to any existing SET expressions.
    3359                Otherwise, this resets the expressions.
    3360            dialect: the dialect used to parse the input expressions.
    3361            copy: if `False`, modify this expression instance in-place.
    3362            opts: other options to use to parse the input expressions.
    3363        """
    3364        return _apply_list_builder(
    3365            *expressions,
    3366            instance=self,
    3367            arg="expressions",
    3368            append=append,
    3369            into=Expression,
    3370            prefix=None,
    3371            dialect=dialect,
    3372            copy=copy,
    3373            **opts,
    3374        )

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

    3376    def where(
    3377        self,
    3378        *expressions: t.Optional[ExpOrStr],
    3379        append: bool = True,
    3380        dialect: DialectType = None,
    3381        copy: bool = True,
    3382        **opts,
    3383    ) -> Select:
    3384        """
    3385        Append to or set the WHERE expressions.
    3386
    3387        Example:
    3388            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3389            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3390
    3391        Args:
    3392            *expressions: the SQL code strings to parse.
    3393                If an `Expression` instance is passed, it will be used as-is.
    3394                Multiple expressions are combined with an AND operator.
    3395            append: if `True`, AND the new expressions to any existing expression.
    3396                Otherwise, this resets the expression.
    3397            dialect: the dialect used to parse the input expressions.
    3398            copy: if `False`, modify this expression instance in-place.
    3399            opts: other options to use to parse the input expressions.
    3400
    3401        Returns:
    3402            Select: the modified expression.
    3403        """
    3404        return _apply_conjunction_builder(
    3405            *expressions,
    3406            instance=self,
    3407            arg="where",
    3408            append=append,
    3409            into=Where,
    3410            dialect=dialect,
    3411            copy=copy,
    3412            **opts,
    3413        )

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

    3415    def from_(
    3416        self,
    3417        expression: t.Optional[ExpOrStr] = None,
    3418        dialect: DialectType = None,
    3419        copy: bool = True,
    3420        **opts,
    3421    ) -> Update:
    3422        """
    3423        Set the FROM expression.
    3424
    3425        Example:
    3426            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3427            'UPDATE my_table SET x = 1 FROM baz'
    3428
    3429        Args:
    3430            expression : the SQL code strings to parse.
    3431                If a `From` instance is passed, this is used as-is.
    3432                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3433                If nothing is passed in then a from is not applied to the expression
    3434            dialect: the dialect used to parse the input expression.
    3435            copy: if `False`, modify this expression instance in-place.
    3436            opts: other options to use to parse the input expressions.
    3437
    3438        Returns:
    3439            The modified Update expression.
    3440        """
    3441        if not expression:
    3442            return maybe_copy(self, copy)
    3443
    3444        return _apply_builder(
    3445            expression=expression,
    3446            instance=self,
    3447            arg="from",
    3448            into=From,
    3449            prefix="FROM",
    3450            dialect=dialect,
    3451            copy=copy,
    3452            **opts,
    3453        )

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

    3455    def with_(
    3456        self,
    3457        alias: ExpOrStr,
    3458        as_: ExpOrStr,
    3459        recursive: t.Optional[bool] = None,
    3460        materialized: t.Optional[bool] = None,
    3461        append: bool = True,
    3462        dialect: DialectType = None,
    3463        copy: bool = True,
    3464        **opts,
    3465    ) -> Update:
    3466        """
    3467        Append to or set the common table expressions.
    3468
    3469        Example:
    3470            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3471            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3472
    3473        Args:
    3474            alias: the SQL code string to parse as the table name.
    3475                If an `Expression` instance is passed, this is used as-is.
    3476            as_: the SQL code string to parse as the table expression.
    3477                If an `Expression` instance is passed, it will be used as-is.
    3478            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3479            materialized: set the MATERIALIZED part of the expression.
    3480            append: if `True`, add to any existing expressions.
    3481                Otherwise, this resets the expressions.
    3482            dialect: the dialect used to parse the input expression.
    3483            copy: if `False`, modify this expression instance in-place.
    3484            opts: other options to use to parse the input expressions.
    3485
    3486        Returns:
    3487            The modified expression.
    3488        """
    3489        return _apply_cte_builder(
    3490            self,
    3491            alias,
    3492            as_,
    3493            recursive=recursive,
    3494            materialized=materialized,
    3495            append=append,
    3496            dialect=dialect,
    3497            copy=copy,
    3498            **opts,
    3499        )

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

    3502class Values(UDTF):
    3503    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

    3506class Var(Expression):
    3507    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

    3510class Version(Expression):
    3511    """
    3512    Time travel, iceberg, bigquery etc
    3513    https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots
    3514    https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html
    3515    https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of
    3516    https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16
    3517    this is either TIMESTAMP or VERSION
    3518    kind is ("AS OF", "BETWEEN")
    3519    """
    3520
    3521    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

    3524class Schema(Expression):
    3525    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

    3530class Lock(Expression):
    3531    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

    3534class Select(Query):
    3535    arg_types = {
    3536        "with": False,
    3537        "kind": False,
    3538        "expressions": False,
    3539        "hint": False,
    3540        "distinct": False,
    3541        "into": False,
    3542        "from": False,
    3543        "operation_modifiers": False,
    3544        **QUERY_MODIFIERS,
    3545    }
    3546
    3547    def from_(
    3548        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3549    ) -> Select:
    3550        """
    3551        Set the FROM expression.
    3552
    3553        Example:
    3554            >>> Select().from_("tbl").select("x").sql()
    3555            'SELECT x FROM tbl'
    3556
    3557        Args:
    3558            expression : the SQL code strings to parse.
    3559                If a `From` instance is passed, this is used as-is.
    3560                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3561            dialect: the dialect used to parse the input expression.
    3562            copy: if `False`, modify this expression instance in-place.
    3563            opts: other options to use to parse the input expressions.
    3564
    3565        Returns:
    3566            The modified Select expression.
    3567        """
    3568        return _apply_builder(
    3569            expression=expression,
    3570            instance=self,
    3571            arg="from",
    3572            into=From,
    3573            prefix="FROM",
    3574            dialect=dialect,
    3575            copy=copy,
    3576            **opts,
    3577        )
    3578
    3579    def group_by(
    3580        self,
    3581        *expressions: t.Optional[ExpOrStr],
    3582        append: bool = True,
    3583        dialect: DialectType = None,
    3584        copy: bool = True,
    3585        **opts,
    3586    ) -> Select:
    3587        """
    3588        Set the GROUP BY expression.
    3589
    3590        Example:
    3591            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3592            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3593
    3594        Args:
    3595            *expressions: the SQL code strings to parse.
    3596                If a `Group` instance is passed, this is used as-is.
    3597                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3598                If nothing is passed in then a group by is not applied to the expression
    3599            append: if `True`, add to any existing expressions.
    3600                Otherwise, this flattens all the `Group` expression into a single expression.
    3601            dialect: the dialect used to parse the input expression.
    3602            copy: if `False`, modify this expression instance in-place.
    3603            opts: other options to use to parse the input expressions.
    3604
    3605        Returns:
    3606            The modified Select expression.
    3607        """
    3608        if not expressions:
    3609            return self if not copy else self.copy()
    3610
    3611        return _apply_child_list_builder(
    3612            *expressions,
    3613            instance=self,
    3614            arg="group",
    3615            append=append,
    3616            copy=copy,
    3617            prefix="GROUP BY",
    3618            into=Group,
    3619            dialect=dialect,
    3620            **opts,
    3621        )
    3622
    3623    def sort_by(
    3624        self,
    3625        *expressions: t.Optional[ExpOrStr],
    3626        append: bool = True,
    3627        dialect: DialectType = None,
    3628        copy: bool = True,
    3629        **opts,
    3630    ) -> Select:
    3631        """
    3632        Set the SORT BY expression.
    3633
    3634        Example:
    3635            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3636            'SELECT x FROM tbl SORT BY x DESC'
    3637
    3638        Args:
    3639            *expressions: the SQL code strings to parse.
    3640                If a `Group` instance is passed, this is used as-is.
    3641                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3642            append: if `True`, add to any existing expressions.
    3643                Otherwise, this flattens all the `Order` expression into a single expression.
    3644            dialect: the dialect used to parse the input expression.
    3645            copy: if `False`, modify this expression instance in-place.
    3646            opts: other options to use to parse the input expressions.
    3647
    3648        Returns:
    3649            The modified Select expression.
    3650        """
    3651        return _apply_child_list_builder(
    3652            *expressions,
    3653            instance=self,
    3654            arg="sort",
    3655            append=append,
    3656            copy=copy,
    3657            prefix="SORT BY",
    3658            into=Sort,
    3659            dialect=dialect,
    3660            **opts,
    3661        )
    3662
    3663    def cluster_by(
    3664        self,
    3665        *expressions: t.Optional[ExpOrStr],
    3666        append: bool = True,
    3667        dialect: DialectType = None,
    3668        copy: bool = True,
    3669        **opts,
    3670    ) -> Select:
    3671        """
    3672        Set the CLUSTER BY expression.
    3673
    3674        Example:
    3675            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3676            'SELECT x FROM tbl CLUSTER BY x DESC'
    3677
    3678        Args:
    3679            *expressions: the SQL code strings to parse.
    3680                If a `Group` instance is passed, this is used as-is.
    3681                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3682            append: if `True`, add to any existing expressions.
    3683                Otherwise, this flattens all the `Order` expression into a single expression.
    3684            dialect: the dialect used to parse the input expression.
    3685            copy: if `False`, modify this expression instance in-place.
    3686            opts: other options to use to parse the input expressions.
    3687
    3688        Returns:
    3689            The modified Select expression.
    3690        """
    3691        return _apply_child_list_builder(
    3692            *expressions,
    3693            instance=self,
    3694            arg="cluster",
    3695            append=append,
    3696            copy=copy,
    3697            prefix="CLUSTER BY",
    3698            into=Cluster,
    3699            dialect=dialect,
    3700            **opts,
    3701        )
    3702
    3703    def select(
    3704        self,
    3705        *expressions: t.Optional[ExpOrStr],
    3706        append: bool = True,
    3707        dialect: DialectType = None,
    3708        copy: bool = True,
    3709        **opts,
    3710    ) -> Select:
    3711        return _apply_list_builder(
    3712            *expressions,
    3713            instance=self,
    3714            arg="expressions",
    3715            append=append,
    3716            dialect=dialect,
    3717            into=Expression,
    3718            copy=copy,
    3719            **opts,
    3720        )
    3721
    3722    def lateral(
    3723        self,
    3724        *expressions: t.Optional[ExpOrStr],
    3725        append: bool = True,
    3726        dialect: DialectType = None,
    3727        copy: bool = True,
    3728        **opts,
    3729    ) -> Select:
    3730        """
    3731        Append to or set the LATERAL expressions.
    3732
    3733        Example:
    3734            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3735            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3736
    3737        Args:
    3738            *expressions: the SQL code strings to parse.
    3739                If an `Expression` instance is passed, it will be used as-is.
    3740            append: if `True`, add to any existing expressions.
    3741                Otherwise, this resets the expressions.
    3742            dialect: the dialect used to parse the input expressions.
    3743            copy: if `False`, modify this expression instance in-place.
    3744            opts: other options to use to parse the input expressions.
    3745
    3746        Returns:
    3747            The modified Select expression.
    3748        """
    3749        return _apply_list_builder(
    3750            *expressions,
    3751            instance=self,
    3752            arg="laterals",
    3753            append=append,
    3754            into=Lateral,
    3755            prefix="LATERAL VIEW",
    3756            dialect=dialect,
    3757            copy=copy,
    3758            **opts,
    3759        )
    3760
    3761    def join(
    3762        self,
    3763        expression: ExpOrStr,
    3764        on: t.Optional[ExpOrStr] = None,
    3765        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3766        append: bool = True,
    3767        join_type: t.Optional[str] = None,
    3768        join_alias: t.Optional[Identifier | str] = None,
    3769        dialect: DialectType = None,
    3770        copy: bool = True,
    3771        **opts,
    3772    ) -> Select:
    3773        """
    3774        Append to or set the JOIN expressions.
    3775
    3776        Example:
    3777            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3778            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3779
    3780            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3781            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3782
    3783            Use `join_type` to change the type of join:
    3784
    3785            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3786            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3787
    3788        Args:
    3789            expression: the SQL code string to parse.
    3790                If an `Expression` instance is passed, it will be used as-is.
    3791            on: optionally specify the join "on" criteria as a SQL string.
    3792                If an `Expression` instance is passed, it will be used as-is.
    3793            using: optionally specify the join "using" criteria as a SQL string.
    3794                If an `Expression` instance is passed, it will be used as-is.
    3795            append: if `True`, add to any existing expressions.
    3796                Otherwise, this resets the expressions.
    3797            join_type: if set, alter the parsed join type.
    3798            join_alias: an optional alias for the joined source.
    3799            dialect: the dialect used to parse the input expressions.
    3800            copy: if `False`, modify this expression instance in-place.
    3801            opts: other options to use to parse the input expressions.
    3802
    3803        Returns:
    3804            Select: the modified expression.
    3805        """
    3806        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3807
    3808        try:
    3809            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3810        except ParseError:
    3811            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3812
    3813        join = expression if isinstance(expression, Join) else Join(this=expression)
    3814
    3815        if isinstance(join.this, Select):
    3816            join.this.replace(join.this.subquery())
    3817
    3818        if join_type:
    3819            method: t.Optional[Token]
    3820            side: t.Optional[Token]
    3821            kind: t.Optional[Token]
    3822
    3823            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3824
    3825            if method:
    3826                join.set("method", method.text)
    3827            if side:
    3828                join.set("side", side.text)
    3829            if kind:
    3830                join.set("kind", kind.text)
    3831
    3832        if on:
    3833            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3834            join.set("on", on)
    3835
    3836        if using:
    3837            join = _apply_list_builder(
    3838                *ensure_list(using),
    3839                instance=join,
    3840                arg="using",
    3841                append=append,
    3842                copy=copy,
    3843                into=Identifier,
    3844                **opts,
    3845            )
    3846
    3847        if join_alias:
    3848            join.set("this", alias_(join.this, join_alias, table=True))
    3849
    3850        return _apply_list_builder(
    3851            join,
    3852            instance=self,
    3853            arg="joins",
    3854            append=append,
    3855            copy=copy,
    3856            **opts,
    3857        )
    3858
    3859    def where(
    3860        self,
    3861        *expressions: t.Optional[ExpOrStr],
    3862        append: bool = True,
    3863        dialect: DialectType = None,
    3864        copy: bool = True,
    3865        **opts,
    3866    ) -> Select:
    3867        """
    3868        Append to or set the WHERE expressions.
    3869
    3870        Example:
    3871            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3872            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3873
    3874        Args:
    3875            *expressions: the SQL code strings to parse.
    3876                If an `Expression` instance is passed, it will be used as-is.
    3877                Multiple expressions are combined with an AND operator.
    3878            append: if `True`, AND the new expressions to any existing expression.
    3879                Otherwise, this resets the expression.
    3880            dialect: the dialect used to parse the input expressions.
    3881            copy: if `False`, modify this expression instance in-place.
    3882            opts: other options to use to parse the input expressions.
    3883
    3884        Returns:
    3885            Select: the modified expression.
    3886        """
    3887        return _apply_conjunction_builder(
    3888            *expressions,
    3889            instance=self,
    3890            arg="where",
    3891            append=append,
    3892            into=Where,
    3893            dialect=dialect,
    3894            copy=copy,
    3895            **opts,
    3896        )
    3897
    3898    def having(
    3899        self,
    3900        *expressions: t.Optional[ExpOrStr],
    3901        append: bool = True,
    3902        dialect: DialectType = None,
    3903        copy: bool = True,
    3904        **opts,
    3905    ) -> Select:
    3906        """
    3907        Append to or set the HAVING expressions.
    3908
    3909        Example:
    3910            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3911            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3912
    3913        Args:
    3914            *expressions: the SQL code strings to parse.
    3915                If an `Expression` instance is passed, it will be used as-is.
    3916                Multiple expressions are combined with an AND operator.
    3917            append: if `True`, AND the new expressions to any existing expression.
    3918                Otherwise, this resets the expression.
    3919            dialect: the dialect used to parse the input expressions.
    3920            copy: if `False`, modify this expression instance in-place.
    3921            opts: other options to use to parse the input expressions.
    3922
    3923        Returns:
    3924            The modified Select expression.
    3925        """
    3926        return _apply_conjunction_builder(
    3927            *expressions,
    3928            instance=self,
    3929            arg="having",
    3930            append=append,
    3931            into=Having,
    3932            dialect=dialect,
    3933            copy=copy,
    3934            **opts,
    3935        )
    3936
    3937    def window(
    3938        self,
    3939        *expressions: t.Optional[ExpOrStr],
    3940        append: bool = True,
    3941        dialect: DialectType = None,
    3942        copy: bool = True,
    3943        **opts,
    3944    ) -> Select:
    3945        return _apply_list_builder(
    3946            *expressions,
    3947            instance=self,
    3948            arg="windows",
    3949            append=append,
    3950            into=Window,
    3951            dialect=dialect,
    3952            copy=copy,
    3953            **opts,
    3954        )
    3955
    3956    def qualify(
    3957        self,
    3958        *expressions: t.Optional[ExpOrStr],
    3959        append: bool = True,
    3960        dialect: DialectType = None,
    3961        copy: bool = True,
    3962        **opts,
    3963    ) -> Select:
    3964        return _apply_conjunction_builder(
    3965            *expressions,
    3966            instance=self,
    3967            arg="qualify",
    3968            append=append,
    3969            into=Qualify,
    3970            dialect=dialect,
    3971            copy=copy,
    3972            **opts,
    3973        )
    3974
    3975    def distinct(
    3976        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3977    ) -> Select:
    3978        """
    3979        Set the OFFSET expression.
    3980
    3981        Example:
    3982            >>> Select().from_("tbl").select("x").distinct().sql()
    3983            'SELECT DISTINCT x FROM tbl'
    3984
    3985        Args:
    3986            ons: the expressions to distinct on
    3987            distinct: whether the Select should be distinct
    3988            copy: if `False`, modify this expression instance in-place.
    3989
    3990        Returns:
    3991            Select: the modified expression.
    3992        """
    3993        instance = maybe_copy(self, copy)
    3994        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3995        instance.set("distinct", Distinct(on=on) if distinct else None)
    3996        return instance
    3997
    3998    def ctas(
    3999        self,
    4000        table: ExpOrStr,
    4001        properties: t.Optional[t.Dict] = None,
    4002        dialect: DialectType = None,
    4003        copy: bool = True,
    4004        **opts,
    4005    ) -> Create:
    4006        """
    4007        Convert this expression to a CREATE TABLE AS statement.
    4008
    4009        Example:
    4010            >>> Select().select("*").from_("tbl").ctas("x").sql()
    4011            'CREATE TABLE x AS SELECT * FROM tbl'
    4012
    4013        Args:
    4014            table: the SQL code string to parse as the table name.
    4015                If another `Expression` instance is passed, it will be used as-is.
    4016            properties: an optional mapping of table properties
    4017            dialect: the dialect used to parse the input table.
    4018            copy: if `False`, modify this expression instance in-place.
    4019            opts: other options to use to parse the input table.
    4020
    4021        Returns:
    4022            The new Create expression.
    4023        """
    4024        instance = maybe_copy(self, copy)
    4025        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4026
    4027        properties_expression = None
    4028        if properties:
    4029            properties_expression = Properties.from_dict(properties)
    4030
    4031        return Create(
    4032            this=table_expression,
    4033            kind="TABLE",
    4034            expression=instance,
    4035            properties=properties_expression,
    4036        )
    4037
    4038    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4039        """
    4040        Set the locking read mode for this expression.
    4041
    4042        Examples:
    4043            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4044            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4045
    4046            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4047            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4048
    4049        Args:
    4050            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4051            copy: if `False`, modify this expression instance in-place.
    4052
    4053        Returns:
    4054            The modified expression.
    4055        """
    4056        inst = maybe_copy(self, copy)
    4057        inst.set("locks", [Lock(update=update)])
    4058
    4059        return inst
    4060
    4061    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4062        """
    4063        Set hints for this expression.
    4064
    4065        Examples:
    4066            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4067            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4068
    4069        Args:
    4070            hints: The SQL code strings to parse as the hints.
    4071                If an `Expression` instance is passed, it will be used as-is.
    4072            dialect: The dialect used to parse the hints.
    4073            copy: If `False`, modify this expression instance in-place.
    4074
    4075        Returns:
    4076            The modified expression.
    4077        """
    4078        inst = maybe_copy(self, copy)
    4079        inst.set(
    4080            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4081        )
    4082
    4083        return inst
    4084
    4085    @property
    4086    def named_selects(self) -> t.List[str]:
    4087        return [e.output_name for e in self.expressions if e.alias_or_name]
    4088
    4089    @property
    4090    def is_star(self) -> bool:
    4091        return any(expression.is_star for expression in self.expressions)
    4092
    4093    @property
    4094    def selects(self) -> t.List[Expression]:
    4095        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

    3547    def from_(
    3548        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3549    ) -> Select:
    3550        """
    3551        Set the FROM expression.
    3552
    3553        Example:
    3554            >>> Select().from_("tbl").select("x").sql()
    3555            'SELECT x FROM tbl'
    3556
    3557        Args:
    3558            expression : the SQL code strings to parse.
    3559                If a `From` instance is passed, this is used as-is.
    3560                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3561            dialect: the dialect used to parse the input expression.
    3562            copy: if `False`, modify this expression instance in-place.
    3563            opts: other options to use to parse the input expressions.
    3564
    3565        Returns:
    3566            The modified Select expression.
    3567        """
    3568        return _apply_builder(
    3569            expression=expression,
    3570            instance=self,
    3571            arg="from",
    3572            into=From,
    3573            prefix="FROM",
    3574            dialect=dialect,
    3575            copy=copy,
    3576            **opts,
    3577        )

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

    3579    def group_by(
    3580        self,
    3581        *expressions: t.Optional[ExpOrStr],
    3582        append: bool = True,
    3583        dialect: DialectType = None,
    3584        copy: bool = True,
    3585        **opts,
    3586    ) -> Select:
    3587        """
    3588        Set the GROUP BY expression.
    3589
    3590        Example:
    3591            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3592            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3593
    3594        Args:
    3595            *expressions: the SQL code strings to parse.
    3596                If a `Group` instance is passed, this is used as-is.
    3597                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3598                If nothing is passed in then a group by is not applied to the expression
    3599            append: if `True`, add to any existing expressions.
    3600                Otherwise, this flattens all the `Group` expression into a single expression.
    3601            dialect: the dialect used to parse the input expression.
    3602            copy: if `False`, modify this expression instance in-place.
    3603            opts: other options to use to parse the input expressions.
    3604
    3605        Returns:
    3606            The modified Select expression.
    3607        """
    3608        if not expressions:
    3609            return self if not copy else self.copy()
    3610
    3611        return _apply_child_list_builder(
    3612            *expressions,
    3613            instance=self,
    3614            arg="group",
    3615            append=append,
    3616            copy=copy,
    3617            prefix="GROUP BY",
    3618            into=Group,
    3619            dialect=dialect,
    3620            **opts,
    3621        )

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

    3623    def sort_by(
    3624        self,
    3625        *expressions: t.Optional[ExpOrStr],
    3626        append: bool = True,
    3627        dialect: DialectType = None,
    3628        copy: bool = True,
    3629        **opts,
    3630    ) -> Select:
    3631        """
    3632        Set the SORT BY expression.
    3633
    3634        Example:
    3635            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3636            'SELECT x FROM tbl SORT BY x DESC'
    3637
    3638        Args:
    3639            *expressions: the SQL code strings to parse.
    3640                If a `Group` instance is passed, this is used as-is.
    3641                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3642            append: if `True`, add to any existing expressions.
    3643                Otherwise, this flattens all the `Order` expression into a single expression.
    3644            dialect: the dialect used to parse the input expression.
    3645            copy: if `False`, modify this expression instance in-place.
    3646            opts: other options to use to parse the input expressions.
    3647
    3648        Returns:
    3649            The modified Select expression.
    3650        """
    3651        return _apply_child_list_builder(
    3652            *expressions,
    3653            instance=self,
    3654            arg="sort",
    3655            append=append,
    3656            copy=copy,
    3657            prefix="SORT BY",
    3658            into=Sort,
    3659            dialect=dialect,
    3660            **opts,
    3661        )

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

    3663    def cluster_by(
    3664        self,
    3665        *expressions: t.Optional[ExpOrStr],
    3666        append: bool = True,
    3667        dialect: DialectType = None,
    3668        copy: bool = True,
    3669        **opts,
    3670    ) -> Select:
    3671        """
    3672        Set the CLUSTER BY expression.
    3673
    3674        Example:
    3675            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3676            'SELECT x FROM tbl CLUSTER BY x DESC'
    3677
    3678        Args:
    3679            *expressions: the SQL code strings to parse.
    3680                If a `Group` instance is passed, this is used as-is.
    3681                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3682            append: if `True`, add to any existing expressions.
    3683                Otherwise, this flattens all the `Order` expression into a single expression.
    3684            dialect: the dialect used to parse the input expression.
    3685            copy: if `False`, modify this expression instance in-place.
    3686            opts: other options to use to parse the input expressions.
    3687
    3688        Returns:
    3689            The modified Select expression.
    3690        """
    3691        return _apply_child_list_builder(
    3692            *expressions,
    3693            instance=self,
    3694            arg="cluster",
    3695            append=append,
    3696            copy=copy,
    3697            prefix="CLUSTER BY",
    3698            into=Cluster,
    3699            dialect=dialect,
    3700            **opts,
    3701        )

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

    3703    def select(
    3704        self,
    3705        *expressions: t.Optional[ExpOrStr],
    3706        append: bool = True,
    3707        dialect: DialectType = None,
    3708        copy: bool = True,
    3709        **opts,
    3710    ) -> Select:
    3711        return _apply_list_builder(
    3712            *expressions,
    3713            instance=self,
    3714            arg="expressions",
    3715            append=append,
    3716            dialect=dialect,
    3717            into=Expression,
    3718            copy=copy,
    3719            **opts,
    3720        )

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

    3722    def lateral(
    3723        self,
    3724        *expressions: t.Optional[ExpOrStr],
    3725        append: bool = True,
    3726        dialect: DialectType = None,
    3727        copy: bool = True,
    3728        **opts,
    3729    ) -> Select:
    3730        """
    3731        Append to or set the LATERAL expressions.
    3732
    3733        Example:
    3734            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3735            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3736
    3737        Args:
    3738            *expressions: the SQL code strings to parse.
    3739                If an `Expression` instance is passed, it will be used as-is.
    3740            append: if `True`, add to any existing expressions.
    3741                Otherwise, this resets the expressions.
    3742            dialect: the dialect used to parse the input expressions.
    3743            copy: if `False`, modify this expression instance in-place.
    3744            opts: other options to use to parse the input expressions.
    3745
    3746        Returns:
    3747            The modified Select expression.
    3748        """
    3749        return _apply_list_builder(
    3750            *expressions,
    3751            instance=self,
    3752            arg="laterals",
    3753            append=append,
    3754            into=Lateral,
    3755            prefix="LATERAL VIEW",
    3756            dialect=dialect,
    3757            copy=copy,
    3758            **opts,
    3759        )

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

    3761    def join(
    3762        self,
    3763        expression: ExpOrStr,
    3764        on: t.Optional[ExpOrStr] = None,
    3765        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3766        append: bool = True,
    3767        join_type: t.Optional[str] = None,
    3768        join_alias: t.Optional[Identifier | str] = None,
    3769        dialect: DialectType = None,
    3770        copy: bool = True,
    3771        **opts,
    3772    ) -> Select:
    3773        """
    3774        Append to or set the JOIN expressions.
    3775
    3776        Example:
    3777            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3778            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3779
    3780            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3781            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3782
    3783            Use `join_type` to change the type of join:
    3784
    3785            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3786            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3787
    3788        Args:
    3789            expression: the SQL code string to parse.
    3790                If an `Expression` instance is passed, it will be used as-is.
    3791            on: optionally specify the join "on" criteria as a SQL string.
    3792                If an `Expression` instance is passed, it will be used as-is.
    3793            using: optionally specify the join "using" criteria as a SQL string.
    3794                If an `Expression` instance is passed, it will be used as-is.
    3795            append: if `True`, add to any existing expressions.
    3796                Otherwise, this resets the expressions.
    3797            join_type: if set, alter the parsed join type.
    3798            join_alias: an optional alias for the joined source.
    3799            dialect: the dialect used to parse the input expressions.
    3800            copy: if `False`, modify this expression instance in-place.
    3801            opts: other options to use to parse the input expressions.
    3802
    3803        Returns:
    3804            Select: the modified expression.
    3805        """
    3806        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3807
    3808        try:
    3809            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3810        except ParseError:
    3811            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3812
    3813        join = expression if isinstance(expression, Join) else Join(this=expression)
    3814
    3815        if isinstance(join.this, Select):
    3816            join.this.replace(join.this.subquery())
    3817
    3818        if join_type:
    3819            method: t.Optional[Token]
    3820            side: t.Optional[Token]
    3821            kind: t.Optional[Token]
    3822
    3823            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3824
    3825            if method:
    3826                join.set("method", method.text)
    3827            if side:
    3828                join.set("side", side.text)
    3829            if kind:
    3830                join.set("kind", kind.text)
    3831
    3832        if on:
    3833            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3834            join.set("on", on)
    3835
    3836        if using:
    3837            join = _apply_list_builder(
    3838                *ensure_list(using),
    3839                instance=join,
    3840                arg="using",
    3841                append=append,
    3842                copy=copy,
    3843                into=Identifier,
    3844                **opts,
    3845            )
    3846
    3847        if join_alias:
    3848            join.set("this", alias_(join.this, join_alias, table=True))
    3849
    3850        return _apply_list_builder(
    3851            join,
    3852            instance=self,
    3853            arg="joins",
    3854            append=append,
    3855            copy=copy,
    3856            **opts,
    3857        )

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

    3859    def where(
    3860        self,
    3861        *expressions: t.Optional[ExpOrStr],
    3862        append: bool = True,
    3863        dialect: DialectType = None,
    3864        copy: bool = True,
    3865        **opts,
    3866    ) -> Select:
    3867        """
    3868        Append to or set the WHERE expressions.
    3869
    3870        Example:
    3871            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3872            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3873
    3874        Args:
    3875            *expressions: the SQL code strings to parse.
    3876                If an `Expression` instance is passed, it will be used as-is.
    3877                Multiple expressions are combined with an AND operator.
    3878            append: if `True`, AND the new expressions to any existing expression.
    3879                Otherwise, this resets the expression.
    3880            dialect: the dialect used to parse the input expressions.
    3881            copy: if `False`, modify this expression instance in-place.
    3882            opts: other options to use to parse the input expressions.
    3883
    3884        Returns:
    3885            Select: the modified expression.
    3886        """
    3887        return _apply_conjunction_builder(
    3888            *expressions,
    3889            instance=self,
    3890            arg="where",
    3891            append=append,
    3892            into=Where,
    3893            dialect=dialect,
    3894            copy=copy,
    3895            **opts,
    3896        )

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

    3898    def having(
    3899        self,
    3900        *expressions: t.Optional[ExpOrStr],
    3901        append: bool = True,
    3902        dialect: DialectType = None,
    3903        copy: bool = True,
    3904        **opts,
    3905    ) -> Select:
    3906        """
    3907        Append to or set the HAVING expressions.
    3908
    3909        Example:
    3910            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3911            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3912
    3913        Args:
    3914            *expressions: the SQL code strings to parse.
    3915                If an `Expression` instance is passed, it will be used as-is.
    3916                Multiple expressions are combined with an AND operator.
    3917            append: if `True`, AND the new expressions to any existing expression.
    3918                Otherwise, this resets the expression.
    3919            dialect: the dialect used to parse the input expressions.
    3920            copy: if `False`, modify this expression instance in-place.
    3921            opts: other options to use to parse the input expressions.
    3922
    3923        Returns:
    3924            The modified Select expression.
    3925        """
    3926        return _apply_conjunction_builder(
    3927            *expressions,
    3928            instance=self,
    3929            arg="having",
    3930            append=append,
    3931            into=Having,
    3932            dialect=dialect,
    3933            copy=copy,
    3934            **opts,
    3935        )

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

    3937    def window(
    3938        self,
    3939        *expressions: t.Optional[ExpOrStr],
    3940        append: bool = True,
    3941        dialect: DialectType = None,
    3942        copy: bool = True,
    3943        **opts,
    3944    ) -> Select:
    3945        return _apply_list_builder(
    3946            *expressions,
    3947            instance=self,
    3948            arg="windows",
    3949            append=append,
    3950            into=Window,
    3951            dialect=dialect,
    3952            copy=copy,
    3953            **opts,
    3954        )

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

    3956    def qualify(
    3957        self,
    3958        *expressions: t.Optional[ExpOrStr],
    3959        append: bool = True,
    3960        dialect: DialectType = None,
    3961        copy: bool = True,
    3962        **opts,
    3963    ) -> Select:
    3964        return _apply_conjunction_builder(
    3965            *expressions,
    3966            instance=self,
    3967            arg="qualify",
    3968            append=append,
    3969            into=Qualify,
    3970            dialect=dialect,
    3971            copy=copy,
    3972            **opts,
    3973        )

def distinct( self, *ons: Union[str, Expression, NoneType], distinct: bool = True, copy: bool = True) -> Select: View Source

    3975    def distinct(
    3976        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3977    ) -> Select:
    3978        """
    3979        Set the OFFSET expression.
    3980
    3981        Example:
    3982            >>> Select().from_("tbl").select("x").distinct().sql()
    3983            'SELECT DISTINCT x FROM tbl'
    3984
    3985        Args:
    3986            ons: the expressions to distinct on
    3987            distinct: whether the Select should be distinct
    3988            copy: if `False`, modify this expression instance in-place.
    3989
    3990        Returns:
    3991            Select: the modified expression.
    3992        """
    3993        instance = maybe_copy(self, copy)
    3994        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3995        instance.set("distinct", Distinct(on=on) if distinct else None)
    3996        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

    3998    def ctas(
    3999        self,
    4000        table: ExpOrStr,
    4001        properties: t.Optional[t.Dict] = None,
    4002        dialect: DialectType = None,
    4003        copy: bool = True,
    4004        **opts,
    4005    ) -> Create:
    4006        """
    4007        Convert this expression to a CREATE TABLE AS statement.
    4008
    4009        Example:
    4010            >>> Select().select("*").from_("tbl").ctas("x").sql()
    4011            'CREATE TABLE x AS SELECT * FROM tbl'
    4012
    4013        Args:
    4014            table: the SQL code string to parse as the table name.
    4015                If another `Expression` instance is passed, it will be used as-is.
    4016            properties: an optional mapping of table properties
    4017            dialect: the dialect used to parse the input table.
    4018            copy: if `False`, modify this expression instance in-place.
    4019            opts: other options to use to parse the input table.
    4020
    4021        Returns:
    4022            The new Create expression.
    4023        """
    4024        instance = maybe_copy(self, copy)
    4025        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4026
    4027        properties_expression = None
    4028        if properties:
    4029            properties_expression = Properties.from_dict(properties)
    4030
    4031        return Create(
    4032            this=table_expression,
    4033            kind="TABLE",
    4034            expression=instance,
    4035            properties=properties_expression,
    4036        )

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

    4038    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4039        """
    4040        Set the locking read mode for this expression.
    4041
    4042        Examples:
    4043            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4044            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4045
    4046            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4047            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4048
    4049        Args:
    4050            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4051            copy: if `False`, modify this expression instance in-place.
    4052
    4053        Returns:
    4054            The modified expression.
    4055        """
    4056        inst = maybe_copy(self, copy)
    4057        inst.set("locks", [Lock(update=update)])
    4058
    4059        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

    4061    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4062        """
    4063        Set hints for this expression.
    4064
    4065        Examples:
    4066            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4067            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4068
    4069        Args:
    4070            hints: The SQL code strings to parse as the hints.
    4071                If an `Expression` instance is passed, it will be used as-is.
    4072            dialect: The dialect used to parse the hints.
    4073            copy: If `False`, modify this expression instance in-place.
    4074
    4075        Returns:
    4076            The modified expression.
    4077        """
    4078        inst = maybe_copy(self, copy)
    4079        inst.set(
    4080            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4081        )
    4082
    4083        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

    4085    @property
    4086    def named_selects(self) -> t.List[str]:
    4087        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

    4089    @property
    4090    def is_star(self) -> bool:
    4091        return any(expression.is_star for expression in self.expressions)

Checks whether an expression is a star.

selects: List[Expression] View Source

    4093    @property
    4094    def selects(self) -> t.List[Expression]:
    4095        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

    4101class Subquery(DerivedTable, Query):
    4102    arg_types = {
    4103        "this": True,
    4104        "alias": False,
    4105        "with": False,
    4106        **QUERY_MODIFIERS,
    4107    }
    4108
    4109    def unnest(self):
    4110        """Returns the first non subquery."""
    4111        expression = self
    4112        while isinstance(expression, Subquery):
    4113            expression = expression.this
    4114        return expression
    4115
    4116    def unwrap(self) -> Subquery:
    4117        expression = self
    4118        while expression.same_parent and expression.is_wrapper:
    4119            expression = t.cast(Subquery, expression.parent)
    4120        return expression
    4121
    4122    def select(
    4123        self,
    4124        *expressions: t.Optional[ExpOrStr],
    4125        append: bool = True,
    4126        dialect: DialectType = None,
    4127        copy: bool = True,
    4128        **opts,
    4129    ) -> Subquery:
    4130        this = maybe_copy(self, copy)
    4131        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4132        return this
    4133
    4134    @property
    4135    def is_wrapper(self) -> bool:
    4136        """
    4137        Whether this Subquery acts as a simple wrapper around another expression.
    4138
    4139        SELECT * FROM (((SELECT * FROM t)))
    4140                      ^
    4141                      This corresponds to a "wrapper" Subquery node
    4142        """
    4143        return all(v is None for k, v in self.args.items() if k != "this")
    4144
    4145    @property
    4146    def is_star(self) -> bool:
    4147        return self.this.is_star
    4148
    4149    @property
    4150    def output_name(self) -> str:
    4151        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

    4109    def unnest(self):
    4110        """Returns the first non subquery."""
    4111        expression = self
    4112        while isinstance(expression, Subquery):
    4113            expression = expression.this
    4114        return expression

Returns the first non subquery.

def unwrap(self) -> Subquery: View Source

    4116    def unwrap(self) -> Subquery:
    4117        expression = self
    4118        while expression.same_parent and expression.is_wrapper:
    4119            expression = t.cast(Subquery, expression.parent)
    4120        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

    4122    def select(
    4123        self,
    4124        *expressions: t.Optional[ExpOrStr],
    4125        append: bool = True,
    4126        dialect: DialectType = None,
    4127        copy: bool = True,
    4128        **opts,
    4129    ) -> Subquery:
    4130        this = maybe_copy(self, copy)
    4131        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4132        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

    4134    @property
    4135    def is_wrapper(self) -> bool:
    4136        """
    4137        Whether this Subquery acts as a simple wrapper around another expression.
    4138
    4139        SELECT * FROM (((SELECT * FROM t)))
    4140                      ^
    4141                      This corresponds to a "wrapper" Subquery node
    4142        """
    4143        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

    4145    @property
    4146    def is_star(self) -> bool:
    4147        return self.this.is_star

Checks whether an expression is a star.

output_name: str View Source

    4149    @property
    4150    def output_name(self) -> str:
    4151        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

    4154class TableSample(Expression):
    4155    arg_types = {
    4156        "expressions": False,
    4157        "method": False,
    4158        "bucket_numerator": False,
    4159        "bucket_denominator": False,
    4160        "bucket_field": False,
    4161        "percent": False,
    4162        "rows": False,
    4163        "size": False,
    4164        "seed": False,
    4165    }

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

    4168class Tag(Expression):
    4169    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    4170
    4171    arg_types = {
    4172        "this": False,
    4173        "prefix": False,
    4174        "postfix": False,
    4175    }

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

    4180class Pivot(Expression):
    4181    arg_types = {
    4182        "this": False,
    4183        "alias": False,
    4184        "expressions": False,
    4185        "field": False,
    4186        "unpivot": False,
    4187        "using": False,
    4188        "group": False,
    4189        "columns": False,
    4190        "include_nulls": False,
    4191        "default_on_null": False,
    4192    }
    4193
    4194    @property
    4195    def unpivot(self) -> bool:
    4196        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

    4194    @property
    4195    def unpivot(self) -> bool:
    4196        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

    4199class Window(Condition):
    4200    arg_types = {
    4201        "this": True,
    4202        "partition_by": False,
    4203        "order": False,
    4204        "spec": False,
    4205        "alias": False,
    4206        "over": False,
    4207        "first": False,
    4208    }

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

    4211class WindowSpec(Expression):
    4212    arg_types = {
    4213        "kind": False,
    4214        "start": False,
    4215        "start_side": False,
    4216        "end": False,
    4217        "end_side": False,
    4218    }

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

    4221class PreWhere(Expression):
    4222    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

    4225class Where(Expression):
    4226    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

    4229class Star(Expression):
    4230    arg_types = {"except": False, "replace": False, "rename": False}
    4231
    4232    @property
    4233    def name(self) -> str:
    4234        return "*"
    4235
    4236    @property
    4237    def output_name(self) -> str:
    4238        return self.name

arg_types = {'except': False, 'replace': False, 'rename': False}
name: str View Source

    4232    @property
    4233    def name(self) -> str:
    4234        return "*"

output_name: str View Source

    4236    @property
    4237    def output_name(self) -> str:
    4238        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

    4241class Parameter(Condition):
    4242    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

    4245class SessionParameter(Condition):
    4246    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

    4249class Placeholder(Condition):
    4250    arg_types = {"this": False, "kind": False}
    4251
    4252    @property
    4253    def name(self) -> str:
    4254        return self.this or "?"

arg_types = {'this': False, 'kind': False}
name: str View Source

    4252    @property
    4253    def name(self) -> str:
    4254        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

    4257class Null(Condition):
    4258    arg_types: t.Dict[str, t.Any] = {}
    4259
    4260    @property
    4261    def name(self) -> str:
    4262        return "NULL"
    4263
    4264    def to_py(self) -> Lit[None]:
    4265        return None

arg_types: Dict[str, Any] = {}
name: str View Source

    4260    @property
    4261    def name(self) -> str:
    4262        return "NULL"

def to_py(self) -> Literal[None]: View Source

    4264    def to_py(self) -> Lit[None]:
    4265        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

    4268class Boolean(Condition):
    4269    def to_py(self) -> bool:
    4270        return self.this

def to_py(self) -> bool: View Source

    4269    def to_py(self) -> bool:
    4270        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

    4273class DataTypeParam(Expression):
    4274    arg_types = {"this": True, "expression": False}
    4275
    4276    @property
    4277    def name(self) -> str:
    4278        return self.this.name

arg_types = {'this': True, 'expression': False}
name: str View Source

    4276    @property
    4277    def name(self) -> str:
    4278        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

    4283class DataType(Expression):
    4284    arg_types = {
    4285        "this": True,
    4286        "expressions": False,
    4287        "nested": False,
    4288        "values": False,
    4289        "prefix": False,
    4290        "kind": False,
    4291        "nullable": False,
    4292    }
    4293
    4294    class Type(AutoName):
    4295        ARRAY = auto()
    4296        AGGREGATEFUNCTION = auto()
    4297        SIMPLEAGGREGATEFUNCTION = auto()
    4298        BIGDECIMAL = auto()
    4299        BIGINT = auto()
    4300        BIGSERIAL = auto()
    4301        BINARY = auto()
    4302        BIT = auto()
    4303        BOOLEAN = auto()
    4304        BPCHAR = auto()
    4305        CHAR = auto()
    4306        DATE = auto()
    4307        DATE32 = auto()
    4308        DATEMULTIRANGE = auto()
    4309        DATERANGE = auto()
    4310        DATETIME = auto()
    4311        DATETIME64 = auto()
    4312        DECIMAL = auto()
    4313        DECIMAL32 = auto()
    4314        DECIMAL64 = auto()
    4315        DECIMAL128 = auto()
    4316        DECIMAL256 = auto()
    4317        DOUBLE = auto()
    4318        ENUM = auto()
    4319        ENUM8 = auto()
    4320        ENUM16 = auto()
    4321        FIXEDSTRING = auto()
    4322        FLOAT = auto()
    4323        GEOGRAPHY = auto()
    4324        GEOMETRY = auto()
    4325        POINT = auto()
    4326        RING = auto()
    4327        LINESTRING = auto()
    4328        MULTILINESTRING = auto()
    4329        POLYGON = auto()
    4330        MULTIPOLYGON = auto()
    4331        HLLSKETCH = auto()
    4332        HSTORE = auto()
    4333        IMAGE = auto()
    4334        INET = auto()
    4335        INT = auto()
    4336        INT128 = auto()
    4337        INT256 = auto()
    4338        INT4MULTIRANGE = auto()
    4339        INT4RANGE = auto()
    4340        INT8MULTIRANGE = auto()
    4341        INT8RANGE = auto()
    4342        INTERVAL = auto()
    4343        IPADDRESS = auto()
    4344        IPPREFIX = auto()
    4345        IPV4 = auto()
    4346        IPV6 = auto()
    4347        JSON = auto()
    4348        JSONB = auto()
    4349        LIST = auto()
    4350        LONGBLOB = auto()
    4351        LONGTEXT = auto()
    4352        LOWCARDINALITY = auto()
    4353        MAP = auto()
    4354        MEDIUMBLOB = auto()
    4355        MEDIUMINT = auto()
    4356        MEDIUMTEXT = auto()
    4357        MONEY = auto()
    4358        NAME = auto()
    4359        NCHAR = auto()
    4360        NESTED = auto()
    4361        NULL = auto()
    4362        NUMMULTIRANGE = auto()
    4363        NUMRANGE = auto()
    4364        NVARCHAR = auto()
    4365        OBJECT = auto()
    4366        RANGE = auto()
    4367        ROWVERSION = auto()
    4368        SERIAL = auto()
    4369        SET = auto()
    4370        SMALLINT = auto()
    4371        SMALLMONEY = auto()
    4372        SMALLSERIAL = auto()
    4373        STRUCT = auto()
    4374        SUPER = auto()
    4375        TEXT = auto()
    4376        TINYBLOB = auto()
    4377        TINYTEXT = auto()
    4378        TIME = auto()
    4379        TIMETZ = auto()
    4380        TIMESTAMP = auto()
    4381        TIMESTAMPNTZ = auto()
    4382        TIMESTAMPLTZ = auto()
    4383        TIMESTAMPTZ = auto()
    4384        TIMESTAMP_S = auto()
    4385        TIMESTAMP_MS = auto()
    4386        TIMESTAMP_NS = auto()
    4387        TINYINT = auto()
    4388        TSMULTIRANGE = auto()
    4389        TSRANGE = auto()
    4390        TSTZMULTIRANGE = auto()
    4391        TSTZRANGE = auto()
    4392        UBIGINT = auto()
    4393        UINT = auto()
    4394        UINT128 = auto()
    4395        UINT256 = auto()
    4396        UMEDIUMINT = auto()
    4397        UDECIMAL = auto()
    4398        UNION = auto()
    4399        UNIQUEIDENTIFIER = auto()
    4400        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4401        USERDEFINED = "USER-DEFINED"
    4402        USMALLINT = auto()
    4403        UTINYINT = auto()
    4404        UUID = auto()
    4405        VARBINARY = auto()
    4406        VARCHAR = auto()
    4407        VARIANT = auto()
    4408        VECTOR = auto()
    4409        XML = auto()
    4410        YEAR = auto()
    4411        TDIGEST = auto()
    4412
    4413    STRUCT_TYPES = {
    4414        Type.NESTED,
    4415        Type.OBJECT,
    4416        Type.STRUCT,
    4417        Type.UNION,
    4418    }
    4419
    4420    ARRAY_TYPES = {
    4421        Type.ARRAY,
    4422        Type.LIST,
    4423    }
    4424
    4425    NESTED_TYPES = {
    4426        *STRUCT_TYPES,
    4427        *ARRAY_TYPES,
    4428        Type.MAP,
    4429    }
    4430
    4431    TEXT_TYPES = {
    4432        Type.CHAR,
    4433        Type.NCHAR,
    4434        Type.NVARCHAR,
    4435        Type.TEXT,
    4436        Type.VARCHAR,
    4437        Type.NAME,
    4438    }
    4439
    4440    SIGNED_INTEGER_TYPES = {
    4441        Type.BIGINT,
    4442        Type.INT,
    4443        Type.INT128,
    4444        Type.INT256,
    4445        Type.MEDIUMINT,
    4446        Type.SMALLINT,
    4447        Type.TINYINT,
    4448    }
    4449
    4450    UNSIGNED_INTEGER_TYPES = {
    4451        Type.UBIGINT,
    4452        Type.UINT,
    4453        Type.UINT128,
    4454        Type.UINT256,
    4455        Type.UMEDIUMINT,
    4456        Type.USMALLINT,
    4457        Type.UTINYINT,
    4458    }
    4459
    4460    INTEGER_TYPES = {
    4461        *SIGNED_INTEGER_TYPES,
    4462        *UNSIGNED_INTEGER_TYPES,
    4463        Type.BIT,
    4464    }
    4465
    4466    FLOAT_TYPES = {
    4467        Type.DOUBLE,
    4468        Type.FLOAT,
    4469    }
    4470
    4471    REAL_TYPES = {
    4472        *FLOAT_TYPES,
    4473        Type.BIGDECIMAL,
    4474        Type.DECIMAL,
    4475        Type.DECIMAL32,
    4476        Type.DECIMAL64,
    4477        Type.DECIMAL128,
    4478        Type.DECIMAL256,
    4479        Type.MONEY,
    4480        Type.SMALLMONEY,
    4481        Type.UDECIMAL,
    4482    }
    4483
    4484    NUMERIC_TYPES = {
    4485        *INTEGER_TYPES,
    4486        *REAL_TYPES,
    4487    }
    4488
    4489    TEMPORAL_TYPES = {
    4490        Type.DATE,
    4491        Type.DATE32,
    4492        Type.DATETIME,
    4493        Type.DATETIME64,
    4494        Type.TIME,
    4495        Type.TIMESTAMP,
    4496        Type.TIMESTAMPNTZ,
    4497        Type.TIMESTAMPLTZ,
    4498        Type.TIMESTAMPTZ,
    4499        Type.TIMESTAMP_MS,
    4500        Type.TIMESTAMP_NS,
    4501        Type.TIMESTAMP_S,
    4502        Type.TIMETZ,
    4503    }
    4504
    4505    @classmethod
    4506    def build(
    4507        cls,
    4508        dtype: DATA_TYPE,
    4509        dialect: DialectType = None,
    4510        udt: bool = False,
    4511        copy: bool = True,
    4512        **kwargs,
    4513    ) -> DataType:
    4514        """
    4515        Constructs a DataType object.
    4516
    4517        Args:
    4518            dtype: the data type of interest.
    4519            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4520            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4521                DataType, thus creating a user-defined type.
    4522            copy: whether to copy the data type.
    4523            kwargs: additional arguments to pass in the constructor of DataType.
    4524
    4525        Returns:
    4526            The constructed DataType object.
    4527        """
    4528        from sqlglot import parse_one
    4529
    4530        if isinstance(dtype, str):
    4531            if dtype.upper() == "UNKNOWN":
    4532                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4533
    4534            try:
    4535                data_type_exp = parse_one(
    4536                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4537                )
    4538            except ParseError:
    4539                if udt:
    4540                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4541                raise
    4542        elif isinstance(dtype, DataType.Type):
    4543            data_type_exp = DataType(this=dtype)
    4544        elif isinstance(dtype, DataType):
    4545            return maybe_copy(dtype, copy)
    4546        else:
    4547            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4548
    4549        return DataType(**{**data_type_exp.args, **kwargs})
    4550
    4551    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4552        """
    4553        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4554        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4555
    4556        Args:
    4557            dtypes: the data types to compare this DataType to.
    4558            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4559                If false, it means that NULLABLE<INT> is equivalent to INT.
    4560
    4561        Returns:
    4562            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4563        """
    4564        self_is_nullable = self.args.get("nullable")
    4565        for dtype in dtypes:
    4566            other_type = DataType.build(dtype, copy=False, udt=True)
    4567            other_is_nullable = other_type.args.get("nullable")
    4568            if (
    4569                other_type.expressions
    4570                or (check_nullable and (self_is_nullable or other_is_nullable))
    4571                or self.this == DataType.Type.USERDEFINED
    4572                or other_type.this == DataType.Type.USERDEFINED
    4573            ):
    4574                matches = self == other_type
    4575            else:
    4576                matches = self.this == other_type.this
    4577
    4578            if matches:
    4579                return True
    4580        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.MAP: 'MAP'>, <Type.UNION: 'UNION'>, <Type.STRUCT: 'STRUCT'>, <Type.LIST: 'LIST'>, <Type.OBJECT: 'OBJECT'>, <Type.NESTED: 'NESTED'>, <Type.ARRAY: 'ARRAY'>}
TEXT_TYPES = {<Type.CHAR: 'CHAR'>, <Type.VARCHAR: 'VARCHAR'>, <Type.NCHAR: 'NCHAR'>, <Type.NAME: 'NAME'>, <Type.NVARCHAR: 'NVARCHAR'>, <Type.TEXT: 'TEXT'>}
SIGNED_INTEGER_TYPES = {<Type.INT128: 'INT128'>, <Type.MEDIUMINT: 'MEDIUMINT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.INT256: 'INT256'>, <Type.TINYINT: 'TINYINT'>, <Type.BIGINT: 'BIGINT'>, <Type.INT: 'INT'>}
UNSIGNED_INTEGER_TYPES = {<Type.USMALLINT: 'USMALLINT'>, <Type.UINT: 'UINT'>, <Type.UTINYINT: 'UTINYINT'>, <Type.UINT256: 'UINT256'>, <Type.UBIGINT: 'UBIGINT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.UINT128: 'UINT128'>}
INTEGER_TYPES = {<Type.INT128: 'INT128'>, <Type.MEDIUMINT: 'MEDIUMINT'>, <Type.USMALLINT: 'USMALLINT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.BIT: 'BIT'>, <Type.UINT: 'UINT'>, <Type.UTINYINT: 'UTINYINT'>, <Type.INT256: 'INT256'>, <Type.TINYINT: 'TINYINT'>, <Type.UINT256: 'UINT256'>, <Type.UBIGINT: 'UBIGINT'>, <Type.BIGINT: 'BIGINT'>, <Type.INT: 'INT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.UINT128: 'UINT128'>}
FLOAT_TYPES = {<Type.FLOAT: 'FLOAT'>, <Type.DOUBLE: 'DOUBLE'>}
REAL_TYPES = {<Type.MONEY: 'MONEY'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL256: 'DECIMAL256'>, <Type.DECIMAL: 'DECIMAL'>, <Type.FLOAT: 'FLOAT'>, <Type.DECIMAL32: 'DECIMAL32'>, <Type.SMALLMONEY: 'SMALLMONEY'>, <Type.DECIMAL64: 'DECIMAL64'>, <Type.DECIMAL128: 'DECIMAL128'>, <Type.UDECIMAL: 'UDECIMAL'>, <Type.BIGDECIMAL: 'BIGDECIMAL'>}
NUMERIC_TYPES = {<Type.MONEY: 'MONEY'>, <Type.INT128: 'INT128'>, <Type.MEDIUMINT: 'MEDIUMINT'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL256: 'DECIMAL256'>, <Type.DECIMAL: 'DECIMAL'>, <Type.DECIMAL32: 'DECIMAL32'>, <Type.UINT: 'UINT'>, <Type.UTINYINT: 'UTINYINT'>, <Type.SMALLMONEY: 'SMALLMONEY'>, <Type.TINYINT: 'TINYINT'>, <Type.DECIMAL128: 'DECIMAL128'>, <Type.UBIGINT: 'UBIGINT'>, <Type.UDECIMAL: 'UDECIMAL'>, <Type.INT: 'INT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.BIGDECIMAL: 'BIGDECIMAL'>, <Type.UINT128: 'UINT128'>, <Type.USMALLINT: 'USMALLINT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.BIT: 'BIT'>, <Type.INT256: 'INT256'>, <Type.UINT256: 'UINT256'>, <Type.DECIMAL64: 'DECIMAL64'>, <Type.BIGINT: 'BIGINT'>, <Type.FLOAT: 'FLOAT'>}
TEMPORAL_TYPES = {<Type.DATE: 'DATE'>, <Type.TIMETZ: 'TIMETZ'>, <Type.DATETIME64: 'DATETIME64'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <Type.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <Type.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <Type.TIMESTAMP_S: 'TIMESTAMP_S'>, <Type.DATE32: 'DATE32'>, <Type.TIMESTAMP: 'TIMESTAMP'>, <Type.TIME: 'TIME'>, <Type.DATETIME: 'DATETIME'>}
@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

    4505    @classmethod
    4506    def build(
    4507        cls,
    4508        dtype: DATA_TYPE,
    4509        dialect: DialectType = None,
    4510        udt: bool = False,
    4511        copy: bool = True,
    4512        **kwargs,
    4513    ) -> DataType:
    4514        """
    4515        Constructs a DataType object.
    4516
    4517        Args:
    4518            dtype: the data type of interest.
    4519            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4520            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4521                DataType, thus creating a user-defined type.
    4522            copy: whether to copy the data type.
    4523            kwargs: additional arguments to pass in the constructor of DataType.
    4524
    4525        Returns:
    4526            The constructed DataType object.
    4527        """
    4528        from sqlglot import parse_one
    4529
    4530        if isinstance(dtype, str):
    4531            if dtype.upper() == "UNKNOWN":
    4532                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4533
    4534            try:
    4535                data_type_exp = parse_one(
    4536                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4537                )
    4538            except ParseError:
    4539                if udt:
    4540                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4541                raise
    4542        elif isinstance(dtype, DataType.Type):
    4543            data_type_exp = DataType(this=dtype)
    4544        elif isinstance(dtype, DataType):
    4545            return maybe_copy(dtype, copy)
    4546        else:
    4547            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4548
    4549        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

    4551    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4552        """
    4553        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4554        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4555
    4556        Args:
    4557            dtypes: the data types to compare this DataType to.
    4558            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4559                If false, it means that NULLABLE<INT> is equivalent to INT.
    4560
    4561        Returns:
    4562            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4563        """
    4564        self_is_nullable = self.args.get("nullable")
    4565        for dtype in dtypes:
    4566            other_type = DataType.build(dtype, copy=False, udt=True)
    4567            other_is_nullable = other_type.args.get("nullable")
    4568            if (
    4569                other_type.expressions
    4570                or (check_nullable and (self_is_nullable or other_is_nullable))
    4571                or self.this == DataType.Type.USERDEFINED
    4572                or other_type.this == DataType.Type.USERDEFINED
    4573            ):
    4574                matches = self == other_type
    4575            else:
    4576                matches = self.this == other_type.this
    4577
    4578            if matches:
    4579                return True
    4580        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

    4294    class Type(AutoName):
    4295        ARRAY = auto()
    4296        AGGREGATEFUNCTION = auto()
    4297        SIMPLEAGGREGATEFUNCTION = auto()
    4298        BIGDECIMAL = auto()
    4299        BIGINT = auto()
    4300        BIGSERIAL = auto()
    4301        BINARY = auto()
    4302        BIT = auto()
    4303        BOOLEAN = auto()
    4304        BPCHAR = auto()
    4305        CHAR = auto()
    4306        DATE = auto()
    4307        DATE32 = auto()
    4308        DATEMULTIRANGE = auto()
    4309        DATERANGE = auto()
    4310        DATETIME = auto()
    4311        DATETIME64 = auto()
    4312        DECIMAL = auto()
    4313        DECIMAL32 = auto()
    4314        DECIMAL64 = auto()
    4315        DECIMAL128 = auto()
    4316        DECIMAL256 = auto()
    4317        DOUBLE = auto()
    4318        ENUM = auto()
    4319        ENUM8 = auto()
    4320        ENUM16 = auto()
    4321        FIXEDSTRING = auto()
    4322        FLOAT = auto()
    4323        GEOGRAPHY = auto()
    4324        GEOMETRY = auto()
    4325        POINT = auto()
    4326        RING = auto()
    4327        LINESTRING = auto()
    4328        MULTILINESTRING = auto()
    4329        POLYGON = auto()
    4330        MULTIPOLYGON = auto()
    4331        HLLSKETCH = auto()
    4332        HSTORE = auto()
    4333        IMAGE = auto()
    4334        INET = auto()
    4335        INT = auto()
    4336        INT128 = auto()
    4337        INT256 = auto()
    4338        INT4MULTIRANGE = auto()
    4339        INT4RANGE = auto()
    4340        INT8MULTIRANGE = auto()
    4341        INT8RANGE = auto()
    4342        INTERVAL = auto()
    4343        IPADDRESS = auto()
    4344        IPPREFIX = auto()
    4345        IPV4 = auto()
    4346        IPV6 = auto()
    4347        JSON = auto()
    4348        JSONB = auto()
    4349        LIST = auto()
    4350        LONGBLOB = auto()
    4351        LONGTEXT = auto()
    4352        LOWCARDINALITY = auto()
    4353        MAP = auto()
    4354        MEDIUMBLOB = auto()
    4355        MEDIUMINT = auto()
    4356        MEDIUMTEXT = auto()
    4357        MONEY = auto()
    4358        NAME = auto()
    4359        NCHAR = auto()
    4360        NESTED = auto()
    4361        NULL = auto()
    4362        NUMMULTIRANGE = auto()
    4363        NUMRANGE = auto()
    4364        NVARCHAR = auto()
    4365        OBJECT = auto()
    4366        RANGE = auto()
    4367        ROWVERSION = auto()
    4368        SERIAL = auto()
    4369        SET = auto()
    4370        SMALLINT = auto()
    4371        SMALLMONEY = auto()
    4372        SMALLSERIAL = auto()
    4373        STRUCT = auto()
    4374        SUPER = auto()
    4375        TEXT = auto()
    4376        TINYBLOB = auto()
    4377        TINYTEXT = auto()
    4378        TIME = auto()
    4379        TIMETZ = auto()
    4380        TIMESTAMP = auto()
    4381        TIMESTAMPNTZ = auto()
    4382        TIMESTAMPLTZ = auto()
    4383        TIMESTAMPTZ = auto()
    4384        TIMESTAMP_S = auto()
    4385        TIMESTAMP_MS = auto()
    4386        TIMESTAMP_NS = auto()
    4387        TINYINT = auto()
    4388        TSMULTIRANGE = auto()
    4389        TSRANGE = auto()
    4390        TSTZMULTIRANGE = auto()
    4391        TSTZRANGE = auto()
    4392        UBIGINT = auto()
    4393        UINT = auto()
    4394        UINT128 = auto()
    4395        UINT256 = auto()
    4396        UMEDIUMINT = auto()
    4397        UDECIMAL = auto()
    4398        UNION = auto()
    4399        UNIQUEIDENTIFIER = auto()
    4400        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4401        USERDEFINED = "USER-DEFINED"
    4402        USMALLINT = auto()
    4403        UTINYINT = auto()
    4404        UUID = auto()
    4405        VARBINARY = auto()
    4406        VARCHAR = auto()
    4407        VARIANT = auto()
    4408        VECTOR = auto()
    4409        XML = auto()
    4410        YEAR = auto()
    4411        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'>
DECIMAL256 = <Type.DECIMAL256: 'DECIMAL256'>
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'>
POINT = <Type.POINT: 'POINT'>
RING = <Type.RING: 'RING'>
LINESTRING = <Type.LINESTRING: 'LINESTRING'>
MULTILINESTRING = <Type.MULTILINESTRING: 'MULTILINESTRING'>
POLYGON = <Type.POLYGON: 'POLYGON'>
MULTIPOLYGON = <Type.MULTIPOLYGON: 'MULTIPOLYGON'>
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

    4587class PseudoType(DataType):
    4588    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

    4592class ObjectIdentifier(DataType):
    4593    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

    4597class SubqueryPredicate(Predicate):
    4598    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

    4601class All(SubqueryPredicate):
    4602    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

    4605class Any(SubqueryPredicate):
    4606    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

    4609class Exists(SubqueryPredicate):
    4610    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

    4615class Command(Expression):
    4616    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

    4619class Transaction(Expression):
    4620    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

    4623class Commit(Expression):
    4624    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

    4627class Rollback(Expression):
    4628    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

    4631class Alter(Expression):
    4632    arg_types = {
    4633        "this": True,
    4634        "kind": True,
    4635        "actions": True,
    4636        "exists": False,
    4637        "only": False,
    4638        "options": False,
    4639        "cluster": False,
    4640        "not_valid": False,
    4641    }
    4642
    4643    @property
    4644    def kind(self) -> t.Optional[str]:
    4645        kind = self.args.get("kind")
    4646        return kind and kind.upper()
    4647
    4648    @property
    4649    def actions(self) -> t.List[Expression]:
    4650        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

    4643    @property
    4644    def kind(self) -> t.Optional[str]:
    4645        kind = self.args.get("kind")
    4646        return kind and kind.upper()

actions: List[Expression] View Source

    4648    @property
    4649    def actions(self) -> t.List[Expression]:
    4650        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

    4653class AddConstraint(Expression):
    4654    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

    4657class DropPartition(Expression):
    4658    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

    4662class ReplacePartition(Expression):
    4663    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

    4667class Binary(Condition):
    4668    arg_types = {"this": True, "expression": True}
    4669
    4670    @property
    4671    def left(self) -> Expression:
    4672        return self.this
    4673
    4674    @property
    4675    def right(self) -> Expression:
    4676        return self.expression

arg_types = {'this': True, 'expression': True}
left: Expression View Source

    4670    @property
    4671    def left(self) -> Expression:
    4672        return self.this

right: Expression View Source

    4674    @property
    4675    def right(self) -> Expression:
    4676        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

    4679class Add(Binary):
    4680    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

    4683class Connector(Binary):
    4684    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

    4687class And(Connector):
    4688    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

    4691class Or(Connector):
    4692    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

    4695class BitwiseAnd(Binary):
    4696    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

    4699class BitwiseLeftShift(Binary):
    4700    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

    4703class BitwiseOr(Binary):
    4704    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

    4707class BitwiseRightShift(Binary):
    4708    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

    4711class BitwiseXor(Binary):
    4712    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

    4715class Div(Binary):
    4716    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

    4719class Overlaps(Binary):
    4720    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

    4723class Dot(Binary):
    4724    @property
    4725    def is_star(self) -> bool:
    4726        return self.expression.is_star
    4727
    4728    @property
    4729    def name(self) -> str:
    4730        return self.expression.name
    4731
    4732    @property
    4733    def output_name(self) -> str:
    4734        return self.name
    4735
    4736    @classmethod
    4737    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    4738        """Build a Dot object with a sequence of expressions."""
    4739        if len(expressions) < 2:
    4740            raise ValueError("Dot requires >= 2 expressions.")
    4741
    4742        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))
    4743
    4744    @property
    4745    def parts(self) -> t.List[Expression]:
    4746        """Return the parts of a table / column in order catalog, db, table."""
    4747        this, *parts = self.flatten()
    4748
    4749        parts.reverse()
    4750
    4751        for arg in COLUMN_PARTS:
    4752            part = this.args.get(arg)
    4753
    4754            if isinstance(part, Expression):
    4755                parts.append(part)
    4756
    4757        parts.reverse()
    4758        return parts

is_star: bool View Source

    4724    @property
    4725    def is_star(self) -> bool:
    4726        return self.expression.is_star

Checks whether an expression is a star.

name: str View Source

    4728    @property
    4729    def name(self) -> str:
    4730        return self.expression.name

output_name: str View Source

    4732    @property
    4733    def output_name(self) -> str:
    4734        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

    4736    @classmethod
    4737    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    4738        """Build a Dot object with a sequence of expressions."""
    4739        if len(expressions) < 2:
    4740            raise ValueError("Dot requires >= 2 expressions.")
    4741
    4742        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

    4744    @property
    4745    def parts(self) -> t.List[Expression]:
    4746        """Return the parts of a table / column in order catalog, db, table."""
    4747        this, *parts = self.flatten()
    4748
    4749        parts.reverse()
    4750
    4751        for arg in COLUMN_PARTS:
    4752            part = this.args.get(arg)
    4753
    4754            if isinstance(part, Expression):
    4755                parts.append(part)
    4756
    4757        parts.reverse()
    4758        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

    4761class DPipe(Binary):
    4762    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

    4765class EQ(Binary, Predicate):
    4766    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

    4769class NullSafeEQ(Binary, Predicate):
    4770    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

    4773class NullSafeNEQ(Binary, Predicate):
    4774    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

    4778class PropertyEQ(Binary):
    4779    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

    4782class Distance(Binary):
    4783    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

    4786class Escape(Binary):
    4787    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

    4790class Glob(Binary, Predicate):
    4791    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

    4794class GT(Binary, Predicate):
    4795    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

    4798class GTE(Binary, Predicate):
    4799    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

    4802class ILike(Binary, Predicate):
    4803    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

    4806class ILikeAny(Binary, Predicate):
    4807    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

    4810class IntDiv(Binary):
    4811    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

    4814class Is(Binary, Predicate):
    4815    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

    4818class Kwarg(Binary):
    4819    """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

    4822class Like(Binary, Predicate):
    4823    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

    4826class LikeAny(Binary, Predicate):
    4827    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

    4830class LT(Binary, Predicate):
    4831    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

    4834class LTE(Binary, Predicate):
    4835    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

    4838class Mod(Binary):
    4839    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

    4842class Mul(Binary):
    4843    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

    4846class NEQ(Binary, Predicate):
    4847    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

    4851class Operator(Binary):
    4852    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

    4855class SimilarTo(Binary, Predicate):
    4856    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

    4859class Slice(Binary):
    4860    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

    4863class Sub(Binary):
    4864    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

    4869class Unary(Condition):
    4870    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

    4873class BitwiseNot(Unary):
    4874    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

    4877class Not(Unary):
    4878    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

    4881class Paren(Unary):
    4882    @property
    4883    def output_name(self) -> str:
    4884        return self.this.name

output_name: str View Source

    4882    @property
    4883    def output_name(self) -> str:
    4884        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

    4887class Neg(Unary):
    4888    def to_py(self) -> int | Decimal:
    4889        if self.is_number:
    4890            return self.this.to_py() * -1
    4891        return super().to_py()

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

    4888    def to_py(self) -> int | Decimal:
    4889        if self.is_number:
    4890            return self.this.to_py() * -1
    4891        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

    4894class Alias(Expression):
    4895    arg_types = {"this": True, "alias": False}
    4896
    4897    @property
    4898    def output_name(self) -> str:
    4899        return self.alias

arg_types = {'this': True, 'alias': False}
output_name: str View Source

    4897    @property
    4898    def output_name(self) -> str:
    4899        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

    4904class PivotAlias(Alias):
    4905    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

    4910class PivotAny(Expression):
    4911    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

    4914class Aliases(Expression):
    4915    arg_types = {"this": True, "expressions": True}
    4916
    4917    @property
    4918    def aliases(self):
    4919        return self.expressions

arg_types = {'this': True, 'expressions': True}
aliases View Source

    4917    @property
    4918    def aliases(self):
    4919        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

    4923class AtIndex(Expression):
    4924    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

    4927class AtTimeZone(Expression):
    4928    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

    4931class FromTimeZone(Expression):
    4932    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

    4935class Between(Predicate):
    4936    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

    4939class Bracket(Condition):
    4940    # https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#array_subscript_operator
    4941    arg_types = {
    4942        "this": True,
    4943        "expressions": True,
    4944        "offset": False,
    4945        "safe": False,
    4946        "returns_list_for_maps": False,
    4947    }
    4948
    4949    @property
    4950    def output_name(self) -> str:
    4951        if len(self.expressions) == 1:
    4952            return self.expressions[0].output_name
    4953
    4954        return super().output_name

arg_types = {'this': True, 'expressions': True, 'offset': False, 'safe': False, 'returns_list_for_maps': False}
output_name: str View Source

    4949    @property
    4950    def output_name(self) -> str:
    4951        if len(self.expressions) == 1:
    4952            return self.expressions[0].output_name
    4953
    4954        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

    4957class Distinct(Expression):
    4958    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

    4961class In(Predicate):
    4962    arg_types = {
    4963        "this": True,
    4964        "expressions": False,
    4965        "query": False,
    4966        "unnest": False,
    4967        "field": False,
    4968        "is_global": False,
    4969    }

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

    4973class ForIn(Expression):
    4974    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

    4977class TimeUnit(Expression):
    4978    """Automatically converts unit arg into a var."""
    4979
    4980    arg_types = {"unit": False}
    4981
    4982    UNABBREVIATED_UNIT_NAME = {
    4983        "D": "DAY",
    4984        "H": "HOUR",
    4985        "M": "MINUTE",
    4986        "MS": "MILLISECOND",
    4987        "NS": "NANOSECOND",
    4988        "Q": "QUARTER",
    4989        "S": "SECOND",
    4990        "US": "MICROSECOND",
    4991        "W": "WEEK",
    4992        "Y": "YEAR",
    4993    }
    4994
    4995    VAR_LIKE = (Column, Literal, Var)
    4996
    4997    def __init__(self, **args):
    4998        unit = args.get("unit")
    4999        if isinstance(unit, self.VAR_LIKE):
    5000            args["unit"] = Var(
    5001                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5002            )
    5003        elif isinstance(unit, Week):
    5004            unit.set("this", Var(this=unit.this.name.upper()))
    5005
    5006        super().__init__(**args)
    5007
    5008    @property
    5009    def unit(self) -> t.Optional[Var | IntervalSpan]:
    5010        return self.args.get("unit")

Automatically converts unit arg into a var.

TimeUnit(**args) View Source

    4997    def __init__(self, **args):
    4998        unit = args.get("unit")
    4999        if isinstance(unit, self.VAR_LIKE):
    5000            args["unit"] = Var(
    5001                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5002            )
    5003        elif isinstance(unit, Week):
    5004            unit.set("this", Var(this=unit.this.name.upper()))
    5005
    5006        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

    5008    @property
    5009    def unit(self) -> t.Optional[Var | IntervalSpan]:
    5010        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

    5013class IntervalOp(TimeUnit):
    5014    arg_types = {"unit": False, "expression": True}
    5015
    5016    def interval(self):
    5017        return Interval(
    5018            this=self.expression.copy(),
    5019            unit=self.unit.copy() if self.unit else None,
    5020        )

arg_types = {'unit': False, 'expression': True}
def interval(self): View Source

    5016    def interval(self):
    5017        return Interval(
    5018            this=self.expression.copy(),
    5019            unit=self.unit.copy() if self.unit else None,
    5020        )

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

    5026class IntervalSpan(DataType):
    5027    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

    5030class Interval(TimeUnit):
    5031    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

    5034class IgnoreNulls(Expression):
    5035    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

    5038class RespectNulls(Expression):
    5039    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

    5043class HavingMax(Expression):
    5044    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

    5048class Func(Condition):
    5049    """
    5050    The base class for all function expressions.
    5051
    5052    Attributes:
    5053        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    5054            treated as a variable length argument and the argument's value will be stored as a list.
    5055        _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this
    5056            function expression. These values are used to map this node to a name during parsing as
    5057            well as to provide the function's name during SQL string generation. By default the SQL
    5058            name is set to the expression's class name transformed to snake case.
    5059    """
    5060
    5061    is_var_len_args = False
    5062
    5063    @classmethod
    5064    def from_arg_list(cls, args):
    5065        if cls.is_var_len_args:
    5066            all_arg_keys = list(cls.arg_types)
    5067            # If this function supports variable length argument treat the last argument as such.
    5068            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5069            num_non_var = len(non_var_len_arg_keys)
    5070
    5071            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5072            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5073        else:
    5074            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5075
    5076        return cls(**args_dict)
    5077
    5078    @classmethod
    5079    def sql_names(cls):
    5080        if cls is Func:
    5081            raise NotImplementedError(
    5082                "SQL name is only supported by concrete function implementations"
    5083            )
    5084        if "_sql_names" not in cls.__dict__:
    5085            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5086        return cls._sql_names
    5087
    5088    @classmethod
    5089    def sql_name(cls):
    5090        return cls.sql_names()[0]
    5091
    5092    @classmethod
    5093    def default_parser_mappings(cls):
    5094        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

    5063    @classmethod
    5064    def from_arg_list(cls, args):
    5065        if cls.is_var_len_args:
    5066            all_arg_keys = list(cls.arg_types)
    5067            # If this function supports variable length argument treat the last argument as such.
    5068            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5069            num_non_var = len(non_var_len_arg_keys)
    5070
    5071            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5072            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5073        else:
    5074            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5075
    5076        return cls(**args_dict)

@classmethod
def sql_names(cls): View Source

    5078    @classmethod
    5079    def sql_names(cls):
    5080        if cls is Func:
    5081            raise NotImplementedError(
    5082                "SQL name is only supported by concrete function implementations"
    5083            )
    5084        if "_sql_names" not in cls.__dict__:
    5085            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5086        return cls._sql_names

@classmethod
def sql_name(cls): View Source

    5088    @classmethod
    5089    def sql_name(cls):
    5090        return cls.sql_names()[0]

@classmethod
def default_parser_mappings(cls): View Source

    5092    @classmethod
    5093    def default_parser_mappings(cls):
    5094        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

    5097class AggFunc(Func):
    5098    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

    5101class ParameterizedAgg(AggFunc):
    5102    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

    5105class Abs(Func):
    5106    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

    5109class ArgMax(AggFunc):
    5110    arg_types = {"this": True, "expression": True, "count": False}
    5111    _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

    5114class ArgMin(AggFunc):
    5115    arg_types = {"this": True, "expression": True, "count": False}
    5116    _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

    5119class ApproxTopK(AggFunc):
    5120    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

    5123class Flatten(Func):
    5124    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

    5128class Transform(Func):
    5129    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

    5132class Anonymous(Func):
    5133    arg_types = {"this": True, "expressions": False}
    5134    is_var_len_args = True
    5135
    5136    @property
    5137    def name(self) -> str:
    5138        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

    5136    @property
    5137    def name(self) -> str:
    5138        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

    5141class AnonymousAggFunc(AggFunc):
    5142    arg_types = {"this": True, "expressions": False}
    5143    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

    5147class CombinedAggFunc(AnonymousAggFunc):
    5148    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

    5151class CombinedParameterizedAgg(ParameterizedAgg):
    5152    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

    5157class Hll(AggFunc):
    5158    arg_types = {"this": True, "expressions": False}
    5159    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

    5162class ApproxDistinct(AggFunc):
    5163    arg_types = {"this": True, "accuracy": False}
    5164    _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

    5167class Apply(Func):
    5168    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

    5171class Array(Func):
    5172    arg_types = {"expressions": False, "bracket_notation": False}
    5173    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

    5177class ToArray(Func):
    5178    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

    5182class List(Func):
    5183    arg_types = {"expressions": False}
    5184    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

    5188class Pad(Func):
    5189    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

    5194class ToChar(Func):
    5195    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

    5200class ToNumber(Func):
    5201    arg_types = {
    5202        "this": True,
    5203        "format": False,
    5204        "nlsparam": False,
    5205        "precision": False,
    5206        "scale": False,
    5207    }

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 ToDouble(Func): View Source

    5211class ToDouble(Func):
    5212    arg_types = {
    5213        "this": True,
    5214        "format": False,
    5215    }

arg_types = {'this': True, 'format': False}
key = 'todouble'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  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

    5218class Columns(Func):
    5219    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

    5223class Convert(Func):
    5224    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

    5227class ConvertTimezone(Func):
    5228    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

    5231class GenerateSeries(Func):
    5232    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

    5238class ExplodingGenerateSeries(GenerateSeries):
    5239    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

    5242class ArrayAgg(AggFunc):
    5243    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

    5246class ArrayUniqueAgg(AggFunc):
    5247    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

    5250class ArrayAll(Func):
    5251    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

    5255class ArrayAny(Func):
    5256    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

    5259class ArrayConcat(Func):
    5260    _sql_names = ["ARRAY_CONCAT", "ARRAY_CAT"]
    5261    arg_types = {"this": True, "expressions": False}
    5262    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

    5265class ArrayConstructCompact(Func):
    5266    arg_types = {"expressions": True}
    5267    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

    5270class ArrayContains(Binary, Func):
    5271    _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

    5274class ArrayContainsAll(Binary, Func):
    5275    _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

    5278class ArrayFilter(Func):
    5279    arg_types = {"this": True, "expression": True}
    5280    _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

    5283class ArrayToString(Func):
    5284    arg_types = {"this": True, "expression": True, "null": False}
    5285    _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 String(Func): View Source

    5289class String(Func):
    5290    arg_types = {"this": True, "zone": False}

arg_types = {'this': True, 'zone': False}
key = 'string'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  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

    5293class StringToArray(Func):
    5294    arg_types = {"this": True, "expression": True, "null": False}
    5295    _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

    5298class ArrayOverlaps(Binary, Func):
    5299    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

    5302class ArraySize(Func):
    5303    arg_types = {"this": True, "expression": False}
    5304    _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

    5307class ArraySort(Func):
    5308    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

    5311class ArraySum(Func):
    5312    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

    5315class ArrayUnionAgg(AggFunc):
    5316    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

    5319class Avg(AggFunc):
    5320    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

    5323class AnyValue(AggFunc):
    5324    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

    5327class Lag(AggFunc):
    5328    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

    5331class Lead(AggFunc):
    5332    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

    5337class First(AggFunc):
    5338    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

    5341class Last(AggFunc):
    5342    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

    5345class FirstValue(AggFunc):
    5346    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

    5349class LastValue(AggFunc):
    5350    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

    5353class NthValue(AggFunc):
    5354    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

    5357class Case(Func):
    5358    arg_types = {"this": False, "ifs": True, "default": False}
    5359
    5360    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5361        instance = maybe_copy(self, copy)
    5362        instance.append(
    5363            "ifs",
    5364            If(
    5365                this=maybe_parse(condition, copy=copy, **opts),
    5366                true=maybe_parse(then, copy=copy, **opts),
    5367            ),
    5368        )
    5369        return instance
    5370
    5371    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5372        instance = maybe_copy(self, copy)
    5373        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5374        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

    5360    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5361        instance = maybe_copy(self, copy)
    5362        instance.append(
    5363            "ifs",
    5364            If(
    5365                this=maybe_parse(condition, copy=copy, **opts),
    5366                true=maybe_parse(then, copy=copy, **opts),
    5367            ),
    5368        )
    5369        return instance

def else_( self, condition: Union[str, Expression], copy: bool = True, **opts) -> Case: View Source

    5371    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5372        instance = maybe_copy(self, copy)
    5373        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5374        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

    5377class Cast(Func):
    5378    arg_types = {
    5379        "this": True,
    5380        "to": True,
    5381        "format": False,
    5382        "safe": False,
    5383        "action": False,
    5384    }
    5385
    5386    @property
    5387    def name(self) -> str:
    5388        return self.this.name
    5389
    5390    @property
    5391    def to(self) -> DataType:
    5392        return self.args["to"]
    5393
    5394    @property
    5395    def output_name(self) -> str:
    5396        return self.name
    5397
    5398    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5399        """
    5400        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5401        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5402        array<int> != array<float>.
    5403
    5404        Args:
    5405            dtypes: the data types to compare this Cast's DataType to.
    5406
    5407        Returns:
    5408            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5409        """
    5410        return self.to.is_type(*dtypes)

arg_types = {'this': True, 'to': True, 'format': False, 'safe': False, 'action': False}
name: str View Source

    5386    @property
    5387    def name(self) -> str:
    5388        return self.this.name

to: DataType View Source

    5390    @property
    5391    def to(self) -> DataType:
    5392        return self.args["to"]

output_name: str View Source

    5394    @property
    5395    def output_name(self) -> str:
    5396        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

    5398    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5399        """
    5400        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5401        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5402        array<int> != array<float>.
    5403
    5404        Args:
    5405            dtypes: the data types to compare this Cast's DataType to.
    5406
    5407        Returns:
    5408            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5409        """
    5410        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

    5413class TryCast(Cast):
    5414    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

    5417class Try(Func):
    5418    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

    5421class CastToStrType(Func):
    5422    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

    5425class Collate(Binary, Func):
    5426    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

    5429class Ceil(Func):
    5430    arg_types = {"this": True, "decimals": False}
    5431    _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

    5434class Coalesce(Func):
    5435    arg_types = {"this": True, "expressions": False, "is_nvl": False}
    5436    is_var_len_args = True
    5437    _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

    5440class Chr(Func):
    5441    arg_types = {"expressions": True, "charset": False}
    5442    is_var_len_args = True
    5443    _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

    5446class Concat(Func):
    5447    arg_types = {"expressions": True, "safe": False, "coalesce": False}
    5448    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

    5451class ConcatWs(Concat):
    5452    _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

    5456class ConnectByRoot(Func):
    5457    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

    5460class Count(AggFunc):
    5461    arg_types = {"this": False, "expressions": False, "big_int": False}
    5462    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

    5465class CountIf(AggFunc):
    5466    _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

    5470class Cbrt(Func):
    5471    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

    5474class CurrentDate(Func):
    5475    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

    5478class CurrentDatetime(Func):
    5479    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

    5482class CurrentTime(Func):
    5483    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

    5486class CurrentTimestamp(Func):
    5487    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

    5490class CurrentUser(Func):
    5491    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

    5494class DateAdd(Func, IntervalOp):
    5495    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

    5498class DateSub(Func, IntervalOp):
    5499    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

    5502class DateDiff(Func, TimeUnit):
    5503    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    5504    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

    5507class DateTrunc(Func):
    5508    arg_types = {"unit": True, "this": True, "zone": False}
    5509
    5510    def __init__(self, **args):
    5511        unit = args.get("unit")
    5512        if isinstance(unit, TimeUnit.VAR_LIKE):
    5513            args["unit"] = Literal.string(
    5514                (TimeUnit.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5515            )
    5516        elif isinstance(unit, Week):
    5517            unit.set("this", Literal.string(unit.this.name.upper()))
    5518
    5519        super().__init__(**args)
    5520
    5521    @property
    5522    def unit(self) -> Expression:
    5523        return self.args["unit"]

DateTrunc(**args) View Source

    5510    def __init__(self, **args):
    5511        unit = args.get("unit")
    5512        if isinstance(unit, TimeUnit.VAR_LIKE):
    5513            args["unit"] = Literal.string(
    5514                (TimeUnit.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5515            )
    5516        elif isinstance(unit, Week):
    5517            unit.set("this", Literal.string(unit.this.name.upper()))
    5518
    5519        super().__init__(**args)

arg_types = {'unit': True, 'this': True, 'zone': False}
unit: Expression View Source

    5521    @property
    5522    def unit(self) -> Expression:
    5523        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

    5528class Datetime(Func):
    5529    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

    5532class DatetimeAdd(Func, IntervalOp):
    5533    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

    5536class DatetimeSub(Func, IntervalOp):
    5537    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

    5540class DatetimeDiff(Func, TimeUnit):
    5541    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

    5544class DatetimeTrunc(Func, TimeUnit):
    5545    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

    5548class DayOfWeek(Func):
    5549    _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

    5554class DayOfWeekIso(Func):
    5555    _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

    5558class DayOfMonth(Func):
    5559    _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

    5562class DayOfYear(Func):
    5563    _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

    5566class ToDays(Func):
    5567    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

    5570class WeekOfYear(Func):
    5571    _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

    5574class MonthsBetween(Func):
    5575    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

    5578class LastDay(Func, TimeUnit):
    5579    _sql_names = ["LAST_DAY", "LAST_DAY_OF_MONTH"]
    5580    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

    5583class Extract(Func):
    5584    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

    5587class Timestamp(Func):
    5588    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

    5591class TimestampAdd(Func, TimeUnit):
    5592    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

    5595class TimestampSub(Func, TimeUnit):
    5596    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

    5599class TimestampDiff(Func, TimeUnit):
    5600    _sql_names = ["TIMESTAMPDIFF", "TIMESTAMP_DIFF"]
    5601    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

    5604class TimestampTrunc(Func, TimeUnit):
    5605    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

    5608class TimeAdd(Func, TimeUnit):
    5609    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

    5612class TimeSub(Func, TimeUnit):
    5613    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

    5616class TimeDiff(Func, TimeUnit):
    5617    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

    5620class TimeTrunc(Func, TimeUnit):
    5621    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

    5624class DateFromParts(Func):
    5625    _sql_names = ["DATE_FROM_PARTS", "DATEFROMPARTS"]
    5626    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

    5629class TimeFromParts(Func):
    5630    _sql_names = ["TIME_FROM_PARTS", "TIMEFROMPARTS"]
    5631    arg_types = {
    5632        "hour": True,
    5633        "min": True,
    5634        "sec": True,
    5635        "nano": False,
    5636        "fractions": False,
    5637        "precision": False,
    5638    }

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

    5641class DateStrToDate(Func):
    5642    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

    5645class DateToDateStr(Func):
    5646    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

    5649class DateToDi(Func):
    5650    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

    5654class Date(Func):
    5655    arg_types = {"this": False, "zone": False, "expressions": False}
    5656    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

    5659class Day(Func):
    5660    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

    5663class Decode(Func):
    5664    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

    5667class DiToDate(Func):
    5668    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

    5671class Encode(Func):
    5672    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

    5675class Exp(Func):
    5676    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

    5680class Explode(Func, UDTF):
    5681    arg_types = {"this": True, "expressions": False}
    5682    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

    5686class Inline(Func):
    5687    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

    5690class ExplodeOuter(Explode):
    5691    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

    5694class Posexplode(Explode):
    5695    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

    5698class PosexplodeOuter(Posexplode, ExplodeOuter):
    5699    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

    5702class Unnest(Func, UDTF):
    5703    arg_types = {
    5704        "expressions": True,
    5705        "alias": False,
    5706        "offset": False,
    5707        "explode_array": False,
    5708    }
    5709
    5710    @property
    5711    def selects(self) -> t.List[Expression]:
    5712        columns = super().selects
    5713        offset = self.args.get("offset")
    5714        if offset:
    5715            columns = columns + [to_identifier("offset") if offset is True else offset]
    5716        return columns

arg_types = {'expressions': True, 'alias': False, 'offset': False, 'explode_array': False}
selects: List[Expression] View Source

    5710    @property
    5711    def selects(self) -> t.List[Expression]:
    5712        columns = super().selects
    5713        offset = self.args.get("offset")
    5714        if offset:
    5715            columns = columns + [to_identifier("offset") if offset is True else offset]
    5716        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

    5719class Floor(Func):
    5720    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

    5723class FromBase64(Func):
    5724    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

    5727class ToBase64(Func):
    5728    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

    5732class FromISO8601Timestamp(Func):
    5733    _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

    5736class GapFill(Func):
    5737    arg_types = {
    5738        "this": True,
    5739        "ts_column": True,
    5740        "bucket_width": True,
    5741        "partitioning_columns": False,
    5742        "value_columns": False,
    5743        "origin": False,
    5744        "ignore_nulls": False,
    5745    }

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

    5749class GenerateDateArray(Func):
    5750    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

    5754class GenerateTimestampArray(Func):
    5755    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

    5758class Greatest(Func):
    5759    arg_types = {"this": True, "expressions": False}
    5760    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

    5763class GroupConcat(AggFunc):
    5764    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

    5767class Hex(Func):
    5768    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

    5771class LowerHex(Hex):
    5772    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

    5775class Xor(Connector, Func):
    5776    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

    5779class If(Func):
    5780    arg_types = {"this": True, "true": True, "false": False}
    5781    _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

    5784class Nullif(Func):
    5785    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

    5788class Initcap(Func):
    5789    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

    5792class IsNan(Func):
    5793    _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

    5796class IsInf(Func):
    5797    _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

    5801class JSON(Expression):
    5802    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

    5805class JSONPath(Expression):
    5806    arg_types = {"expressions": True, "escape": False}
    5807
    5808    @property
    5809    def output_name(self) -> str:
    5810        last_segment = self.expressions[-1].this
    5811        return last_segment if isinstance(last_segment, str) else ""

arg_types = {'expressions': True, 'escape': False}
output_name: str View Source

    5808    @property
    5809    def output_name(self) -> str:
    5810        last_segment = self.expressions[-1].this
    5811        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

    5814class JSONPathPart(Expression):
    5815    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

    5818class JSONPathFilter(JSONPathPart):
    5819    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

    5822class JSONPathKey(JSONPathPart):
    5823    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

    5826class JSONPathRecursive(JSONPathPart):
    5827    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

    5830class JSONPathRoot(JSONPathPart):
    5831    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

    5834class JSONPathScript(JSONPathPart):
    5835    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

    5838class JSONPathSlice(JSONPathPart):
    5839    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

    5842class JSONPathSelector(JSONPathPart):
    5843    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

    5846class JSONPathSubscript(JSONPathPart):
    5847    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

    5850class JSONPathUnion(JSONPathPart):
    5851    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

    5854class JSONPathWildcard(JSONPathPart):
    5855    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

    5858class FormatJson(Expression):
    5859    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

    5862class JSONKeyValue(Expression):
    5863    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

    5866class JSONObject(Func):
    5867    arg_types = {
    5868        "expressions": False,
    5869        "null_handling": False,
    5870        "unique_keys": False,
    5871        "return_type": False,
    5872        "encoding": False,
    5873    }

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

    5876class JSONObjectAgg(AggFunc):
    5877    arg_types = {
    5878        "expressions": False,
    5879        "null_handling": False,
    5880        "unique_keys": False,
    5881        "return_type": False,
    5882        "encoding": False,
    5883    }

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

    5887class JSONArray(Func):
    5888    arg_types = {
    5889        "expressions": True,
    5890        "null_handling": False,
    5891        "return_type": False,
    5892        "strict": False,
    5893    }

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

    5897class JSONArrayAgg(Func):
    5898    arg_types = {
    5899        "this": True,
    5900        "order": False,
    5901        "null_handling": False,
    5902        "return_type": False,
    5903        "strict": False,
    5904    }

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

    5907class JSONExists(Func):
    5908    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

    5913class JSONColumnDef(Expression):
    5914    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

    5917class JSONSchema(Expression):
    5918    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

    5922class JSONValue(Expression):
    5923    arg_types = {
    5924        "this": True,
    5925        "path": True,
    5926        "returning": False,
    5927        "on_condition": False,
    5928    }

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

    5932class JSONTable(Func):
    5933    arg_types = {
    5934        "this": True,
    5935        "schema": True,
    5936        "path": False,
    5937        "error_handling": False,
    5938        "empty_handling": False,
    5939    }

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

    5943class ObjectInsert(Func):
    5944    arg_types = {
    5945        "this": True,
    5946        "key": True,
    5947        "value": True,
    5948        "update_flag": False,
    5949    }

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

    5952class OpenJSONColumnDef(Expression):
    5953    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

    5956class OpenJSON(Func):
    5957    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

    5960class JSONBContains(Binary, Func):
    5961    _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

    5964class JSONExtract(Binary, Func):
    5965    arg_types = {
    5966        "this": True,
    5967        "expression": True,
    5968        "only_json_types": False,
    5969        "expressions": False,
    5970        "variant_extract": False,
    5971        "json_query": False,
    5972        "option": False,
    5973    }
    5974    _sql_names = ["JSON_EXTRACT"]
    5975    is_var_len_args = True
    5976
    5977    @property
    5978    def output_name(self) -> str:
    5979        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

    5977    @property
    5978    def output_name(self) -> str:
    5979        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

    5982class JSONExtractScalar(Binary, Func):
    5983    arg_types = {"this": True, "expression": True, "only_json_types": False, "expressions": False}
    5984    _sql_names = ["JSON_EXTRACT_SCALAR"]
    5985    is_var_len_args = True
    5986
    5987    @property
    5988    def output_name(self) -> str:
    5989        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

    5987    @property
    5988    def output_name(self) -> str:
    5989        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

    5992class JSONBExtract(Binary, Func):
    5993    _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

    5996class JSONBExtractScalar(Binary, Func):
    5997    _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

    6000class JSONFormat(Func):
    6001    arg_types = {"this": False, "options": False}
    6002    _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

    6006class JSONArrayContains(Binary, Predicate, Func):
    6007    _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

    6010class ParseJSON(Func):
    6011    # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
    6012    # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
    6013    _sql_names = ["PARSE_JSON", "JSON_PARSE"]
    6014    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

    6017class Least(Func):
    6018    arg_types = {"this": True, "expressions": False}
    6019    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

    6022class Left(Func):
    6023    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

    6026class Right(Func):
    6027    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

    6030class Length(Func):
    6031    arg_types = {"this": True, "binary": False}
    6032    _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

    6035class Levenshtein(Func):
    6036    arg_types = {
    6037        "this": True,
    6038        "expression": False,
    6039        "ins_cost": False,
    6040        "del_cost": False,
    6041        "sub_cost": False,
    6042        "max_dist": False,
    6043    }

arg_types = {'this': True, 'expression': False, 'ins_cost': False, 'del_cost': False, 'sub_cost': False, 'max_dist': 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

    6046class Ln(Func):
    6047    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

    6050class Log(Func):
    6051    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

    6054class LogicalOr(AggFunc):
    6055    _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

    6058class LogicalAnd(AggFunc):
    6059    _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

    6062class Lower(Func):
    6063    _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

    6066class Map(Func):
    6067    arg_types = {"keys": False, "values": False}
    6068
    6069    @property
    6070    def keys(self) -> t.List[Expression]:
    6071        keys = self.args.get("keys")
    6072        return keys.expressions if keys else []
    6073
    6074    @property
    6075    def values(self) -> t.List[Expression]:
    6076        values = self.args.get("values")
    6077        return values.expressions if values else []

arg_types = {'keys': False, 'values': False}
keys: List[Expression] View Source

    6069    @property
    6070    def keys(self) -> t.List[Expression]:
    6071        keys = self.args.get("keys")
    6072        return keys.expressions if keys else []

values: List[Expression] View Source

    6074    @property
    6075    def values(self) -> t.List[Expression]:
    6076        values = self.args.get("values")
    6077        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

    6081class ToMap(Func):
    6082    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

    6085class MapFromEntries(Func):
    6086    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

    6090class ScopeResolution(Expression):
    6091    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

    6094class Stream(Expression):
    6095    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

    6098class StarMap(Func):
    6099    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

    6102class VarMap(Func):
    6103    arg_types = {"keys": True, "values": True}
    6104    is_var_len_args = True
    6105
    6106    @property
    6107    def keys(self) -> t.List[Expression]:
    6108        return self.args["keys"].expressions
    6109
    6110    @property
    6111    def values(self) -> t.List[Expression]:
    6112        return self.args["values"].expressions

arg_types = {'keys': True, 'values': True}
is_var_len_args = True
keys: List[Expression] View Source

    6106    @property
    6107    def keys(self) -> t.List[Expression]:
    6108        return self.args["keys"].expressions

values: List[Expression] View Source

    6110    @property
    6111    def values(self) -> t.List[Expression]:
    6112        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

    6116class MatchAgainst(Func):
    6117    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

    6120class Max(AggFunc):
    6121    arg_types = {"this": True, "expressions": False}
    6122    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

    6125class MD5(Func):
    6126    _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

    6130class MD5Digest(Func):
    6131    _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

    6134class Min(AggFunc):
    6135    arg_types = {"this": True, "expressions": False}
    6136    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

    6139class Month(Func):
    6140    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

    6143class AddMonths(Func):
    6144    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

    6147class Nvl2(Func):
    6148    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

    6151class Normalize(Func):
    6152    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

    6155class Overlay(Func):
    6156    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

    6160class Predict(Func):
    6161    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

    6164class Pow(Binary, Func):
    6165    _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

    6168class PercentileCont(AggFunc):
    6169    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

    6172class PercentileDisc(AggFunc):
    6173    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

    6176class Quantile(AggFunc):
    6177    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

    6180class ApproxQuantile(Quantile):
    6181    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

    6184class Quarter(Func):
    6185    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

    6190class Rand(Func):
    6191    _sql_names = ["RAND", "RANDOM"]
    6192    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

    6195class Randn(Func):
    6196    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

    6199class RangeN(Func):
    6200    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

    6203class ReadCSV(Func):
    6204    _sql_names = ["READ_CSV"]
    6205    is_var_len_args = True
    6206    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

    6209class Reduce(Func):
    6210    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

    6213class RegexpExtract(Func):
    6214    arg_types = {
    6215        "this": True,
    6216        "expression": True,
    6217        "position": False,
    6218        "occurrence": False,
    6219        "parameters": False,
    6220        "group": False,
    6221    }

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

    6224class RegexpReplace(Func):
    6225    arg_types = {
    6226        "this": True,
    6227        "expression": True,
    6228        "replacement": False,
    6229        "position": False,
    6230        "occurrence": False,
    6231        "modifiers": False,
    6232    }

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

    6235class RegexpLike(Binary, Func):
    6236    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

    6239class RegexpILike(Binary, Func):
    6240    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

    6245class RegexpSplit(Func):
    6246    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

    6249class Repeat(Func):
    6250    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

    6255class Round(Func):
    6256    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

    6259class RowNumber(Func):
    6260    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

    6263class SafeDivide(Func):
    6264    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

    6267class SHA(Func):
    6268    _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

    6271class SHA2(Func):
    6272    _sql_names = ["SHA2"]
    6273    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

    6276class Sign(Func):
    6277    _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

    6280class SortArray(Func):
    6281    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

    6284class Split(Func):
    6285    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

    6289class SplitPart(Func):
    6290    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

    6295class Substring(Func):
    6296    _sql_names = ["SUBSTRING", "SUBSTR"]
    6297    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

    6300class StandardHash(Func):
    6301    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

    6304class StartsWith(Func):
    6305    _sql_names = ["STARTS_WITH", "STARTSWITH"]
    6306    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

    6309class StrPosition(Func):
    6310    arg_types = {
    6311        "this": True,
    6312        "substr": True,
    6313        "position": False,
    6314        "instance": False,
    6315    }

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

    6318class StrToDate(Func):
    6319    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

    6322class StrToTime(Func):
    6323    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

    6328class StrToUnix(Func):
    6329    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

    6334class StrToMap(Func):
    6335    arg_types = {
    6336        "this": True,
    6337        "pair_delim": False,
    6338        "key_value_delim": False,
    6339        "duplicate_resolution_callback": False,
    6340    }

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

    6343class NumberToStr(Func):
    6344    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

    6347class FromBase(Func):
    6348    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

    6351class Struct(Func):
    6352    arg_types = {"expressions": False}
    6353    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

    6356class StructExtract(Func):
    6357    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

    6362class Stuff(Func):
    6363    _sql_names = ["STUFF", "INSERT"]
    6364    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

    6367class Sum(AggFunc):
    6368    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

    6371class Sqrt(Func):
    6372    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

    6375class Stddev(AggFunc):
    6376    _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

    6379class StddevPop(AggFunc):
    6380    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

    6383class StddevSamp(AggFunc):
    6384    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

    6388class Time(Func):
    6389    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

    6392class TimeToStr(Func):
    6393    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

    6396class TimeToTimeStr(Func):
    6397    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

    6400class TimeToUnix(Func):
    6401    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

    6404class TimeStrToDate(Func):
    6405    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

    6408class TimeStrToTime(Func):
    6409    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

    6412class TimeStrToUnix(Func):
    6413    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

    6416class Trim(Func):
    6417    arg_types = {
    6418        "this": True,
    6419        "expression": False,
    6420        "position": False,
    6421        "collation": False,
    6422    }

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

    6425class TsOrDsAdd(Func, TimeUnit):
    6426    # return_type is used to correctly cast the arguments of this expression when transpiling it
    6427    arg_types = {"this": True, "expression": True, "unit": False, "return_type": False}
    6428
    6429    @property
    6430    def return_type(self) -> DataType:
    6431        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

    6429    @property
    6430    def return_type(self) -> DataType:
    6431        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

    6434class TsOrDsDiff(Func, TimeUnit):
    6435    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

    6438class TsOrDsToDateStr(Func):
    6439    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

    6442class TsOrDsToDate(Func):
    6443    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

    6446class TsOrDsToTime(Func):
    6447    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

    6450class TsOrDsToTimestamp(Func):
    6451    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

    6454class TsOrDiToDi(Func):
    6455    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

    6458class Unhex(Func):
    6459    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

    6463class UnixDate(Func):
    6464    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

    6467class UnixToStr(Func):
    6468    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

    6473class UnixToTime(Func):
    6474    arg_types = {
    6475        "this": True,
    6476        "scale": False,
    6477        "zone": False,
    6478        "hours": False,
    6479        "minutes": False,
    6480        "format": False,
    6481    }
    6482
    6483    SECONDS = Literal.number(0)
    6484    DECIS = Literal.number(1)
    6485    CENTIS = Literal.number(2)
    6486    MILLIS = Literal.number(3)
    6487    DECIMILLIS = Literal.number(4)
    6488    CENTIMILLIS = Literal.number(5)
    6489    MICROS = Literal.number(6)
    6490    DECIMICROS = Literal.number(7)
    6491    CENTIMICROS = Literal.number(8)
    6492    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

    6495class UnixToTimeStr(Func):
    6496    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

    6499class Uuid(Func):
    6500    _sql_names = ["UUID", "GEN_RANDOM_UUID", "GENERATE_UUID", "UUID_STRING"]
    6501
    6502    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

    6505class TimestampFromParts(Func):
    6506    _sql_names = ["TIMESTAMP_FROM_PARTS", "TIMESTAMPFROMPARTS"]
    6507    arg_types = {
    6508        "year": True,
    6509        "month": True,
    6510        "day": True,
    6511        "hour": True,
    6512        "min": True,
    6513        "sec": True,
    6514        "nano": False,
    6515        "zone": False,
    6516        "milli": False,
    6517    }

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

    6520class Upper(Func):
    6521    _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

    6524class Corr(Binary, AggFunc):
    6525    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

    6528class Variance(AggFunc):
    6529    _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

    6532class VariancePop(AggFunc):
    6533    _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

    6536class CovarSamp(Binary, AggFunc):
    6537    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

    6540class CovarPop(Binary, AggFunc):
    6541    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

    6544class Week(Func):
    6545    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

    6548class XMLTable(Func):
    6549    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

    6552class Year(Func):
    6553    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

    6556class Use(Expression):
    6557    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

    6560class Merge(DML):
    6561    arg_types = {
    6562        "this": True,
    6563        "using": True,
    6564        "on": True,
    6565        "expressions": True,
    6566        "with": False,
    6567        "returning": False,
    6568    }

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

    6571class When(Func):
    6572    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

    6577class NextValueFor(Func):
    6578    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

    6583class Semicolon(Expression):
    6584    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 'String'>, <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 'ToDouble'>, <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': <class 'String'>, '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_DOUBLE': <class 'ToDouble'>, '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

    6624def maybe_parse(
    6625    sql_or_expression: ExpOrStr,
    6626    *,
    6627    into: t.Optional[IntoType] = None,
    6628    dialect: DialectType = None,
    6629    prefix: t.Optional[str] = None,
    6630    copy: bool = False,
    6631    **opts,
    6632) -> Expression:
    6633    """Gracefully handle a possible string or expression.
    6634
    6635    Example:
    6636        >>> maybe_parse("1")
    6637        Literal(this=1, is_string=False)
    6638        >>> maybe_parse(to_identifier("x"))
    6639        Identifier(this=x, quoted=False)
    6640
    6641    Args:
    6642        sql_or_expression: the SQL code string or an expression
    6643        into: the SQLGlot Expression to parse into
    6644        dialect: the dialect used to parse the input expressions (in the case that an
    6645            input expression is a SQL string).
    6646        prefix: a string to prefix the sql with before it gets parsed
    6647            (automatically includes a space)
    6648        copy: whether to copy the expression.
    6649        **opts: other options to use to parse the input expressions (again, in the case
    6650            that an input expression is a SQL string).
    6651
    6652    Returns:
    6653        Expression: the parsed or given expression.
    6654    """
    6655    if isinstance(sql_or_expression, Expression):
    6656        if copy:
    6657            return sql_or_expression.copy()
    6658        return sql_or_expression
    6659
    6660    if sql_or_expression is None:
    6661        raise ParseError("SQL cannot be None")
    6662
    6663    import sqlglot
    6664
    6665    sql = str(sql_or_expression)
    6666    if prefix:
    6667        sql = f"{prefix} {sql}"
    6668
    6669    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

    6680def maybe_copy(instance, copy=True):
    6681    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

    6916def union(
    6917    *expressions: ExpOrStr,
    6918    distinct: bool = True,
    6919    dialect: DialectType = None,
    6920    copy: bool = True,
    6921    **opts,
    6922) -> Union:
    6923    """
    6924    Initializes a syntax tree for the `UNION` operation.
    6925
    6926    Example:
    6927        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6928        'SELECT * FROM foo UNION SELECT * FROM bla'
    6929
    6930    Args:
    6931        expressions: the SQL code strings, corresponding to the `UNION`'s operands.
    6932            If `Expression` instances are passed, they will be used as-is.
    6933        distinct: set the DISTINCT flag if and only if this is true.
    6934        dialect: the dialect used to parse the input expression.
    6935        copy: whether to copy the expression.
    6936        opts: other options to use to parse the input expressions.
    6937
    6938    Returns:
    6939        The new Union instance.
    6940    """
    6941    assert len(expressions) >= 2, "At least two expressions are required by `union`."
    6942    return _apply_set_operation(
    6943        *expressions, set_operation=Union, distinct=distinct, dialect=dialect, copy=copy, **opts
    6944    )

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

    6947def intersect(
    6948    *expressions: ExpOrStr,
    6949    distinct: bool = True,
    6950    dialect: DialectType = None,
    6951    copy: bool = True,
    6952    **opts,
    6953) -> Intersect:
    6954    """
    6955    Initializes a syntax tree for the `INTERSECT` operation.
    6956
    6957    Example:
    6958        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6959        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    6960
    6961    Args:
    6962        expressions: the SQL code strings, corresponding to the `INTERSECT`'s operands.
    6963            If `Expression` instances are passed, they will be used as-is.
    6964        distinct: set the DISTINCT flag if and only if this is true.
    6965        dialect: the dialect used to parse the input expression.
    6966        copy: whether to copy the expression.
    6967        opts: other options to use to parse the input expressions.
    6968
    6969    Returns:
    6970        The new Intersect instance.
    6971    """
    6972    assert len(expressions) >= 2, "At least two expressions are required by `intersect`."
    6973    return _apply_set_operation(
    6974        *expressions, set_operation=Intersect, distinct=distinct, dialect=dialect, copy=copy, **opts
    6975    )

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

    6978def except_(
    6979    *expressions: ExpOrStr,
    6980    distinct: bool = True,
    6981    dialect: DialectType = None,
    6982    copy: bool = True,
    6983    **opts,
    6984) -> Except:
    6985    """
    6986    Initializes a syntax tree for the `EXCEPT` operation.
    6987
    6988    Example:
    6989        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    6990        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    6991
    6992    Args:
    6993        expressions: the SQL code strings, corresponding to the `EXCEPT`'s operands.
    6994            If `Expression` instances are passed, they will be used as-is.
    6995        distinct: set the DISTINCT flag if and only if this is true.
    6996        dialect: the dialect used to parse the input expression.
    6997        copy: whether to copy the expression.
    6998        opts: other options to use to parse the input expressions.
    6999
    7000    Returns:
    7001        The new Except instance.
    7002    """
    7003    assert len(expressions) >= 2, "At least two expressions are required by `except_`."
    7004    return _apply_set_operation(
    7005        *expressions, set_operation=Except, distinct=distinct, dialect=dialect, copy=copy, **opts
    7006    )

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

    7009def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    7010    """
    7011    Initializes a syntax tree from one or multiple SELECT expressions.
    7012
    7013    Example:
    7014        >>> select("col1", "col2").from_("tbl").sql()
    7015        'SELECT col1, col2 FROM tbl'
    7016
    7017    Args:
    7018        *expressions: the SQL code string to parse as the expressions of a
    7019            SELECT statement. If an Expression instance is passed, this is used as-is.
    7020        dialect: the dialect used to parse the input expressions (in the case that an
    7021            input expression is a SQL string).
    7022        **opts: other options to use to parse the input expressions (again, in the case
    7023            that an input expression is a SQL string).
    7024
    7025    Returns:
    7026        Select: the syntax tree for the SELECT statement.
    7027    """
    7028    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

    7031def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    7032    """
    7033    Initializes a syntax tree from a FROM expression.
    7034
    7035    Example:
    7036        >>> from_("tbl").select("col1", "col2").sql()
    7037        'SELECT col1, col2 FROM tbl'
    7038
    7039    Args:
    7040        *expression: the SQL code string to parse as the FROM expressions of a
    7041            SELECT statement. If an Expression instance is passed, this is used as-is.
    7042        dialect: the dialect used to parse the input expression (in the case that the
    7043            input expression is a SQL string).
    7044        **opts: other options to use to parse the input expressions (again, in the case
    7045            that the input expression is a SQL string).
    7046
    7047    Returns:
    7048        Select: the syntax tree for the SELECT statement.
    7049    """
    7050    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

    7053def update(
    7054    table: str | Table,
    7055    properties: t.Optional[dict] = None,
    7056    where: t.Optional[ExpOrStr] = None,
    7057    from_: t.Optional[ExpOrStr] = None,
    7058    with_: t.Optional[t.Dict[str, ExpOrStr]] = None,
    7059    dialect: DialectType = None,
    7060    **opts,
    7061) -> Update:
    7062    """
    7063    Creates an update statement.
    7064
    7065    Example:
    7066        >>> 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()
    7067        "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"
    7068
    7069    Args:
    7070        properties: dictionary of properties to SET which are
    7071            auto converted to sql objects eg None -> NULL
    7072        where: sql conditional parsed into a WHERE statement
    7073        from_: sql statement parsed into a FROM statement
    7074        with_: dictionary of CTE aliases / select statements to include in a WITH clause.
    7075        dialect: the dialect used to parse the input expressions.
    7076        **opts: other options to use to parse the input expressions.
    7077
    7078    Returns:
    7079        Update: the syntax tree for the UPDATE statement.
    7080    """
    7081    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    7082    if properties:
    7083        update_expr.set(
    7084            "expressions",
    7085            [
    7086                EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    7087                for k, v in properties.items()
    7088            ],
    7089        )
    7090    if from_:
    7091        update_expr.set(
    7092            "from",
    7093            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    7094        )
    7095    if isinstance(where, Condition):
    7096        where = Where(this=where)
    7097    if where:
    7098        update_expr.set(
    7099            "where",
    7100            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    7101        )
    7102    if with_:
    7103        cte_list = [
    7104            alias_(CTE(this=maybe_parse(qry, dialect=dialect, **opts)), alias, table=True)
    7105            for alias, qry in with_.items()
    7106        ]
    7107        update_expr.set(
    7108            "with",
    7109            With(expressions=cte_list),
    7110        )
    7111    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

    7114def delete(
    7115    table: ExpOrStr,
    7116    where: t.Optional[ExpOrStr] = None,
    7117    returning: t.Optional[ExpOrStr] = None,
    7118    dialect: DialectType = None,
    7119    **opts,
    7120) -> Delete:
    7121    """
    7122    Builds a delete statement.
    7123
    7124    Example:
    7125        >>> delete("my_table", where="id > 1").sql()
    7126        'DELETE FROM my_table WHERE id > 1'
    7127
    7128    Args:
    7129        where: sql conditional parsed into a WHERE statement
    7130        returning: sql conditional parsed into a RETURNING statement
    7131        dialect: the dialect used to parse the input expressions.
    7132        **opts: other options to use to parse the input expressions.
    7133
    7134    Returns:
    7135        Delete: the syntax tree for the DELETE statement.
    7136    """
    7137    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    7138    if where:
    7139        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    7140    if returning:
    7141        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    7142    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

    7145def insert(
    7146    expression: ExpOrStr,
    7147    into: ExpOrStr,
    7148    columns: t.Optional[t.Sequence[str | Identifier]] = None,
    7149    overwrite: t.Optional[bool] = None,
    7150    returning: t.Optional[ExpOrStr] = None,
    7151    dialect: DialectType = None,
    7152    copy: bool = True,
    7153    **opts,
    7154) -> Insert:
    7155    """
    7156    Builds an INSERT statement.
    7157
    7158    Example:
    7159        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    7160        'INSERT INTO tbl VALUES (1, 2, 3)'
    7161
    7162    Args:
    7163        expression: the sql string or expression of the INSERT statement
    7164        into: the tbl to insert data to.
    7165        columns: optionally the table's column names.
    7166        overwrite: whether to INSERT OVERWRITE or not.
    7167        returning: sql conditional parsed into a RETURNING statement
    7168        dialect: the dialect used to parse the input expressions.
    7169        copy: whether to copy the expression.
    7170        **opts: other options to use to parse the input expressions.
    7171
    7172    Returns:
    7173        Insert: the syntax tree for the INSERT statement.
    7174    """
    7175    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7176    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    7177
    7178    if columns:
    7179        this = Schema(this=this, expressions=[to_identifier(c, copy=copy) for c in columns])
    7180
    7181    insert = Insert(this=this, expression=expr, overwrite=overwrite)
    7182
    7183    if returning:
    7184        insert = insert.returning(returning, dialect=dialect, copy=False, **opts)
    7185
    7186    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

    7189def merge(
    7190    *when_exprs: ExpOrStr,
    7191    into: ExpOrStr,
    7192    using: ExpOrStr,
    7193    on: ExpOrStr,
    7194    returning: t.Optional[ExpOrStr] = None,
    7195    dialect: DialectType = None,
    7196    copy: bool = True,
    7197    **opts,
    7198) -> Merge:
    7199    """
    7200    Builds a MERGE statement.
    7201
    7202    Example:
    7203        >>> merge("WHEN MATCHED THEN UPDATE SET col1 = source_table.col1",
    7204        ...       "WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)",
    7205        ...       into="my_table",
    7206        ...       using="source_table",
    7207        ...       on="my_table.id = source_table.id").sql()
    7208        '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)'
    7209
    7210    Args:
    7211        *when_exprs: The WHEN clauses specifying actions for matched and unmatched rows.
    7212        into: The target table to merge data into.
    7213        using: The source table to merge data from.
    7214        on: The join condition for the merge.
    7215        returning: The columns to return from the merge.
    7216        dialect: The dialect used to parse the input expressions.
    7217        copy: Whether to copy the expression.
    7218        **opts: Other options to use to parse the input expressions.
    7219
    7220    Returns:
    7221        Merge: The syntax tree for the MERGE statement.
    7222    """
    7223    merge = Merge(
    7224        this=maybe_parse(into, dialect=dialect, copy=copy, **opts),
    7225        using=maybe_parse(using, dialect=dialect, copy=copy, **opts),
    7226        on=maybe_parse(on, dialect=dialect, copy=copy, **opts),
    7227        expressions=[
    7228            maybe_parse(when_expr, dialect=dialect, copy=copy, into=When, **opts)
    7229            for when_expr in when_exprs
    7230        ],
    7231    )
    7232    if returning:
    7233        merge = merge.returning(returning, dialect=dialect, copy=False, **opts)
    7234
    7235    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

    7238def condition(
    7239    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    7240) -> Condition:
    7241    """
    7242    Initialize a logical condition expression.
    7243
    7244    Example:
    7245        >>> condition("x=1").sql()
    7246        'x = 1'
    7247
    7248        This is helpful for composing larger logical syntax trees:
    7249        >>> where = condition("x=1")
    7250        >>> where = where.and_("y=1")
    7251        >>> Select().from_("tbl").select("*").where(where).sql()
    7252        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    7253
    7254    Args:
    7255        *expression: the SQL code string to parse.
    7256            If an Expression instance is passed, this is used as-is.
    7257        dialect: the dialect used to parse the input expression (in the case that the
    7258            input expression is a SQL string).
    7259        copy: Whether to copy `expression` (only applies to expressions).
    7260        **opts: other options to use to parse the input expressions (again, in the case
    7261            that the input expression is a SQL string).
    7262
    7263    Returns:
    7264        The new Condition instance
    7265    """
    7266    return maybe_parse(
    7267        expression,
    7268        into=Condition,
    7269        dialect=dialect,
    7270        copy=copy,
    7271        **opts,
    7272    )

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

    7275def and_(
    7276    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7277) -> Condition:
    7278    """
    7279    Combine multiple conditions with an AND logical operator.
    7280
    7281    Example:
    7282        >>> and_("x=1", and_("y=1", "z=1")).sql()
    7283        'x = 1 AND (y = 1 AND z = 1)'
    7284
    7285    Args:
    7286        *expressions: the SQL code strings to parse.
    7287            If an Expression instance is passed, this is used as-is.
    7288        dialect: the dialect used to parse the input expression.
    7289        copy: whether to copy `expressions` (only applies to Expressions).
    7290        **opts: other options to use to parse the input expressions.
    7291
    7292    Returns:
    7293        The new condition
    7294    """
    7295    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

    7298def or_(
    7299    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7300) -> Condition:
    7301    """
    7302    Combine multiple conditions with an OR logical operator.
    7303
    7304    Example:
    7305        >>> or_("x=1", or_("y=1", "z=1")).sql()
    7306        'x = 1 OR (y = 1 OR z = 1)'
    7307
    7308    Args:
    7309        *expressions: the SQL code strings to parse.
    7310            If an Expression instance is passed, this is used as-is.
    7311        dialect: the dialect used to parse the input expression.
    7312        copy: whether to copy `expressions` (only applies to Expressions).
    7313        **opts: other options to use to parse the input expressions.
    7314
    7315    Returns:
    7316        The new condition
    7317    """
    7318    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

    7321def xor(
    7322    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    7323) -> Condition:
    7324    """
    7325    Combine multiple conditions with an XOR logical operator.
    7326
    7327    Example:
    7328        >>> xor("x=1", xor("y=1", "z=1")).sql()
    7329        'x = 1 XOR (y = 1 XOR z = 1)'
    7330
    7331    Args:
    7332        *expressions: the SQL code strings to parse.
    7333            If an Expression instance is passed, this is used as-is.
    7334        dialect: the dialect used to parse the input expression.
    7335        copy: whether to copy `expressions` (only applies to Expressions).
    7336        **opts: other options to use to parse the input expressions.
    7337
    7338    Returns:
    7339        The new condition
    7340    """
    7341    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

    7344def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    7345    """
    7346    Wrap a condition with a NOT operator.
    7347
    7348    Example:
    7349        >>> not_("this_suit='black'").sql()
    7350        "NOT this_suit = 'black'"
    7351
    7352    Args:
    7353        expression: the SQL code string to parse.
    7354            If an Expression instance is passed, this is used as-is.
    7355        dialect: the dialect used to parse the input expression.
    7356        copy: whether to copy the expression or not.
    7357        **opts: other options to use to parse the input expressions.
    7358
    7359    Returns:
    7360        The new condition.
    7361    """
    7362    this = condition(
    7363        expression,
    7364        dialect=dialect,
    7365        copy=copy,
    7366        **opts,
    7367    )
    7368    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

    7371def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    7372    """
    7373    Wrap an expression in parentheses.
    7374
    7375    Example:
    7376        >>> paren("5 + 3").sql()
    7377        '(5 + 3)'
    7378
    7379    Args:
    7380        expression: the SQL code string to parse.
    7381            If an Expression instance is passed, this is used as-is.
    7382        copy: whether to copy the expression or not.
    7383
    7384    Returns:
    7385        The wrapped expression.
    7386    """
    7387    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

    7403def to_identifier(name, quoted=None, copy=True):
    7404    """Builds an identifier.
    7405
    7406    Args:
    7407        name: The name to turn into an identifier.
    7408        quoted: Whether to force quote the identifier.
    7409        copy: Whether to copy name if it's an Identifier.
    7410
    7411    Returns:
    7412        The identifier ast node.
    7413    """
    7414
    7415    if name is None:
    7416        return None
    7417
    7418    if isinstance(name, Identifier):
    7419        identifier = maybe_copy(name, copy)
    7420    elif isinstance(name, str):
    7421        identifier = Identifier(
    7422            this=name,
    7423            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    7424        )
    7425    else:
    7426        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    7427    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

    7430def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Identifier:
    7431    """
    7432    Parses a given string into an identifier.
    7433
    7434    Args:
    7435        name: The name to parse into an identifier.
    7436        dialect: The dialect to parse against.
    7437
    7438    Returns:
    7439        The identifier ast node.
    7440    """
    7441    try:
    7442        expression = maybe_parse(name, dialect=dialect, into=Identifier)
    7443    except (ParseError, TokenError):
    7444        expression = to_identifier(name)
    7445
    7446    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

    7452def to_interval(interval: str | Literal) -> Interval:
    7453    """Builds an interval expression from a string like '1 day' or '5 months'."""
    7454    if isinstance(interval, Literal):
    7455        if not interval.is_string:
    7456            raise ValueError("Invalid interval string.")
    7457
    7458        interval = interval.this
    7459
    7460    interval = maybe_parse(f"INTERVAL {interval}")
    7461    assert isinstance(interval, Interval)
    7462    return interval

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

    7465def to_table(
    7466    sql_path: str | Table, dialect: DialectType = None, copy: bool = True, **kwargs
    7467) -> Table:
    7468    """
    7469    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    7470    If a table is passed in then that table is returned.
    7471
    7472    Args:
    7473        sql_path: a `[catalog].[schema].[table]` string.
    7474        dialect: the source dialect according to which the table name will be parsed.
    7475        copy: Whether to copy a table if it is passed in.
    7476        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    7477
    7478    Returns:
    7479        A table expression.
    7480    """
    7481    if isinstance(sql_path, Table):
    7482        return maybe_copy(sql_path, copy=copy)
    7483
    7484    table = maybe_parse(sql_path, into=Table, dialect=dialect)
    7485
    7486    for k, v in kwargs.items():
    7487        table.set(k, v)
    7488
    7489    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

    7492def to_column(
    7493    sql_path: str | Column,
    7494    quoted: t.Optional[bool] = None,
    7495    dialect: DialectType = None,
    7496    copy: bool = True,
    7497    **kwargs,
    7498) -> Column:
    7499    """
    7500    Create a column from a `[table].[column]` sql path. Table is optional.
    7501    If a column is passed in then that column is returned.
    7502
    7503    Args:
    7504        sql_path: a `[table].[column]` string.
    7505        quoted: Whether or not to force quote identifiers.
    7506        dialect: the source dialect according to which the column name will be parsed.
    7507        copy: Whether to copy a column if it is passed in.
    7508        kwargs: the kwargs to instantiate the resulting `Column` expression with.
    7509
    7510    Returns:
    7511        A column expression.
    7512    """
    7513    if isinstance(sql_path, Column):
    7514        return maybe_copy(sql_path, copy=copy)
    7515
    7516    try:
    7517        col = maybe_parse(sql_path, into=Column, dialect=dialect)
    7518    except ParseError:
    7519        return column(*reversed(sql_path.split(".")), quoted=quoted, **kwargs)
    7520
    7521    for k, v in kwargs.items():
    7522        col.set(k, v)
    7523
    7524    if quoted:
    7525        for i in col.find_all(Identifier):
    7526            i.set("quoted", True)
    7527
    7528    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

    7531def alias_(
    7532    expression: ExpOrStr,
    7533    alias: t.Optional[str | Identifier],
    7534    table: bool | t.Sequence[str | Identifier] = False,
    7535    quoted: t.Optional[bool] = None,
    7536    dialect: DialectType = None,
    7537    copy: bool = True,
    7538    **opts,
    7539):
    7540    """Create an Alias expression.
    7541
    7542    Example:
    7543        >>> alias_('foo', 'bar').sql()
    7544        'foo AS bar'
    7545
    7546        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    7547        '(SELECT 1, 2) AS bar(a, b)'
    7548
    7549    Args:
    7550        expression: the SQL code strings to parse.
    7551            If an Expression instance is passed, this is used as-is.
    7552        alias: the alias name to use. If the name has
    7553            special characters it is quoted.
    7554        table: Whether to create a table alias, can also be a list of columns.
    7555        quoted: whether to quote the alias
    7556        dialect: the dialect used to parse the input expression.
    7557        copy: Whether to copy the expression.
    7558        **opts: other options to use to parse the input expressions.
    7559
    7560    Returns:
    7561        Alias: the aliased expression
    7562    """
    7563    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7564    alias = to_identifier(alias, quoted=quoted)
    7565
    7566    if table:
    7567        table_alias = TableAlias(this=alias)
    7568        exp.set("alias", table_alias)
    7569
    7570        if not isinstance(table, bool):
    7571            for column in table:
    7572                table_alias.append("columns", to_identifier(column, quoted=quoted))
    7573
    7574        return exp
    7575
    7576    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    7577    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    7578    # for the complete Window expression.
    7579    #
    7580    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    7581
    7582    if "alias" in exp.arg_types and not isinstance(exp, Window):
    7583        exp.set("alias", alias)
    7584        return exp
    7585    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

    7588def subquery(
    7589    expression: ExpOrStr,
    7590    alias: t.Optional[Identifier | str] = None,
    7591    dialect: DialectType = None,
    7592    **opts,
    7593) -> Select:
    7594    """
    7595    Build a subquery expression that's selected from.
    7596
    7597    Example:
    7598        >>> subquery('select x from tbl', 'bar').select('x').sql()
    7599        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    7600
    7601    Args:
    7602        expression: the SQL code strings to parse.
    7603            If an Expression instance is passed, this is used as-is.
    7604        alias: the alias name to use.
    7605        dialect: the dialect used to parse the input expression.
    7606        **opts: other options to use to parse the input expressions.
    7607
    7608    Returns:
    7609        A new Select instance with the subquery expression included.
    7610    """
    7611
    7612    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias, **opts)
    7613    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

    7644def column(
    7645    col,
    7646    table=None,
    7647    db=None,
    7648    catalog=None,
    7649    *,
    7650    fields=None,
    7651    quoted=None,
    7652    copy=True,
    7653):
    7654    """
    7655    Build a Column.
    7656
    7657    Args:
    7658        col: Column name.
    7659        table: Table name.
    7660        db: Database name.
    7661        catalog: Catalog name.
    7662        fields: Additional fields using dots.
    7663        quoted: Whether to force quotes on the column's identifiers.
    7664        copy: Whether to copy identifiers if passed in.
    7665
    7666    Returns:
    7667        The new Column instance.
    7668    """
    7669    this = Column(
    7670        this=to_identifier(col, quoted=quoted, copy=copy),
    7671        table=to_identifier(table, quoted=quoted, copy=copy),
    7672        db=to_identifier(db, quoted=quoted, copy=copy),
    7673        catalog=to_identifier(catalog, quoted=quoted, copy=copy),
    7674    )
    7675
    7676    if fields:
    7677        this = Dot.build(
    7678            (this, *(to_identifier(field, quoted=quoted, copy=copy) for field in fields))
    7679        )
    7680    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

    7683def cast(
    7684    expression: ExpOrStr, to: DATA_TYPE, copy: bool = True, dialect: DialectType = None, **opts
    7685) -> Cast:
    7686    """Cast an expression to a data type.
    7687
    7688    Example:
    7689        >>> cast('x + 1', 'int').sql()
    7690        'CAST(x + 1 AS INT)'
    7691
    7692    Args:
    7693        expression: The expression to cast.
    7694        to: The datatype to cast to.
    7695        copy: Whether to copy the supplied expressions.
    7696        dialect: The target dialect. This is used to prevent a re-cast in the following scenario:
    7697            - The expression to be cast is already a exp.Cast expression
    7698            - The existing cast is to a type that is logically equivalent to new type
    7699
    7700            For example, if :expression='CAST(x as DATETIME)' and :to=Type.TIMESTAMP,
    7701            but in the target dialect DATETIME is mapped to TIMESTAMP, then we will NOT return `CAST(x (as DATETIME) as TIMESTAMP)`
    7702            and instead just return the original expression `CAST(x as DATETIME)`.
    7703
    7704            This is to prevent it being output as a double cast `CAST(x (as TIMESTAMP) as TIMESTAMP)` once the DATETIME -> TIMESTAMP
    7705            mapping is applied in the target dialect generator.
    7706
    7707    Returns:
    7708        The new Cast instance.
    7709    """
    7710    expr = maybe_parse(expression, copy=copy, dialect=dialect, **opts)
    7711    data_type = DataType.build(to, copy=copy, dialect=dialect, **opts)
    7712
    7713    # dont re-cast if the expression is already a cast to the correct type
    7714    if isinstance(expr, Cast):
    7715        from sqlglot.dialects.dialect import Dialect
    7716
    7717        target_dialect = Dialect.get_or_raise(dialect)
    7718        type_mapping = target_dialect.generator_class.TYPE_MAPPING
    7719
    7720        existing_cast_type: DataType.Type = expr.to.this
    7721        new_cast_type: DataType.Type = data_type.this
    7722        types_are_equivalent = type_mapping.get(
    7723            existing_cast_type, existing_cast_type
    7724        ) == type_mapping.get(new_cast_type, new_cast_type)
    7725        if expr.is_type(data_type) or types_are_equivalent:
    7726            return expr
    7727
    7728    expr = Cast(this=expr, to=data_type)
    7729    expr.type = data_type
    7730
    7731    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

    7734def table_(
    7735    table: Identifier | str,
    7736    db: t.Optional[Identifier | str] = None,
    7737    catalog: t.Optional[Identifier | str] = None,
    7738    quoted: t.Optional[bool] = None,
    7739    alias: t.Optional[Identifier | str] = None,
    7740) -> Table:
    7741    """Build a Table.
    7742
    7743    Args:
    7744        table: Table name.
    7745        db: Database name.
    7746        catalog: Catalog name.
    7747        quote: Whether to force quotes on the table's identifiers.
    7748        alias: Table's alias.
    7749
    7750    Returns:
    7751        The new Table instance.
    7752    """
    7753    return Table(
    7754        this=to_identifier(table, quoted=quoted) if table else None,
    7755        db=to_identifier(db, quoted=quoted) if db else None,
    7756        catalog=to_identifier(catalog, quoted=quoted) if catalog else None,
    7757        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    7758    )

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

    7761def values(
    7762    values: t.Iterable[t.Tuple[t.Any, ...]],
    7763    alias: t.Optional[str] = None,
    7764    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    7765) -> Values:
    7766    """Build VALUES statement.
    7767
    7768    Example:
    7769        >>> values([(1, '2')]).sql()
    7770        "VALUES (1, '2')"
    7771
    7772    Args:
    7773        values: values statements that will be converted to SQL
    7774        alias: optional alias
    7775        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    7776         If either are provided then an alias is also required.
    7777
    7778    Returns:
    7779        Values: the Values expression object
    7780    """
    7781    if columns and not alias:
    7782        raise ValueError("Alias is required when providing columns")
    7783
    7784    return Values(
    7785        expressions=[convert(tup) for tup in values],
    7786        alias=(
    7787            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    7788            if columns
    7789            else (TableAlias(this=to_identifier(alias)) if alias else None)
    7790        ),
    7791    )

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

    7794def var(name: t.Optional[ExpOrStr]) -> Var:
    7795    """Build a SQL variable.
    7796
    7797    Example:
    7798        >>> repr(var('x'))
    7799        'Var(this=x)'
    7800
    7801        >>> repr(var(column('x', table='y')))
    7802        'Var(this=x)'
    7803
    7804    Args:
    7805        name: The name of the var or an expression who's name will become the var.
    7806
    7807    Returns:
    7808        The new variable node.
    7809    """
    7810    if not name:
    7811        raise ValueError("Cannot convert empty name into var.")
    7812
    7813    if isinstance(name, Expression):
    7814        name = name.name
    7815    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

    7818def rename_table(
    7819    old_name: str | Table,
    7820    new_name: str | Table,
    7821    dialect: DialectType = None,
    7822) -> Alter:
    7823    """Build ALTER TABLE... RENAME... expression
    7824
    7825    Args:
    7826        old_name: The old name of the table
    7827        new_name: The new name of the table
    7828        dialect: The dialect to parse the table.
    7829
    7830    Returns:
    7831        Alter table expression
    7832    """
    7833    old_table = to_table(old_name, dialect=dialect)
    7834    new_table = to_table(new_name, dialect=dialect)
    7835    return Alter(
    7836        this=old_table,
    7837        kind="TABLE",
    7838        actions=[
    7839            AlterRename(this=new_table),
    7840        ],
    7841    )

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

    7844def rename_column(
    7845    table_name: str | Table,
    7846    old_column_name: str | Column,
    7847    new_column_name: str | Column,
    7848    exists: t.Optional[bool] = None,
    7849    dialect: DialectType = None,
    7850) -> Alter:
    7851    """Build ALTER TABLE... RENAME COLUMN... expression
    7852
    7853    Args:
    7854        table_name: Name of the table
    7855        old_column: The old name of the column
    7856        new_column: The new name of the column
    7857        exists: Whether to add the `IF EXISTS` clause
    7858        dialect: The dialect to parse the table/column.
    7859
    7860    Returns:
    7861        Alter table expression
    7862    """
    7863    table = to_table(table_name, dialect=dialect)
    7864    old_column = to_column(old_column_name, dialect=dialect)
    7865    new_column = to_column(new_column_name, dialect=dialect)
    7866    return Alter(
    7867        this=table,
    7868        kind="TABLE",
    7869        actions=[
    7870            RenameColumn(this=old_column, to=new_column, exists=exists),
    7871        ],
    7872    )

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

    7875def convert(value: t.Any, copy: bool = False) -> Expression:
    7876    """Convert a python value into an expression object.
    7877
    7878    Raises an error if a conversion is not possible.
    7879
    7880    Args:
    7881        value: A python object.
    7882        copy: Whether to copy `value` (only applies to Expressions and collections).
    7883
    7884    Returns:
    7885        The equivalent expression object.
    7886    """
    7887    if isinstance(value, Expression):
    7888        return maybe_copy(value, copy)
    7889    if isinstance(value, str):
    7890        return Literal.string(value)
    7891    if isinstance(value, bool):
    7892        return Boolean(this=value)
    7893    if value is None or (isinstance(value, float) and math.isnan(value)):
    7894        return null()
    7895    if isinstance(value, numbers.Number):
    7896        return Literal.number(value)
    7897    if isinstance(value, bytes):
    7898        return HexString(this=value.hex())
    7899    if isinstance(value, datetime.datetime):
    7900        datetime_literal = Literal.string(value.isoformat(sep=" "))
    7901
    7902        tz = None
    7903        if value.tzinfo:
    7904            # this works for zoneinfo.ZoneInfo, pytz.timezone and datetime.datetime.utc to return IANA timezone names like "America/Los_Angeles"
    7905            # instead of abbreviations like "PDT". This is for consistency with other timezone handling functions in SQLGlot
    7906            tz = Literal.string(str(value.tzinfo))
    7907
    7908        return TimeStrToTime(this=datetime_literal, zone=tz)
    7909    if isinstance(value, datetime.date):
    7910        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    7911        return DateStrToDate(this=date_literal)
    7912    if isinstance(value, tuple):
    7913        if hasattr(value, "_fields"):
    7914            return Struct(
    7915                expressions=[
    7916                    PropertyEQ(
    7917                        this=to_identifier(k), expression=convert(getattr(value, k), copy=copy)
    7918                    )
    7919                    for k in value._fields
    7920                ]
    7921            )
    7922        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    7923    if isinstance(value, list):
    7924        return Array(expressions=[convert(v, copy=copy) for v in value])
    7925    if isinstance(value, dict):
    7926        return Map(
    7927            keys=Array(expressions=[convert(k, copy=copy) for k in value]),
    7928            values=Array(expressions=[convert(v, copy=copy) for v in value.values()]),
    7929        )
    7930    if hasattr(value, "__dict__"):
    7931        return Struct(
    7932            expressions=[
    7933                PropertyEQ(this=to_identifier(k), expression=convert(v, copy=copy))
    7934                for k, v in value.__dict__.items()
    7935            ]
    7936        )
    7937    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

    7940def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    7941    """
    7942    Replace children of an expression with the result of a lambda fun(child) -> exp.
    7943    """
    7944    for k, v in tuple(expression.args.items()):
    7945        is_list_arg = type(v) is list
    7946
    7947        child_nodes = v if is_list_arg else [v]
    7948        new_child_nodes = []
    7949
    7950        for cn in child_nodes:
    7951            if isinstance(cn, Expression):
    7952                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    7953                    new_child_nodes.append(child_node)
    7954            else:
    7955                new_child_nodes.append(cn)
    7956
    7957        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

    7960def replace_tree(
    7961    expression: Expression,
    7962    fun: t.Callable,
    7963    prune: t.Optional[t.Callable[[Expression], bool]] = None,
    7964) -> Expression:
    7965    """
    7966    Replace an entire tree with the result of function calls on each node.
    7967
    7968    This will be traversed in reverse dfs, so leaves first.
    7969    If new nodes are created as a result of function calls, they will also be traversed.
    7970    """
    7971    stack = list(expression.dfs(prune=prune))
    7972
    7973    while stack:
    7974        node = stack.pop()
    7975        new_node = fun(node)
    7976
    7977        if new_node is not node:
    7978            node.replace(new_node)
    7979
    7980            if isinstance(new_node, Expression):
    7981                stack.append(new_node)
    7982
    7983    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

    7986def column_table_names(expression: Expression, exclude: str = "") -> t.Set[str]:
    7987    """
    7988    Return all table names referenced through columns in an expression.
    7989
    7990    Example:
    7991        >>> import sqlglot
    7992        >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
    7993        ['a', 'c']
    7994
    7995    Args:
    7996        expression: expression to find table names.
    7997        exclude: a table name to exclude
    7998
    7999    Returns:
    8000        A list of unique names.
    8001    """
    8002    return {
    8003        table
    8004        for table in (column.table for column in expression.find_all(Column))
    8005        if table and table != exclude
    8006    }

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

    8009def table_name(table: Table | str, dialect: DialectType = None, identify: bool = False) -> str:
    8010    """Get the full name of a table as a string.
    8011
    8012    Args:
    8013        table: Table expression node or string.
    8014        dialect: The dialect to generate the table name for.
    8015        identify: Determines when an identifier should be quoted. Possible values are:
    8016            False (default): Never quote, except in cases where it's mandatory by the dialect.
    8017            True: Always quote.
    8018
    8019    Examples:
    8020        >>> from sqlglot import exp, parse_one
    8021        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    8022        'a.b.c'
    8023
    8024    Returns:
    8025        The table name.
    8026    """
    8027
    8028    table = maybe_parse(table, into=Table, dialect=dialect)
    8029
    8030    if not table:
    8031        raise ValueError(f"Cannot parse {table}")
    8032
    8033    return ".".join(
    8034        (
    8035            part.sql(dialect=dialect, identify=True, copy=False)
    8036            if identify or not SAFE_IDENTIFIER_RE.match(part.name)
    8037            else part.name
    8038        )
    8039        for part in table.parts
    8040    )

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

    8043def normalize_table_name(table: str | Table, dialect: DialectType = None, copy: bool = True) -> str:
    8044    """Returns a case normalized table name without quotes.
    8045
    8046    Args:
    8047        table: the table to normalize
    8048        dialect: the dialect to use for normalization rules
    8049        copy: whether to copy the expression.
    8050
    8051    Examples:
    8052        >>> normalize_table_name("`A-B`.c", dialect="bigquery")
    8053        'A-B.c'
    8054    """
    8055    from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
    8056
    8057    return ".".join(
    8058        p.name
    8059        for p in normalize_identifiers(
    8060            to_table(table, dialect=dialect, copy=copy), dialect=dialect
    8061        ).parts
    8062    )

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

    8065def replace_tables(
    8066    expression: E, mapping: t.Dict[str, str], dialect: DialectType = None, copy: bool = True
    8067) -> E:
    8068    """Replace all tables in expression according to the mapping.
    8069
    8070    Args:
    8071        expression: expression node to be transformed and replaced.
    8072        mapping: mapping of table names.
    8073        dialect: the dialect of the mapping table
    8074        copy: whether to copy the expression.
    8075
    8076    Examples:
    8077        >>> from sqlglot import exp, parse_one
    8078        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    8079        'SELECT * FROM c /* a.b */'
    8080
    8081    Returns:
    8082        The mapped expression.
    8083    """
    8084
    8085    mapping = {normalize_table_name(k, dialect=dialect): v for k, v in mapping.items()}
    8086
    8087    def _replace_tables(node: Expression) -> Expression:
    8088        if isinstance(node, Table):
    8089            original = normalize_table_name(node, dialect=dialect)
    8090            new_name = mapping.get(original)
    8091
    8092            if new_name:
    8093                table = to_table(
    8094                    new_name,
    8095                    **{k: v for k, v in node.args.items() if k not in TABLE_PARTS},
    8096                    dialect=dialect,
    8097                )
    8098                table.add_comments([original])
    8099                return table
    8100        return node
    8101
    8102    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

    8105def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    8106    """Replace placeholders in an expression.
    8107
    8108    Args:
    8109        expression: expression node to be transformed and replaced.
    8110        args: positional names that will substitute unnamed placeholders in the given order.
    8111        kwargs: keyword arguments that will substitute named placeholders.
    8112
    8113    Examples:
    8114        >>> from sqlglot import exp, parse_one
    8115        >>> replace_placeholders(
    8116        ...     parse_one("select * from :tbl where ? = ?"),
    8117        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    8118        ... ).sql()
    8119        "SELECT * FROM foo WHERE str_col = 'b'"
    8120
    8121    Returns:
    8122        The mapped expression.
    8123    """
    8124
    8125    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    8126        if isinstance(node, Placeholder):
    8127            if node.this:
    8128                new_name = kwargs.get(node.this)
    8129                if new_name is not None:
    8130                    return convert(new_name)
    8131            else:
    8132                try:
    8133                    return convert(next(args))
    8134                except StopIteration:
    8135                    pass
    8136        return node
    8137
    8138    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

    8141def expand(
    8142    expression: Expression,
    8143    sources: t.Dict[str, Query],
    8144    dialect: DialectType = None,
    8145    copy: bool = True,
    8146) -> Expression:
    8147    """Transforms an expression by expanding all referenced sources into subqueries.
    8148
    8149    Examples:
    8150        >>> from sqlglot import parse_one
    8151        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    8152        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    8153
    8154        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    8155        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    8156
    8157    Args:
    8158        expression: The expression to expand.
    8159        sources: A dictionary of name to Queries.
    8160        dialect: The dialect of the sources dict.
    8161        copy: Whether to copy the expression during transformation. Defaults to True.
    8162
    8163    Returns:
    8164        The transformed expression.
    8165    """
    8166    sources = {normalize_table_name(k, dialect=dialect): v for k, v in sources.items()}
    8167
    8168    def _expand(node: Expression):
    8169        if isinstance(node, Table):
    8170            name = normalize_table_name(node, dialect=dialect)
    8171            source = sources.get(name)
    8172            if source:
    8173                subquery = source.subquery(node.alias or name)
    8174                subquery.comments = [f"source: {name}"]
    8175                return subquery.transform(_expand, copy=False)
    8176        return node
    8177
    8178    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

    8181def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwargs) -> Func:
    8182    """
    8183    Returns a Func expression.
    8184
    8185    Examples:
    8186        >>> func("abs", 5).sql()
    8187        'ABS(5)'
    8188
    8189        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    8190        'CAST(5 AS DOUBLE)'
    8191
    8192    Args:
    8193        name: the name of the function to build.
    8194        args: the args used to instantiate the function of interest.
    8195        copy: whether to copy the argument expressions.
    8196        dialect: the source dialect.
    8197        kwargs: the kwargs used to instantiate the function of interest.
    8198
    8199    Note:
    8200        The arguments `args` and `kwargs` are mutually exclusive.
    8201
    8202    Returns:
    8203        An instance of the function of interest, or an anonymous function, if `name` doesn't
    8204        correspond to an existing `sqlglot.expressions.Func` class.
    8205    """
    8206    if args and kwargs:
    8207        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    8208
    8209    from sqlglot.dialects.dialect import Dialect
    8210
    8211    dialect = Dialect.get_or_raise(dialect)
    8212
    8213    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect, copy=copy) for arg in args]
    8214    kwargs = {key: maybe_parse(value, dialect=dialect, copy=copy) for key, value in kwargs.items()}
    8215
    8216    constructor = dialect.parser_class.FUNCTIONS.get(name.upper())
    8217    if constructor:
    8218        if converted:
    8219            if "dialect" in constructor.__code__.co_varnames:
    8220                function = constructor(converted, dialect=dialect)
    8221            else:
    8222                function = constructor(converted)
    8223        elif constructor.__name__ == "from_arg_list":
    8224            function = constructor.__self__(**kwargs)  # type: ignore
    8225        else:
    8226            constructor = FUNCTION_BY_NAME.get(name.upper())
    8227            if constructor:
    8228                function = constructor(**kwargs)
    8229            else:
    8230                raise ValueError(
    8231                    f"Unable to convert '{name}' into a Func. Either manually construct "
    8232                    "the Func expression of interest or parse the function call."
    8233                )
    8234    else:
    8235        kwargs = kwargs or {"expressions": converted}
    8236        function = Anonymous(this=name, **kwargs)
    8237
    8238    for error_message in function.error_messages(converted):
    8239        raise ValueError(error_message)
    8240
    8241    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

    8244def case(
    8245    expression: t.Optional[ExpOrStr] = None,
    8246    **opts,
    8247) -> Case:
    8248    """
    8249    Initialize a CASE statement.
    8250
    8251    Example:
    8252        case().when("a = 1", "foo").else_("bar")
    8253
    8254    Args:
    8255        expression: Optionally, the input expression (not all dialects support this)
    8256        **opts: Extra keyword arguments for parsing `expression`
    8257    """
    8258    if expression is not None:
    8259        this = maybe_parse(expression, **opts)
    8260    else:
    8261        this = None
    8262    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

    8265def array(
    8266    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8267) -> Array:
    8268    """
    8269    Returns an array.
    8270
    8271    Examples:
    8272        >>> array(1, 'x').sql()
    8273        'ARRAY(1, x)'
    8274
    8275    Args:
    8276        expressions: the expressions to add to the array.
    8277        copy: whether to copy the argument expressions.
    8278        dialect: the source dialect.
    8279        kwargs: the kwargs used to instantiate the function of interest.
    8280
    8281    Returns:
    8282        An array expression.
    8283    """
    8284    return Array(
    8285        expressions=[
    8286            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8287            for expression in expressions
    8288        ]
    8289    )

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

    8292def tuple_(
    8293    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8294) -> Tuple:
    8295    """
    8296    Returns an tuple.
    8297
    8298    Examples:
    8299        >>> tuple_(1, 'x').sql()
    8300        '(1, x)'
    8301
    8302    Args:
    8303        expressions: the expressions to add to the tuple.
    8304        copy: whether to copy the argument expressions.
    8305        dialect: the source dialect.
    8306        kwargs: the kwargs used to instantiate the function of interest.
    8307
    8308    Returns:
    8309        A tuple expression.
    8310    """
    8311    return Tuple(
    8312        expressions=[
    8313            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8314            for expression in expressions
    8315        ]
    8316    )

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

    8319def true() -> Boolean:
    8320    """
    8321    Returns a true Boolean expression.
    8322    """
    8323    return Boolean(this=True)

Returns a true Boolean expression.

def false() -> Boolean: View Source

    8326def false() -> Boolean:
    8327    """
    8328    Returns a false Boolean expression.
    8329    """
    8330    return Boolean(this=False)

Returns a false Boolean expression.

def null() -> Null: View Source

    8333def null() -> Null:
    8334    """
    8335    Returns a Null expression.
    8336    """
    8337    return Null()

Returns a Null expression.

NONNULL_CONSTANTS = (<class 'Literal'>, <class 'Boolean'>)
CONSTANTS = (<class 'Literal'>, <class 'Boolean'>, <class 'Null'>)