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

SQLGLOT_META = 'sqlglot.meta'
SQLGLOT_ANONYMOUS = 'sqlglot.anonymous'
TABLE_PARTS = ('this', 'db', 'catalog')
COLUMN_PARTS = ('this', 'table', 'db', 'catalog')
POSITION_META_KEYS = ('line', 'col', 'start', 'end')
class Expression: View Source

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

    108    def __init__(self, **args: t.Any):
    109        self.args: t.Dict[str, t.Any] = args
    110        self.parent: t.Optional[Expression] = None
    111        self.arg_key: t.Optional[str] = None
    112        self.index: t.Optional[int] = None
    113        self.comments: t.Optional[t.List[str]] = None
    114        self._type: t.Optional[DataType] = None
    115        self._meta: t.Optional[t.Dict[str, t.Any]] = None
    116        self._hash: t.Optional[int] = None
    117
    118        for arg_key, value in self.args.items():
    119            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

    124    @property
    125    def hashable_args(self) -> t.Any:
    126        return frozenset(
    127            (k, tuple(_norm_arg(a) for a in v) if type(v) is list else _norm_arg(v))
    128            for k, v in self.args.items()
    129            if not (v is None or v is False or (type(v) is list and not v))
    130        )

this: Any View Source

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

Retrieves the argument with key "this".

expression: Any View Source

    145    @property
    146    def expression(self) -> t.Any:
    147        """
    148        Retrieves the argument with key "expression".
    149        """
    150        return self.args.get("expression")

Retrieves the argument with key "expression".

expressions: List[Any] View Source

    152    @property
    153    def expressions(self) -> t.List[t.Any]:
    154        """
    155        Retrieves the argument with key "expressions".
    156        """
    157        return self.args.get("expressions") or []

Retrieves the argument with key "expressions".

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

    159    def text(self, key) -> str:
    160        """
    161        Returns a textual representation of the argument corresponding to "key". This can only be used
    162        for args that are strings or leaf Expression instances, such as identifiers and literals.
    163        """
    164        field = self.args.get(key)
    165        if isinstance(field, str):
    166            return field
    167        if isinstance(field, (Identifier, Literal, Var)):
    168            return field.this
    169        if isinstance(field, (Star, Null)):
    170            return field.name
    171        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

    173    @property
    174    def is_string(self) -> bool:
    175        """
    176        Checks whether a Literal expression is a string.
    177        """
    178        return isinstance(self, Literal) and self.args["is_string"]

Checks whether a Literal expression is a string.

is_number: bool View Source

    180    @property
    181    def is_number(self) -> bool:
    182        """
    183        Checks whether a Literal expression is a number.
    184        """
    185        return (isinstance(self, Literal) and not self.args["is_string"]) or (
    186            isinstance(self, Neg) and self.this.is_number
    187        )

Checks whether a Literal expression is a number.

def to_py(self) -> Any: View Source

    189    def to_py(self) -> t.Any:
    190        """
    191        Returns a Python object equivalent of the SQL node.
    192        """
    193        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

    195    @property
    196    def is_int(self) -> bool:
    197        """
    198        Checks whether an expression is an integer.
    199        """
    200        return self.is_number and isinstance(self.to_py(), int)

Checks whether an expression is an integer.

is_star: bool View Source

    202    @property
    203    def is_star(self) -> bool:
    204        """Checks whether an expression is a star."""
    205        return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))

Checks whether an expression is a star.

alias: str View Source

    207    @property
    208    def alias(self) -> str:
    209        """
    210        Returns the alias of the expression, or an empty string if it's not aliased.
    211        """
    212        if isinstance(self.args.get("alias"), TableAlias):
    213            return self.args["alias"].name
    214        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

    216    @property
    217    def alias_column_names(self) -> t.List[str]:
    218        table_alias = self.args.get("alias")
    219        if not table_alias:
    220            return []
    221        return [c.name for c in table_alias.args.get("columns") or []]

name: str View Source

    223    @property
    224    def name(self) -> str:
    225        return self.text("this")

alias_or_name: str View Source

    227    @property
    228    def alias_or_name(self) -> str:
    229        return self.alias or self.name

output_name: str View Source

    231    @property
    232    def output_name(self) -> str:
    233        """
    234        Name of the output column if this expression is a selection.
    235
    236        If the Expression has no output name, an empty string is returned.
    237
    238        Example:
    239            >>> from sqlglot import parse_one
    240            >>> parse_one("SELECT a").expressions[0].output_name
    241            'a'
    242            >>> parse_one("SELECT b AS c").expressions[0].output_name
    243            'c'
    244            >>> parse_one("SELECT 1 + 2").expressions[0].output_name
    245            ''
    246        """
    247        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

    249    @property
    250    def type(self) -> t.Optional[DataType]:
    251        return self._type

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

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

def is_leaf(self) -> bool: View Source

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

meta: Dict[str, Any] View Source

    265    @property
    266    def meta(self) -> t.Dict[str, t.Any]:
    267        if self._meta is None:
    268            self._meta = {}
    269        return self._meta

def copy(self) -> typing_extensions.Self: View Source

    305    def copy(self) -> Self:
    306        """
    307        Returns a deep copy of the expression.
    308        """
    309        return deepcopy(self)

Returns a deep copy of the expression.

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

    311    def add_comments(self, comments: t.Optional[t.List[str]] = None, prepend: bool = False) -> None:
    312        if self.comments is None:
    313            self.comments = []
    314
    315        if comments:
    316            for comment in comments:
    317                _, *meta = comment.split(SQLGLOT_META)
    318                if meta:
    319                    for kv in "".join(meta).split(","):
    320                        k, *v = kv.split("=")
    321                        value = v[0].strip() if v else True
    322                        self.meta[k.strip()] = to_bool(value)
    323
    324                if not prepend:
    325                    self.comments.append(comment)
    326
    327            if prepend:
    328                self.comments = comments + self.comments

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

    330    def pop_comments(self) -> t.List[str]:
    331        comments = self.comments or []
    332        self.comments = None
    333        return comments

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

    335    def append(self, arg_key: str, value: t.Any) -> None:
    336        """
    337        Appends value to arg_key if it's a list or sets it as a new list.
    338
    339        Args:
    340            arg_key (str): name of the list expression arg
    341            value (Any): value to append to the list
    342        """
    343        if type(self.args.get(arg_key)) is not list:
    344            self.args[arg_key] = []
    345        self._set_parent(arg_key, value)
    346        values = self.args[arg_key]
    347        if hasattr(value, "parent"):
    348            value.index = len(values)
    349        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

    351    def set(
    352        self,
    353        arg_key: str,
    354        value: t.Any,
    355        index: t.Optional[int] = None,
    356        overwrite: bool = True,
    357    ) -> None:
    358        """
    359        Sets arg_key to value.
    360
    361        Args:
    362            arg_key: name of the expression arg.
    363            value: value to set the arg to.
    364            index: if the arg is a list, this specifies what position to add the value in it.
    365            overwrite: assuming an index is given, this determines whether to overwrite the
    366                list entry instead of only inserting a new value (i.e., like list.insert).
    367        """
    368        if index is not None:
    369            expressions = self.args.get(arg_key) or []
    370
    371            if seq_get(expressions, index) is None:
    372                return
    373            if value is None:
    374                expressions.pop(index)
    375                for v in expressions[index:]:
    376                    v.index = v.index - 1
    377                return
    378
    379            if isinstance(value, list):
    380                expressions.pop(index)
    381                expressions[index:index] = value
    382            elif overwrite:
    383                expressions[index] = value
    384            else:
    385                expressions.insert(index, value)
    386
    387            value = expressions
    388        elif value is None:
    389            self.args.pop(arg_key, None)
    390            return
    391
    392        self.args[arg_key] = value
    393        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

    407    @property
    408    def depth(self) -> int:
    409        """
    410        Returns the depth of this tree.
    411        """
    412        if self.parent:
    413            return self.parent.depth + 1
    414        return 0

Returns the depth of this tree.

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

    416    def iter_expressions(self, reverse: bool = False) -> t.Iterator[Expression]:
    417        """Yields the key and expression for all arguments, exploding list args."""
    418        for vs in reversed(self.args.values()) if reverse else self.args.values():  # type: ignore
    419            if type(vs) is list:
    420                for v in reversed(vs) if reverse else vs:  # type: ignore
    421                    if hasattr(v, "parent"):
    422                        yield v
    423            else:
    424                if hasattr(vs, "parent"):
    425                    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

    427    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
    428        """
    429        Returns the first node in this tree which matches at least one of
    430        the specified types.
    431
    432        Args:
    433            expression_types: the expression type(s) to match.
    434            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    435
    436        Returns:
    437            The node which matches the criteria or None if no such node was found.
    438        """
    439        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

    441    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
    442        """
    443        Returns a generator object which visits all nodes in this tree and only
    444        yields those that match at least one of the specified expression types.
    445
    446        Args:
    447            expression_types: the expression type(s) to match.
    448            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    449
    450        Returns:
    451            The generator object.
    452        """
    453        for expression in self.walk(bfs=bfs):
    454            if isinstance(expression, expression_types):
    455                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

    457    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
    458        """
    459        Returns a nearest parent matching expression_types.
    460
    461        Args:
    462            expression_types: the expression type(s) to match.
    463
    464        Returns:
    465            The parent node.
    466        """
    467        ancestor = self.parent
    468        while ancestor and not isinstance(ancestor, expression_types):
    469            ancestor = ancestor.parent
    470        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

    472    @property
    473    def parent_select(self) -> t.Optional[Select]:
    474        """
    475        Returns the parent select statement.
    476        """
    477        return self.find_ancestor(Select)

Returns the parent select statement.

same_parent: bool View Source

    479    @property
    480    def same_parent(self) -> bool:
    481        """Returns if the parent is the same class as itself."""
    482        return type(self.parent) is self.__class__

Returns if the parent is the same class as itself.

def root(self) -> Expression: View Source

    484    def root(self) -> Expression:
    485        """
    486        Returns the root expression of this tree.
    487        """
    488        expression = self
    489        while expression.parent:
    490            expression = expression.parent
    491        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

    493    def walk(
    494        self, bfs: bool = True, prune: t.Optional[t.Callable[[Expression], bool]] = None
    495    ) -> t.Iterator[Expression]:
    496        """
    497        Returns a generator object which visits all nodes in this tree.
    498
    499        Args:
    500            bfs: if set to True the BFS traversal order will be applied,
    501                otherwise the DFS traversal will be used instead.
    502            prune: callable that returns True if the generator should stop traversing
    503                this branch of the tree.
    504
    505        Returns:
    506            the generator object.
    507        """
    508        if bfs:
    509            yield from self.bfs(prune=prune)
    510        else:
    511            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

    513    def dfs(
    514        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
    515    ) -> t.Iterator[Expression]:
    516        """
    517        Returns a generator object which visits all nodes in this tree in
    518        the DFS (Depth-first) order.
    519
    520        Returns:
    521            The generator object.
    522        """
    523        stack = [self]
    524
    525        while stack:
    526            node = stack.pop()
    527
    528            yield node
    529
    530            if prune and prune(node):
    531                continue
    532
    533            for v in node.iter_expressions(reverse=True):
    534                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

    536    def bfs(
    537        self, prune: t.Optional[t.Callable[[Expression], bool]] = None
    538    ) -> t.Iterator[Expression]:
    539        """
    540        Returns a generator object which visits all nodes in this tree in
    541        the BFS (Breadth-first) order.
    542
    543        Returns:
    544            The generator object.
    545        """
    546        queue = deque([self])
    547
    548        while queue:
    549            node = queue.popleft()
    550
    551            yield node
    552
    553            if prune and prune(node):
    554                continue
    555
    556            for v in node.iter_expressions():
    557                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

    559    def unnest(self):
    560        """
    561        Returns the first non parenthesis child or self.
    562        """
    563        expression = self
    564        while type(expression) is Paren:
    565            expression = expression.this
    566        return expression

Returns the first non parenthesis child or self.

def unalias(self): View Source

    568    def unalias(self):
    569        """
    570        Returns the inner expression if this is an Alias.
    571        """
    572        if isinstance(self, Alias):
    573            return self.this
    574        return self

Returns the inner expression if this is an Alias.

def unnest_operands(self): View Source

    576    def unnest_operands(self):
    577        """
    578        Returns unnested operands as a tuple.
    579        """
    580        return tuple(arg.unnest() for arg in self.iter_expressions())

Returns unnested operands as a tuple.

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

    582    def flatten(self, unnest=True):
    583        """
    584        Returns a generator which yields child nodes whose parents are the same class.
    585
    586        A AND B AND C -> [A, B, C]
    587        """
    588        for node in self.dfs(prune=lambda n: n.parent and type(n) is not self.__class__):
    589            if type(node) is not self.__class__:
    590                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

    598    def to_s(self) -> str:
    599        """
    600        Same as __repr__, but includes additional information which can be useful
    601        for debugging, like empty or missing args and the AST nodes' object IDs.
    602        """
    603        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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> str: View Source

    605    def sql(self, dialect: DialectType = None, **opts) -> str:
    606        """
    607        Returns SQL string representation of this tree.
    608
    609        Args:
    610            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
    611            opts: other `sqlglot.generator.Generator` options.
    612
    613        Returns:
    614            The SQL string.
    615        """
    616        from sqlglot.dialects import Dialect
    617
    618        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

    620    def transform(self, fun: t.Callable, *args: t.Any, copy: bool = True, **kwargs) -> Expression:
    621        """
    622        Visits all tree nodes (excluding already transformed ones)
    623        and applies the given transformation function to each node.
    624
    625        Args:
    626            fun: a function which takes a node as an argument and returns a
    627                new transformed node or the same node without modifications. If the function
    628                returns None, then the corresponding node will be removed from the syntax tree.
    629            copy: if set to True a new tree instance is constructed, otherwise the tree is
    630                modified in place.
    631
    632        Returns:
    633            The transformed tree.
    634        """
    635        root = None
    636        new_node = None
    637
    638        for node in (self.copy() if copy else self).dfs(prune=lambda n: n is not new_node):
    639            parent, arg_key, index = node.parent, node.arg_key, node.index
    640            new_node = fun(node, *args, **kwargs)
    641
    642            if not root:
    643                root = new_node
    644            elif parent and arg_key and new_node is not node:
    645                parent.set(arg_key, new_node, index)
    646
    647        assert root
    648        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

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

    697    def pop(self: E) -> E:
    698        """
    699        Remove this expression from its AST.
    700
    701        Returns:
    702            The popped expression.
    703        """
    704        self.replace(None)
    705        return self

Remove this expression from its AST.

###### Returns:

> The popped expression.

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

    707    def assert_is(self, type_: t.Type[E]) -> E:
    708        """
    709        Assert that this `Expression` is an instance of `type_`.
    710
    711        If it is NOT an instance of `type_`, this raises an assertion error.
    712        Otherwise, this returns this expression.
    713
    714        Examples:
    715            This is useful for type security in chained expressions:
    716
    717            >>> import sqlglot
    718            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
    719            'SELECT x, z FROM y'
    720        """
    721        if not isinstance(self, type_):
    722            raise AssertionError(f"{self} is not {type_}.")
    723        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

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

    759    def dump(self):
    760        """
    761        Dump this Expression to a JSON-serializable dict.
    762        """
    763        from sqlglot.serde import dump
    764
    765        return dump(self)

Dump this Expression to a JSON-serializable dict.

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

    767    @classmethod
    768    def load(cls, obj):
    769        """
    770        Load a dict (as returned by `Expression.dump`) into an Expression instance.
    771        """
    772        from sqlglot.serde import load
    773
    774        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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, wrap: bool = True, **opts) -> Condition: View Source

    776    def and_(
    777        self,
    778        *expressions: t.Optional[ExpOrStr],
    779        dialect: DialectType = None,
    780        copy: bool = True,
    781        wrap: bool = True,
    782        **opts,
    783    ) -> Condition:
    784        """
    785        AND this condition with one or multiple expressions.
    786
    787        Example:
    788            >>> condition("x=1").and_("y=1").sql()
    789            'x = 1 AND y = 1'
    790
    791        Args:
    792            *expressions: the SQL code strings to parse.
    793                If an `Expression` instance is passed, it will be used as-is.
    794            dialect: the dialect used to parse the input expression.
    795            copy: whether to copy the involved expressions (only applies to Expressions).
    796            wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid
    797                precedence issues, but can be turned off when the produced AST is too deep and
    798                causes recursion-related issues.
    799            opts: other options to use to parse the input expressions.
    800
    801        Returns:
    802            The new And condition.
    803        """
    804        return and_(self, *expressions, dialect=dialect, copy=copy, wrap=wrap, **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).
- wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues.
- 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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, wrap: bool = True, **opts) -> Condition: View Source

    806    def or_(
    807        self,
    808        *expressions: t.Optional[ExpOrStr],
    809        dialect: DialectType = None,
    810        copy: bool = True,
    811        wrap: bool = True,
    812        **opts,
    813    ) -> Condition:
    814        """
    815        OR this condition with one or multiple expressions.
    816
    817        Example:
    818            >>> condition("x=1").or_("y=1").sql()
    819            'x = 1 OR y = 1'
    820
    821        Args:
    822            *expressions: the SQL code strings to parse.
    823                If an `Expression` instance is passed, it will be used as-is.
    824            dialect: the dialect used to parse the input expression.
    825            copy: whether to copy the involved expressions (only applies to Expressions).
    826            wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid
    827                precedence issues, but can be turned off when the produced AST is too deep and
    828                causes recursion-related issues.
    829            opts: other options to use to parse the input expressions.
    830
    831        Returns:
    832            The new Or condition.
    833        """
    834        return or_(self, *expressions, dialect=dialect, copy=copy, wrap=wrap, **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).
- wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues.
- opts: other options to use to parse the input expressions.

###### Returns:

> The new Or condition.

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

    836    def not_(self, copy: bool = True):
    837        """
    838        Wrap this condition with NOT.
    839
    840        Example:
    841            >>> condition("x=1").not_().sql()
    842            'NOT x = 1'
    843
    844        Args:
    845            copy: whether to copy this object.
    846
    847        Returns:
    848            The new Not instance.
    849        """
    850        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 update_positions( self: ~E, other: Union[sqlglot.tokens.Token, Expression, NoneType] = None, **kwargs: Any) -> ~E: View Source

    852    def update_positions(
    853        self: E, other: t.Optional[Token | Expression] = None, **kwargs: t.Any
    854    ) -> E:
    855        """
    856        Update this expression with positions from a token or other expression.
    857
    858        Args:
    859            other: a token or expression to update this expression with.
    860
    861        Returns:
    862            The updated expression.
    863        """
    864        if isinstance(other, Expression):
    865            self.meta.update({k: v for k, v in other.meta.items() if k in POSITION_META_KEYS})
    866        elif other is not None:
    867            self.meta.update(
    868                {
    869                    "line": other.line,
    870                    "col": other.col,
    871                    "start": other.start,
    872                    "end": other.end,
    873                }
    874            )
    875        self.meta.update({k: v for k, v in kwargs.items() if k in POSITION_META_KEYS})
    876        return self

Update this expression with positions from a token or other expression.

###### Arguments:

- other: a token or expression to update this expression with.

###### Returns:

> The updated expression.

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

    878    def as_(
    879        self,
    880        alias: str | Identifier,
    881        quoted: t.Optional[bool] = None,
    882        dialect: DialectType = None,
    883        copy: bool = True,
    884        **opts,
    885    ) -> Alias:
    886        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

    911    def isin(
    912        self,
    913        *expressions: t.Any,
    914        query: t.Optional[ExpOrStr] = None,
    915        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    916        copy: bool = True,
    917        **opts,
    918    ) -> In:
    919        subquery = maybe_parse(query, copy=copy, **opts) if query else None
    920        if subquery and not isinstance(subquery, Subquery):
    921            subquery = subquery.subquery(copy=False)
    922
    923        return In(
    924            this=maybe_copy(self, copy),
    925            expressions=[convert(e, copy=copy) for e in expressions],
    926            query=subquery,
    927            unnest=(
    928                Unnest(
    929                    expressions=[
    930                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    931                        for e in ensure_list(unnest)
    932                    ]
    933                )
    934                if unnest
    935                else None
    936            ),
    937        )

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

    939    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
    940        return Between(
    941            this=maybe_copy(self, copy),
    942            low=convert(low, copy=copy, **opts),
    943            high=convert(high, copy=copy, **opts),
    944        )

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

    946    def is_(self, other: ExpOrStr) -> Is:
    947        return self._binop(Is, other)

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

    949    def like(self, other: ExpOrStr) -> Like:
    950        return self._binop(Like, other)

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

    952    def ilike(self, other: ExpOrStr) -> ILike:
    953        return self._binop(ILike, other)

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

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

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

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

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

    961    def rlike(self, other: ExpOrStr) -> RegexpLike:
    962        return self._binop(RegexpLike, other)

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

    964    def div(self, other: ExpOrStr, typed: bool = False, safe: bool = False) -> Div:
    965        div = self._binop(Div, other)
    966        div.args["typed"] = typed
    967        div.args["safe"] = safe
    968        return div

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

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

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

    973    def desc(self, nulls_first: bool = False) -> Ordered:
    974        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

    1057class Condition(Expression):
    1058    """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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Predicate(Condition): View Source

    1061class Predicate(Condition):
    1062    """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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DerivedTable(Expression): View Source

    1065class DerivedTable(Expression):
    1066    @property
    1067    def selects(self) -> t.List[Expression]:
    1068        return self.this.selects if isinstance(self.this, Query) else []
    1069
    1070    @property
    1071    def named_selects(self) -> t.List[str]:
    1072        return [select.output_name for select in self.selects]

selects: List[Expression] View Source

    1066    @property
    1067    def selects(self) -> t.List[Expression]:
    1068        return self.this.selects if isinstance(self.this, Query) else []

named_selects: List[str] View Source

    1070    @property
    1071    def named_selects(self) -> t.List[str]:
    1072        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Query(Expression): View Source

    1075class Query(Expression):
    1076    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    1077        """
    1078        Returns a `Subquery` that wraps around this query.
    1079
    1080        Example:
    1081            >>> subquery = Select().select("x").from_("tbl").subquery()
    1082            >>> Select().select("x").from_(subquery).sql()
    1083            'SELECT x FROM (SELECT x FROM tbl)'
    1084
    1085        Args:
    1086            alias: an optional alias for the subquery.
    1087            copy: if `False`, modify this expression instance in-place.
    1088        """
    1089        instance = maybe_copy(self, copy)
    1090        if not isinstance(alias, Expression):
    1091            alias = TableAlias(this=to_identifier(alias)) if alias else None
    1092
    1093        return Subquery(this=instance, alias=alias)
    1094
    1095    def limit(
    1096        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1097    ) -> Q:
    1098        """
    1099        Adds a LIMIT clause to this query.
    1100
    1101        Example:
    1102            >>> select("1").union(select("1")).limit(1).sql()
    1103            'SELECT 1 UNION SELECT 1 LIMIT 1'
    1104
    1105        Args:
    1106            expression: the SQL code string to parse.
    1107                This can also be an integer.
    1108                If a `Limit` instance is passed, it will be used as-is.
    1109                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    1110            dialect: the dialect used to parse the input expression.
    1111            copy: if `False`, modify this expression instance in-place.
    1112            opts: other options to use to parse the input expressions.
    1113
    1114        Returns:
    1115            A limited Select expression.
    1116        """
    1117        return _apply_builder(
    1118            expression=expression,
    1119            instance=self,
    1120            arg="limit",
    1121            into=Limit,
    1122            prefix="LIMIT",
    1123            dialect=dialect,
    1124            copy=copy,
    1125            into_arg="expression",
    1126            **opts,
    1127        )
    1128
    1129    def offset(
    1130        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1131    ) -> Q:
    1132        """
    1133        Set the OFFSET expression.
    1134
    1135        Example:
    1136            >>> Select().from_("tbl").select("x").offset(10).sql()
    1137            'SELECT x FROM tbl OFFSET 10'
    1138
    1139        Args:
    1140            expression: the SQL code string to parse.
    1141                This can also be an integer.
    1142                If a `Offset` instance is passed, this is used as-is.
    1143                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    1144            dialect: the dialect used to parse the input expression.
    1145            copy: if `False`, modify this expression instance in-place.
    1146            opts: other options to use to parse the input expressions.
    1147
    1148        Returns:
    1149            The modified Select expression.
    1150        """
    1151        return _apply_builder(
    1152            expression=expression,
    1153            instance=self,
    1154            arg="offset",
    1155            into=Offset,
    1156            prefix="OFFSET",
    1157            dialect=dialect,
    1158            copy=copy,
    1159            into_arg="expression",
    1160            **opts,
    1161        )
    1162
    1163    def order_by(
    1164        self: Q,
    1165        *expressions: t.Optional[ExpOrStr],
    1166        append: bool = True,
    1167        dialect: DialectType = None,
    1168        copy: bool = True,
    1169        **opts,
    1170    ) -> Q:
    1171        """
    1172        Set the ORDER BY expression.
    1173
    1174        Example:
    1175            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    1176            'SELECT x FROM tbl ORDER BY x DESC'
    1177
    1178        Args:
    1179            *expressions: the SQL code strings to parse.
    1180                If a `Group` instance is passed, this is used as-is.
    1181                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    1182            append: if `True`, add to any existing expressions.
    1183                Otherwise, this flattens all the `Order` expression into a single expression.
    1184            dialect: the dialect used to parse the input expression.
    1185            copy: if `False`, modify this expression instance in-place.
    1186            opts: other options to use to parse the input expressions.
    1187
    1188        Returns:
    1189            The modified Select expression.
    1190        """
    1191        return _apply_child_list_builder(
    1192            *expressions,
    1193            instance=self,
    1194            arg="order",
    1195            append=append,
    1196            copy=copy,
    1197            prefix="ORDER BY",
    1198            into=Order,
    1199            dialect=dialect,
    1200            **opts,
    1201        )
    1202
    1203    @property
    1204    def ctes(self) -> t.List[CTE]:
    1205        """Returns a list of all the CTEs attached to this query."""
    1206        with_ = self.args.get("with")
    1207        return with_.expressions if with_ else []
    1208
    1209    @property
    1210    def selects(self) -> t.List[Expression]:
    1211        """Returns the query's projections."""
    1212        raise NotImplementedError("Query objects must implement `selects`")
    1213
    1214    @property
    1215    def named_selects(self) -> t.List[str]:
    1216        """Returns the output names of the query's projections."""
    1217        raise NotImplementedError("Query objects must implement `named_selects`")
    1218
    1219    def select(
    1220        self: Q,
    1221        *expressions: t.Optional[ExpOrStr],
    1222        append: bool = True,
    1223        dialect: DialectType = None,
    1224        copy: bool = True,
    1225        **opts,
    1226    ) -> Q:
    1227        """
    1228        Append to or set the SELECT expressions.
    1229
    1230        Example:
    1231            >>> Select().select("x", "y").sql()
    1232            'SELECT x, y'
    1233
    1234        Args:
    1235            *expressions: the SQL code strings to parse.
    1236                If an `Expression` instance is passed, it will be used as-is.
    1237            append: if `True`, add to any existing expressions.
    1238                Otherwise, this resets the expressions.
    1239            dialect: the dialect used to parse the input expressions.
    1240            copy: if `False`, modify this expression instance in-place.
    1241            opts: other options to use to parse the input expressions.
    1242
    1243        Returns:
    1244            The modified Query expression.
    1245        """
    1246        raise NotImplementedError("Query objects must implement `select`")
    1247
    1248    def where(
    1249        self: Q,
    1250        *expressions: t.Optional[ExpOrStr],
    1251        append: bool = True,
    1252        dialect: DialectType = None,
    1253        copy: bool = True,
    1254        **opts,
    1255    ) -> Q:
    1256        """
    1257        Append to or set the WHERE expressions.
    1258
    1259        Examples:
    1260            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    1261            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    1262
    1263        Args:
    1264            *expressions: the SQL code strings to parse.
    1265                If an `Expression` instance is passed, it will be used as-is.
    1266                Multiple expressions are combined with an AND operator.
    1267            append: if `True`, AND the new expressions to any existing expression.
    1268                Otherwise, this resets the expression.
    1269            dialect: the dialect used to parse the input expressions.
    1270            copy: if `False`, modify this expression instance in-place.
    1271            opts: other options to use to parse the input expressions.
    1272
    1273        Returns:
    1274            The modified expression.
    1275        """
    1276        return _apply_conjunction_builder(
    1277            *[expr.this if isinstance(expr, Where) else expr for expr in expressions],
    1278            instance=self,
    1279            arg="where",
    1280            append=append,
    1281            into=Where,
    1282            dialect=dialect,
    1283            copy=copy,
    1284            **opts,
    1285        )
    1286
    1287    def with_(
    1288        self: Q,
    1289        alias: ExpOrStr,
    1290        as_: ExpOrStr,
    1291        recursive: t.Optional[bool] = None,
    1292        materialized: t.Optional[bool] = None,
    1293        append: bool = True,
    1294        dialect: DialectType = None,
    1295        copy: bool = True,
    1296        scalar: bool = False,
    1297        **opts,
    1298    ) -> Q:
    1299        """
    1300        Append to or set the common table expressions.
    1301
    1302        Example:
    1303            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    1304            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    1305
    1306        Args:
    1307            alias: the SQL code string to parse as the table name.
    1308                If an `Expression` instance is passed, this is used as-is.
    1309            as_: the SQL code string to parse as the table expression.
    1310                If an `Expression` instance is passed, it will be used as-is.
    1311            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1312            materialized: set the MATERIALIZED part of the expression.
    1313            append: if `True`, add to any existing expressions.
    1314                Otherwise, this resets the expressions.
    1315            dialect: the dialect used to parse the input expression.
    1316            copy: if `False`, modify this expression instance in-place.
    1317            scalar: if `True`, this is a scalar common table expression.
    1318            opts: other options to use to parse the input expressions.
    1319
    1320        Returns:
    1321            The modified expression.
    1322        """
    1323        return _apply_cte_builder(
    1324            self,
    1325            alias,
    1326            as_,
    1327            recursive=recursive,
    1328            materialized=materialized,
    1329            append=append,
    1330            dialect=dialect,
    1331            copy=copy,
    1332            scalar=scalar,
    1333            **opts,
    1334        )
    1335
    1336    def union(
    1337        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1338    ) -> Union:
    1339        """
    1340        Builds a UNION expression.
    1341
    1342        Example:
    1343            >>> import sqlglot
    1344            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    1345            'SELECT * FROM foo UNION SELECT * FROM bla'
    1346
    1347        Args:
    1348            expressions: the SQL code strings.
    1349                If `Expression` instances are passed, they will be used as-is.
    1350            distinct: set the DISTINCT flag if and only if this is true.
    1351            dialect: the dialect used to parse the input expression.
    1352            opts: other options to use to parse the input expressions.
    1353
    1354        Returns:
    1355            The new Union expression.
    1356        """
    1357        return union(self, *expressions, distinct=distinct, dialect=dialect, **opts)
    1358
    1359    def intersect(
    1360        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1361    ) -> Intersect:
    1362        """
    1363        Builds an INTERSECT expression.
    1364
    1365        Example:
    1366            >>> import sqlglot
    1367            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    1368            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    1369
    1370        Args:
    1371            expressions: the SQL code strings.
    1372                If `Expression` instances are passed, they will be used as-is.
    1373            distinct: set the DISTINCT flag if and only if this is true.
    1374            dialect: the dialect used to parse the input expression.
    1375            opts: other options to use to parse the input expressions.
    1376
    1377        Returns:
    1378            The new Intersect expression.
    1379        """
    1380        return intersect(self, *expressions, distinct=distinct, dialect=dialect, **opts)
    1381
    1382    def except_(
    1383        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1384    ) -> Except:
    1385        """
    1386        Builds an EXCEPT expression.
    1387
    1388        Example:
    1389            >>> import sqlglot
    1390            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    1391            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    1392
    1393        Args:
    1394            expressions: the SQL code strings.
    1395                If `Expression` instance are passed, they will be used as-is.
    1396            distinct: set the DISTINCT flag if and only if this is true.
    1397            dialect: the dialect used to parse the input expression.
    1398            opts: other options to use to parse the input expressions.
    1399
    1400        Returns:
    1401            The new Except expression.
    1402        """
    1403        return except_(self, *expressions, distinct=distinct, dialect=dialect, **opts)

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

    1076    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    1077        """
    1078        Returns a `Subquery` that wraps around this query.
    1079
    1080        Example:
    1081            >>> subquery = Select().select("x").from_("tbl").subquery()
    1082            >>> Select().select("x").from_(subquery).sql()
    1083            'SELECT x FROM (SELECT x FROM tbl)'
    1084
    1085        Args:
    1086            alias: an optional alias for the subquery.
    1087            copy: if `False`, modify this expression instance in-place.
    1088        """
    1089        instance = maybe_copy(self, copy)
    1090        if not isinstance(alias, Expression):
    1091            alias = TableAlias(this=to_identifier(alias)) if alias else None
    1092
    1093        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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1095    def limit(
    1096        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1097    ) -> Q:
    1098        """
    1099        Adds a LIMIT clause to this query.
    1100
    1101        Example:
    1102            >>> select("1").union(select("1")).limit(1).sql()
    1103            'SELECT 1 UNION SELECT 1 LIMIT 1'
    1104
    1105        Args:
    1106            expression: the SQL code string to parse.
    1107                This can also be an integer.
    1108                If a `Limit` instance is passed, it will be used as-is.
    1109                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    1110            dialect: the dialect used to parse the input expression.
    1111            copy: if `False`, modify this expression instance in-place.
    1112            opts: other options to use to parse the input expressions.
    1113
    1114        Returns:
    1115            A limited Select expression.
    1116        """
    1117        return _apply_builder(
    1118            expression=expression,
    1119            instance=self,
    1120            arg="limit",
    1121            into=Limit,
    1122            prefix="LIMIT",
    1123            dialect=dialect,
    1124            copy=copy,
    1125            into_arg="expression",
    1126            **opts,
    1127        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1129    def offset(
    1130        self: Q, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    1131    ) -> Q:
    1132        """
    1133        Set the OFFSET expression.
    1134
    1135        Example:
    1136            >>> Select().from_("tbl").select("x").offset(10).sql()
    1137            'SELECT x FROM tbl OFFSET 10'
    1138
    1139        Args:
    1140            expression: the SQL code string to parse.
    1141                This can also be an integer.
    1142                If a `Offset` instance is passed, this is used as-is.
    1143                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    1144            dialect: the dialect used to parse the input expression.
    1145            copy: if `False`, modify this expression instance in-place.
    1146            opts: other options to use to parse the input expressions.
    1147
    1148        Returns:
    1149            The modified Select expression.
    1150        """
    1151        return _apply_builder(
    1152            expression=expression,
    1153            instance=self,
    1154            arg="offset",
    1155            into=Offset,
    1156            prefix="OFFSET",
    1157            dialect=dialect,
    1158            copy=copy,
    1159            into_arg="expression",
    1160            **opts,
    1161        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1163    def order_by(
    1164        self: Q,
    1165        *expressions: t.Optional[ExpOrStr],
    1166        append: bool = True,
    1167        dialect: DialectType = None,
    1168        copy: bool = True,
    1169        **opts,
    1170    ) -> Q:
    1171        """
    1172        Set the ORDER BY expression.
    1173
    1174        Example:
    1175            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    1176            'SELECT x FROM tbl ORDER BY x DESC'
    1177
    1178        Args:
    1179            *expressions: the SQL code strings to parse.
    1180                If a `Group` instance is passed, this is used as-is.
    1181                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    1182            append: if `True`, add to any existing expressions.
    1183                Otherwise, this flattens all the `Order` expression into a single expression.
    1184            dialect: the dialect used to parse the input expression.
    1185            copy: if `False`, modify this expression instance in-place.
    1186            opts: other options to use to parse the input expressions.
    1187
    1188        Returns:
    1189            The modified Select expression.
    1190        """
    1191        return _apply_child_list_builder(
    1192            *expressions,
    1193            instance=self,
    1194            arg="order",
    1195            append=append,
    1196            copy=copy,
    1197            prefix="ORDER BY",
    1198            into=Order,
    1199            dialect=dialect,
    1200            **opts,
    1201        )

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

    1203    @property
    1204    def ctes(self) -> t.List[CTE]:
    1205        """Returns a list of all the CTEs attached to this query."""
    1206        with_ = self.args.get("with")
    1207        return with_.expressions if with_ else []

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

selects: List[Expression] View Source

    1209    @property
    1210    def selects(self) -> t.List[Expression]:
    1211        """Returns the query's projections."""
    1212        raise NotImplementedError("Query objects must implement `selects`")

Returns the query's projections.

named_selects: List[str] View Source

    1214    @property
    1215    def named_selects(self) -> t.List[str]:
    1216        """Returns the output names of the query's projections."""
    1217        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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1219    def select(
    1220        self: Q,
    1221        *expressions: t.Optional[ExpOrStr],
    1222        append: bool = True,
    1223        dialect: DialectType = None,
    1224        copy: bool = True,
    1225        **opts,
    1226    ) -> Q:
    1227        """
    1228        Append to or set the SELECT expressions.
    1229
    1230        Example:
    1231            >>> Select().select("x", "y").sql()
    1232            'SELECT x, y'
    1233
    1234        Args:
    1235            *expressions: the SQL code strings to parse.
    1236                If an `Expression` instance is passed, it will be used as-is.
    1237            append: if `True`, add to any existing expressions.
    1238                Otherwise, this resets the expressions.
    1239            dialect: the dialect used to parse the input expressions.
    1240            copy: if `False`, modify this expression instance in-place.
    1241            opts: other options to use to parse the input expressions.
    1242
    1243        Returns:
    1244            The modified Query expression.
    1245        """
    1246        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 where( self: ~Q, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.Dialect, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~Q: View Source

    1248    def where(
    1249        self: Q,
    1250        *expressions: t.Optional[ExpOrStr],
    1251        append: bool = True,
    1252        dialect: DialectType = None,
    1253        copy: bool = True,
    1254        **opts,
    1255    ) -> Q:
    1256        """
    1257        Append to or set the WHERE expressions.
    1258
    1259        Examples:
    1260            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    1261            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    1262
    1263        Args:
    1264            *expressions: the SQL code strings to parse.
    1265                If an `Expression` instance is passed, it will be used as-is.
    1266                Multiple expressions are combined with an AND operator.
    1267            append: if `True`, AND the new expressions to any existing expression.
    1268                Otherwise, this resets the expression.
    1269            dialect: the dialect used to parse the input expressions.
    1270            copy: if `False`, modify this expression instance in-place.
    1271            opts: other options to use to parse the input expressions.
    1272
    1273        Returns:
    1274            The modified expression.
    1275        """
    1276        return _apply_conjunction_builder(
    1277            *[expr.this if isinstance(expr, Where) else expr for expr in expressions],
    1278            instance=self,
    1279            arg="where",
    1280            append=append,
    1281            into=Where,
    1282            dialect=dialect,
    1283            copy=copy,
    1284            **opts,
    1285        )

Append to or set the WHERE expressions.

###### Examples:

>     >>> 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:

> The modified 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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, scalar: bool = False, **opts) -> ~Q: View Source

    1287    def with_(
    1288        self: Q,
    1289        alias: ExpOrStr,
    1290        as_: ExpOrStr,
    1291        recursive: t.Optional[bool] = None,
    1292        materialized: t.Optional[bool] = None,
    1293        append: bool = True,
    1294        dialect: DialectType = None,
    1295        copy: bool = True,
    1296        scalar: bool = False,
    1297        **opts,
    1298    ) -> Q:
    1299        """
    1300        Append to or set the common table expressions.
    1301
    1302        Example:
    1303            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    1304            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    1305
    1306        Args:
    1307            alias: the SQL code string to parse as the table name.
    1308                If an `Expression` instance is passed, this is used as-is.
    1309            as_: the SQL code string to parse as the table expression.
    1310                If an `Expression` instance is passed, it will be used as-is.
    1311            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1312            materialized: set the MATERIALIZED part of the expression.
    1313            append: if `True`, add to any existing expressions.
    1314                Otherwise, this resets the expressions.
    1315            dialect: the dialect used to parse the input expression.
    1316            copy: if `False`, modify this expression instance in-place.
    1317            scalar: if `True`, this is a scalar common table expression.
    1318            opts: other options to use to parse the input expressions.
    1319
    1320        Returns:
    1321            The modified expression.
    1322        """
    1323        return _apply_cte_builder(
    1324            self,
    1325            alias,
    1326            as_,
    1327            recursive=recursive,
    1328            materialized=materialized,
    1329            append=append,
    1330            dialect=dialect,
    1331            copy=copy,
    1332            scalar=scalar,
    1333            **opts,
    1334        )

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.
- scalar: if `True`, this is a scalar common table expression.
- 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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Union: View Source

    1336    def union(
    1337        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1338    ) -> Union:
    1339        """
    1340        Builds a UNION expression.
    1341
    1342        Example:
    1343            >>> import sqlglot
    1344            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    1345            'SELECT * FROM foo UNION SELECT * FROM bla'
    1346
    1347        Args:
    1348            expressions: the SQL code strings.
    1349                If `Expression` instances are passed, they will be used as-is.
    1350            distinct: set the DISTINCT flag if and only if this is true.
    1351            dialect: the dialect used to parse the input expression.
    1352            opts: other options to use to parse the input expressions.
    1353
    1354        Returns:
    1355            The new Union expression.
    1356        """
    1357        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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Intersect: View Source

    1359    def intersect(
    1360        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1361    ) -> Intersect:
    1362        """
    1363        Builds an INTERSECT expression.
    1364
    1365        Example:
    1366            >>> import sqlglot
    1367            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    1368            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    1369
    1370        Args:
    1371            expressions: the SQL code strings.
    1372                If `Expression` instances are passed, they will be used as-is.
    1373            distinct: set the DISTINCT flag if and only if this is true.
    1374            dialect: the dialect used to parse the input expression.
    1375            opts: other options to use to parse the input expressions.
    1376
    1377        Returns:
    1378            The new Intersect expression.
    1379        """
    1380        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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Except: View Source

    1382    def except_(
    1383        self, *expressions: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    1384    ) -> Except:
    1385        """
    1386        Builds an EXCEPT expression.
    1387
    1388        Example:
    1389            >>> import sqlglot
    1390            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    1391            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    1392
    1393        Args:
    1394            expressions: the SQL code strings.
    1395                If `Expression` instance are passed, they will be used as-is.
    1396            distinct: set the DISTINCT flag if and only if this is true.
    1397            dialect: the dialect used to parse the input expression.
    1398            opts: other options to use to parse the input expressions.
    1399
    1400        Returns:
    1401            The new Except expression.
    1402        """
    1403        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UDTF(DerivedTable): View Source

    1406class UDTF(DerivedTable):
    1407    @property
    1408    def selects(self) -> t.List[Expression]:
    1409        alias = self.args.get("alias")
    1410        return alias.columns if alias else []

selects: List[Expression] View Source

    1407    @property
    1408    def selects(self) -> t.List[Expression]:
    1409        alias = self.args.get("alias")
    1410        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DerivedTable
  named_selects

class Cache(Expression): View Source

    1413class Cache(Expression):
    1414    arg_types = {
    1415        "this": True,
    1416        "lazy": False,
    1417        "options": False,
    1418        "expression": False,
    1419    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Uncache(Expression): View Source

    1422class Uncache(Expression):
    1423    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Refresh(Expression): View Source

    1426class Refresh(Expression):
    1427    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DDL(Expression): View Source

    1430class DDL(Expression):
    1431    @property
    1432    def ctes(self) -> t.List[CTE]:
    1433        """Returns a list of all the CTEs attached to this statement."""
    1434        with_ = self.args.get("with")
    1435        return with_.expressions if with_ else []
    1436
    1437    @property
    1438    def selects(self) -> t.List[Expression]:
    1439        """If this statement contains a query (e.g. a CTAS), this returns the query's projections."""
    1440        return self.expression.selects if isinstance(self.expression, Query) else []
    1441
    1442    @property
    1443    def named_selects(self) -> t.List[str]:
    1444        """
    1445        If this statement contains a query (e.g. a CTAS), this returns the output
    1446        names of the query's projections.
    1447        """
    1448        return self.expression.named_selects if isinstance(self.expression, Query) else []

ctes: List[CTE] View Source

    1431    @property
    1432    def ctes(self) -> t.List[CTE]:
    1433        """Returns a list of all the CTEs attached to this statement."""
    1434        with_ = self.args.get("with")
    1435        return with_.expressions if with_ else []

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

selects: List[Expression] View Source

    1437    @property
    1438    def selects(self) -> t.List[Expression]:
    1439        """If this statement contains a query (e.g. a CTAS), this returns the query's projections."""
    1440        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

    1442    @property
    1443    def named_selects(self) -> t.List[str]:
    1444        """
    1445        If this statement contains a query (e.g. a CTAS), this returns the output
    1446        names of the query's projections.
    1447        """
    1448        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DML(Expression): View Source

    1451class DML(Expression):
    1452    def returning(
    1453        self,
    1454        expression: ExpOrStr,
    1455        dialect: DialectType = None,
    1456        copy: bool = True,
    1457        **opts,
    1458    ) -> "Self":
    1459        """
    1460        Set the RETURNING expression. Not supported by all dialects.
    1461
    1462        Example:
    1463            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1464            'DELETE FROM tbl RETURNING *'
    1465
    1466        Args:
    1467            expression: the SQL code strings to parse.
    1468                If an `Expression` instance is passed, it will be used as-is.
    1469            dialect: the dialect used to parse the input expressions.
    1470            copy: if `False`, modify this expression instance in-place.
    1471            opts: other options to use to parse the input expressions.
    1472
    1473        Returns:
    1474            Delete: the modified expression.
    1475        """
    1476        return _apply_builder(
    1477            expression=expression,
    1478            instance=self,
    1479            arg="returning",
    1480            prefix="RETURNING",
    1481            dialect=dialect,
    1482            copy=copy,
    1483            into=Returning,
    1484            **opts,
    1485        )

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

    1452    def returning(
    1453        self,
    1454        expression: ExpOrStr,
    1455        dialect: DialectType = None,
    1456        copy: bool = True,
    1457        **opts,
    1458    ) -> "Self":
    1459        """
    1460        Set the RETURNING expression. Not supported by all dialects.
    1461
    1462        Example:
    1463            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1464            'DELETE FROM tbl RETURNING *'
    1465
    1466        Args:
    1467            expression: the SQL code strings to parse.
    1468                If an `Expression` instance is passed, it will be used as-is.
    1469            dialect: the dialect used to parse the input expressions.
    1470            copy: if `False`, modify this expression instance in-place.
    1471            opts: other options to use to parse the input expressions.
    1472
    1473        Returns:
    1474            Delete: the modified expression.
    1475        """
    1476        return _apply_builder(
    1477            expression=expression,
    1478            instance=self,
    1479            arg="returning",
    1480            prefix="RETURNING",
    1481            dialect=dialect,
    1482            copy=copy,
    1483            into=Returning,
    1484            **opts,
    1485        )

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Create(DDL): View Source

    1488class Create(DDL):
    1489    arg_types = {
    1490        "with": False,
    1491        "this": True,
    1492        "kind": True,
    1493        "expression": False,
    1494        "exists": False,
    1495        "properties": False,
    1496        "replace": False,
    1497        "refresh": False,
    1498        "unique": False,
    1499        "indexes": False,
    1500        "no_schema_binding": False,
    1501        "begin": False,
    1502        "end": False,
    1503        "clone": False,
    1504        "concurrently": False,
    1505        "clustered": False,
    1506    }
    1507
    1508    @property
    1509    def kind(self) -> t.Optional[str]:
    1510        kind = self.args.get("kind")
    1511        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

    1508    @property
    1509    def kind(self) -> t.Optional[str]:
    1510        kind = self.args.get("kind")
    1511        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DDL
  ctes
  selects
  named_selects

class SequenceProperties(Expression): View Source

    1514class SequenceProperties(Expression):
    1515    arg_types = {
    1516        "increment": False,
    1517        "minvalue": False,
    1518        "maxvalue": False,
    1519        "cache": False,
    1520        "start": False,
    1521        "owned": False,
    1522        "options": False,
    1523    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TruncateTable(Expression): View Source

    1526class TruncateTable(Expression):
    1527    arg_types = {
    1528        "expressions": True,
    1529        "is_database": False,
    1530        "exists": False,
    1531        "only": False,
    1532        "cluster": False,
    1533        "identity": False,
    1534        "option": False,
    1535        "partition": False,
    1536    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Clone(Expression): View Source

    1542class Clone(Expression):
    1543    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Describe(Expression): View Source

    1546class Describe(Expression):
    1547    arg_types = {
    1548        "this": True,
    1549        "style": False,
    1550        "kind": False,
    1551        "expressions": False,
    1552        "partition": False,
    1553        "format": False,
    1554    }

arg_types = {'this': True, 'style': False, 'kind': False, 'expressions': False, 'partition': False, 'format': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Attach(Expression): View Source

    1558class Attach(Expression):
    1559    arg_types = {"this": True, "exists": False, "expressions": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Detach(Expression): View Source

    1563class Detach(Expression):
    1564    arg_types = {"this": True, "exists": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Summarize(Expression): View Source

    1568class Summarize(Expression):
    1569    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Kill(Expression): View Source

    1572class Kill(Expression):
    1573    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Pragma(Expression): View Source

    1576class Pragma(Expression):
    1577    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Declare(Expression): View Source

    1580class Declare(Expression):
    1581    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DeclareItem(Expression): View Source

    1584class DeclareItem(Expression):
    1585    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Set(Expression): View Source

    1588class Set(Expression):
    1589    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Heredoc(Expression): View Source

    1592class Heredoc(Expression):
    1593    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetItem(Expression): View Source

    1596class SetItem(Expression):
    1597    arg_types = {
    1598        "this": False,
    1599        "expressions": False,
    1600        "kind": False,
    1601        "collate": False,  # MySQL SET NAMES statement
    1602        "global": False,
    1603    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Show(Expression): View Source

    1606class Show(Expression):
    1607    arg_types = {
    1608        "this": True,
    1609        "history": False,
    1610        "terse": False,
    1611        "target": False,
    1612        "offset": False,
    1613        "starts_with": False,
    1614        "limit": False,
    1615        "from": False,
    1616        "like": False,
    1617        "where": False,
    1618        "db": False,
    1619        "scope": False,
    1620        "scope_kind": False,
    1621        "full": False,
    1622        "mutex": False,
    1623        "query": False,
    1624        "channel": False,
    1625        "global": False,
    1626        "log": False,
    1627        "position": False,
    1628        "types": False,
    1629        "privileges": False,
    1630    }

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, 'privileges': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UserDefinedFunction(Expression): View Source

    1633class UserDefinedFunction(Expression):
    1634    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CharacterSet(Expression): View Source

    1637class CharacterSet(Expression):
    1638    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RecursiveWithSearch(Expression): View Source

    1641class RecursiveWithSearch(Expression):
    1642    arg_types = {"kind": True, "this": True, "expression": True, "using": False}

arg_types = {'kind': True, 'this': True, 'expression': True, 'using': False}
key = 'recursivewithsearch'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class With(Expression): View Source

    1645class With(Expression):
    1646    arg_types = {"expressions": True, "recursive": False, "search": False}
    1647
    1648    @property
    1649    def recursive(self) -> bool:
    1650        return bool(self.args.get("recursive"))

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

    1648    @property
    1649    def recursive(self) -> bool:
    1650        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithinGroup(Expression): View Source

    1653class WithinGroup(Expression):
    1654    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CTE(DerivedTable): View Source

    1659class CTE(DerivedTable):
    1660    arg_types = {
    1661        "this": True,
    1662        "alias": True,
    1663        "scalar": False,
    1664        "materialized": False,
    1665    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DerivedTable
  selects
  named_selects

class ProjectionDef(Expression): View Source

    1668class ProjectionDef(Expression):
    1669    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TableAlias(Expression): View Source

    1672class TableAlias(Expression):
    1673    arg_types = {"this": False, "columns": False}
    1674
    1675    @property
    1676    def columns(self):
    1677        return self.args.get("columns") or []

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

    1675    @property
    1676    def columns(self):
    1677        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BitString(Condition): View Source

    1680class BitString(Condition):
    1681    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HexString(Condition): View Source

    1684class HexString(Condition):
    1685    arg_types = {"this": True, "is_integer": False}

arg_types = {'this': True, 'is_integer': False}
key = 'hexstring'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ByteString(Condition): View Source

    1688class ByteString(Condition):
    1689    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RawString(Condition): View Source

    1692class RawString(Condition):
    1693    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UnicodeString(Condition): View Source

    1696class UnicodeString(Condition):
    1697    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Column(Condition): View Source

    1700class Column(Condition):
    1701    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
    1702
    1703    @property
    1704    def table(self) -> str:
    1705        return self.text("table")
    1706
    1707    @property
    1708    def db(self) -> str:
    1709        return self.text("db")
    1710
    1711    @property
    1712    def catalog(self) -> str:
    1713        return self.text("catalog")
    1714
    1715    @property
    1716    def output_name(self) -> str:
    1717        return self.name
    1718
    1719    @property
    1720    def parts(self) -> t.List[Identifier]:
    1721        """Return the parts of a column in order catalog, db, table, name."""
    1722        return [
    1723            t.cast(Identifier, self.args[part])
    1724            for part in ("catalog", "db", "table", "this")
    1725            if self.args.get(part)
    1726        ]
    1727
    1728    def to_dot(self, include_dots: bool = True) -> Dot | Identifier:
    1729        """Converts the column into a dot expression."""
    1730        parts = self.parts
    1731        parent = self.parent
    1732
    1733        if include_dots:
    1734            while isinstance(parent, Dot):
    1735                parts.append(parent.expression)
    1736                parent = parent.parent
    1737
    1738        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

    1703    @property
    1704    def table(self) -> str:
    1705        return self.text("table")

db: str View Source

    1707    @property
    1708    def db(self) -> str:
    1709        return self.text("db")

catalog: str View Source

    1711    @property
    1712    def catalog(self) -> str:
    1713        return self.text("catalog")

output_name: str View Source

    1715    @property
    1716    def output_name(self) -> str:
    1717        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

    1719    @property
    1720    def parts(self) -> t.List[Identifier]:
    1721        """Return the parts of a column in order catalog, db, table, name."""
    1722        return [
    1723            t.cast(Identifier, self.args[part])
    1724            for part in ("catalog", "db", "table", "this")
    1725            if self.args.get(part)
    1726        ]

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

def to_dot( self, include_dots: bool = True) -> Dot | Identifier: View Source

    1728    def to_dot(self, include_dots: bool = True) -> Dot | Identifier:
    1729        """Converts the column into a dot expression."""
    1730        parts = self.parts
    1731        parent = self.parent
    1732
    1733        if include_dots:
    1734            while isinstance(parent, Dot):
    1735                parts.append(parent.expression)
    1736                parent = parent.parent
    1737
    1738        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnPosition(Expression): View Source

    1741class ColumnPosition(Expression):
    1742    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnDef(Expression): View Source

    1745class ColumnDef(Expression):
    1746    arg_types = {
    1747        "this": True,
    1748        "kind": False,
    1749        "constraints": False,
    1750        "exists": False,
    1751        "position": False,
    1752        "default": False,
    1753        "output": False,
    1754    }
    1755
    1756    @property
    1757    def constraints(self) -> t.List[ColumnConstraint]:
    1758        return self.args.get("constraints") or []
    1759
    1760    @property
    1761    def kind(self) -> t.Optional[DataType]:
    1762        return self.args.get("kind")

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

    1756    @property
    1757    def constraints(self) -> t.List[ColumnConstraint]:
    1758        return self.args.get("constraints") or []

kind: Optional[DataType] View Source

    1760    @property
    1761    def kind(self) -> t.Optional[DataType]:
    1762        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterColumn(Expression): View Source

    1765class AlterColumn(Expression):
    1766    arg_types = {
    1767        "this": True,
    1768        "dtype": False,
    1769        "collate": False,
    1770        "using": False,
    1771        "default": False,
    1772        "drop": False,
    1773        "comment": False,
    1774        "allow_null": False,
    1775        "visible": False,
    1776    }

arg_types = {'this': True, 'dtype': False, 'collate': False, 'using': False, 'default': False, 'drop': False, 'comment': False, 'allow_null': False, 'visible': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterIndex(Expression): View Source

    1780class AlterIndex(Expression):
    1781    arg_types = {"this": True, "visible": True}

arg_types = {'this': True, 'visible': True}
key = 'alterindex'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterDistStyle(Expression): View Source

    1785class AlterDistStyle(Expression):
    1786    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterSortKey(Expression): View Source

    1789class AlterSortKey(Expression):
    1790    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterSet(Expression): View Source

    1793class AlterSet(Expression):
    1794    arg_types = {
    1795        "expressions": False,
    1796        "option": False,
    1797        "tablespace": False,
    1798        "access_method": False,
    1799        "file_format": False,
    1800        "copy_options": False,
    1801        "tag": False,
    1802        "location": False,
    1803        "serde": False,
    1804    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RenameColumn(Expression): View Source

    1807class RenameColumn(Expression):
    1808    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlterRename(Expression): View Source

    1811class AlterRename(Expression):
    1812    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SwapTable(Expression): View Source

    1815class SwapTable(Expression):
    1816    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Comment(Expression): View Source

    1819class Comment(Expression):
    1820    arg_types = {
    1821        "this": True,
    1822        "kind": True,
    1823        "expression": True,
    1824        "exists": False,
    1825        "materialized": False,
    1826    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Comprehension(Expression): View Source

    1829class Comprehension(Expression):
    1830    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MergeTreeTTLAction(Expression): View Source

    1834class MergeTreeTTLAction(Expression):
    1835    arg_types = {
    1836        "this": True,
    1837        "delete": False,
    1838        "recompress": False,
    1839        "to_disk": False,
    1840        "to_volume": False,
    1841    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MergeTreeTTL(Expression): View Source

    1845class MergeTreeTTL(Expression):
    1846    arg_types = {
    1847        "expressions": True,
    1848        "where": False,
    1849        "group": False,
    1850        "aggregates": False,
    1851    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexConstraintOption(Expression): View Source

    1855class IndexConstraintOption(Expression):
    1856    arg_types = {
    1857        "key_block_size": False,
    1858        "using": False,
    1859        "parser": False,
    1860        "comment": False,
    1861        "visible": False,
    1862        "engine_attr": False,
    1863        "secondary_engine_attr": False,
    1864    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnConstraint(Expression): View Source

    1867class ColumnConstraint(Expression):
    1868    arg_types = {"this": False, "kind": True}
    1869
    1870    @property
    1871    def kind(self) -> ColumnConstraintKind:
    1872        return self.args["kind"]

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

    1870    @property
    1871    def kind(self) -> ColumnConstraintKind:
    1872        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnConstraintKind(Expression): View Source

    1875class ColumnConstraintKind(Expression):
    1876    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AutoIncrementColumnConstraint(ColumnConstraintKind): View Source

    1879class AutoIncrementColumnConstraint(ColumnConstraintKind):
    1880    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PeriodForSystemTimeConstraint(ColumnConstraintKind): View Source

    1883class PeriodForSystemTimeConstraint(ColumnConstraintKind):
    1884    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CaseSpecificColumnConstraint(ColumnConstraintKind): View Source

    1887class CaseSpecificColumnConstraint(ColumnConstraintKind):
    1888    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CharacterSetColumnConstraint(ColumnConstraintKind): View Source

    1891class CharacterSetColumnConstraint(ColumnConstraintKind):
    1892    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CheckColumnConstraint(ColumnConstraintKind): View Source

    1895class CheckColumnConstraint(ColumnConstraintKind):
    1896    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ClusteredColumnConstraint(ColumnConstraintKind): View Source

    1899class ClusteredColumnConstraint(ColumnConstraintKind):
    1900    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CollateColumnConstraint(ColumnConstraintKind): View Source

    1903class CollateColumnConstraint(ColumnConstraintKind):
    1904    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CommentColumnConstraint(ColumnConstraintKind): View Source

    1907class CommentColumnConstraint(ColumnConstraintKind):
    1908    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CompressColumnConstraint(ColumnConstraintKind): View Source

    1911class CompressColumnConstraint(ColumnConstraintKind):
    1912    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateFormatColumnConstraint(ColumnConstraintKind): View Source

    1915class DateFormatColumnConstraint(ColumnConstraintKind):
    1916    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DefaultColumnConstraint(ColumnConstraintKind): View Source

    1919class DefaultColumnConstraint(ColumnConstraintKind):
    1920    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EncodeColumnConstraint(ColumnConstraintKind): View Source

    1923class EncodeColumnConstraint(ColumnConstraintKind):
    1924    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ExcludeColumnConstraint(ColumnConstraintKind): View Source

    1928class ExcludeColumnConstraint(ColumnConstraintKind):
    1929    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EphemeralColumnConstraint(ColumnConstraintKind): View Source

    1932class EphemeralColumnConstraint(ColumnConstraintKind):
    1933    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithOperator(Expression): View Source

    1936class WithOperator(Expression):
    1937    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind): View Source

    1940class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
    1941    # this: True -> ALWAYS, this: False -> BY DEFAULT
    1942    arg_types = {
    1943        "this": False,
    1944        "expression": False,
    1945        "on_null": False,
    1946        "start": False,
    1947        "increment": False,
    1948        "minvalue": False,
    1949        "maxvalue": False,
    1950        "cycle": False,
    1951        "order": False,
    1952    }

arg_types = {'this': False, 'expression': False, 'on_null': False, 'start': False, 'increment': False, 'minvalue': False, 'maxvalue': False, 'cycle': False, 'order': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GeneratedAsRowColumnConstraint(ColumnConstraintKind): View Source

    1955class GeneratedAsRowColumnConstraint(ColumnConstraintKind):
    1956    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexColumnConstraint(ColumnConstraintKind): View Source

    1961class IndexColumnConstraint(ColumnConstraintKind):
    1962    arg_types = {
    1963        "this": False,
    1964        "expressions": False,
    1965        "kind": False,
    1966        "index_type": False,
    1967        "options": False,
    1968        "expression": False,  # Clickhouse
    1969        "granularity": False,
    1970    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InlineLengthColumnConstraint(ColumnConstraintKind): View Source

    1973class InlineLengthColumnConstraint(ColumnConstraintKind):
    1974    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NonClusteredColumnConstraint(ColumnConstraintKind): View Source

    1977class NonClusteredColumnConstraint(ColumnConstraintKind):
    1978    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NotForReplicationColumnConstraint(ColumnConstraintKind): View Source

    1981class NotForReplicationColumnConstraint(ColumnConstraintKind):
    1982    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MaskingPolicyColumnConstraint(ColumnConstraintKind): View Source

    1986class MaskingPolicyColumnConstraint(ColumnConstraintKind):
    1987    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NotNullColumnConstraint(ColumnConstraintKind): View Source

    1990class NotNullColumnConstraint(ColumnConstraintKind):
    1991    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnUpdateColumnConstraint(ColumnConstraintKind): View Source

    1995class OnUpdateColumnConstraint(ColumnConstraintKind):
    1996    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PrimaryKeyColumnConstraint(ColumnConstraintKind): View Source

    1999class PrimaryKeyColumnConstraint(ColumnConstraintKind):
    2000    arg_types = {"desc": False, "options": False}

arg_types = {'desc': False, 'options': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TitleColumnConstraint(ColumnConstraintKind): View Source

    2003class TitleColumnConstraint(ColumnConstraintKind):
    2004    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UniqueColumnConstraint(ColumnConstraintKind): View Source

    2007class UniqueColumnConstraint(ColumnConstraintKind):
    2008    arg_types = {
    2009        "this": False,
    2010        "index_type": False,
    2011        "on_conflict": False,
    2012        "nulls": False,
    2013        "options": False,
    2014    }

arg_types = {'this': False, 'index_type': False, 'on_conflict': False, 'nulls': False, 'options': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UppercaseColumnConstraint(ColumnConstraintKind): View Source

    2017class UppercaseColumnConstraint(ColumnConstraintKind):
    2018    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WatermarkColumnConstraint(Expression): View Source

    2022class WatermarkColumnConstraint(Expression):
    2023    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PathColumnConstraint(ColumnConstraintKind): View Source

    2026class PathColumnConstraint(ColumnConstraintKind):
    2027    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ProjectionPolicyColumnConstraint(ColumnConstraintKind): View Source

    2031class ProjectionPolicyColumnConstraint(ColumnConstraintKind):
    2032    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ComputedColumnConstraint(ColumnConstraintKind): View Source

    2037class ComputedColumnConstraint(ColumnConstraintKind):
    2038    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Constraint(Expression): View Source

    2041class Constraint(Expression):
    2042    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Delete(DML): View Source

    2045class Delete(DML):
    2046    arg_types = {
    2047        "with": False,
    2048        "this": False,
    2049        "using": False,
    2050        "where": False,
    2051        "returning": False,
    2052        "limit": False,
    2053        "tables": False,  # Multiple-Table Syntax (MySQL)
    2054        "cluster": False,  # Clickhouse
    2055    }
    2056
    2057    def delete(
    2058        self,
    2059        table: ExpOrStr,
    2060        dialect: DialectType = None,
    2061        copy: bool = True,
    2062        **opts,
    2063    ) -> Delete:
    2064        """
    2065        Create a DELETE expression or replace the table on an existing DELETE expression.
    2066
    2067        Example:
    2068            >>> delete("tbl").sql()
    2069            'DELETE FROM tbl'
    2070
    2071        Args:
    2072            table: the table from which to delete.
    2073            dialect: the dialect used to parse the input expression.
    2074            copy: if `False`, modify this expression instance in-place.
    2075            opts: other options to use to parse the input expressions.
    2076
    2077        Returns:
    2078            Delete: the modified expression.
    2079        """
    2080        return _apply_builder(
    2081            expression=table,
    2082            instance=self,
    2083            arg="this",
    2084            dialect=dialect,
    2085            into=Table,
    2086            copy=copy,
    2087            **opts,
    2088        )
    2089
    2090    def where(
    2091        self,
    2092        *expressions: t.Optional[ExpOrStr],
    2093        append: bool = True,
    2094        dialect: DialectType = None,
    2095        copy: bool = True,
    2096        **opts,
    2097    ) -> Delete:
    2098        """
    2099        Append to or set the WHERE expressions.
    2100
    2101        Example:
    2102            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    2103            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    2104
    2105        Args:
    2106            *expressions: the SQL code strings to parse.
    2107                If an `Expression` instance is passed, it will be used as-is.
    2108                Multiple expressions are combined with an AND operator.
    2109            append: if `True`, AND the new expressions to any existing expression.
    2110                Otherwise, this resets the expression.
    2111            dialect: the dialect used to parse the input expressions.
    2112            copy: if `False`, modify this expression instance in-place.
    2113            opts: other options to use to parse the input expressions.
    2114
    2115        Returns:
    2116            Delete: the modified expression.
    2117        """
    2118        return _apply_conjunction_builder(
    2119            *expressions,
    2120            instance=self,
    2121            arg="where",
    2122            append=append,
    2123            into=Where,
    2124            dialect=dialect,
    2125            copy=copy,
    2126            **opts,
    2127        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Delete: View Source

    2057    def delete(
    2058        self,
    2059        table: ExpOrStr,
    2060        dialect: DialectType = None,
    2061        copy: bool = True,
    2062        **opts,
    2063    ) -> Delete:
    2064        """
    2065        Create a DELETE expression or replace the table on an existing DELETE expression.
    2066
    2067        Example:
    2068            >>> delete("tbl").sql()
    2069            'DELETE FROM tbl'
    2070
    2071        Args:
    2072            table: the table from which to delete.
    2073            dialect: the dialect used to parse the input expression.
    2074            copy: if `False`, modify this expression instance in-place.
    2075            opts: other options to use to parse the input expressions.
    2076
    2077        Returns:
    2078            Delete: the modified expression.
    2079        """
    2080        return _apply_builder(
    2081            expression=table,
    2082            instance=self,
    2083            arg="this",
    2084            dialect=dialect,
    2085            into=Table,
    2086            copy=copy,
    2087            **opts,
    2088        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Delete: View Source

    2090    def where(
    2091        self,
    2092        *expressions: t.Optional[ExpOrStr],
    2093        append: bool = True,
    2094        dialect: DialectType = None,
    2095        copy: bool = True,
    2096        **opts,
    2097    ) -> Delete:
    2098        """
    2099        Append to or set the WHERE expressions.
    2100
    2101        Example:
    2102            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    2103            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    2104
    2105        Args:
    2106            *expressions: the SQL code strings to parse.
    2107                If an `Expression` instance is passed, it will be used as-is.
    2108                Multiple expressions are combined with an AND operator.
    2109            append: if `True`, AND the new expressions to any existing expression.
    2110                Otherwise, this resets the expression.
    2111            dialect: the dialect used to parse the input expressions.
    2112            copy: if `False`, modify this expression instance in-place.
    2113            opts: other options to use to parse the input expressions.
    2114
    2115        Returns:
    2116            Delete: the modified expression.
    2117        """
    2118        return _apply_conjunction_builder(
    2119            *expressions,
    2120            instance=self,
    2121            arg="where",
    2122            append=append,
    2123            into=Where,
    2124            dialect=dialect,
    2125            copy=copy,
    2126            **opts,
    2127        )

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class Drop(Expression): View Source

    2130class Drop(Expression):
    2131    arg_types = {
    2132        "this": False,
    2133        "kind": False,
    2134        "expressions": False,
    2135        "exists": False,
    2136        "temporary": False,
    2137        "materialized": False,
    2138        "cascade": False,
    2139        "constraints": False,
    2140        "purge": False,
    2141        "cluster": False,
    2142        "concurrently": False,
    2143    }
    2144
    2145    @property
    2146    def kind(self) -> t.Optional[str]:
    2147        kind = self.args.get("kind")
    2148        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

    2145    @property
    2146    def kind(self) -> t.Optional[str]:
    2147        kind = self.args.get("kind")
    2148        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Export(Expression): View Source

    2152class Export(Expression):
    2153    arg_types = {"this": True, "connection": False, "options": True}

arg_types = {'this': True, 'connection': False, 'options': True}
key = 'export'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Filter(Expression): View Source

    2156class Filter(Expression):
    2157    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Check(Expression): View Source

    2160class Check(Expression):
    2161    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Changes(Expression): View Source

    2164class Changes(Expression):
    2165    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Connect(Expression): View Source

    2169class Connect(Expression):
    2170    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CopyParameter(Expression): View Source

    2173class CopyParameter(Expression):
    2174    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Copy(DML): View Source

    2177class Copy(DML):
    2178    arg_types = {
    2179        "this": True,
    2180        "kind": True,
    2181        "files": True,
    2182        "credentials": False,
    2183        "format": False,
    2184        "params": False,
    2185    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class Credentials(Expression): View Source

    2188class Credentials(Expression):
    2189    arg_types = {
    2190        "credentials": False,
    2191        "encryption": False,
    2192        "storage": False,
    2193        "iam_role": False,
    2194        "region": False,
    2195    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Prior(Expression): View Source

    2198class Prior(Expression):
    2199    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Directory(Expression): View Source

    2202class Directory(Expression):
    2203    # https://spark.apache.org/docs/3.0.0-preview/sql-ref-syntax-dml-insert-overwrite-directory-hive.html
    2204    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ForeignKey(Expression): View Source

    2207class ForeignKey(Expression):
    2208    arg_types = {
    2209        "expressions": False,
    2210        "reference": False,
    2211        "delete": False,
    2212        "update": False,
    2213        "options": False,
    2214    }

arg_types = {'expressions': False, 'reference': False, 'delete': False, 'update': False, 'options': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ColumnPrefix(Expression): View Source

    2217class ColumnPrefix(Expression):
    2218    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PrimaryKey(Expression): View Source

    2221class PrimaryKey(Expression):
    2222    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Into(Expression): View Source

    2227class Into(Expression):
    2228    arg_types = {
    2229        "this": False,
    2230        "temporary": False,
    2231        "unlogged": False,
    2232        "bulk_collect": False,
    2233        "expressions": False,
    2234    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class From(Expression): View Source

    2237class From(Expression):
    2238    @property
    2239    def name(self) -> str:
    2240        return self.this.name
    2241
    2242    @property
    2243    def alias_or_name(self) -> str:
    2244        return self.this.alias_or_name

name: str View Source

    2238    @property
    2239    def name(self) -> str:
    2240        return self.this.name

alias_or_name: str View Source

    2242    @property
    2243    def alias_or_name(self) -> str:
    2244        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Having(Expression): View Source

    2247class Having(Expression):
    2248    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Hint(Expression): View Source

    2251class Hint(Expression):
    2252    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JoinHint(Expression): View Source

    2255class JoinHint(Expression):
    2256    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Identifier(Expression): View Source

    2259class Identifier(Expression):
    2260    arg_types = {"this": True, "quoted": False, "global": False, "temporary": False}
    2261
    2262    @property
    2263    def quoted(self) -> bool:
    2264        return bool(self.args.get("quoted"))
    2265
    2266    @property
    2267    def hashable_args(self) -> t.Any:
    2268        return (self.this, self.quoted)
    2269
    2270    @property
    2271    def output_name(self) -> str:
    2272        return self.name

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

    2262    @property
    2263    def quoted(self) -> bool:
    2264        return bool(self.args.get("quoted"))

hashable_args: Any View Source

    2266    @property
    2267    def hashable_args(self) -> t.Any:
    2268        return (self.this, self.quoted)

output_name: str View Source

    2270    @property
    2271    def output_name(self) -> str:
    2272        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Opclass(Expression): View Source

    2276class Opclass(Expression):
    2277    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Index(Expression): View Source

    2280class Index(Expression):
    2281    arg_types = {
    2282        "this": False,
    2283        "table": False,
    2284        "unique": False,
    2285        "primary": False,
    2286        "amp": False,  # teradata
    2287        "params": False,
    2288    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexParameters(Expression): View Source

    2291class IndexParameters(Expression):
    2292    arg_types = {
    2293        "using": False,
    2294        "include": False,
    2295        "columns": False,
    2296        "with_storage": False,
    2297        "partition_by": False,
    2298        "tablespace": False,
    2299        "where": False,
    2300        "on": False,
    2301    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Insert(DDL, DML): View Source

    2304class Insert(DDL, DML):
    2305    arg_types = {
    2306        "hint": False,
    2307        "with": False,
    2308        "is_function": False,
    2309        "this": False,
    2310        "expression": False,
    2311        "conflict": False,
    2312        "returning": False,
    2313        "overwrite": False,
    2314        "exists": False,
    2315        "alternative": False,
    2316        "where": False,
    2317        "ignore": False,
    2318        "by_name": False,
    2319        "stored": False,
    2320        "partition": False,
    2321        "settings": False,
    2322        "source": False,
    2323    }
    2324
    2325    def with_(
    2326        self,
    2327        alias: ExpOrStr,
    2328        as_: ExpOrStr,
    2329        recursive: t.Optional[bool] = None,
    2330        materialized: t.Optional[bool] = None,
    2331        append: bool = True,
    2332        dialect: DialectType = None,
    2333        copy: bool = True,
    2334        **opts,
    2335    ) -> Insert:
    2336        """
    2337        Append to or set the common table expressions.
    2338
    2339        Example:
    2340            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    2341            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    2342
    2343        Args:
    2344            alias: the SQL code string to parse as the table name.
    2345                If an `Expression` instance is passed, this is used as-is.
    2346            as_: the SQL code string to parse as the table expression.
    2347                If an `Expression` instance is passed, it will be used as-is.
    2348            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2349            materialized: set the MATERIALIZED part of the expression.
    2350            append: if `True`, add to any existing expressions.
    2351                Otherwise, this resets the expressions.
    2352            dialect: the dialect used to parse the input expression.
    2353            copy: if `False`, modify this expression instance in-place.
    2354            opts: other options to use to parse the input expressions.
    2355
    2356        Returns:
    2357            The modified expression.
    2358        """
    2359        return _apply_cte_builder(
    2360            self,
    2361            alias,
    2362            as_,
    2363            recursive=recursive,
    2364            materialized=materialized,
    2365            append=append,
    2366            dialect=dialect,
    2367            copy=copy,
    2368            **opts,
    2369        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Insert: View Source

    2325    def with_(
    2326        self,
    2327        alias: ExpOrStr,
    2328        as_: ExpOrStr,
    2329        recursive: t.Optional[bool] = None,
    2330        materialized: t.Optional[bool] = None,
    2331        append: bool = True,
    2332        dialect: DialectType = None,
    2333        copy: bool = True,
    2334        **opts,
    2335    ) -> Insert:
    2336        """
    2337        Append to or set the common table expressions.
    2338
    2339        Example:
    2340            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    2341            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    2342
    2343        Args:
    2344            alias: the SQL code string to parse as the table name.
    2345                If an `Expression` instance is passed, this is used as-is.
    2346            as_: the SQL code string to parse as the table expression.
    2347                If an `Expression` instance is passed, it will be used as-is.
    2348            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2349            materialized: set the MATERIALIZED part of the expression.
    2350            append: if `True`, add to any existing expressions.
    2351                Otherwise, this resets the expressions.
    2352            dialect: the dialect used to parse the input expression.
    2353            copy: if `False`, modify this expression instance in-place.
    2354            opts: other options to use to parse the input expressions.
    2355
    2356        Returns:
    2357            The modified expression.
    2358        """
    2359        return _apply_cte_builder(
    2360            self,
    2361            alias,
    2362            as_,
    2363            recursive=recursive,
    2364            materialized=materialized,
    2365            append=append,
    2366            dialect=dialect,
    2367            copy=copy,
    2368            **opts,
    2369        )

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DDL
  ctes
  selects
  named_selects
DML
  returning

class ConditionalInsert(Expression): View Source

    2372class ConditionalInsert(Expression):
    2373    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MultitableInserts(Expression): View Source

    2376class MultitableInserts(Expression):
    2377    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnConflict(Expression): View Source

    2380class OnConflict(Expression):
    2381    arg_types = {
    2382        "duplicate": False,
    2383        "expressions": False,
    2384        "action": False,
    2385        "conflict_keys": False,
    2386        "constraint": False,
    2387        "where": False,
    2388    }

arg_types = {'duplicate': False, 'expressions': False, 'action': False, 'conflict_keys': False, 'constraint': False, 'where': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnCondition(Expression): View Source

    2391class OnCondition(Expression):
    2392    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Returning(Expression): View Source

    2395class Returning(Expression):
    2396    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Introducer(Expression): View Source

    2400class Introducer(Expression):
    2401    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class National(Expression): View Source

    2405class National(Expression):
    2406    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LoadData(Expression): View Source

    2409class LoadData(Expression):
    2410    arg_types = {
    2411        "this": True,
    2412        "local": False,
    2413        "overwrite": False,
    2414        "inpath": True,
    2415        "partition": False,
    2416        "input_format": False,
    2417        "serde": False,
    2418    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Partition(Expression): View Source

    2421class Partition(Expression):
    2422    arg_types = {"expressions": True, "subpartition": False}

arg_types = {'expressions': True, 'subpartition': False}
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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionRange(Expression): View Source

    2425class PartitionRange(Expression):
    2426    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionId(Expression): View Source

    2430class PartitionId(Expression):
    2431    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Fetch(Expression): View Source

    2434class Fetch(Expression):
    2435    arg_types = {
    2436        "direction": False,
    2437        "count": False,
    2438        "limit_options": False,
    2439    }

arg_types = {'direction': False, 'count': False, 'limit_options': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Grant(Expression): View Source

    2442class Grant(Expression):
    2443    arg_types = {
    2444        "privileges": True,
    2445        "kind": False,
    2446        "securable": True,
    2447        "principals": True,
    2448        "grant_option": False,
    2449    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Group(Expression): View Source

    2452class Group(Expression):
    2453    arg_types = {
    2454        "expressions": False,
    2455        "grouping_sets": False,
    2456        "cube": False,
    2457        "rollup": False,
    2458        "totals": False,
    2459        "all": False,
    2460    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Cube(Expression): View Source

    2463class Cube(Expression):
    2464    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Rollup(Expression): View Source

    2467class Rollup(Expression):
    2468    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GroupingSets(Expression): View Source

    2471class GroupingSets(Expression):
    2472    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Lambda(Expression): View Source

    2475class Lambda(Expression):
    2476    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Limit(Expression): View Source

    2479class Limit(Expression):
    2480    arg_types = {
    2481        "this": False,
    2482        "expression": True,
    2483        "offset": False,
    2484        "limit_options": False,
    2485        "expressions": False,
    2486    }

arg_types = {'this': False, 'expression': True, 'offset': False, 'limit_options': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LimitOptions(Expression): View Source

    2489class LimitOptions(Expression):
    2490    arg_types = {
    2491        "percent": False,
    2492        "rows": False,
    2493        "with_ties": False,
    2494    }

arg_types = {'percent': False, 'rows': False, 'with_ties': False}
key = 'limitoptions'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Literal(Condition): View Source

    2497class Literal(Condition):
    2498    arg_types = {"this": True, "is_string": True}
    2499
    2500    @property
    2501    def hashable_args(self) -> t.Any:
    2502        return (self.this, self.args.get("is_string"))
    2503
    2504    @classmethod
    2505    def number(cls, number) -> Literal:
    2506        return cls(this=str(number), is_string=False)
    2507
    2508    @classmethod
    2509    def string(cls, string) -> Literal:
    2510        return cls(this=str(string), is_string=True)
    2511
    2512    @property
    2513    def output_name(self) -> str:
    2514        return self.name
    2515
    2516    def to_py(self) -> int | str | Decimal:
    2517        if self.is_number:
    2518            try:
    2519                return int(self.this)
    2520            except ValueError:
    2521                return Decimal(self.this)
    2522        return self.this

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

    2500    @property
    2501    def hashable_args(self) -> t.Any:
    2502        return (self.this, self.args.get("is_string"))

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

    2504    @classmethod
    2505    def number(cls, number) -> Literal:
    2506        return cls(this=str(number), is_string=False)

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

    2508    @classmethod
    2509    def string(cls, string) -> Literal:
    2510        return cls(this=str(string), is_string=True)

output_name: str View Source

    2512    @property
    2513    def output_name(self) -> str:
    2514        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

    2516    def to_py(self) -> int | str | Decimal:
    2517        if self.is_number:
    2518            try:
    2519                return int(self.this)
    2520            except ValueError:
    2521                return Decimal(self.this)
    2522        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Join(Expression): View Source

    2525class Join(Expression):
    2526    arg_types = {
    2527        "this": True,
    2528        "on": False,
    2529        "side": False,
    2530        "kind": False,
    2531        "using": False,
    2532        "method": False,
    2533        "global": False,
    2534        "hint": False,
    2535        "match_condition": False,  # Snowflake
    2536        "expressions": False,
    2537        "pivots": False,
    2538    }
    2539
    2540    @property
    2541    def method(self) -> str:
    2542        return self.text("method").upper()
    2543
    2544    @property
    2545    def kind(self) -> str:
    2546        return self.text("kind").upper()
    2547
    2548    @property
    2549    def side(self) -> str:
    2550        return self.text("side").upper()
    2551
    2552    @property
    2553    def hint(self) -> str:
    2554        return self.text("hint").upper()
    2555
    2556    @property
    2557    def alias_or_name(self) -> str:
    2558        return self.this.alias_or_name
    2559
    2560    @property
    2561    def is_semi_or_anti_join(self) -> bool:
    2562        return self.kind in ("SEMI", "ANTI")
    2563
    2564    def on(
    2565        self,
    2566        *expressions: t.Optional[ExpOrStr],
    2567        append: bool = True,
    2568        dialect: DialectType = None,
    2569        copy: bool = True,
    2570        **opts,
    2571    ) -> Join:
    2572        """
    2573        Append to or set the ON expressions.
    2574
    2575        Example:
    2576            >>> import sqlglot
    2577            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    2578            'JOIN x ON y = 1'
    2579
    2580        Args:
    2581            *expressions: the SQL code strings to parse.
    2582                If an `Expression` instance is passed, it will be used as-is.
    2583                Multiple expressions are combined with an AND operator.
    2584            append: if `True`, AND the new expressions to any existing expression.
    2585                Otherwise, this resets the expression.
    2586            dialect: the dialect used to parse the input expressions.
    2587            copy: if `False`, modify this expression instance in-place.
    2588            opts: other options to use to parse the input expressions.
    2589
    2590        Returns:
    2591            The modified Join expression.
    2592        """
    2593        join = _apply_conjunction_builder(
    2594            *expressions,
    2595            instance=self,
    2596            arg="on",
    2597            append=append,
    2598            dialect=dialect,
    2599            copy=copy,
    2600            **opts,
    2601        )
    2602
    2603        if join.kind == "CROSS":
    2604            join.set("kind", None)
    2605
    2606        return join
    2607
    2608    def using(
    2609        self,
    2610        *expressions: t.Optional[ExpOrStr],
    2611        append: bool = True,
    2612        dialect: DialectType = None,
    2613        copy: bool = True,
    2614        **opts,
    2615    ) -> Join:
    2616        """
    2617        Append to or set the USING expressions.
    2618
    2619        Example:
    2620            >>> import sqlglot
    2621            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    2622            'JOIN x USING (foo, bla)'
    2623
    2624        Args:
    2625            *expressions: the SQL code strings to parse.
    2626                If an `Expression` instance is passed, it will be used as-is.
    2627            append: if `True`, concatenate the new expressions to the existing "using" list.
    2628                Otherwise, this resets the expression.
    2629            dialect: the dialect used to parse the input expressions.
    2630            copy: if `False`, modify this expression instance in-place.
    2631            opts: other options to use to parse the input expressions.
    2632
    2633        Returns:
    2634            The modified Join expression.
    2635        """
    2636        join = _apply_list_builder(
    2637            *expressions,
    2638            instance=self,
    2639            arg="using",
    2640            append=append,
    2641            dialect=dialect,
    2642            copy=copy,
    2643            **opts,
    2644        )
    2645
    2646        if join.kind == "CROSS":
    2647            join.set("kind", None)
    2648
    2649        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, 'pivots': False}
method: str View Source

    2540    @property
    2541    def method(self) -> str:
    2542        return self.text("method").upper()

kind: str View Source

    2544    @property
    2545    def kind(self) -> str:
    2546        return self.text("kind").upper()

side: str View Source

    2548    @property
    2549    def side(self) -> str:
    2550        return self.text("side").upper()

hint: str View Source

    2552    @property
    2553    def hint(self) -> str:
    2554        return self.text("hint").upper()

alias_or_name: str View Source

    2556    @property
    2557    def alias_or_name(self) -> str:
    2558        return self.this.alias_or_name

is_semi_or_anti_join: bool View Source

    2560    @property
    2561    def is_semi_or_anti_join(self) -> bool:
    2562        return self.kind in ("SEMI", "ANTI")

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

    2564    def on(
    2565        self,
    2566        *expressions: t.Optional[ExpOrStr],
    2567        append: bool = True,
    2568        dialect: DialectType = None,
    2569        copy: bool = True,
    2570        **opts,
    2571    ) -> Join:
    2572        """
    2573        Append to or set the ON expressions.
    2574
    2575        Example:
    2576            >>> import sqlglot
    2577            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    2578            'JOIN x ON y = 1'
    2579
    2580        Args:
    2581            *expressions: the SQL code strings to parse.
    2582                If an `Expression` instance is passed, it will be used as-is.
    2583                Multiple expressions are combined with an AND operator.
    2584            append: if `True`, AND the new expressions to any existing expression.
    2585                Otherwise, this resets the expression.
    2586            dialect: the dialect used to parse the input expressions.
    2587            copy: if `False`, modify this expression instance in-place.
    2588            opts: other options to use to parse the input expressions.
    2589
    2590        Returns:
    2591            The modified Join expression.
    2592        """
    2593        join = _apply_conjunction_builder(
    2594            *expressions,
    2595            instance=self,
    2596            arg="on",
    2597            append=append,
    2598            dialect=dialect,
    2599            copy=copy,
    2600            **opts,
    2601        )
    2602
    2603        if join.kind == "CROSS":
    2604            join.set("kind", None)
    2605
    2606        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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Join: View Source

    2608    def using(
    2609        self,
    2610        *expressions: t.Optional[ExpOrStr],
    2611        append: bool = True,
    2612        dialect: DialectType = None,
    2613        copy: bool = True,
    2614        **opts,
    2615    ) -> Join:
    2616        """
    2617        Append to or set the USING expressions.
    2618
    2619        Example:
    2620            >>> import sqlglot
    2621            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    2622            'JOIN x USING (foo, bla)'
    2623
    2624        Args:
    2625            *expressions: the SQL code strings to parse.
    2626                If an `Expression` instance is passed, it will be used as-is.
    2627            append: if `True`, concatenate the new expressions to the existing "using" list.
    2628                Otherwise, this resets the expression.
    2629            dialect: the dialect used to parse the input expressions.
    2630            copy: if `False`, modify this expression instance in-place.
    2631            opts: other options to use to parse the input expressions.
    2632
    2633        Returns:
    2634            The modified Join expression.
    2635        """
    2636        join = _apply_list_builder(
    2637            *expressions,
    2638            instance=self,
    2639            arg="using",
    2640            append=append,
    2641            dialect=dialect,
    2642            copy=copy,
    2643            **opts,
    2644        )
    2645
    2646        if join.kind == "CROSS":
    2647            join.set("kind", None)
    2648
    2649        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Lateral(UDTF): View Source

    2652class Lateral(UDTF):
    2653    arg_types = {
    2654        "this": True,
    2655        "view": False,
    2656        "outer": False,
    2657        "alias": False,
    2658        "cross_apply": False,  # True -> CROSS APPLY, False -> OUTER APPLY
    2659        "ordinality": False,
    2660    }

arg_types = {'this': True, 'view': False, 'outer': False, 'alias': False, 'cross_apply': False, 'ordinality': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
UDTF
  selects
DerivedTable
  named_selects

class TableFromRows(UDTF): View Source

    2665class TableFromRows(UDTF):
    2666    arg_types = {
    2667        "this": True,
    2668        "alias": False,
    2669        "joins": False,
    2670        "pivots": False,
    2671        "sample": False,
    2672    }

arg_types = {'this': True, 'alias': False, 'joins': False, 'pivots': False, 'sample': False}
key = 'tablefromrows'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
UDTF
  selects
DerivedTable
  named_selects

class MatchRecognizeMeasure(Expression): View Source

    2675class MatchRecognizeMeasure(Expression):
    2676    arg_types = {
    2677        "this": True,
    2678        "window_frame": False,
    2679    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MatchRecognize(Expression): View Source

    2682class MatchRecognize(Expression):
    2683    arg_types = {
    2684        "partition_by": False,
    2685        "order": False,
    2686        "measures": False,
    2687        "rows": False,
    2688        "after": False,
    2689        "pattern": False,
    2690        "define": False,
    2691        "alias": False,
    2692    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Final(Expression): View Source

    2697class Final(Expression):
    2698    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Offset(Expression): View Source

    2701class Offset(Expression):
    2702    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Order(Expression): View Source

    2705class Order(Expression):
    2706    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithFill(Expression): View Source

    2710class WithFill(Expression):
    2711    arg_types = {
    2712        "from": False,
    2713        "to": False,
    2714        "step": False,
    2715        "interpolate": False,
    2716    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Cluster(Order): View Source

    2721class Cluster(Order):
    2722    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Order
  arg_types

class Distribute(Order): View Source

    2725class Distribute(Order):
    2726    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Order
  arg_types

class Sort(Order): View Source

    2729class Sort(Order):
    2730    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Order
  arg_types

class Ordered(Expression): View Source

    2733class Ordered(Expression):
    2734    arg_types = {"this": True, "desc": False, "nulls_first": True, "with_fill": False}
    2735
    2736    @property
    2737    def name(self) -> str:
    2738        return self.this.name

arg_types = {'this': True, 'desc': False, 'nulls_first': True, 'with_fill': False}
name: str View Source

    2736    @property
    2737    def name(self) -> str:
    2738        return self.this.name

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
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Property(Expression): View Source

    2741class Property(Expression):
    2742    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GrantPrivilege(Expression): View Source

    2745class GrantPrivilege(Expression):
    2746    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GrantPrincipal(Expression): View Source

    2749class GrantPrincipal(Expression):
    2750    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AllowedValuesProperty(Expression): View Source

    2753class AllowedValuesProperty(Expression):
    2754    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AlgorithmProperty(Property): View Source

    2757class AlgorithmProperty(Property):
    2758    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AutoIncrementProperty(Property): View Source

    2761class AutoIncrementProperty(Property):
    2762    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AutoRefreshProperty(Property): View Source

    2766class AutoRefreshProperty(Property):
    2767    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BackupProperty(Property): View Source

    2770class BackupProperty(Property):
    2771    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BlockCompressionProperty(Property): View Source

    2774class BlockCompressionProperty(Property):
    2775    arg_types = {
    2776        "autotemp": False,
    2777        "always": False,
    2778        "default": False,
    2779        "manual": False,
    2780        "never": False,
    2781    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CharacterSetProperty(Property): View Source

    2784class CharacterSetProperty(Property):
    2785    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ChecksumProperty(Property): View Source

    2788class ChecksumProperty(Property):
    2789    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CollateProperty(Property): View Source

    2792class CollateProperty(Property):
    2793    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CopyGrantsProperty(Property): View Source

    2796class CopyGrantsProperty(Property):
    2797    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataBlocksizeProperty(Property): View Source

    2800class DataBlocksizeProperty(Property):
    2801    arg_types = {
    2802        "size": False,
    2803        "units": False,
    2804        "minimum": False,
    2805        "maximum": False,
    2806        "default": False,
    2807    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataDeletionProperty(Property): View Source

    2810class DataDeletionProperty(Property):
    2811    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DefinerProperty(Property): View Source

    2814class DefinerProperty(Property):
    2815    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DistKeyProperty(Property): View Source

    2818class DistKeyProperty(Property):
    2819    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DistributedByProperty(Property): View Source

    2824class DistributedByProperty(Property):
    2825    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DistStyleProperty(Property): View Source

    2828class DistStyleProperty(Property):
    2829    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DuplicateKeyProperty(Property): View Source

    2832class DuplicateKeyProperty(Property):
    2833    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EngineProperty(Property): View Source

    2836class EngineProperty(Property):
    2837    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HeapProperty(Property): View Source

    2840class HeapProperty(Property):
    2841    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ToTableProperty(Property): View Source

    2844class ToTableProperty(Property):
    2845    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ExecuteAsProperty(Property): View Source

    2848class ExecuteAsProperty(Property):
    2849    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ExternalProperty(Property): View Source

    2852class ExternalProperty(Property):
    2853    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FallbackProperty(Property): View Source

    2856class FallbackProperty(Property):
    2857    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FileFormatProperty(Property): View Source

    2860class FileFormatProperty(Property):
    2861    arg_types = {"this": False, "expressions": False}

arg_types = {'this': False, 'expressions': False}
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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class CredentialsProperty(Property): View Source

    2864class CredentialsProperty(Property):
    2865    arg_types = {"expressions": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FreespaceProperty(Property): View Source

    2868class FreespaceProperty(Property):
    2869    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GlobalProperty(Property): View Source

    2872class GlobalProperty(Property):
    2873    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IcebergProperty(Property): View Source

    2876class IcebergProperty(Property):
    2877    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InheritsProperty(Property): View Source

    2880class InheritsProperty(Property):
    2881    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InputModelProperty(Property): View Source

    2884class InputModelProperty(Property):
    2885    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OutputModelProperty(Property): View Source

    2888class OutputModelProperty(Property):
    2889    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IsolatedLoadingProperty(Property): View Source

    2892class IsolatedLoadingProperty(Property):
    2893    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JournalProperty(Property): View Source

    2896class JournalProperty(Property):
    2897    arg_types = {
    2898        "no": False,
    2899        "dual": False,
    2900        "before": False,
    2901        "local": False,
    2902        "after": False,
    2903    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LanguageProperty(Property): View Source

    2906class LanguageProperty(Property):
    2907    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EnviromentProperty(Property): View Source

    2910class EnviromentProperty(Property):
    2911    arg_types = {"expressions": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ClusteredByProperty(Property): View Source

    2915class ClusteredByProperty(Property):
    2916    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DictProperty(Property): View Source

    2919class DictProperty(Property):
    2920    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DictSubProperty(Property): View Source

    2923class DictSubProperty(Property):
    2924    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Property
  arg_types

class DictRange(Property): View Source

    2927class DictRange(Property):
    2928    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DynamicProperty(Property): View Source

    2931class DynamicProperty(Property):
    2932    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnCluster(Property): View Source

    2937class OnCluster(Property):
    2938    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EmptyProperty(Property): View Source

    2942class EmptyProperty(Property):
    2943    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LikeProperty(Property): View Source

    2946class LikeProperty(Property):
    2947    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LocationProperty(Property): View Source

    2950class LocationProperty(Property):
    2951    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LockProperty(Property): View Source

    2954class LockProperty(Property):
    2955    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LockingProperty(Property): View Source

    2958class LockingProperty(Property):
    2959    arg_types = {
    2960        "this": False,
    2961        "kind": True,
    2962        "for_or_in": False,
    2963        "lock_type": True,
    2964        "override": False,
    2965    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class LogProperty(Property): View Source

    2968class LogProperty(Property):
    2969    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MaterializedProperty(Property): View Source

    2972class MaterializedProperty(Property):
    2973    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class MergeBlockRatioProperty(Property): View Source

    2976class MergeBlockRatioProperty(Property):
    2977    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NoPrimaryIndexProperty(Property): View Source

    2980class NoPrimaryIndexProperty(Property):
    2981    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnProperty(Property): View Source

    2984class OnProperty(Property):
    2985    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OnCommitProperty(Property): View Source

    2988class OnCommitProperty(Property):
    2989    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionedByProperty(Property): View Source

    2992class PartitionedByProperty(Property):
    2993    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionedByBucket(Property): View Source

    2996class PartitionedByBucket(Property):
    2997    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionByTruncate(Property): View Source

    3000class PartitionByTruncate(Property):
    3001    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionByRangeProperty(Property): View Source

    3005class PartitionByRangeProperty(Property):
    3006    arg_types = {"partition_expressions": True, "create_expressions": True}

arg_types = {'partition_expressions': True, 'create_expressions': True}
key = 'partitionbyrangeproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionByRangePropertyDynamic(Expression): View Source

    3010class PartitionByRangePropertyDynamic(Expression):
    3011    arg_types = {"this": False, "start": True, "end": True, "every": True}

arg_types = {'this': False, 'start': True, 'end': True, 'every': True}
key = 'partitionbyrangepropertydynamic'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UniqueKeyProperty(Property): View Source

    3015class UniqueKeyProperty(Property):
    3016    arg_types = {"expressions": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionBoundSpec(Expression): View Source

    3020class PartitionBoundSpec(Expression):
    3021    # this -> IN / MODULUS, expression -> REMAINDER, from_expressions -> FROM (...), to_expressions -> TO (...)
    3022    arg_types = {
    3023        "this": False,
    3024        "expression": False,
    3025        "from_expressions": False,
    3026        "to_expressions": False,
    3027    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PartitionedOfProperty(Property): View Source

    3030class PartitionedOfProperty(Property):
    3031    # this -> parent_table (schema), expression -> FOR VALUES ... / DEFAULT
    3032    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StreamingTableProperty(Property): View Source

    3035class StreamingTableProperty(Property):
    3036    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RemoteWithConnectionModelProperty(Property): View Source

    3039class RemoteWithConnectionModelProperty(Property):
    3040    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ReturnsProperty(Property): View Source

    3043class ReturnsProperty(Property):
    3044    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StrictProperty(Property): View Source

    3047class StrictProperty(Property):
    3048    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RowFormatProperty(Property): View Source

    3051class RowFormatProperty(Property):
    3052    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RowFormatDelimitedProperty(Property): View Source

    3055class RowFormatDelimitedProperty(Property):
    3056    # https://cwiki.apache.org/confluence/display/hive/languagemanual+dml
    3057    arg_types = {
    3058        "fields": False,
    3059        "escaped": False,
    3060        "collection_items": False,
    3061        "map_keys": False,
    3062        "lines": False,
    3063        "null": False,
    3064        "serde": False,
    3065    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RowFormatSerdeProperty(Property): View Source

    3068class RowFormatSerdeProperty(Property):
    3069    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class QueryTransform(Expression): View Source

    3073class QueryTransform(Expression):
    3074    arg_types = {
    3075        "expressions": True,
    3076        "command_script": True,
    3077        "schema": False,
    3078        "row_format_before": False,
    3079        "record_writer": False,
    3080        "row_format_after": False,
    3081        "record_reader": False,
    3082    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SampleProperty(Property): View Source

    3085class SampleProperty(Property):
    3086    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SecurityProperty(Property): View Source

    3090class SecurityProperty(Property):
    3091    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SchemaCommentProperty(Property): View Source

    3094class SchemaCommentProperty(Property):
    3095    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SerdeProperties(Property): View Source

    3098class SerdeProperties(Property):
    3099    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetProperty(Property): View Source

    3102class SetProperty(Property):
    3103    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SharingProperty(Property): View Source

    3106class SharingProperty(Property):
    3107    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetConfigProperty(Property): View Source

    3110class SetConfigProperty(Property):
    3111    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SettingsProperty(Property): View Source

    3114class SettingsProperty(Property):
    3115    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SortKeyProperty(Property): View Source

    3118class SortKeyProperty(Property):
    3119    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SqlReadWriteProperty(Property): View Source

    3122class SqlReadWriteProperty(Property):
    3123    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SqlSecurityProperty(Property): View Source

    3126class SqlSecurityProperty(Property):
    3127    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StabilityProperty(Property): View Source

    3130class StabilityProperty(Property):
    3131    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StorageHandlerProperty(Property): View Source

    3134class StorageHandlerProperty(Property):
    3135    arg_types = {"this": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TemporaryProperty(Property): View Source

    3138class TemporaryProperty(Property):
    3139    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SecureProperty(Property): View Source

    3142class SecureProperty(Property):
    3143    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Tags(ColumnConstraintKind, Property): View Source

    3147class Tags(ColumnConstraintKind, Property):
    3148    arg_types = {"expressions": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TransformModelProperty(Property): View Source

    3151class TransformModelProperty(Property):
    3152    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TransientProperty(Property): View Source

    3155class TransientProperty(Property):
    3156    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UnloggedProperty(Property): View Source

    3159class UnloggedProperty(Property):
    3160    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UsingTemplateProperty(Property): View Source

    3164class UsingTemplateProperty(Property):
    3165    arg_types = {"this": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ViewAttributeProperty(Property): View Source

    3169class ViewAttributeProperty(Property):
    3170    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class VolatileProperty(Property): View Source

    3173class VolatileProperty(Property):
    3174    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithDataProperty(Property): View Source

    3177class WithDataProperty(Property):
    3178    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithJournalTableProperty(Property): View Source

    3181class WithJournalTableProperty(Property):
    3182    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithSchemaBindingProperty(Property): View Source

    3185class WithSchemaBindingProperty(Property):
    3186    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithSystemVersioningProperty(Property): View Source

    3189class WithSystemVersioningProperty(Property):
    3190    arg_types = {
    3191        "on": False,
    3192        "this": False,
    3193        "data_consistency": False,
    3194        "retention_period": False,
    3195        "with": True,
    3196    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithProcedureOptions(Property): View Source

    3199class WithProcedureOptions(Property):
    3200    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class EncodeProperty(Property): View Source

    3203class EncodeProperty(Property):
    3204    arg_types = {"this": True, "properties": False, "key": False}

arg_types = {'this': True, 'properties': False, 'key': False}
key = 'encodeproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IncludeProperty(Property): View Source

    3207class IncludeProperty(Property):
    3208    arg_types = {"this": True, "alias": False, "column_def": False}

arg_types = {'this': True, 'alias': False, 'column_def': False}
key = 'includeproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ForceProperty(Property): View Source

    3211class ForceProperty(Property):
    3212    arg_types = {}

arg_types = {}
key = 'forceproperty'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Properties(Expression): View Source

    3215class Properties(Expression):
    3216    arg_types = {"expressions": True}
    3217
    3218    NAME_TO_PROPERTY = {
    3219        "ALGORITHM": AlgorithmProperty,
    3220        "AUTO_INCREMENT": AutoIncrementProperty,
    3221        "CHARACTER SET": CharacterSetProperty,
    3222        "CLUSTERED_BY": ClusteredByProperty,
    3223        "COLLATE": CollateProperty,
    3224        "COMMENT": SchemaCommentProperty,
    3225        "CREDENTIALS": CredentialsProperty,
    3226        "DEFINER": DefinerProperty,
    3227        "DISTKEY": DistKeyProperty,
    3228        "DISTRIBUTED_BY": DistributedByProperty,
    3229        "DISTSTYLE": DistStyleProperty,
    3230        "ENGINE": EngineProperty,
    3231        "EXECUTE AS": ExecuteAsProperty,
    3232        "FORMAT": FileFormatProperty,
    3233        "LANGUAGE": LanguageProperty,
    3234        "LOCATION": LocationProperty,
    3235        "LOCK": LockProperty,
    3236        "PARTITIONED_BY": PartitionedByProperty,
    3237        "RETURNS": ReturnsProperty,
    3238        "ROW_FORMAT": RowFormatProperty,
    3239        "SORTKEY": SortKeyProperty,
    3240        "ENCODE": EncodeProperty,
    3241        "INCLUDE": IncludeProperty,
    3242    }
    3243
    3244    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    3245
    3246    # CREATE property locations
    3247    # Form: schema specified
    3248    #   create [POST_CREATE]
    3249    #     table a [POST_NAME]
    3250    #     (b int) [POST_SCHEMA]
    3251    #     with ([POST_WITH])
    3252    #     index (b) [POST_INDEX]
    3253    #
    3254    # Form: alias selection
    3255    #   create [POST_CREATE]
    3256    #     table a [POST_NAME]
    3257    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    3258    #     index (c) [POST_INDEX]
    3259    class Location(AutoName):
    3260        POST_CREATE = auto()
    3261        POST_NAME = auto()
    3262        POST_SCHEMA = auto()
    3263        POST_WITH = auto()
    3264        POST_ALIAS = auto()
    3265        POST_EXPRESSION = auto()
    3266        POST_INDEX = auto()
    3267        UNSUPPORTED = auto()
    3268
    3269    @classmethod
    3270    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3271        expressions = []
    3272        for key, value in properties_dict.items():
    3273            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3274            if property_cls:
    3275                expressions.append(property_cls(this=convert(value)))
    3276            else:
    3277                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3278
    3279        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'>, 'CREDENTIALS': <class 'CredentialsProperty'>, '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'>, 'ENCODE': <class 'EncodeProperty'>, 'INCLUDE': <class 'IncludeProperty'>}
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 'CredentialsProperty'>: 'CREDENTIALS', <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', <class 'EncodeProperty'>: 'ENCODE', <class 'IncludeProperty'>: 'INCLUDE'}
@classmethod
def from_dict(cls, properties_dict: Dict) -> Properties: View Source

    3269    @classmethod
    3270    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    3271        expressions = []
    3272        for key, value in properties_dict.items():
    3273            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    3274            if property_cls:
    3275                expressions.append(property_cls(this=convert(value)))
    3276            else:
    3277                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    3278
    3279        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Properties.Location(sqlglot.helper.AutoName): View Source

    3259    class Location(AutoName):
    3260        POST_CREATE = auto()
    3261        POST_NAME = auto()
    3262        POST_SCHEMA = auto()
    3263        POST_WITH = auto()
    3264        POST_ALIAS = auto()
    3265        POST_EXPRESSION = auto()
    3266        POST_INDEX = auto()
    3267        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

    3282class Qualify(Expression):
    3283    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class InputOutputFormat(Expression): View Source

    3286class InputOutputFormat(Expression):
    3287    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Return(Expression): View Source

    3291class Return(Expression):
    3292    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Reference(Expression): View Source

    3295class Reference(Expression):
    3296    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Tuple(Expression): View Source

    3299class Tuple(Expression):
    3300    arg_types = {"expressions": False}
    3301
    3302    def isin(
    3303        self,
    3304        *expressions: t.Any,
    3305        query: t.Optional[ExpOrStr] = None,
    3306        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3307        copy: bool = True,
    3308        **opts,
    3309    ) -> In:
    3310        return In(
    3311            this=maybe_copy(self, copy),
    3312            expressions=[convert(e, copy=copy) for e in expressions],
    3313            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3314            unnest=(
    3315                Unnest(
    3316                    expressions=[
    3317                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3318                        for e in ensure_list(unnest)
    3319                    ]
    3320                )
    3321                if unnest
    3322                else None
    3323            ),
    3324        )

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

    3302    def isin(
    3303        self,
    3304        *expressions: t.Any,
    3305        query: t.Optional[ExpOrStr] = None,
    3306        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    3307        copy: bool = True,
    3308        **opts,
    3309    ) -> In:
    3310        return In(
    3311            this=maybe_copy(self, copy),
    3312            expressions=[convert(e, copy=copy) for e in expressions],
    3313            query=maybe_parse(query, copy=copy, **opts) if query else None,
    3314            unnest=(
    3315                Unnest(
    3316                    expressions=[
    3317                        maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
    3318                        for e in ensure_list(unnest)
    3319                    ]
    3320                )
    3321                if unnest
    3322                else None
    3323            ),
    3324        )

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_
  update_positions
  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

    3355class QueryOption(Expression):
    3356    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WithTableHint(Expression): View Source

    3360class WithTableHint(Expression):
    3361    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IndexTableHint(Expression): View Source

    3365class IndexTableHint(Expression):
    3366    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HistoricalData(Expression): View Source

    3370class HistoricalData(Expression):
    3371    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Put(Expression): View Source

    3375class Put(Expression):
    3376    arg_types = {"this": True, "target": True, "properties": False}

arg_types = {'this': True, 'target': True, 'properties': False}
key = 'put'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Get(Expression): View Source

    3380class Get(Expression):
    3381    arg_types = {"this": True, "target": True, "properties": False}

arg_types = {'this': True, 'target': True, 'properties': False}
key = 'get'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Table(Expression): View Source

    3384class Table(Expression):
    3385    arg_types = {
    3386        "this": False,
    3387        "alias": False,
    3388        "db": False,
    3389        "catalog": False,
    3390        "laterals": False,
    3391        "joins": False,
    3392        "pivots": False,
    3393        "hints": False,
    3394        "system_time": False,
    3395        "version": False,
    3396        "format": False,
    3397        "pattern": False,
    3398        "ordinality": False,
    3399        "when": False,
    3400        "only": False,
    3401        "partition": False,
    3402        "changes": False,
    3403        "rows_from": False,
    3404        "sample": False,
    3405    }
    3406
    3407    @property
    3408    def name(self) -> str:
    3409        if not self.this or isinstance(self.this, Func):
    3410            return ""
    3411        return self.this.name
    3412
    3413    @property
    3414    def db(self) -> str:
    3415        return self.text("db")
    3416
    3417    @property
    3418    def catalog(self) -> str:
    3419        return self.text("catalog")
    3420
    3421    @property
    3422    def selects(self) -> t.List[Expression]:
    3423        return []
    3424
    3425    @property
    3426    def named_selects(self) -> t.List[str]:
    3427        return []
    3428
    3429    @property
    3430    def parts(self) -> t.List[Expression]:
    3431        """Return the parts of a table in order catalog, db, table."""
    3432        parts: t.List[Expression] = []
    3433
    3434        for arg in ("catalog", "db", "this"):
    3435            part = self.args.get(arg)
    3436
    3437            if isinstance(part, Dot):
    3438                parts.extend(part.flatten())
    3439            elif isinstance(part, Expression):
    3440                parts.append(part)
    3441
    3442        return parts
    3443
    3444    def to_column(self, copy: bool = True) -> Expression:
    3445        parts = self.parts
    3446        last_part = parts[-1]
    3447
    3448        if isinstance(last_part, Identifier):
    3449            col: Expression = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3450        else:
    3451            # This branch will be reached if a function or array is wrapped in a `Table`
    3452            col = last_part
    3453
    3454        alias = self.args.get("alias")
    3455        if alias:
    3456            col = alias_(col, alias.this, copy=copy)
    3457
    3458        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

    3407    @property
    3408    def name(self) -> str:
    3409        if not self.this or isinstance(self.this, Func):
    3410            return ""
    3411        return self.this.name

db: str View Source

    3413    @property
    3414    def db(self) -> str:
    3415        return self.text("db")

catalog: str View Source

    3417    @property
    3418    def catalog(self) -> str:
    3419        return self.text("catalog")

selects: List[Expression] View Source

    3421    @property
    3422    def selects(self) -> t.List[Expression]:
    3423        return []

named_selects: List[str] View Source

    3425    @property
    3426    def named_selects(self) -> t.List[str]:
    3427        return []

parts: List[Expression] View Source

    3429    @property
    3430    def parts(self) -> t.List[Expression]:
    3431        """Return the parts of a table in order catalog, db, table."""
    3432        parts: t.List[Expression] = []
    3433
    3434        for arg in ("catalog", "db", "this"):
    3435            part = self.args.get(arg)
    3436
    3437            if isinstance(part, Dot):
    3438                parts.extend(part.flatten())
    3439            elif isinstance(part, Expression):
    3440                parts.append(part)
    3441
    3442        return parts

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

def to_column(self, copy: bool = True) -> Expression: View Source

    3444    def to_column(self, copy: bool = True) -> Expression:
    3445        parts = self.parts
    3446        last_part = parts[-1]
    3447
    3448        if isinstance(last_part, Identifier):
    3449            col: Expression = column(*reversed(parts[0:4]), fields=parts[4:], copy=copy)  # type: ignore
    3450        else:
    3451            # This branch will be reached if a function or array is wrapped in a `Table`
    3452            col = last_part
    3453
    3454        alias = self.args.get("alias")
    3455        if alias:
    3456            col = alias_(col, alias.this, copy=copy)
    3457
    3458        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SetOperation(Query): View Source

    3461class SetOperation(Query):
    3462    arg_types = {
    3463        "with": False,
    3464        "this": True,
    3465        "expression": True,
    3466        "distinct": False,
    3467        "by_name": False,
    3468        "side": False,
    3469        "kind": False,
    3470        "on": False,
    3471        **QUERY_MODIFIERS,
    3472    }
    3473
    3474    def select(
    3475        self: S,
    3476        *expressions: t.Optional[ExpOrStr],
    3477        append: bool = True,
    3478        dialect: DialectType = None,
    3479        copy: bool = True,
    3480        **opts,
    3481    ) -> S:
    3482        this = maybe_copy(self, copy)
    3483        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3484        this.expression.unnest().select(
    3485            *expressions, append=append, dialect=dialect, copy=False, **opts
    3486        )
    3487        return this
    3488
    3489    @property
    3490    def named_selects(self) -> t.List[str]:
    3491        return self.this.unnest().named_selects
    3492
    3493    @property
    3494    def is_star(self) -> bool:
    3495        return self.this.is_star or self.expression.is_star
    3496
    3497    @property
    3498    def selects(self) -> t.List[Expression]:
    3499        return self.this.unnest().selects
    3500
    3501    @property
    3502    def left(self) -> Query:
    3503        return self.this
    3504
    3505    @property
    3506    def right(self) -> Query:
    3507        return self.expression
    3508
    3509    @property
    3510    def kind(self) -> str:
    3511        return self.text("kind").upper()
    3512
    3513    @property
    3514    def side(self) -> str:
    3515        return self.text("side").upper()

arg_types = {'with': False, 'this': True, 'expression': True, 'distinct': False, 'by_name': False, 'side': False, 'kind': False, 'on': 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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> ~S: View Source

    3474    def select(
    3475        self: S,
    3476        *expressions: t.Optional[ExpOrStr],
    3477        append: bool = True,
    3478        dialect: DialectType = None,
    3479        copy: bool = True,
    3480        **opts,
    3481    ) -> S:
    3482        this = maybe_copy(self, copy)
    3483        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    3484        this.expression.unnest().select(
    3485            *expressions, append=append, dialect=dialect, copy=False, **opts
    3486        )
    3487        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

    3489    @property
    3490    def named_selects(self) -> t.List[str]:
    3491        return self.this.unnest().named_selects

Returns the output names of the query's projections.

is_star: bool View Source

    3493    @property
    3494    def is_star(self) -> bool:
    3495        return self.this.is_star or self.expression.is_star

Checks whether an expression is a star.

selects: List[Expression] View Source

    3497    @property
    3498    def selects(self) -> t.List[Expression]:
    3499        return self.this.unnest().selects

Returns the query's projections.

left: Query View Source

    3501    @property
    3502    def left(self) -> Query:
    3503        return self.this

right: Query View Source

    3505    @property
    3506    def right(self) -> Query:
    3507        return self.expression

kind: str View Source

    3509    @property
    3510    def kind(self) -> str:
    3511        return self.text("kind").upper()

side: str View Source

    3513    @property
    3514    def side(self) -> str:
    3515        return self.text("side").upper()

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Query
  subquery
  limit
  offset
  order_by
  ctes
  where
  with_
  union
  intersect
  except_

class Union(SetOperation): View Source

    3518class Union(SetOperation):
    3519    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
SetOperation
  arg_types
  select
  named_selects
  is_star
  selects
  left
  right
  kind
  side
Query
  subquery
  limit
  offset
  order_by
  ctes
  where
  with_
  union
  intersect
  except_

class Except(SetOperation): View Source

    3522class Except(SetOperation):
    3523    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
SetOperation
  arg_types
  select
  named_selects
  is_star
  selects
  left
  right
  kind
  side
Query
  subquery
  limit
  offset
  order_by
  ctes
  where
  with_
  union
  intersect
  except_

class Intersect(SetOperation): View Source

    3526class Intersect(SetOperation):
    3527    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
SetOperation
  arg_types
  select
  named_selects
  is_star
  selects
  left
  right
  kind
  side
Query
  subquery
  limit
  offset
  order_by
  ctes
  where
  with_
  union
  intersect
  except_

class Update(DML): View Source

    3530class Update(DML):
    3531    arg_types = {
    3532        "with": False,
    3533        "this": False,
    3534        "expressions": True,
    3535        "from": False,
    3536        "where": False,
    3537        "returning": False,
    3538        "order": False,
    3539        "limit": False,
    3540    }
    3541
    3542    def table(
    3543        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3544    ) -> Update:
    3545        """
    3546        Set the table to update.
    3547
    3548        Example:
    3549            >>> Update().table("my_table").set_("x = 1").sql()
    3550            'UPDATE my_table SET x = 1'
    3551
    3552        Args:
    3553            expression : the SQL code strings to parse.
    3554                If a `Table` instance is passed, this is used as-is.
    3555                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3556            dialect: the dialect used to parse the input expression.
    3557            copy: if `False`, modify this expression instance in-place.
    3558            opts: other options to use to parse the input expressions.
    3559
    3560        Returns:
    3561            The modified Update expression.
    3562        """
    3563        return _apply_builder(
    3564            expression=expression,
    3565            instance=self,
    3566            arg="this",
    3567            into=Table,
    3568            prefix=None,
    3569            dialect=dialect,
    3570            copy=copy,
    3571            **opts,
    3572        )
    3573
    3574    def set_(
    3575        self,
    3576        *expressions: ExpOrStr,
    3577        append: bool = True,
    3578        dialect: DialectType = None,
    3579        copy: bool = True,
    3580        **opts,
    3581    ) -> Update:
    3582        """
    3583        Append to or set the SET expressions.
    3584
    3585        Example:
    3586            >>> Update().table("my_table").set_("x = 1").sql()
    3587            'UPDATE my_table SET x = 1'
    3588
    3589        Args:
    3590            *expressions: the SQL code strings to parse.
    3591                If `Expression` instance(s) are passed, they will be used as-is.
    3592                Multiple expressions are combined with a comma.
    3593            append: if `True`, add the new expressions to any existing SET expressions.
    3594                Otherwise, this resets the expressions.
    3595            dialect: the dialect used to parse the input expressions.
    3596            copy: if `False`, modify this expression instance in-place.
    3597            opts: other options to use to parse the input expressions.
    3598        """
    3599        return _apply_list_builder(
    3600            *expressions,
    3601            instance=self,
    3602            arg="expressions",
    3603            append=append,
    3604            into=Expression,
    3605            prefix=None,
    3606            dialect=dialect,
    3607            copy=copy,
    3608            **opts,
    3609        )
    3610
    3611    def where(
    3612        self,
    3613        *expressions: t.Optional[ExpOrStr],
    3614        append: bool = True,
    3615        dialect: DialectType = None,
    3616        copy: bool = True,
    3617        **opts,
    3618    ) -> Select:
    3619        """
    3620        Append to or set the WHERE expressions.
    3621
    3622        Example:
    3623            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3624            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3625
    3626        Args:
    3627            *expressions: the SQL code strings to parse.
    3628                If an `Expression` instance is passed, it will be used as-is.
    3629                Multiple expressions are combined with an AND operator.
    3630            append: if `True`, AND the new expressions to any existing expression.
    3631                Otherwise, this resets the expression.
    3632            dialect: the dialect used to parse the input expressions.
    3633            copy: if `False`, modify this expression instance in-place.
    3634            opts: other options to use to parse the input expressions.
    3635
    3636        Returns:
    3637            Select: the modified expression.
    3638        """
    3639        return _apply_conjunction_builder(
    3640            *expressions,
    3641            instance=self,
    3642            arg="where",
    3643            append=append,
    3644            into=Where,
    3645            dialect=dialect,
    3646            copy=copy,
    3647            **opts,
    3648        )
    3649
    3650    def from_(
    3651        self,
    3652        expression: t.Optional[ExpOrStr] = None,
    3653        dialect: DialectType = None,
    3654        copy: bool = True,
    3655        **opts,
    3656    ) -> Update:
    3657        """
    3658        Set the FROM expression.
    3659
    3660        Example:
    3661            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3662            'UPDATE my_table SET x = 1 FROM baz'
    3663
    3664        Args:
    3665            expression : the SQL code strings to parse.
    3666                If a `From` instance is passed, this is used as-is.
    3667                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3668                If nothing is passed in then a from is not applied to the expression
    3669            dialect: the dialect used to parse the input expression.
    3670            copy: if `False`, modify this expression instance in-place.
    3671            opts: other options to use to parse the input expressions.
    3672
    3673        Returns:
    3674            The modified Update expression.
    3675        """
    3676        if not expression:
    3677            return maybe_copy(self, copy)
    3678
    3679        return _apply_builder(
    3680            expression=expression,
    3681            instance=self,
    3682            arg="from",
    3683            into=From,
    3684            prefix="FROM",
    3685            dialect=dialect,
    3686            copy=copy,
    3687            **opts,
    3688        )
    3689
    3690    def with_(
    3691        self,
    3692        alias: ExpOrStr,
    3693        as_: ExpOrStr,
    3694        recursive: t.Optional[bool] = None,
    3695        materialized: t.Optional[bool] = None,
    3696        append: bool = True,
    3697        dialect: DialectType = None,
    3698        copy: bool = True,
    3699        **opts,
    3700    ) -> Update:
    3701        """
    3702        Append to or set the common table expressions.
    3703
    3704        Example:
    3705            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3706            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3707
    3708        Args:
    3709            alias: the SQL code string to parse as the table name.
    3710                If an `Expression` instance is passed, this is used as-is.
    3711            as_: the SQL code string to parse as the table expression.
    3712                If an `Expression` instance is passed, it will be used as-is.
    3713            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3714            materialized: set the MATERIALIZED part of the expression.
    3715            append: if `True`, add to any existing expressions.
    3716                Otherwise, this resets the expressions.
    3717            dialect: the dialect used to parse the input expression.
    3718            copy: if `False`, modify this expression instance in-place.
    3719            opts: other options to use to parse the input expressions.
    3720
    3721        Returns:
    3722            The modified expression.
    3723        """
    3724        return _apply_cte_builder(
    3725            self,
    3726            alias,
    3727            as_,
    3728            recursive=recursive,
    3729            materialized=materialized,
    3730            append=append,
    3731            dialect=dialect,
    3732            copy=copy,
    3733            **opts,
    3734        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3542    def table(
    3543        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3544    ) -> Update:
    3545        """
    3546        Set the table to update.
    3547
    3548        Example:
    3549            >>> Update().table("my_table").set_("x = 1").sql()
    3550            'UPDATE my_table SET x = 1'
    3551
    3552        Args:
    3553            expression : the SQL code strings to parse.
    3554                If a `Table` instance is passed, this is used as-is.
    3555                If another `Expression` instance is passed, it will be wrapped in a `Table`.
    3556            dialect: the dialect used to parse the input expression.
    3557            copy: if `False`, modify this expression instance in-place.
    3558            opts: other options to use to parse the input expressions.
    3559
    3560        Returns:
    3561            The modified Update expression.
    3562        """
    3563        return _apply_builder(
    3564            expression=expression,
    3565            instance=self,
    3566            arg="this",
    3567            into=Table,
    3568            prefix=None,
    3569            dialect=dialect,
    3570            copy=copy,
    3571            **opts,
    3572        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3574    def set_(
    3575        self,
    3576        *expressions: ExpOrStr,
    3577        append: bool = True,
    3578        dialect: DialectType = None,
    3579        copy: bool = True,
    3580        **opts,
    3581    ) -> Update:
    3582        """
    3583        Append to or set the SET expressions.
    3584
    3585        Example:
    3586            >>> Update().table("my_table").set_("x = 1").sql()
    3587            'UPDATE my_table SET x = 1'
    3588
    3589        Args:
    3590            *expressions: the SQL code strings to parse.
    3591                If `Expression` instance(s) are passed, they will be used as-is.
    3592                Multiple expressions are combined with a comma.
    3593            append: if `True`, add the new expressions to any existing SET expressions.
    3594                Otherwise, this resets the expressions.
    3595            dialect: the dialect used to parse the input expressions.
    3596            copy: if `False`, modify this expression instance in-place.
    3597            opts: other options to use to parse the input expressions.
    3598        """
    3599        return _apply_list_builder(
    3600            *expressions,
    3601            instance=self,
    3602            arg="expressions",
    3603            append=append,
    3604            into=Expression,
    3605            prefix=None,
    3606            dialect=dialect,
    3607            copy=copy,
    3608            **opts,
    3609        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3611    def where(
    3612        self,
    3613        *expressions: t.Optional[ExpOrStr],
    3614        append: bool = True,
    3615        dialect: DialectType = None,
    3616        copy: bool = True,
    3617        **opts,
    3618    ) -> Select:
    3619        """
    3620        Append to or set the WHERE expressions.
    3621
    3622        Example:
    3623            >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql()
    3624            "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'"
    3625
    3626        Args:
    3627            *expressions: the SQL code strings to parse.
    3628                If an `Expression` instance is passed, it will be used as-is.
    3629                Multiple expressions are combined with an AND operator.
    3630            append: if `True`, AND the new expressions to any existing expression.
    3631                Otherwise, this resets the expression.
    3632            dialect: the dialect used to parse the input expressions.
    3633            copy: if `False`, modify this expression instance in-place.
    3634            opts: other options to use to parse the input expressions.
    3635
    3636        Returns:
    3637            Select: the modified expression.
    3638        """
    3639        return _apply_conjunction_builder(
    3640            *expressions,
    3641            instance=self,
    3642            arg="where",
    3643            append=append,
    3644            into=Where,
    3645            dialect=dialect,
    3646            copy=copy,
    3647            **opts,
    3648        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3650    def from_(
    3651        self,
    3652        expression: t.Optional[ExpOrStr] = None,
    3653        dialect: DialectType = None,
    3654        copy: bool = True,
    3655        **opts,
    3656    ) -> Update:
    3657        """
    3658        Set the FROM expression.
    3659
    3660        Example:
    3661            >>> Update().table("my_table").set_("x = 1").from_("baz").sql()
    3662            'UPDATE my_table SET x = 1 FROM baz'
    3663
    3664        Args:
    3665            expression : the SQL code strings to parse.
    3666                If a `From` instance is passed, this is used as-is.
    3667                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3668                If nothing is passed in then a from is not applied to the expression
    3669            dialect: the dialect used to parse the input expression.
    3670            copy: if `False`, modify this expression instance in-place.
    3671            opts: other options to use to parse the input expressions.
    3672
    3673        Returns:
    3674            The modified Update expression.
    3675        """
    3676        if not expression:
    3677            return maybe_copy(self, copy)
    3678
    3679        return _apply_builder(
    3680            expression=expression,
    3681            instance=self,
    3682            arg="from",
    3683            into=From,
    3684            prefix="FROM",
    3685            dialect=dialect,
    3686            copy=copy,
    3687            **opts,
    3688        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Update: View Source

    3690    def with_(
    3691        self,
    3692        alias: ExpOrStr,
    3693        as_: ExpOrStr,
    3694        recursive: t.Optional[bool] = None,
    3695        materialized: t.Optional[bool] = None,
    3696        append: bool = True,
    3697        dialect: DialectType = None,
    3698        copy: bool = True,
    3699        **opts,
    3700    ) -> Update:
    3701        """
    3702        Append to or set the common table expressions.
    3703
    3704        Example:
    3705            >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql()
    3706            'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz'
    3707
    3708        Args:
    3709            alias: the SQL code string to parse as the table name.
    3710                If an `Expression` instance is passed, this is used as-is.
    3711            as_: the SQL code string to parse as the table expression.
    3712                If an `Expression` instance is passed, it will be used as-is.
    3713            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    3714            materialized: set the MATERIALIZED part of the expression.
    3715            append: if `True`, add to any existing expressions.
    3716                Otherwise, this resets the expressions.
    3717            dialect: the dialect used to parse the input expression.
    3718            copy: if `False`, modify this expression instance in-place.
    3719            opts: other options to use to parse the input expressions.
    3720
    3721        Returns:
    3722            The modified expression.
    3723        """
    3724        return _apply_cte_builder(
    3725            self,
    3726            alias,
    3727            as_,
    3728            recursive=recursive,
    3729            materialized=materialized,
    3730            append=append,
    3731            dialect=dialect,
    3732            copy=copy,
    3733            **opts,
    3734        )

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class Values(UDTF): View Source

    3737class Values(UDTF):
    3738    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
UDTF
  selects
DerivedTable
  named_selects

class Var(Expression): View Source

    3741class Var(Expression):
    3742    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Version(Expression): View Source

    3745class Version(Expression):
    3746    """
    3747    Time travel, iceberg, bigquery etc
    3748    https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots
    3749    https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html
    3750    https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of
    3751    https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16
    3752    this is either TIMESTAMP or VERSION
    3753    kind is ("AS OF", "BETWEEN")
    3754    """
    3755
    3756    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Schema(Expression): View Source

    3759class Schema(Expression):
    3760    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Lock(Expression): View Source

    3765class Lock(Expression):
    3766    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Select(Query): View Source

    3769class Select(Query):
    3770    arg_types = {
    3771        "with": False,
    3772        "kind": False,
    3773        "expressions": False,
    3774        "hint": False,
    3775        "distinct": False,
    3776        "into": False,
    3777        "from": False,
    3778        "operation_modifiers": False,
    3779        **QUERY_MODIFIERS,
    3780    }
    3781
    3782    def from_(
    3783        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3784    ) -> Select:
    3785        """
    3786        Set the FROM expression.
    3787
    3788        Example:
    3789            >>> Select().from_("tbl").select("x").sql()
    3790            'SELECT x FROM tbl'
    3791
    3792        Args:
    3793            expression : the SQL code strings to parse.
    3794                If a `From` instance is passed, this is used as-is.
    3795                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3796            dialect: the dialect used to parse the input expression.
    3797            copy: if `False`, modify this expression instance in-place.
    3798            opts: other options to use to parse the input expressions.
    3799
    3800        Returns:
    3801            The modified Select expression.
    3802        """
    3803        return _apply_builder(
    3804            expression=expression,
    3805            instance=self,
    3806            arg="from",
    3807            into=From,
    3808            prefix="FROM",
    3809            dialect=dialect,
    3810            copy=copy,
    3811            **opts,
    3812        )
    3813
    3814    def group_by(
    3815        self,
    3816        *expressions: t.Optional[ExpOrStr],
    3817        append: bool = True,
    3818        dialect: DialectType = None,
    3819        copy: bool = True,
    3820        **opts,
    3821    ) -> Select:
    3822        """
    3823        Set the GROUP BY expression.
    3824
    3825        Example:
    3826            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3827            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3828
    3829        Args:
    3830            *expressions: the SQL code strings to parse.
    3831                If a `Group` instance is passed, this is used as-is.
    3832                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3833                If nothing is passed in then a group by is not applied to the expression
    3834            append: if `True`, add to any existing expressions.
    3835                Otherwise, this flattens all the `Group` expression into a single expression.
    3836            dialect: the dialect used to parse the input expression.
    3837            copy: if `False`, modify this expression instance in-place.
    3838            opts: other options to use to parse the input expressions.
    3839
    3840        Returns:
    3841            The modified Select expression.
    3842        """
    3843        if not expressions:
    3844            return self if not copy else self.copy()
    3845
    3846        return _apply_child_list_builder(
    3847            *expressions,
    3848            instance=self,
    3849            arg="group",
    3850            append=append,
    3851            copy=copy,
    3852            prefix="GROUP BY",
    3853            into=Group,
    3854            dialect=dialect,
    3855            **opts,
    3856        )
    3857
    3858    def sort_by(
    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        Set the SORT BY expression.
    3868
    3869        Example:
    3870            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3871            'SELECT x FROM tbl SORT BY x DESC'
    3872
    3873        Args:
    3874            *expressions: the SQL code strings to parse.
    3875                If a `Group` instance is passed, this is used as-is.
    3876                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3877            append: if `True`, add to any existing expressions.
    3878                Otherwise, this flattens all the `Order` expression into a single expression.
    3879            dialect: the dialect used to parse the input expression.
    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            The modified Select expression.
    3885        """
    3886        return _apply_child_list_builder(
    3887            *expressions,
    3888            instance=self,
    3889            arg="sort",
    3890            append=append,
    3891            copy=copy,
    3892            prefix="SORT BY",
    3893            into=Sort,
    3894            dialect=dialect,
    3895            **opts,
    3896        )
    3897
    3898    def cluster_by(
    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        Set the CLUSTER BY expression.
    3908
    3909        Example:
    3910            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3911            'SELECT x FROM tbl CLUSTER BY x DESC'
    3912
    3913        Args:
    3914            *expressions: the SQL code strings to parse.
    3915                If a `Group` instance is passed, this is used as-is.
    3916                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3917            append: if `True`, add to any existing expressions.
    3918                Otherwise, this flattens all the `Order` expression into a single expression.
    3919            dialect: the dialect used to parse the input expression.
    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_child_list_builder(
    3927            *expressions,
    3928            instance=self,
    3929            arg="cluster",
    3930            append=append,
    3931            copy=copy,
    3932            prefix="CLUSTER BY",
    3933            into=Cluster,
    3934            dialect=dialect,
    3935            **opts,
    3936        )
    3937
    3938    def select(
    3939        self,
    3940        *expressions: t.Optional[ExpOrStr],
    3941        append: bool = True,
    3942        dialect: DialectType = None,
    3943        copy: bool = True,
    3944        **opts,
    3945    ) -> Select:
    3946        return _apply_list_builder(
    3947            *expressions,
    3948            instance=self,
    3949            arg="expressions",
    3950            append=append,
    3951            dialect=dialect,
    3952            into=Expression,
    3953            copy=copy,
    3954            **opts,
    3955        )
    3956
    3957    def lateral(
    3958        self,
    3959        *expressions: t.Optional[ExpOrStr],
    3960        append: bool = True,
    3961        dialect: DialectType = None,
    3962        copy: bool = True,
    3963        **opts,
    3964    ) -> Select:
    3965        """
    3966        Append to or set the LATERAL expressions.
    3967
    3968        Example:
    3969            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3970            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3971
    3972        Args:
    3973            *expressions: the SQL code strings to parse.
    3974                If an `Expression` instance is passed, it will be used as-is.
    3975            append: if `True`, add to any existing expressions.
    3976                Otherwise, this resets the expressions.
    3977            dialect: the dialect used to parse the input expressions.
    3978            copy: if `False`, modify this expression instance in-place.
    3979            opts: other options to use to parse the input expressions.
    3980
    3981        Returns:
    3982            The modified Select expression.
    3983        """
    3984        return _apply_list_builder(
    3985            *expressions,
    3986            instance=self,
    3987            arg="laterals",
    3988            append=append,
    3989            into=Lateral,
    3990            prefix="LATERAL VIEW",
    3991            dialect=dialect,
    3992            copy=copy,
    3993            **opts,
    3994        )
    3995
    3996    def join(
    3997        self,
    3998        expression: ExpOrStr,
    3999        on: t.Optional[ExpOrStr] = None,
    4000        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    4001        append: bool = True,
    4002        join_type: t.Optional[str] = None,
    4003        join_alias: t.Optional[Identifier | str] = None,
    4004        dialect: DialectType = None,
    4005        copy: bool = True,
    4006        **opts,
    4007    ) -> Select:
    4008        """
    4009        Append to or set the JOIN expressions.
    4010
    4011        Example:
    4012            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    4013            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    4014
    4015            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    4016            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    4017
    4018            Use `join_type` to change the type of join:
    4019
    4020            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    4021            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    4022
    4023        Args:
    4024            expression: the SQL code string to parse.
    4025                If an `Expression` instance is passed, it will be used as-is.
    4026            on: optionally specify the join "on" criteria as a SQL string.
    4027                If an `Expression` instance is passed, it will be used as-is.
    4028            using: optionally specify the join "using" criteria as a SQL string.
    4029                If an `Expression` instance is passed, it will be used as-is.
    4030            append: if `True`, add to any existing expressions.
    4031                Otherwise, this resets the expressions.
    4032            join_type: if set, alter the parsed join type.
    4033            join_alias: an optional alias for the joined source.
    4034            dialect: the dialect used to parse the input expressions.
    4035            copy: if `False`, modify this expression instance in-place.
    4036            opts: other options to use to parse the input expressions.
    4037
    4038        Returns:
    4039            Select: the modified expression.
    4040        """
    4041        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    4042
    4043        try:
    4044            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    4045        except ParseError:
    4046            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    4047
    4048        join = expression if isinstance(expression, Join) else Join(this=expression)
    4049
    4050        if isinstance(join.this, Select):
    4051            join.this.replace(join.this.subquery())
    4052
    4053        if join_type:
    4054            method: t.Optional[Token]
    4055            side: t.Optional[Token]
    4056            kind: t.Optional[Token]
    4057
    4058            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    4059
    4060            if method:
    4061                join.set("method", method.text)
    4062            if side:
    4063                join.set("side", side.text)
    4064            if kind:
    4065                join.set("kind", kind.text)
    4066
    4067        if on:
    4068            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    4069            join.set("on", on)
    4070
    4071        if using:
    4072            join = _apply_list_builder(
    4073                *ensure_list(using),
    4074                instance=join,
    4075                arg="using",
    4076                append=append,
    4077                copy=copy,
    4078                into=Identifier,
    4079                **opts,
    4080            )
    4081
    4082        if join_alias:
    4083            join.set("this", alias_(join.this, join_alias, table=True))
    4084
    4085        return _apply_list_builder(
    4086            join,
    4087            instance=self,
    4088            arg="joins",
    4089            append=append,
    4090            copy=copy,
    4091            **opts,
    4092        )
    4093
    4094    def having(
    4095        self,
    4096        *expressions: t.Optional[ExpOrStr],
    4097        append: bool = True,
    4098        dialect: DialectType = None,
    4099        copy: bool = True,
    4100        **opts,
    4101    ) -> Select:
    4102        """
    4103        Append to or set the HAVING expressions.
    4104
    4105        Example:
    4106            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    4107            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    4108
    4109        Args:
    4110            *expressions: the SQL code strings to parse.
    4111                If an `Expression` instance is passed, it will be used as-is.
    4112                Multiple expressions are combined with an AND operator.
    4113            append: if `True`, AND the new expressions to any existing expression.
    4114                Otherwise, this resets the expression.
    4115            dialect: the dialect used to parse the input expressions.
    4116            copy: if `False`, modify this expression instance in-place.
    4117            opts: other options to use to parse the input expressions.
    4118
    4119        Returns:
    4120            The modified Select expression.
    4121        """
    4122        return _apply_conjunction_builder(
    4123            *expressions,
    4124            instance=self,
    4125            arg="having",
    4126            append=append,
    4127            into=Having,
    4128            dialect=dialect,
    4129            copy=copy,
    4130            **opts,
    4131        )
    4132
    4133    def window(
    4134        self,
    4135        *expressions: t.Optional[ExpOrStr],
    4136        append: bool = True,
    4137        dialect: DialectType = None,
    4138        copy: bool = True,
    4139        **opts,
    4140    ) -> Select:
    4141        return _apply_list_builder(
    4142            *expressions,
    4143            instance=self,
    4144            arg="windows",
    4145            append=append,
    4146            into=Window,
    4147            dialect=dialect,
    4148            copy=copy,
    4149            **opts,
    4150        )
    4151
    4152    def qualify(
    4153        self,
    4154        *expressions: t.Optional[ExpOrStr],
    4155        append: bool = True,
    4156        dialect: DialectType = None,
    4157        copy: bool = True,
    4158        **opts,
    4159    ) -> Select:
    4160        return _apply_conjunction_builder(
    4161            *expressions,
    4162            instance=self,
    4163            arg="qualify",
    4164            append=append,
    4165            into=Qualify,
    4166            dialect=dialect,
    4167            copy=copy,
    4168            **opts,
    4169        )
    4170
    4171    def distinct(
    4172        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    4173    ) -> Select:
    4174        """
    4175        Set the OFFSET expression.
    4176
    4177        Example:
    4178            >>> Select().from_("tbl").select("x").distinct().sql()
    4179            'SELECT DISTINCT x FROM tbl'
    4180
    4181        Args:
    4182            ons: the expressions to distinct on
    4183            distinct: whether the Select should be distinct
    4184            copy: if `False`, modify this expression instance in-place.
    4185
    4186        Returns:
    4187            Select: the modified expression.
    4188        """
    4189        instance = maybe_copy(self, copy)
    4190        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    4191        instance.set("distinct", Distinct(on=on) if distinct else None)
    4192        return instance
    4193
    4194    def ctas(
    4195        self,
    4196        table: ExpOrStr,
    4197        properties: t.Optional[t.Dict] = None,
    4198        dialect: DialectType = None,
    4199        copy: bool = True,
    4200        **opts,
    4201    ) -> Create:
    4202        """
    4203        Convert this expression to a CREATE TABLE AS statement.
    4204
    4205        Example:
    4206            >>> Select().select("*").from_("tbl").ctas("x").sql()
    4207            'CREATE TABLE x AS SELECT * FROM tbl'
    4208
    4209        Args:
    4210            table: the SQL code string to parse as the table name.
    4211                If another `Expression` instance is passed, it will be used as-is.
    4212            properties: an optional mapping of table properties
    4213            dialect: the dialect used to parse the input table.
    4214            copy: if `False`, modify this expression instance in-place.
    4215            opts: other options to use to parse the input table.
    4216
    4217        Returns:
    4218            The new Create expression.
    4219        """
    4220        instance = maybe_copy(self, copy)
    4221        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4222
    4223        properties_expression = None
    4224        if properties:
    4225            properties_expression = Properties.from_dict(properties)
    4226
    4227        return Create(
    4228            this=table_expression,
    4229            kind="TABLE",
    4230            expression=instance,
    4231            properties=properties_expression,
    4232        )
    4233
    4234    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4235        """
    4236        Set the locking read mode for this expression.
    4237
    4238        Examples:
    4239            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4240            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4241
    4242            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4243            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4244
    4245        Args:
    4246            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4247            copy: if `False`, modify this expression instance in-place.
    4248
    4249        Returns:
    4250            The modified expression.
    4251        """
    4252        inst = maybe_copy(self, copy)
    4253        inst.set("locks", [Lock(update=update)])
    4254
    4255        return inst
    4256
    4257    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4258        """
    4259        Set hints for this expression.
    4260
    4261        Examples:
    4262            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4263            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4264
    4265        Args:
    4266            hints: The SQL code strings to parse as the hints.
    4267                If an `Expression` instance is passed, it will be used as-is.
    4268            dialect: The dialect used to parse the hints.
    4269            copy: If `False`, modify this expression instance in-place.
    4270
    4271        Returns:
    4272            The modified expression.
    4273        """
    4274        inst = maybe_copy(self, copy)
    4275        inst.set(
    4276            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4277        )
    4278
    4279        return inst
    4280
    4281    @property
    4282    def named_selects(self) -> t.List[str]:
    4283        return [e.output_name for e in self.expressions if e.alias_or_name]
    4284
    4285    @property
    4286    def is_star(self) -> bool:
    4287        return any(expression.is_star for expression in self.expressions)
    4288
    4289    @property
    4290    def selects(self) -> t.List[Expression]:
    4291        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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3782    def from_(
    3783        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    3784    ) -> Select:
    3785        """
    3786        Set the FROM expression.
    3787
    3788        Example:
    3789            >>> Select().from_("tbl").select("x").sql()
    3790            'SELECT x FROM tbl'
    3791
    3792        Args:
    3793            expression : the SQL code strings to parse.
    3794                If a `From` instance is passed, this is used as-is.
    3795                If another `Expression` instance is passed, it will be wrapped in a `From`.
    3796            dialect: the dialect used to parse the input expression.
    3797            copy: if `False`, modify this expression instance in-place.
    3798            opts: other options to use to parse the input expressions.
    3799
    3800        Returns:
    3801            The modified Select expression.
    3802        """
    3803        return _apply_builder(
    3804            expression=expression,
    3805            instance=self,
    3806            arg="from",
    3807            into=From,
    3808            prefix="FROM",
    3809            dialect=dialect,
    3810            copy=copy,
    3811            **opts,
    3812        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3814    def group_by(
    3815        self,
    3816        *expressions: t.Optional[ExpOrStr],
    3817        append: bool = True,
    3818        dialect: DialectType = None,
    3819        copy: bool = True,
    3820        **opts,
    3821    ) -> Select:
    3822        """
    3823        Set the GROUP BY expression.
    3824
    3825        Example:
    3826            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    3827            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    3828
    3829        Args:
    3830            *expressions: the SQL code strings to parse.
    3831                If a `Group` instance is passed, this is used as-is.
    3832                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    3833                If nothing is passed in then a group by is not applied to the expression
    3834            append: if `True`, add to any existing expressions.
    3835                Otherwise, this flattens all the `Group` expression into a single expression.
    3836            dialect: the dialect used to parse the input expression.
    3837            copy: if `False`, modify this expression instance in-place.
    3838            opts: other options to use to parse the input expressions.
    3839
    3840        Returns:
    3841            The modified Select expression.
    3842        """
    3843        if not expressions:
    3844            return self if not copy else self.copy()
    3845
    3846        return _apply_child_list_builder(
    3847            *expressions,
    3848            instance=self,
    3849            arg="group",
    3850            append=append,
    3851            copy=copy,
    3852            prefix="GROUP BY",
    3853            into=Group,
    3854            dialect=dialect,
    3855            **opts,
    3856        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3858    def sort_by(
    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        Set the SORT BY expression.
    3868
    3869        Example:
    3870            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    3871            'SELECT x FROM tbl SORT BY x DESC'
    3872
    3873        Args:
    3874            *expressions: the SQL code strings to parse.
    3875                If a `Group` instance is passed, this is used as-is.
    3876                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    3877            append: if `True`, add to any existing expressions.
    3878                Otherwise, this flattens all the `Order` expression into a single expression.
    3879            dialect: the dialect used to parse the input expression.
    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            The modified Select expression.
    3885        """
    3886        return _apply_child_list_builder(
    3887            *expressions,
    3888            instance=self,
    3889            arg="sort",
    3890            append=append,
    3891            copy=copy,
    3892            prefix="SORT BY",
    3893            into=Sort,
    3894            dialect=dialect,
    3895            **opts,
    3896        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3898    def cluster_by(
    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        Set the CLUSTER BY expression.
    3908
    3909        Example:
    3910            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    3911            'SELECT x FROM tbl CLUSTER BY x DESC'
    3912
    3913        Args:
    3914            *expressions: the SQL code strings to parse.
    3915                If a `Group` instance is passed, this is used as-is.
    3916                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    3917            append: if `True`, add to any existing expressions.
    3918                Otherwise, this flattens all the `Order` expression into a single expression.
    3919            dialect: the dialect used to parse the input expression.
    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_child_list_builder(
    3927            *expressions,
    3928            instance=self,
    3929            arg="cluster",
    3930            append=append,
    3931            copy=copy,
    3932            prefix="CLUSTER BY",
    3933            into=Cluster,
    3934            dialect=dialect,
    3935            **opts,
    3936        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

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

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3957    def lateral(
    3958        self,
    3959        *expressions: t.Optional[ExpOrStr],
    3960        append: bool = True,
    3961        dialect: DialectType = None,
    3962        copy: bool = True,
    3963        **opts,
    3964    ) -> Select:
    3965        """
    3966        Append to or set the LATERAL expressions.
    3967
    3968        Example:
    3969            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3970            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3971
    3972        Args:
    3973            *expressions: the SQL code strings to parse.
    3974                If an `Expression` instance is passed, it will be used as-is.
    3975            append: if `True`, add to any existing expressions.
    3976                Otherwise, this resets the expressions.
    3977            dialect: the dialect used to parse the input expressions.
    3978            copy: if `False`, modify this expression instance in-place.
    3979            opts: other options to use to parse the input expressions.
    3980
    3981        Returns:
    3982            The modified Select expression.
    3983        """
    3984        return _apply_list_builder(
    3985            *expressions,
    3986            instance=self,
    3987            arg="laterals",
    3988            append=append,
    3989            into=Lateral,
    3990            prefix="LATERAL VIEW",
    3991            dialect=dialect,
    3992            copy=copy,
    3993            **opts,
    3994        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3996    def join(
    3997        self,
    3998        expression: ExpOrStr,
    3999        on: t.Optional[ExpOrStr] = None,
    4000        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    4001        append: bool = True,
    4002        join_type: t.Optional[str] = None,
    4003        join_alias: t.Optional[Identifier | str] = None,
    4004        dialect: DialectType = None,
    4005        copy: bool = True,
    4006        **opts,
    4007    ) -> Select:
    4008        """
    4009        Append to or set the JOIN expressions.
    4010
    4011        Example:
    4012            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    4013            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    4014
    4015            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    4016            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    4017
    4018            Use `join_type` to change the type of join:
    4019
    4020            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    4021            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    4022
    4023        Args:
    4024            expression: the SQL code string to parse.
    4025                If an `Expression` instance is passed, it will be used as-is.
    4026            on: optionally specify the join "on" criteria as a SQL string.
    4027                If an `Expression` instance is passed, it will be used as-is.
    4028            using: optionally specify the join "using" criteria as a SQL string.
    4029                If an `Expression` instance is passed, it will be used as-is.
    4030            append: if `True`, add to any existing expressions.
    4031                Otherwise, this resets the expressions.
    4032            join_type: if set, alter the parsed join type.
    4033            join_alias: an optional alias for the joined source.
    4034            dialect: the dialect used to parse the input expressions.
    4035            copy: if `False`, modify this expression instance in-place.
    4036            opts: other options to use to parse the input expressions.
    4037
    4038        Returns:
    4039            Select: the modified expression.
    4040        """
    4041        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    4042
    4043        try:
    4044            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    4045        except ParseError:
    4046            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    4047
    4048        join = expression if isinstance(expression, Join) else Join(this=expression)
    4049
    4050        if isinstance(join.this, Select):
    4051            join.this.replace(join.this.subquery())
    4052
    4053        if join_type:
    4054            method: t.Optional[Token]
    4055            side: t.Optional[Token]
    4056            kind: t.Optional[Token]
    4057
    4058            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    4059
    4060            if method:
    4061                join.set("method", method.text)
    4062            if side:
    4063                join.set("side", side.text)
    4064            if kind:
    4065                join.set("kind", kind.text)
    4066
    4067        if on:
    4068            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    4069            join.set("on", on)
    4070
    4071        if using:
    4072            join = _apply_list_builder(
    4073                *ensure_list(using),
    4074                instance=join,
    4075                arg="using",
    4076                append=append,
    4077                copy=copy,
    4078                into=Identifier,
    4079                **opts,
    4080            )
    4081
    4082        if join_alias:
    4083            join.set("this", alias_(join.this, join_alias, table=True))
    4084
    4085        return _apply_list_builder(
    4086            join,
    4087            instance=self,
    4088            arg="joins",
    4089            append=append,
    4090            copy=copy,
    4091            **opts,
    4092        )

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 having( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.Dialect, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    4094    def having(
    4095        self,
    4096        *expressions: t.Optional[ExpOrStr],
    4097        append: bool = True,
    4098        dialect: DialectType = None,
    4099        copy: bool = True,
    4100        **opts,
    4101    ) -> Select:
    4102        """
    4103        Append to or set the HAVING expressions.
    4104
    4105        Example:
    4106            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    4107            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    4108
    4109        Args:
    4110            *expressions: the SQL code strings to parse.
    4111                If an `Expression` instance is passed, it will be used as-is.
    4112                Multiple expressions are combined with an AND operator.
    4113            append: if `True`, AND the new expressions to any existing expression.
    4114                Otherwise, this resets the expression.
    4115            dialect: the dialect used to parse the input expressions.
    4116            copy: if `False`, modify this expression instance in-place.
    4117            opts: other options to use to parse the input expressions.
    4118
    4119        Returns:
    4120            The modified Select expression.
    4121        """
    4122        return _apply_conjunction_builder(
    4123            *expressions,
    4124            instance=self,
    4125            arg="having",
    4126            append=append,
    4127            into=Having,
    4128            dialect=dialect,
    4129            copy=copy,
    4130            **opts,
    4131        )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    4133    def window(
    4134        self,
    4135        *expressions: t.Optional[ExpOrStr],
    4136        append: bool = True,
    4137        dialect: DialectType = None,
    4138        copy: bool = True,
    4139        **opts,
    4140    ) -> Select:
    4141        return _apply_list_builder(
    4142            *expressions,
    4143            instance=self,
    4144            arg="windows",
    4145            append=append,
    4146            into=Window,
    4147            dialect=dialect,
    4148            copy=copy,
    4149            **opts,
    4150        )

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

    4152    def qualify(
    4153        self,
    4154        *expressions: t.Optional[ExpOrStr],
    4155        append: bool = True,
    4156        dialect: DialectType = None,
    4157        copy: bool = True,
    4158        **opts,
    4159    ) -> Select:
    4160        return _apply_conjunction_builder(
    4161            *expressions,
    4162            instance=self,
    4163            arg="qualify",
    4164            append=append,
    4165            into=Qualify,
    4166            dialect=dialect,
    4167            copy=copy,
    4168            **opts,
    4169        )

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

    4171    def distinct(
    4172        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    4173    ) -> Select:
    4174        """
    4175        Set the OFFSET expression.
    4176
    4177        Example:
    4178            >>> Select().from_("tbl").select("x").distinct().sql()
    4179            'SELECT DISTINCT x FROM tbl'
    4180
    4181        Args:
    4182            ons: the expressions to distinct on
    4183            distinct: whether the Select should be distinct
    4184            copy: if `False`, modify this expression instance in-place.
    4185
    4186        Returns:
    4187            Select: the modified expression.
    4188        """
    4189        instance = maybe_copy(self, copy)
    4190        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    4191        instance.set("distinct", Distinct(on=on) if distinct else None)
    4192        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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Create: View Source

    4194    def ctas(
    4195        self,
    4196        table: ExpOrStr,
    4197        properties: t.Optional[t.Dict] = None,
    4198        dialect: DialectType = None,
    4199        copy: bool = True,
    4200        **opts,
    4201    ) -> Create:
    4202        """
    4203        Convert this expression to a CREATE TABLE AS statement.
    4204
    4205        Example:
    4206            >>> Select().select("*").from_("tbl").ctas("x").sql()
    4207            'CREATE TABLE x AS SELECT * FROM tbl'
    4208
    4209        Args:
    4210            table: the SQL code string to parse as the table name.
    4211                If another `Expression` instance is passed, it will be used as-is.
    4212            properties: an optional mapping of table properties
    4213            dialect: the dialect used to parse the input table.
    4214            copy: if `False`, modify this expression instance in-place.
    4215            opts: other options to use to parse the input table.
    4216
    4217        Returns:
    4218            The new Create expression.
    4219        """
    4220        instance = maybe_copy(self, copy)
    4221        table_expression = maybe_parse(table, into=Table, dialect=dialect, **opts)
    4222
    4223        properties_expression = None
    4224        if properties:
    4225            properties_expression = Properties.from_dict(properties)
    4226
    4227        return Create(
    4228            this=table_expression,
    4229            kind="TABLE",
    4230            expression=instance,
    4231            properties=properties_expression,
    4232        )

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

    4234    def lock(self, update: bool = True, copy: bool = True) -> Select:
    4235        """
    4236        Set the locking read mode for this expression.
    4237
    4238        Examples:
    4239            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    4240            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    4241
    4242            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    4243            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    4244
    4245        Args:
    4246            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    4247            copy: if `False`, modify this expression instance in-place.
    4248
    4249        Returns:
    4250            The modified expression.
    4251        """
    4252        inst = maybe_copy(self, copy)
    4253        inst.set("locks", [Lock(update=update)])
    4254
    4255        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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True) -> Select: View Source

    4257    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    4258        """
    4259        Set hints for this expression.
    4260
    4261        Examples:
    4262            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    4263            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    4264
    4265        Args:
    4266            hints: The SQL code strings to parse as the hints.
    4267                If an `Expression` instance is passed, it will be used as-is.
    4268            dialect: The dialect used to parse the hints.
    4269            copy: If `False`, modify this expression instance in-place.
    4270
    4271        Returns:
    4272            The modified expression.
    4273        """
    4274        inst = maybe_copy(self, copy)
    4275        inst.set(
    4276            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    4277        )
    4278
    4279        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

    4281    @property
    4282    def named_selects(self) -> t.List[str]:
    4283        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

    4285    @property
    4286    def is_star(self) -> bool:
    4287        return any(expression.is_star for expression in self.expressions)

Checks whether an expression is a star.

selects: List[Expression] View Source

    4289    @property
    4290    def selects(self) -> t.List[Expression]:
    4291        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Query
  subquery
  limit
  offset
  order_by
  ctes
  where
  with_
  union
  intersect
  except_

UNWRAPPED_QUERIES = (<class 'Select'>, <class 'SetOperation'>)
class Subquery(DerivedTable, Query): View Source

    4297class Subquery(DerivedTable, Query):
    4298    arg_types = {
    4299        "this": True,
    4300        "alias": False,
    4301        "with": False,
    4302        **QUERY_MODIFIERS,
    4303    }
    4304
    4305    def unnest(self):
    4306        """Returns the first non subquery."""
    4307        expression = self
    4308        while isinstance(expression, Subquery):
    4309            expression = expression.this
    4310        return expression
    4311
    4312    def unwrap(self) -> Subquery:
    4313        expression = self
    4314        while expression.same_parent and expression.is_wrapper:
    4315            expression = t.cast(Subquery, expression.parent)
    4316        return expression
    4317
    4318    def select(
    4319        self,
    4320        *expressions: t.Optional[ExpOrStr],
    4321        append: bool = True,
    4322        dialect: DialectType = None,
    4323        copy: bool = True,
    4324        **opts,
    4325    ) -> Subquery:
    4326        this = maybe_copy(self, copy)
    4327        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4328        return this
    4329
    4330    @property
    4331    def is_wrapper(self) -> bool:
    4332        """
    4333        Whether this Subquery acts as a simple wrapper around another expression.
    4334
    4335        SELECT * FROM (((SELECT * FROM t)))
    4336                      ^
    4337                      This corresponds to a "wrapper" Subquery node
    4338        """
    4339        return all(v is None for k, v in self.args.items() if k != "this")
    4340
    4341    @property
    4342    def is_star(self) -> bool:
    4343        return self.this.is_star
    4344
    4345    @property
    4346    def output_name(self) -> str:
    4347        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

    4305    def unnest(self):
    4306        """Returns the first non subquery."""
    4307        expression = self
    4308        while isinstance(expression, Subquery):
    4309            expression = expression.this
    4310        return expression

Returns the first non subquery.

def unwrap(self) -> Subquery: View Source

    4312    def unwrap(self) -> Subquery:
    4313        expression = self
    4314        while expression.same_parent and expression.is_wrapper:
    4315            expression = t.cast(Subquery, expression.parent)
    4316        return expression

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

    4318    def select(
    4319        self,
    4320        *expressions: t.Optional[ExpOrStr],
    4321        append: bool = True,
    4322        dialect: DialectType = None,
    4323        copy: bool = True,
    4324        **opts,
    4325    ) -> Subquery:
    4326        this = maybe_copy(self, copy)
    4327        this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    4328        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

    4330    @property
    4331    def is_wrapper(self) -> bool:
    4332        """
    4333        Whether this Subquery acts as a simple wrapper around another expression.
    4334
    4335        SELECT * FROM (((SELECT * FROM t)))
    4336                      ^
    4337                      This corresponds to a "wrapper" Subquery node
    4338        """
    4339        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

    4341    @property
    4342    def is_star(self) -> bool:
    4343        return self.this.is_star

Checks whether an expression is a star.

output_name: str View Source

    4345    @property
    4346    def output_name(self) -> str:
    4347        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DerivedTable
  selects
  named_selects
Query
  subquery
  limit
  offset
  order_by
  ctes
  where
  with_
  union
  intersect
  except_

class TableSample(Expression): View Source

    4350class TableSample(Expression):
    4351    arg_types = {
    4352        "expressions": False,
    4353        "method": False,
    4354        "bucket_numerator": False,
    4355        "bucket_denominator": False,
    4356        "bucket_field": False,
    4357        "percent": False,
    4358        "rows": False,
    4359        "size": False,
    4360        "seed": False,
    4361    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Tag(Expression): View Source

    4364class Tag(Expression):
    4365    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    4366
    4367    arg_types = {
    4368        "this": False,
    4369        "prefix": False,
    4370        "postfix": False,
    4371    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Pivot(Expression): View Source

    4376class Pivot(Expression):
    4377    arg_types = {
    4378        "this": False,
    4379        "alias": False,
    4380        "expressions": False,
    4381        "fields": False,
    4382        "unpivot": False,
    4383        "using": False,
    4384        "group": False,
    4385        "columns": False,
    4386        "include_nulls": False,
    4387        "default_on_null": False,
    4388        "into": False,
    4389    }
    4390
    4391    @property
    4392    def unpivot(self) -> bool:
    4393        return bool(self.args.get("unpivot"))
    4394
    4395    @property
    4396    def fields(self) -> t.List[Expression]:
    4397        return self.args.get("fields", [])

arg_types = {'this': False, 'alias': False, 'expressions': False, 'fields': False, 'unpivot': False, 'using': False, 'group': False, 'columns': False, 'include_nulls': False, 'default_on_null': False, 'into': False}
unpivot: bool View Source

    4391    @property
    4392    def unpivot(self) -> bool:
    4393        return bool(self.args.get("unpivot"))

fields: List[Expression] View Source

    4395    @property
    4396    def fields(self) -> t.List[Expression]:
    4397        return self.args.get("fields", [])

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UnpivotColumns(Expression): View Source

    4402class UnpivotColumns(Expression):
    4403    arg_types = {"this": True, "expressions": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Window(Condition): View Source

    4406class Window(Condition):
    4407    arg_types = {
    4408        "this": True,
    4409        "partition_by": False,
    4410        "order": False,
    4411        "spec": False,
    4412        "alias": False,
    4413        "over": False,
    4414        "first": False,
    4415    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class WindowSpec(Expression): View Source

    4418class WindowSpec(Expression):
    4419    arg_types = {
    4420        "kind": False,
    4421        "start": False,
    4422        "start_side": False,
    4423        "end": False,
    4424        "end_side": False,
    4425        "exclude": False,
    4426    }

arg_types = {'kind': False, 'start': False, 'start_side': False, 'end': False, 'end_side': False, 'exclude': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PreWhere(Expression): View Source

    4429class PreWhere(Expression):
    4430    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Where(Expression): View Source

    4433class Where(Expression):
    4434    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Star(Expression): View Source

    4437class Star(Expression):
    4438    arg_types = {"except": False, "replace": False, "rename": False}
    4439
    4440    @property
    4441    def name(self) -> str:
    4442        return "*"
    4443
    4444    @property
    4445    def output_name(self) -> str:
    4446        return self.name

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

    4440    @property
    4441    def name(self) -> str:
    4442        return "*"

output_name: str View Source

    4444    @property
    4445    def output_name(self) -> str:
    4446        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Parameter(Condition): View Source

    4449class Parameter(Condition):
    4450    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class SessionParameter(Condition): View Source

    4453class SessionParameter(Condition):
    4454    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Placeholder(Condition): View Source

    4458class Placeholder(Condition):
    4459    arg_types = {"this": False, "kind": False, "widget": False}
    4460
    4461    @property
    4462    def name(self) -> str:
    4463        return self.this or "?"

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

    4461    @property
    4462    def name(self) -> str:
    4463        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Null(Condition): View Source

    4466class Null(Condition):
    4467    arg_types: t.Dict[str, t.Any] = {}
    4468
    4469    @property
    4470    def name(self) -> str:
    4471        return "NULL"
    4472
    4473    def to_py(self) -> Lit[None]:
    4474        return None

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

    4469    @property
    4470    def name(self) -> str:
    4471        return "NULL"

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

    4473    def to_py(self) -> Lit[None]:
    4474        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Boolean(Condition): View Source

    4477class Boolean(Condition):
    4478    def to_py(self) -> bool:
    4479        return self.this

def to_py(self) -> bool: View Source

    4478    def to_py(self) -> bool:
    4479        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataTypeParam(Expression): View Source

    4482class DataTypeParam(Expression):
    4483    arg_types = {"this": True, "expression": False}
    4484
    4485    @property
    4486    def name(self) -> str:
    4487        return self.this.name

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

    4485    @property
    4486    def name(self) -> str:
    4487        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataType(Expression): View Source

    4492class DataType(Expression):
    4493    arg_types = {
    4494        "this": True,
    4495        "expressions": False,
    4496        "nested": False,
    4497        "values": False,
    4498        "prefix": False,
    4499        "kind": False,
    4500        "nullable": False,
    4501    }
    4502
    4503    class Type(AutoName):
    4504        ARRAY = auto()
    4505        AGGREGATEFUNCTION = auto()
    4506        SIMPLEAGGREGATEFUNCTION = auto()
    4507        BIGDECIMAL = auto()
    4508        BIGINT = auto()
    4509        BIGSERIAL = auto()
    4510        BINARY = auto()
    4511        BIT = auto()
    4512        BLOB = auto()
    4513        BOOLEAN = auto()
    4514        BPCHAR = auto()
    4515        CHAR = auto()
    4516        DATE = auto()
    4517        DATE32 = auto()
    4518        DATEMULTIRANGE = auto()
    4519        DATERANGE = auto()
    4520        DATETIME = auto()
    4521        DATETIME2 = auto()
    4522        DATETIME64 = auto()
    4523        DECIMAL = auto()
    4524        DECIMAL32 = auto()
    4525        DECIMAL64 = auto()
    4526        DECIMAL128 = auto()
    4527        DECIMAL256 = auto()
    4528        DOUBLE = auto()
    4529        DYNAMIC = auto()
    4530        ENUM = auto()
    4531        ENUM8 = auto()
    4532        ENUM16 = auto()
    4533        FIXEDSTRING = auto()
    4534        FLOAT = auto()
    4535        GEOGRAPHY = auto()
    4536        GEOMETRY = auto()
    4537        POINT = auto()
    4538        RING = auto()
    4539        LINESTRING = auto()
    4540        MULTILINESTRING = auto()
    4541        POLYGON = auto()
    4542        MULTIPOLYGON = auto()
    4543        HLLSKETCH = auto()
    4544        HSTORE = auto()
    4545        IMAGE = auto()
    4546        INET = auto()
    4547        INT = auto()
    4548        INT128 = auto()
    4549        INT256 = auto()
    4550        INT4MULTIRANGE = auto()
    4551        INT4RANGE = auto()
    4552        INT8MULTIRANGE = auto()
    4553        INT8RANGE = auto()
    4554        INTERVAL = auto()
    4555        IPADDRESS = auto()
    4556        IPPREFIX = auto()
    4557        IPV4 = auto()
    4558        IPV6 = auto()
    4559        JSON = auto()
    4560        JSONB = auto()
    4561        LIST = auto()
    4562        LONGBLOB = auto()
    4563        LONGTEXT = auto()
    4564        LOWCARDINALITY = auto()
    4565        MAP = auto()
    4566        MEDIUMBLOB = auto()
    4567        MEDIUMINT = auto()
    4568        MEDIUMTEXT = auto()
    4569        MONEY = auto()
    4570        NAME = auto()
    4571        NCHAR = auto()
    4572        NESTED = auto()
    4573        NOTHING = auto()
    4574        NULL = auto()
    4575        NUMMULTIRANGE = auto()
    4576        NUMRANGE = auto()
    4577        NVARCHAR = auto()
    4578        OBJECT = auto()
    4579        RANGE = auto()
    4580        ROWVERSION = auto()
    4581        SERIAL = auto()
    4582        SET = auto()
    4583        SMALLDATETIME = auto()
    4584        SMALLINT = auto()
    4585        SMALLMONEY = auto()
    4586        SMALLSERIAL = auto()
    4587        STRUCT = auto()
    4588        SUPER = auto()
    4589        TEXT = auto()
    4590        TINYBLOB = auto()
    4591        TINYTEXT = auto()
    4592        TIME = auto()
    4593        TIMETZ = auto()
    4594        TIMESTAMP = auto()
    4595        TIMESTAMPNTZ = auto()
    4596        TIMESTAMPLTZ = auto()
    4597        TIMESTAMPTZ = auto()
    4598        TIMESTAMP_S = auto()
    4599        TIMESTAMP_MS = auto()
    4600        TIMESTAMP_NS = auto()
    4601        TINYINT = auto()
    4602        TSMULTIRANGE = auto()
    4603        TSRANGE = auto()
    4604        TSTZMULTIRANGE = auto()
    4605        TSTZRANGE = auto()
    4606        UBIGINT = auto()
    4607        UINT = auto()
    4608        UINT128 = auto()
    4609        UINT256 = auto()
    4610        UMEDIUMINT = auto()
    4611        UDECIMAL = auto()
    4612        UDOUBLE = auto()
    4613        UNION = auto()
    4614        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4615        USERDEFINED = "USER-DEFINED"
    4616        USMALLINT = auto()
    4617        UTINYINT = auto()
    4618        UUID = auto()
    4619        VARBINARY = auto()
    4620        VARCHAR = auto()
    4621        VARIANT = auto()
    4622        VECTOR = auto()
    4623        XML = auto()
    4624        YEAR = auto()
    4625        TDIGEST = auto()
    4626
    4627    STRUCT_TYPES = {
    4628        Type.NESTED,
    4629        Type.OBJECT,
    4630        Type.STRUCT,
    4631        Type.UNION,
    4632    }
    4633
    4634    ARRAY_TYPES = {
    4635        Type.ARRAY,
    4636        Type.LIST,
    4637    }
    4638
    4639    NESTED_TYPES = {
    4640        *STRUCT_TYPES,
    4641        *ARRAY_TYPES,
    4642        Type.MAP,
    4643    }
    4644
    4645    TEXT_TYPES = {
    4646        Type.CHAR,
    4647        Type.NCHAR,
    4648        Type.NVARCHAR,
    4649        Type.TEXT,
    4650        Type.VARCHAR,
    4651        Type.NAME,
    4652    }
    4653
    4654    SIGNED_INTEGER_TYPES = {
    4655        Type.BIGINT,
    4656        Type.INT,
    4657        Type.INT128,
    4658        Type.INT256,
    4659        Type.MEDIUMINT,
    4660        Type.SMALLINT,
    4661        Type.TINYINT,
    4662    }
    4663
    4664    UNSIGNED_INTEGER_TYPES = {
    4665        Type.UBIGINT,
    4666        Type.UINT,
    4667        Type.UINT128,
    4668        Type.UINT256,
    4669        Type.UMEDIUMINT,
    4670        Type.USMALLINT,
    4671        Type.UTINYINT,
    4672    }
    4673
    4674    INTEGER_TYPES = {
    4675        *SIGNED_INTEGER_TYPES,
    4676        *UNSIGNED_INTEGER_TYPES,
    4677        Type.BIT,
    4678    }
    4679
    4680    FLOAT_TYPES = {
    4681        Type.DOUBLE,
    4682        Type.FLOAT,
    4683    }
    4684
    4685    REAL_TYPES = {
    4686        *FLOAT_TYPES,
    4687        Type.BIGDECIMAL,
    4688        Type.DECIMAL,
    4689        Type.DECIMAL32,
    4690        Type.DECIMAL64,
    4691        Type.DECIMAL128,
    4692        Type.DECIMAL256,
    4693        Type.MONEY,
    4694        Type.SMALLMONEY,
    4695        Type.UDECIMAL,
    4696        Type.UDOUBLE,
    4697    }
    4698
    4699    NUMERIC_TYPES = {
    4700        *INTEGER_TYPES,
    4701        *REAL_TYPES,
    4702    }
    4703
    4704    TEMPORAL_TYPES = {
    4705        Type.DATE,
    4706        Type.DATE32,
    4707        Type.DATETIME,
    4708        Type.DATETIME2,
    4709        Type.DATETIME64,
    4710        Type.SMALLDATETIME,
    4711        Type.TIME,
    4712        Type.TIMESTAMP,
    4713        Type.TIMESTAMPNTZ,
    4714        Type.TIMESTAMPLTZ,
    4715        Type.TIMESTAMPTZ,
    4716        Type.TIMESTAMP_MS,
    4717        Type.TIMESTAMP_NS,
    4718        Type.TIMESTAMP_S,
    4719        Type.TIMETZ,
    4720    }
    4721
    4722    @classmethod
    4723    def build(
    4724        cls,
    4725        dtype: DATA_TYPE,
    4726        dialect: DialectType = None,
    4727        udt: bool = False,
    4728        copy: bool = True,
    4729        **kwargs,
    4730    ) -> DataType:
    4731        """
    4732        Constructs a DataType object.
    4733
    4734        Args:
    4735            dtype: the data type of interest.
    4736            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4737            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4738                DataType, thus creating a user-defined type.
    4739            copy: whether to copy the data type.
    4740            kwargs: additional arguments to pass in the constructor of DataType.
    4741
    4742        Returns:
    4743            The constructed DataType object.
    4744        """
    4745        from sqlglot import parse_one
    4746
    4747        if isinstance(dtype, str):
    4748            if dtype.upper() == "UNKNOWN":
    4749                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4750
    4751            try:
    4752                data_type_exp = parse_one(
    4753                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4754                )
    4755            except ParseError:
    4756                if udt:
    4757                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4758                raise
    4759        elif isinstance(dtype, (Identifier, Dot)) and udt:
    4760            return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4761        elif isinstance(dtype, DataType.Type):
    4762            data_type_exp = DataType(this=dtype)
    4763        elif isinstance(dtype, DataType):
    4764            return maybe_copy(dtype, copy)
    4765        else:
    4766            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4767
    4768        return DataType(**{**data_type_exp.args, **kwargs})
    4769
    4770    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4771        """
    4772        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4773        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4774
    4775        Args:
    4776            dtypes: the data types to compare this DataType to.
    4777            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4778                If false, it means that NULLABLE<INT> is equivalent to INT.
    4779
    4780        Returns:
    4781            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4782        """
    4783        self_is_nullable = self.args.get("nullable")
    4784        for dtype in dtypes:
    4785            other_type = DataType.build(dtype, copy=False, udt=True)
    4786            other_is_nullable = other_type.args.get("nullable")
    4787            if (
    4788                other_type.expressions
    4789                or (check_nullable and (self_is_nullable or other_is_nullable))
    4790                or self.this == DataType.Type.USERDEFINED
    4791                or other_type.this == DataType.Type.USERDEFINED
    4792            ):
    4793                matches = self == other_type
    4794            else:
    4795                matches = self.this == other_type.this
    4796
    4797            if matches:
    4798                return True
    4799        return False

arg_types = {'this': True, 'expressions': False, 'nested': False, 'values': False, 'prefix': False, 'kind': False, 'nullable': False}
STRUCT_TYPES = {<Type.NESTED: 'NESTED'>, <Type.STRUCT: 'STRUCT'>, <Type.OBJECT: 'OBJECT'>, <Type.UNION: 'UNION'>}
ARRAY_TYPES = {<Type.ARRAY: 'ARRAY'>, <Type.LIST: 'LIST'>}
NESTED_TYPES = {<Type.NESTED: 'NESTED'>, <Type.ARRAY: 'ARRAY'>, <Type.LIST: 'LIST'>, <Type.MAP: 'MAP'>, <Type.STRUCT: 'STRUCT'>, <Type.OBJECT: 'OBJECT'>, <Type.UNION: 'UNION'>}
TEXT_TYPES = {<Type.TEXT: 'TEXT'>, <Type.NAME: 'NAME'>, <Type.CHAR: 'CHAR'>, <Type.VARCHAR: 'VARCHAR'>, <Type.NVARCHAR: 'NVARCHAR'>, <Type.NCHAR: 'NCHAR'>}
SIGNED_INTEGER_TYPES = {<Type.TINYINT: 'TINYINT'>, <Type.BIGINT: 'BIGINT'>, <Type.INT128: 'INT128'>, <Type.MEDIUMINT: 'MEDIUMINT'>, <Type.INT: 'INT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.INT256: 'INT256'>}
UNSIGNED_INTEGER_TYPES = {<Type.UINT256: 'UINT256'>, <Type.UINT128: 'UINT128'>, <Type.UTINYINT: 'UTINYINT'>, <Type.UBIGINT: 'UBIGINT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.USMALLINT: 'USMALLINT'>, <Type.UINT: 'UINT'>}
INTEGER_TYPES = {<Type.TINYINT: 'TINYINT'>, <Type.BIGINT: 'BIGINT'>, <Type.INT128: 'INT128'>, <Type.UINT256: 'UINT256'>, <Type.MEDIUMINT: 'MEDIUMINT'>, <Type.UINT128: 'UINT128'>, <Type.UTINYINT: 'UTINYINT'>, <Type.UBIGINT: 'UBIGINT'>, <Type.INT: 'INT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.USMALLINT: 'USMALLINT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.UINT: 'UINT'>, <Type.INT256: 'INT256'>, <Type.BIT: 'BIT'>}
FLOAT_TYPES = {<Type.DOUBLE: 'DOUBLE'>, <Type.FLOAT: 'FLOAT'>}
REAL_TYPES = {<Type.DECIMAL64: 'DECIMAL64'>, <Type.DECIMAL128: 'DECIMAL128'>, <Type.DOUBLE: 'DOUBLE'>, <Type.MONEY: 'MONEY'>, <Type.DECIMAL256: 'DECIMAL256'>, <Type.UDECIMAL: 'UDECIMAL'>, <Type.DECIMAL: 'DECIMAL'>, <Type.BIGDECIMAL: 'BIGDECIMAL'>, <Type.DECIMAL32: 'DECIMAL32'>, <Type.FLOAT: 'FLOAT'>, <Type.UDOUBLE: 'UDOUBLE'>, <Type.SMALLMONEY: 'SMALLMONEY'>}
NUMERIC_TYPES = {<Type.DECIMAL64: 'DECIMAL64'>, <Type.DECIMAL128: 'DECIMAL128'>, <Type.UINT256: 'UINT256'>, <Type.UINT128: 'UINT128'>, <Type.UTINYINT: 'UTINYINT'>, <Type.UBIGINT: 'UBIGINT'>, <Type.DOUBLE: 'DOUBLE'>, <Type.INT: 'INT'>, <Type.USMALLINT: 'USMALLINT'>, <Type.UDECIMAL: 'UDECIMAL'>, <Type.UINT: 'UINT'>, <Type.BIGDECIMAL: 'BIGDECIMAL'>, <Type.FLOAT: 'FLOAT'>, <Type.BIT: 'BIT'>, <Type.UDOUBLE: 'UDOUBLE'>, <Type.SMALLMONEY: 'SMALLMONEY'>, <Type.TINYINT: 'TINYINT'>, <Type.BIGINT: 'BIGINT'>, <Type.INT128: 'INT128'>, <Type.MEDIUMINT: 'MEDIUMINT'>, <Type.UMEDIUMINT: 'UMEDIUMINT'>, <Type.MONEY: 'MONEY'>, <Type.DECIMAL256: 'DECIMAL256'>, <Type.SMALLINT: 'SMALLINT'>, <Type.DECIMAL: 'DECIMAL'>, <Type.DECIMAL32: 'DECIMAL32'>, <Type.INT256: 'INT256'>}
TEMPORAL_TYPES = {<Type.DATE32: 'DATE32'>, <Type.TIMESTAMP_S: 'TIMESTAMP_S'>, <Type.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <Type.TIME: 'TIME'>, <Type.DATETIME64: 'DATETIME64'>, <Type.TIMESTAMP: 'TIMESTAMP'>, <Type.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <Type.DATETIME: 'DATETIME'>, <Type.SMALLDATETIME: 'SMALLDATETIME'>, <Type.DATE: 'DATE'>, <Type.TIMETZ: 'TIMETZ'>, <Type.DATETIME2: 'DATETIME2'>}
@classmethod
def build( cls, dtype: Union[str, Identifier, Dot, DataType, DataType.Type], dialect: Union[str, sqlglot.dialects.Dialect, Type[sqlglot.dialects.Dialect], NoneType] = None, udt: bool = False, copy: bool = True, **kwargs) -> DataType: View Source

    4722    @classmethod
    4723    def build(
    4724        cls,
    4725        dtype: DATA_TYPE,
    4726        dialect: DialectType = None,
    4727        udt: bool = False,
    4728        copy: bool = True,
    4729        **kwargs,
    4730    ) -> DataType:
    4731        """
    4732        Constructs a DataType object.
    4733
    4734        Args:
    4735            dtype: the data type of interest.
    4736            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    4737            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    4738                DataType, thus creating a user-defined type.
    4739            copy: whether to copy the data type.
    4740            kwargs: additional arguments to pass in the constructor of DataType.
    4741
    4742        Returns:
    4743            The constructed DataType object.
    4744        """
    4745        from sqlglot import parse_one
    4746
    4747        if isinstance(dtype, str):
    4748            if dtype.upper() == "UNKNOWN":
    4749                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    4750
    4751            try:
    4752                data_type_exp = parse_one(
    4753                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
    4754                )
    4755            except ParseError:
    4756                if udt:
    4757                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4758                raise
    4759        elif isinstance(dtype, (Identifier, Dot)) and udt:
    4760            return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    4761        elif isinstance(dtype, DataType.Type):
    4762            data_type_exp = DataType(this=dtype)
    4763        elif isinstance(dtype, DataType):
    4764            return maybe_copy(dtype, copy)
    4765        else:
    4766            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    4767
    4768        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, Identifier, Dot, DataType, DataType.Type], check_nullable: bool = False) -> bool: View Source

    4770    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
    4771        """
    4772        Checks whether this DataType matches one of the provided data types. Nested types or precision
    4773        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    4774
    4775        Args:
    4776            dtypes: the data types to compare this DataType to.
    4777            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
    4778                If false, it means that NULLABLE<INT> is equivalent to INT.
    4779
    4780        Returns:
    4781            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    4782        """
    4783        self_is_nullable = self.args.get("nullable")
    4784        for dtype in dtypes:
    4785            other_type = DataType.build(dtype, copy=False, udt=True)
    4786            other_is_nullable = other_type.args.get("nullable")
    4787            if (
    4788                other_type.expressions
    4789                or (check_nullable and (self_is_nullable or other_is_nullable))
    4790                or self.this == DataType.Type.USERDEFINED
    4791                or other_type.this == DataType.Type.USERDEFINED
    4792            ):
    4793                matches = self == other_type
    4794            else:
    4795                matches = self.this == other_type.this
    4796
    4797            if matches:
    4798                return True
    4799        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DataType.Type(sqlglot.helper.AutoName): View Source

    4503    class Type(AutoName):
    4504        ARRAY = auto()
    4505        AGGREGATEFUNCTION = auto()
    4506        SIMPLEAGGREGATEFUNCTION = auto()
    4507        BIGDECIMAL = auto()
    4508        BIGINT = auto()
    4509        BIGSERIAL = auto()
    4510        BINARY = auto()
    4511        BIT = auto()
    4512        BLOB = auto()
    4513        BOOLEAN = auto()
    4514        BPCHAR = auto()
    4515        CHAR = auto()
    4516        DATE = auto()
    4517        DATE32 = auto()
    4518        DATEMULTIRANGE = auto()
    4519        DATERANGE = auto()
    4520        DATETIME = auto()
    4521        DATETIME2 = auto()
    4522        DATETIME64 = auto()
    4523        DECIMAL = auto()
    4524        DECIMAL32 = auto()
    4525        DECIMAL64 = auto()
    4526        DECIMAL128 = auto()
    4527        DECIMAL256 = auto()
    4528        DOUBLE = auto()
    4529        DYNAMIC = auto()
    4530        ENUM = auto()
    4531        ENUM8 = auto()
    4532        ENUM16 = auto()
    4533        FIXEDSTRING = auto()
    4534        FLOAT = auto()
    4535        GEOGRAPHY = auto()
    4536        GEOMETRY = auto()
    4537        POINT = auto()
    4538        RING = auto()
    4539        LINESTRING = auto()
    4540        MULTILINESTRING = auto()
    4541        POLYGON = auto()
    4542        MULTIPOLYGON = auto()
    4543        HLLSKETCH = auto()
    4544        HSTORE = auto()
    4545        IMAGE = auto()
    4546        INET = auto()
    4547        INT = auto()
    4548        INT128 = auto()
    4549        INT256 = auto()
    4550        INT4MULTIRANGE = auto()
    4551        INT4RANGE = auto()
    4552        INT8MULTIRANGE = auto()
    4553        INT8RANGE = auto()
    4554        INTERVAL = auto()
    4555        IPADDRESS = auto()
    4556        IPPREFIX = auto()
    4557        IPV4 = auto()
    4558        IPV6 = auto()
    4559        JSON = auto()
    4560        JSONB = auto()
    4561        LIST = auto()
    4562        LONGBLOB = auto()
    4563        LONGTEXT = auto()
    4564        LOWCARDINALITY = auto()
    4565        MAP = auto()
    4566        MEDIUMBLOB = auto()
    4567        MEDIUMINT = auto()
    4568        MEDIUMTEXT = auto()
    4569        MONEY = auto()
    4570        NAME = auto()
    4571        NCHAR = auto()
    4572        NESTED = auto()
    4573        NOTHING = auto()
    4574        NULL = auto()
    4575        NUMMULTIRANGE = auto()
    4576        NUMRANGE = auto()
    4577        NVARCHAR = auto()
    4578        OBJECT = auto()
    4579        RANGE = auto()
    4580        ROWVERSION = auto()
    4581        SERIAL = auto()
    4582        SET = auto()
    4583        SMALLDATETIME = auto()
    4584        SMALLINT = auto()
    4585        SMALLMONEY = auto()
    4586        SMALLSERIAL = auto()
    4587        STRUCT = auto()
    4588        SUPER = auto()
    4589        TEXT = auto()
    4590        TINYBLOB = auto()
    4591        TINYTEXT = auto()
    4592        TIME = auto()
    4593        TIMETZ = auto()
    4594        TIMESTAMP = auto()
    4595        TIMESTAMPNTZ = auto()
    4596        TIMESTAMPLTZ = auto()
    4597        TIMESTAMPTZ = auto()
    4598        TIMESTAMP_S = auto()
    4599        TIMESTAMP_MS = auto()
    4600        TIMESTAMP_NS = auto()
    4601        TINYINT = auto()
    4602        TSMULTIRANGE = auto()
    4603        TSRANGE = auto()
    4604        TSTZMULTIRANGE = auto()
    4605        TSTZRANGE = auto()
    4606        UBIGINT = auto()
    4607        UINT = auto()
    4608        UINT128 = auto()
    4609        UINT256 = auto()
    4610        UMEDIUMINT = auto()
    4611        UDECIMAL = auto()
    4612        UDOUBLE = auto()
    4613        UNION = auto()
    4614        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    4615        USERDEFINED = "USER-DEFINED"
    4616        USMALLINT = auto()
    4617        UTINYINT = auto()
    4618        UUID = auto()
    4619        VARBINARY = auto()
    4620        VARCHAR = auto()
    4621        VARIANT = auto()
    4622        VECTOR = auto()
    4623        XML = auto()
    4624        YEAR = auto()
    4625        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'>
BLOB = <Type.BLOB: 'BLOB'>
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'>
DATETIME2 = <Type.DATETIME2: 'DATETIME2'>
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'>
DYNAMIC = <Type.DYNAMIC: 'DYNAMIC'>
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'>
NOTHING = <Type.NOTHING: 'NOTHING'>
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'>
SMALLDATETIME = <Type.SMALLDATETIME: 'SMALLDATETIME'>
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'>
UDOUBLE = <Type.UDOUBLE: 'UDOUBLE'>
UNION = <Type.UNION: 'UNION'>
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'>
class PseudoType(DataType): View Source

    4803class PseudoType(DataType):
    4804    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_
  update_positions
  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

    4808class ObjectIdentifier(DataType):
    4809    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_
  update_positions
  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

    4813class SubqueryPredicate(Predicate):
    4814    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class All(SubqueryPredicate): View Source

    4817class All(SubqueryPredicate):
    4818    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Any(SubqueryPredicate): View Source

    4821class Any(SubqueryPredicate):
    4822    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Command(Expression): View Source

    4827class Command(Expression):
    4828    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Transaction(Expression): View Source

    4831class Transaction(Expression):
    4832    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Commit(Expression): View Source

    4835class Commit(Expression):
    4836    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Rollback(Expression): View Source

    4839class Rollback(Expression):
    4840    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Alter(Expression): View Source

    4843class Alter(Expression):
    4844    arg_types = {
    4845        "this": True,
    4846        "kind": True,
    4847        "actions": True,
    4848        "exists": False,
    4849        "only": False,
    4850        "options": False,
    4851        "cluster": False,
    4852        "not_valid": False,
    4853    }
    4854
    4855    @property
    4856    def kind(self) -> t.Optional[str]:
    4857        kind = self.args.get("kind")
    4858        return kind and kind.upper()
    4859
    4860    @property
    4861    def actions(self) -> t.List[Expression]:
    4862        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

    4855    @property
    4856    def kind(self) -> t.Optional[str]:
    4857        kind = self.args.get("kind")
    4858        return kind and kind.upper()

actions: List[Expression] View Source

    4860    @property
    4861    def actions(self) -> t.List[Expression]:
    4862        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Analyze(Expression): View Source

    4865class Analyze(Expression):
    4866    arg_types = {
    4867        "kind": False,
    4868        "this": False,
    4869        "options": False,
    4870        "mode": False,
    4871        "partition": False,
    4872        "expression": False,
    4873        "properties": False,
    4874    }

arg_types = {'kind': False, 'this': False, 'options': False, 'mode': False, 'partition': False, 'expression': False, 'properties': False}
key = 'analyze'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeStatistics(Expression): View Source

    4877class AnalyzeStatistics(Expression):
    4878    arg_types = {
    4879        "kind": True,
    4880        "option": False,
    4881        "this": False,
    4882        "expressions": False,
    4883    }

arg_types = {'kind': True, 'option': False, 'this': False, 'expressions': False}
key = 'analyzestatistics'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeHistogram(Expression): View Source

    4886class AnalyzeHistogram(Expression):
    4887    arg_types = {
    4888        "this": True,
    4889        "expressions": True,
    4890        "expression": False,
    4891        "update_options": False,
    4892    }

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeSample(Expression): View Source

    4895class AnalyzeSample(Expression):
    4896    arg_types = {"kind": True, "sample": True}

arg_types = {'kind': True, 'sample': True}
key = 'analyzesample'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeListChainedRows(Expression): View Source

    4899class AnalyzeListChainedRows(Expression):
    4900    arg_types = {"expression": False}

arg_types = {'expression': False}
key = 'analyzelistchainedrows'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeDelete(Expression): View Source

    4903class AnalyzeDelete(Expression):
    4904    arg_types = {"kind": False}

arg_types = {'kind': False}
key = 'analyzedelete'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeWith(Expression): View Source

    4907class AnalyzeWith(Expression):
    4908    arg_types = {"expressions": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeValidate(Expression): View Source

    4911class AnalyzeValidate(Expression):
    4912    arg_types = {
    4913        "kind": True,
    4914        "this": False,
    4915        "expression": False,
    4916    }

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AnalyzeColumns(Expression): View Source

    4919class AnalyzeColumns(Expression):
    4920    pass

key = 'analyzecolumns'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class UsingData(Expression): View Source

    4923class UsingData(Expression):
    4924    pass

key = 'usingdata'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AddConstraint(Expression): View Source

    4927class AddConstraint(Expression):
    4928    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AddPartition(Expression): View Source

    4931class AddPartition(Expression):
    4932    arg_types = {"this": True, "exists": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AttachOption(Expression): View Source

    4935class AttachOption(Expression):
    4936    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DropPartition(Expression): View Source

    4939class DropPartition(Expression):
    4940    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ReplacePartition(Expression): View Source

    4944class ReplacePartition(Expression):
    4945    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Binary(Condition): View Source

    4949class Binary(Condition):
    4950    arg_types = {"this": True, "expression": True}
    4951
    4952    @property
    4953    def left(self) -> Expression:
    4954        return self.this
    4955
    4956    @property
    4957    def right(self) -> Expression:
    4958        return self.expression

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

    4952    @property
    4953    def left(self) -> Expression:
    4954        return self.this

right: Expression View Source

    4956    @property
    4957    def right(self) -> Expression:
    4958        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Add(Binary): View Source

    4961class Add(Binary):
    4962    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Connector(Binary): View Source

    4965class Connector(Binary):
    4966    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseAnd(Binary): View Source

    4969class BitwiseAnd(Binary):
    4970    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseLeftShift(Binary): View Source

    4973class BitwiseLeftShift(Binary):
    4974    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseOr(Binary): View Source

    4977class BitwiseOr(Binary):
    4978    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseRightShift(Binary): View Source

    4981class BitwiseRightShift(Binary):
    4982    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class BitwiseXor(Binary): View Source

    4985class BitwiseXor(Binary):
    4986    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Div(Binary): View Source

    4989class Div(Binary):
    4990    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class Overlaps(Binary): View Source

    4993class Overlaps(Binary):
    4994    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Dot(Binary): View Source

    4997class Dot(Binary):
    4998    @property
    4999    def is_star(self) -> bool:
    5000        return self.expression.is_star
    5001
    5002    @property
    5003    def name(self) -> str:
    5004        return self.expression.name
    5005
    5006    @property
    5007    def output_name(self) -> str:
    5008        return self.name
    5009
    5010    @classmethod
    5011    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    5012        """Build a Dot object with a sequence of expressions."""
    5013        if len(expressions) < 2:
    5014            raise ValueError("Dot requires >= 2 expressions.")
    5015
    5016        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))
    5017
    5018    @property
    5019    def parts(self) -> t.List[Expression]:
    5020        """Return the parts of a table / column in order catalog, db, table."""
    5021        this, *parts = self.flatten()
    5022
    5023        parts.reverse()
    5024
    5025        for arg in COLUMN_PARTS:
    5026            part = this.args.get(arg)
    5027
    5028            if isinstance(part, Expression):
    5029                parts.append(part)
    5030
    5031        parts.reverse()
    5032        return parts

is_star: bool View Source

    4998    @property
    4999    def is_star(self) -> bool:
    5000        return self.expression.is_star

Checks whether an expression is a star.

name: str View Source

    5002    @property
    5003    def name(self) -> str:
    5004        return self.expression.name

output_name: str View Source

    5006    @property
    5007    def output_name(self) -> str:
    5008        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

    5010    @classmethod
    5011    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    5012        """Build a Dot object with a sequence of expressions."""
    5013        if len(expressions) < 2:
    5014            raise ValueError("Dot requires >= 2 expressions.")
    5015
    5016        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

    5018    @property
    5019    def parts(self) -> t.List[Expression]:
    5020        """Return the parts of a table / column in order catalog, db, table."""
    5021        this, *parts = self.flatten()
    5022
    5023        parts.reverse()
    5024
    5025        for arg in COLUMN_PARTS:
    5026            part = this.args.get(arg)
    5027
    5028            if isinstance(part, Expression):
    5029                parts.append(part)
    5030
    5031        parts.reverse()
    5032        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

DATA_TYPE = typing.Union[str, Identifier, Dot, DataType, DataType.Type]
class DPipe(Binary): View Source

    5038class DPipe(Binary):
    5039    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class EQ(Binary, Predicate): View Source

    5042class EQ(Binary, Predicate):
    5043    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class NullSafeEQ(Binary, Predicate): View Source

    5046class NullSafeEQ(Binary, Predicate):
    5047    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class NullSafeNEQ(Binary, Predicate): View Source

    5050class NullSafeNEQ(Binary, Predicate):
    5051    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class PropertyEQ(Binary): View Source

    5055class PropertyEQ(Binary):
    5056    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Distance(Binary): View Source

    5059class Distance(Binary):
    5060    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Escape(Binary): View Source

    5063class Escape(Binary):
    5064    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Glob(Binary, Predicate): View Source

    5067class Glob(Binary, Predicate):
    5068    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class GT(Binary, Predicate): View Source

    5071class GT(Binary, Predicate):
    5072    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class GTE(Binary, Predicate): View Source

    5075class GTE(Binary, Predicate):
    5076    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class ILike(Binary, Predicate): View Source

    5079class ILike(Binary, Predicate):
    5080    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class ILikeAny(Binary, Predicate): View Source

    5083class ILikeAny(Binary, Predicate):
    5084    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class IntDiv(Binary): View Source

    5087class IntDiv(Binary):
    5088    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Is(Binary, Predicate): View Source

    5091class Is(Binary, Predicate):
    5092    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Kwarg(Binary): View Source

    5095class Kwarg(Binary):
    5096    """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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Like(Binary, Predicate): View Source

    5099class Like(Binary, Predicate):
    5100    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class LikeAny(Binary, Predicate): View Source

    5103class LikeAny(Binary, Predicate):
    5104    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class LT(Binary, Predicate): View Source

    5107class LT(Binary, Predicate):
    5108    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class LTE(Binary, Predicate): View Source

    5111class LTE(Binary, Predicate):
    5112    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Mod(Binary): View Source

    5115class Mod(Binary):
    5116    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Mul(Binary): View Source

    5119class Mul(Binary):
    5120    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class NEQ(Binary, Predicate): View Source

    5123class NEQ(Binary, Predicate):
    5124    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Operator(Binary): View Source

    5128class Operator(Binary):
    5129    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class SimilarTo(Binary, Predicate): View Source

    5132class SimilarTo(Binary, Predicate):
    5133    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Slice(Binary): View Source

    5136class Slice(Binary):
    5137    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  left
  right

class Sub(Binary): View Source

    5140class Sub(Binary):
    5141    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Binary
  arg_types
  left
  right

class Unary(Condition): View Source

    5146class Unary(Condition):
    5147    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class BitwiseNot(Unary): View Source

    5150class BitwiseNot(Unary):
    5151    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Not(Unary): View Source

    5154class Not(Unary):
    5155    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Paren(Unary): View Source

    5158class Paren(Unary):
    5159    @property
    5160    def output_name(self) -> str:
    5161        return self.this.name

output_name: str View Source

    5159    @property
    5160    def output_name(self) -> str:
    5161        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Neg(Unary): View Source

    5164class Neg(Unary):
    5165    def to_py(self) -> int | Decimal:
    5166        if self.is_number:
    5167            return self.this.to_py() * -1
    5168        return super().to_py()

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

    5165    def to_py(self) -> int | Decimal:
    5166        if self.is_number:
    5167            return self.this.to_py() * -1
    5168        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Alias(Expression): View Source

    5171class Alias(Expression):
    5172    arg_types = {"this": True, "alias": False}
    5173
    5174    @property
    5175    def output_name(self) -> str:
    5176        return self.alias

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

    5174    @property
    5175    def output_name(self) -> str:
    5176        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class PivotAlias(Alias): View Source

    5181class PivotAlias(Alias):
    5182    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Alias
  arg_types
  output_name

class PivotAny(Expression): View Source

    5187class PivotAny(Expression):
    5188    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Aliases(Expression): View Source

    5191class Aliases(Expression):
    5192    arg_types = {"this": True, "expressions": True}
    5193
    5194    @property
    5195    def aliases(self):
    5196        return self.expressions

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

    5194    @property
    5195    def aliases(self):
    5196        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AtIndex(Expression): View Source

    5200class AtIndex(Expression):
    5201    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AtTimeZone(Expression): View Source

    5204class AtTimeZone(Expression):
    5205    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class FromTimeZone(Expression): View Source

    5208class FromTimeZone(Expression):
    5209    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Between(Predicate): View Source

    5212class Between(Predicate):
    5213    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Bracket(Condition): View Source

    5216class Bracket(Condition):
    5217    # https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#array_subscript_operator
    5218    arg_types = {
    5219        "this": True,
    5220        "expressions": True,
    5221        "offset": False,
    5222        "safe": False,
    5223        "returns_list_for_maps": False,
    5224    }
    5225
    5226    @property
    5227    def output_name(self) -> str:
    5228        if len(self.expressions) == 1:
    5229            return self.expressions[0].output_name
    5230
    5231        return super().output_name

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

    5226    @property
    5227    def output_name(self) -> str:
    5228        if len(self.expressions) == 1:
    5229            return self.expressions[0].output_name
    5230
    5231        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Distinct(Expression): View Source

    5234class Distinct(Expression):
    5235    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class In(Predicate): View Source

    5238class In(Predicate):
    5239    arg_types = {
    5240        "this": True,
    5241        "expressions": False,
    5242        "query": False,
    5243        "unnest": False,
    5244        "field": False,
    5245        "is_global": False,
    5246    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class ForIn(Expression): View Source

    5250class ForIn(Expression):
    5251    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeUnit(Expression): View Source

    5254class TimeUnit(Expression):
    5255    """Automatically converts unit arg into a var."""
    5256
    5257    arg_types = {"unit": False}
    5258
    5259    UNABBREVIATED_UNIT_NAME = {
    5260        "D": "DAY",
    5261        "H": "HOUR",
    5262        "M": "MINUTE",
    5263        "MS": "MILLISECOND",
    5264        "NS": "NANOSECOND",
    5265        "Q": "QUARTER",
    5266        "S": "SECOND",
    5267        "US": "MICROSECOND",
    5268        "W": "WEEK",
    5269        "Y": "YEAR",
    5270    }
    5271
    5272    VAR_LIKE = (Column, Literal, Var)
    5273
    5274    def __init__(self, **args):
    5275        unit = args.get("unit")
    5276        if isinstance(unit, self.VAR_LIKE):
    5277            args["unit"] = Var(
    5278                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5279            )
    5280        elif isinstance(unit, Week):
    5281            unit.set("this", Var(this=unit.this.name.upper()))
    5282
    5283        super().__init__(**args)
    5284
    5285    @property
    5286    def unit(self) -> t.Optional[Var | IntervalSpan]:
    5287        return self.args.get("unit")

Automatically converts unit arg into a var.

TimeUnit(**args) View Source

    5274    def __init__(self, **args):
    5275        unit = args.get("unit")
    5276        if isinstance(unit, self.VAR_LIKE):
    5277            args["unit"] = Var(
    5278                this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
    5279            )
    5280        elif isinstance(unit, Week):
    5281            unit.set("this", Var(this=unit.this.name.upper()))
    5282
    5283        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

    5285    @property
    5286    def unit(self) -> t.Optional[Var | IntervalSpan]:
    5287        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IntervalOp(TimeUnit): View Source

    5290class IntervalOp(TimeUnit):
    5291    arg_types = {"unit": False, "expression": True}
    5292
    5293    def interval(self):
    5294        return Interval(
    5295            this=self.expression.copy(),
    5296            unit=self.unit.copy() if self.unit else None,
    5297        )

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

    5293    def interval(self):
    5294        return Interval(
    5295            this=self.expression.copy(),
    5296            unit=self.unit.copy() if self.unit else None,
    5297        )

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IntervalSpan(DataType): View Source

    5303class IntervalSpan(DataType):
    5304    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_
  update_positions
  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

    5307class Interval(TimeUnit):
    5308    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class IgnoreNulls(Expression): View Source

    5311class IgnoreNulls(Expression):
    5312    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class RespectNulls(Expression): View Source

    5315class RespectNulls(Expression):
    5316    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class HavingMax(Expression): View Source

    5320class HavingMax(Expression):
    5321    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Func(Condition): View Source

    5325class Func(Condition):
    5326    """
    5327    The base class for all function expressions.
    5328
    5329    Attributes:
    5330        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    5331            treated as a variable length argument and the argument's value will be stored as a list.
    5332        _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this
    5333            function expression. These values are used to map this node to a name during parsing as
    5334            well as to provide the function's name during SQL string generation. By default the SQL
    5335            name is set to the expression's class name transformed to snake case.
    5336    """
    5337
    5338    is_var_len_args = False
    5339
    5340    @classmethod
    5341    def from_arg_list(cls, args):
    5342        if cls.is_var_len_args:
    5343            all_arg_keys = list(cls.arg_types)
    5344            # If this function supports variable length argument treat the last argument as such.
    5345            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5346            num_non_var = len(non_var_len_arg_keys)
    5347
    5348            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5349            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5350        else:
    5351            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5352
    5353        return cls(**args_dict)
    5354
    5355    @classmethod
    5356    def sql_names(cls):
    5357        if cls is Func:
    5358            raise NotImplementedError(
    5359                "SQL name is only supported by concrete function implementations"
    5360            )
    5361        if "_sql_names" not in cls.__dict__:
    5362            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5363        return cls._sql_names
    5364
    5365    @classmethod
    5366    def sql_name(cls):
    5367        return cls.sql_names()[0]
    5368
    5369    @classmethod
    5370    def default_parser_mappings(cls):
    5371        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

    5340    @classmethod
    5341    def from_arg_list(cls, args):
    5342        if cls.is_var_len_args:
    5343            all_arg_keys = list(cls.arg_types)
    5344            # If this function supports variable length argument treat the last argument as such.
    5345            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    5346            num_non_var = len(non_var_len_arg_keys)
    5347
    5348            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    5349            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    5350        else:
    5351            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    5352
    5353        return cls(**args_dict)

@classmethod
def sql_names(cls): View Source

    5355    @classmethod
    5356    def sql_names(cls):
    5357        if cls is Func:
    5358            raise NotImplementedError(
    5359                "SQL name is only supported by concrete function implementations"
    5360            )
    5361        if "_sql_names" not in cls.__dict__:
    5362            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    5363        return cls._sql_names

@classmethod
def sql_name(cls): View Source

    5365    @classmethod
    5366    def sql_name(cls):
    5367        return cls.sql_names()[0]

@classmethod
def default_parser_mappings(cls): View Source

    5369    @classmethod
    5370    def default_parser_mappings(cls):
    5371        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class AggFunc(Func): View Source

    5374class AggFunc(Func):
    5375    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayRemove(Func): View Source

    5378class ArrayRemove(Func):
    5379    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

    5382class ParameterizedAgg(AggFunc):
    5383    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5386class Abs(Func):
    5387    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5390class ArgMax(AggFunc):
    5391    arg_types = {"this": True, "expression": True, "count": False}
    5392    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5395class ArgMin(AggFunc):
    5396    arg_types = {"this": True, "expression": True, "count": False}
    5397    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5400class ApproxTopK(AggFunc):
    5401    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5404class Flatten(Func):
    5405    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5409class Transform(Func):
    5410    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5413class Anonymous(Func):
    5414    arg_types = {"this": True, "expressions": False}
    5415    is_var_len_args = True
    5416
    5417    @property
    5418    def name(self) -> str:
    5419        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

    5417    @property
    5418    def name(self) -> str:
    5419        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_
  update_positions
  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

    5422class AnonymousAggFunc(AggFunc):
    5423    arg_types = {"this": True, "expressions": False}
    5424    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_
  update_positions
  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

    5428class CombinedAggFunc(AnonymousAggFunc):
    5429    arg_types = {"this": True, "expressions": False}

arg_types = {'this': True, 'expressions': False}
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_
  update_positions
  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

    5432class CombinedParameterizedAgg(ParameterizedAgg):
    5433    arg_types = {"this": True, "expressions": True, "params": True}

arg_types = {'this': True, 'expressions': True, 'params': 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_
  update_positions
  as_
  isin
  between
  is_
  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

    5438class Hll(AggFunc):
    5439    arg_types = {"this": True, "expressions": False}
    5440    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_
  update_positions
  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

    5443class ApproxDistinct(AggFunc):
    5444    arg_types = {"this": True, "accuracy": False}
    5445    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5448class Apply(Func):
    5449    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5452class Array(Func):
    5453    arg_types = {"expressions": False, "bracket_notation": False}
    5454    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_
  update_positions
  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

    5458class ToArray(Func):
    5459    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5463class List(Func):
    5464    arg_types = {"expressions": False}
    5465    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_
  update_positions
  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

    5469class Pad(Func):
    5470    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5475class ToChar(Func):
    5476    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5481class ToNumber(Func):
    5482    arg_types = {
    5483        "this": True,
    5484        "format": False,
    5485        "nlsparam": False,
    5486        "precision": False,
    5487        "scale": False,
    5488    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    5492class ToDouble(Func):
    5493    arg_types = {
    5494        "this": True,
    5495        "format": False,
    5496    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    5499class Columns(Func):
    5500    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5504class Convert(Func):
    5505    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ConvertToCharset(Func): View Source

    5509class ConvertToCharset(Func):
    5510    arg_types = {"this": True, "dest": True, "source": False}

arg_types = {'this': True, 'dest': True, 'source': False}
key = 'converttocharset'

##### Inherited Members

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

    5513class ConvertTimezone(Func):
    5514    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5517class GenerateSeries(Func):
    5518    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5524class ExplodingGenerateSeries(GenerateSeries):
    5525    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_
  update_positions
  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

    5528class ArrayAgg(AggFunc):
    5529    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5532class ArrayUniqueAgg(AggFunc):
    5533    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5536class ArrayAll(Func):
    5537    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5541class ArrayAny(Func):
    5542    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5545class ArrayConcat(Func):
    5546    _sql_names = ["ARRAY_CONCAT", "ARRAY_CAT"]
    5547    arg_types = {"this": True, "expressions": False}
    5548    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayConcatAgg(AggFunc): View Source

    5551class ArrayConcatAgg(AggFunc):
    5552    pass

key = 'arrayconcatagg'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayConstructCompact(Func): View Source

    5555class ArrayConstructCompact(Func):
    5556    arg_types = {"expressions": True}
    5557    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_
  update_positions
  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

    5560class ArrayContains(Binary, Func):
    5561    _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_
  update_positions
  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

    5564class ArrayContainsAll(Binary, Func):
    5565    _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_
  update_positions
  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

    5568class ArrayFilter(Func):
    5569    arg_types = {"this": True, "expression": True}
    5570    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5573class ArrayToString(Func):
    5574    arg_types = {"this": True, "expression": True, "null": False}
    5575    _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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayIntersect(Func): View Source

    5578class ArrayIntersect(Func):
    5579    arg_types = {"expressions": True}
    5580    is_var_len_args = True
    5581    _sql_names = ["ARRAY_INTERSECT", "ARRAY_INTERSECTION"]

arg_types = {'expressions': True}
is_var_len_args = True
key = 'arrayintersect'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StPoint(Func): View Source

    5584class StPoint(Func):
    5585    arg_types = {"this": True, "expression": True, "null": False}
    5586    _sql_names = ["ST_POINT", "ST_MAKEPOINT"]

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class StDistance(Func): View Source

    5589class StDistance(Func):
    5590    arg_types = {"this": True, "expression": True, "use_spheroid": False}

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

##### Inherited Members

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

    5594class String(Func):
    5595    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5598class StringToArray(Func):
    5599    arg_types = {"this": True, "expression": False, "null": False}
    5600    _sql_names = ["STRING_TO_ARRAY", "SPLIT_BY_STRING", "STRTOK_TO_ARRAY"]

arg_types = {'this': True, 'expression': False, '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_
  update_positions
  as_
  isin
  between
  is_
  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

    5603class ArrayOverlaps(Binary, Func):
    5604    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_
  update_positions
  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

    5607class ArraySize(Func):
    5608    arg_types = {"this": True, "expression": False}
    5609    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5612class ArraySort(Func):
    5613    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5616class ArraySum(Func):
    5617    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5620class ArrayUnionAgg(AggFunc):
    5621    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5624class Avg(AggFunc):
    5625    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5628class AnyValue(AggFunc):
    5629    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5632class Lag(AggFunc):
    5633    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5636class Lead(AggFunc):
    5637    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5642class First(AggFunc):
    5643    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5646class Last(AggFunc):
    5647    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5650class FirstValue(AggFunc):
    5651    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5654class LastValue(AggFunc):
    5655    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5658class NthValue(AggFunc):
    5659    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5662class Case(Func):
    5663    arg_types = {"this": False, "ifs": True, "default": False}
    5664
    5665    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5666        instance = maybe_copy(self, copy)
    5667        instance.append(
    5668            "ifs",
    5669            If(
    5670                this=maybe_parse(condition, copy=copy, **opts),
    5671                true=maybe_parse(then, copy=copy, **opts),
    5672            ),
    5673        )
    5674        return instance
    5675
    5676    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5677        instance = maybe_copy(self, copy)
    5678        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5679        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

    5665    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    5666        instance = maybe_copy(self, copy)
    5667        instance.append(
    5668            "ifs",
    5669            If(
    5670                this=maybe_parse(condition, copy=copy, **opts),
    5671                true=maybe_parse(then, copy=copy, **opts),
    5672            ),
    5673        )
    5674        return instance

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

    5676    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    5677        instance = maybe_copy(self, copy)
    5678        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    5679        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_
  update_positions
  as_
  isin
  between
  is_
  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

    5682class Cast(Func):
    5683    arg_types = {
    5684        "this": True,
    5685        "to": True,
    5686        "format": False,
    5687        "safe": False,
    5688        "action": False,
    5689        "default": False,
    5690    }
    5691
    5692    @property
    5693    def name(self) -> str:
    5694        return self.this.name
    5695
    5696    @property
    5697    def to(self) -> DataType:
    5698        return self.args["to"]
    5699
    5700    @property
    5701    def output_name(self) -> str:
    5702        return self.name
    5703
    5704    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5705        """
    5706        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5707        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5708        array<int> != array<float>.
    5709
    5710        Args:
    5711            dtypes: the data types to compare this Cast's DataType to.
    5712
    5713        Returns:
    5714            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5715        """
    5716        return self.to.is_type(*dtypes)

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

    5692    @property
    5693    def name(self) -> str:
    5694        return self.this.name

to: DataType View Source

    5696    @property
    5697    def to(self) -> DataType:
    5698        return self.args["to"]

output_name: str View Source

    5700    @property
    5701    def output_name(self) -> str:
    5702        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, Identifier, Dot, DataType, DataType.Type]) -> bool: View Source

    5704    def is_type(self, *dtypes: DATA_TYPE) -> bool:
    5705        """
    5706        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    5707        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    5708        array<int> != array<float>.
    5709
    5710        Args:
    5711            dtypes: the data types to compare this Cast's DataType to.
    5712
    5713        Returns:
    5714            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    5715        """
    5716        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_
  update_positions
  as_
  isin
  between
  is_
  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

    5719class TryCast(Cast):
    5720    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_
  update_positions
  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 JSONCast(Cast): View Source

    5724class JSONCast(Cast):
    5725    pass

key = 'jsoncast'

##### Inherited Members

Expression
  Expression
  args
  parent
  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_
  update_positions
  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

    5728class Try(Func):
    5729    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5732class CastToStrType(Func):
    5733    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TranslateCharacters(Expression): View Source

    5737class TranslateCharacters(Expression):
    5738    arg_types = {"this": True, "expression": True, "with_error": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Collate(Binary, Func): View Source

    5741class Collate(Binary, Func):
    5742    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_
  update_positions
  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

    5745class Ceil(Func):
    5746    arg_types = {"this": True, "decimals": False, "to": False}
    5747    _sql_names = ["CEIL", "CEILING"]

arg_types = {'this': True, 'decimals': False, 'to': 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_
  update_positions
  as_
  isin
  between
  is_
  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

    5750class Coalesce(Func):
    5751    arg_types = {"this": True, "expressions": False, "is_nvl": False, "is_null": False}
    5752    is_var_len_args = True
    5753    _sql_names = ["COALESCE", "IFNULL", "NVL"]

arg_types = {'this': True, 'expressions': False, 'is_nvl': False, 'is_null': 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_
  update_positions
  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

    5756class Chr(Func):
    5757    arg_types = {"expressions": True, "charset": False}
    5758    is_var_len_args = True
    5759    _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_
  update_positions
  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

    5762class Concat(Func):
    5763    arg_types = {"expressions": True, "safe": False, "coalesce": False}
    5764    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_
  update_positions
  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

    5767class ConcatWs(Concat):
    5768    _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_
  update_positions
  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 Contains(Func): View Source

    5771class Contains(Func):
    5772    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ConnectByRoot(Func): View Source

    5776class ConnectByRoot(Func):
    5777    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5780class Count(AggFunc):
    5781    arg_types = {"this": False, "expressions": False, "big_int": False}
    5782    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_
  update_positions
  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

    5785class CountIf(AggFunc):
    5786    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5790class Cbrt(Func):
    5791    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5794class CurrentDate(Func):
    5795    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5798class CurrentDatetime(Func):
    5799    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5802class CurrentTime(Func):
    5803    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5806class CurrentTimestamp(Func):
    5807    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CurrentTimestampLTZ(Func): View Source

    5810class CurrentTimestampLTZ(Func):
    5811    arg_types = {}

arg_types = {}
key = 'currenttimestampltz'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class CurrentSchema(Func): View Source

    5814class CurrentSchema(Func):
    5815    arg_types = {"this": False}

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

##### Inherited Members

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

    5818class CurrentUser(Func):
    5819    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5822class DateAdd(Func, IntervalOp):
    5823    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateBin(Func, IntervalOp): View Source

    5826class DateBin(Func, IntervalOp):
    5827    arg_types = {"this": True, "expression": True, "unit": False, "zone": False}

arg_types = {'this': True, 'expression': True, 'unit': False, 'zone': False}
key = 'datebin'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateSub(Func, IntervalOp): View Source

    5830class DateSub(Func, IntervalOp):
    5831    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateDiff(Func, TimeUnit): View Source

    5834class DateDiff(Func, TimeUnit):
    5835    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    5836    arg_types = {"this": True, "expression": True, "unit": False, "zone": False}

arg_types = {'this': True, 'expression': True, 'unit': False, 'zone': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateTrunc(Func): View Source

    5839class DateTrunc(Func):
    5840    arg_types = {"unit": True, "this": True, "zone": False}
    5841
    5842    def __init__(self, **args):
    5843        # Across most dialects it's safe to unabbreviate the unit (e.g. 'Q' -> 'QUARTER') except Oracle
    5844        # https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ROUND-and-TRUNC-Date-Functions.html
    5845        unabbreviate = args.pop("unabbreviate", True)
    5846
    5847        unit = args.get("unit")
    5848        if isinstance(unit, TimeUnit.VAR_LIKE):
    5849            unit_name = unit.name.upper()
    5850            if unabbreviate and unit_name in TimeUnit.UNABBREVIATED_UNIT_NAME:
    5851                unit_name = TimeUnit.UNABBREVIATED_UNIT_NAME[unit_name]
    5852
    5853            args["unit"] = Literal.string(unit_name)
    5854
    5855        super().__init__(**args)
    5856
    5857    @property
    5858    def unit(self) -> Expression:
    5859        return self.args["unit"]

DateTrunc(**args) View Source

    5842    def __init__(self, **args):
    5843        # Across most dialects it's safe to unabbreviate the unit (e.g. 'Q' -> 'QUARTER') except Oracle
    5844        # https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ROUND-and-TRUNC-Date-Functions.html
    5845        unabbreviate = args.pop("unabbreviate", True)
    5846
    5847        unit = args.get("unit")
    5848        if isinstance(unit, TimeUnit.VAR_LIKE):
    5849            unit_name = unit.name.upper()
    5850            if unabbreviate and unit_name in TimeUnit.UNABBREVIATED_UNIT_NAME:
    5851                unit_name = TimeUnit.UNABBREVIATED_UNIT_NAME[unit_name]
    5852
    5853            args["unit"] = Literal.string(unit_name)
    5854
    5855        super().__init__(**args)

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

    5857    @property
    5858    def unit(self) -> Expression:
    5859        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Datetime(Func): View Source

    5864class Datetime(Func):
    5865    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5868class DatetimeAdd(Func, IntervalOp):
    5869    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DatetimeSub(Func, IntervalOp): View Source

    5872class DatetimeSub(Func, IntervalOp):
    5873    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DatetimeDiff(Func, TimeUnit): View Source

    5876class DatetimeDiff(Func, TimeUnit):
    5877    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DatetimeTrunc(Func, TimeUnit): View Source

    5880class DatetimeTrunc(Func, TimeUnit):
    5881    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DayOfWeek(Func): View Source

    5884class DayOfWeek(Func):
    5885    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5890class DayOfWeekIso(Func):
    5891    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5894class DayOfMonth(Func):
    5895    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5898class DayOfYear(Func):
    5899    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5902class ToDays(Func):
    5903    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5906class WeekOfYear(Func):
    5907    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    5910class MonthsBetween(Func):
    5911    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class MakeInterval(Func): View Source

    5914class MakeInterval(Func):
    5915    arg_types = {
    5916        "year": False,
    5917        "month": False,
    5918        "day": False,
    5919        "hour": False,
    5920        "minute": False,
    5921        "second": False,
    5922    }

arg_types = {'year': False, 'month': False, 'day': False, 'hour': False, 'minute': False, 'second': False}
key = 'makeinterval'

##### Inherited Members

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

    5925class LastDay(Func, TimeUnit):
    5926    _sql_names = ["LAST_DAY", "LAST_DAY_OF_MONTH"]
    5927    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Extract(Func): View Source

    5930class Extract(Func):
    5931    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Exists(Func, SubqueryPredicate): View Source

    5934class Exists(Func, SubqueryPredicate):
    5935    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

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

    5938class Timestamp(Func):
    5939    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5942class TimestampAdd(Func, TimeUnit):
    5943    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimestampSub(Func, TimeUnit): View Source

    5946class TimestampSub(Func, TimeUnit):
    5947    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimestampDiff(Func, TimeUnit): View Source

    5950class TimestampDiff(Func, TimeUnit):
    5951    _sql_names = ["TIMESTAMPDIFF", "TIMESTAMP_DIFF"]
    5952    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimestampTrunc(Func, TimeUnit): View Source

    5955class TimestampTrunc(Func, TimeUnit):
    5956    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeAdd(Func, TimeUnit): View Source

    5959class TimeAdd(Func, TimeUnit):
    5960    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeSub(Func, TimeUnit): View Source

    5963class TimeSub(Func, TimeUnit):
    5964    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeDiff(Func, TimeUnit): View Source

    5967class TimeDiff(Func, TimeUnit):
    5968    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TimeTrunc(Func, TimeUnit): View Source

    5971class TimeTrunc(Func, TimeUnit):
    5972    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class DateFromParts(Func): View Source

    5975class DateFromParts(Func):
    5976    _sql_names = ["DATE_FROM_PARTS", "DATEFROMPARTS"]
    5977    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5980class TimeFromParts(Func):
    5981    _sql_names = ["TIME_FROM_PARTS", "TIMEFROMPARTS"]
    5982    arg_types = {
    5983        "hour": True,
    5984        "min": True,
    5985        "sec": True,
    5986        "nano": False,
    5987        "fractions": False,
    5988        "precision": False,
    5989    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    5992class DateStrToDate(Func):
    5993    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_
  update_positions
  as_
  isin
  between
  is_
  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

    5996class DateToDateStr(Func):
    5997    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6000class DateToDi(Func):
    6001    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6005class Date(Func):
    6006    arg_types = {"this": False, "zone": False, "expressions": False}
    6007    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_
  update_positions
  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

    6010class Day(Func):
    6011    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6014class Decode(Func):
    6015    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6018class DiToDate(Func):
    6019    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6022class Encode(Func):
    6023    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6026class Exp(Func):
    6027    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6031class Explode(Func, UDTF):
    6032    arg_types = {"this": True, "expressions": False}
    6033    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_
  update_positions
  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

    6037class Inline(Func):
    6038    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6041class ExplodeOuter(Explode):
    6042    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_
  update_positions
  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

    6045class Posexplode(Explode):
    6046    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_
  update_positions
  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

    6049class PosexplodeOuter(Posexplode, ExplodeOuter):
    6050    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_
  update_positions
  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

    6053class Unnest(Func, UDTF):
    6054    arg_types = {
    6055        "expressions": True,
    6056        "alias": False,
    6057        "offset": False,
    6058        "explode_array": False,
    6059    }
    6060
    6061    @property
    6062    def selects(self) -> t.List[Expression]:
    6063        columns = super().selects
    6064        offset = self.args.get("offset")
    6065        if offset:
    6066            columns = columns + [to_identifier("offset") if offset is True else offset]
    6067        return columns

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

    6061    @property
    6062    def selects(self) -> t.List[Expression]:
    6063        columns = super().selects
    6064        offset = self.args.get("offset")
    6065        if offset:
    6066            columns = columns + [to_identifier("offset") if offset is True else offset]
    6067        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_
  update_positions
  as_
  isin
  between
  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

    6070class Floor(Func):
    6071    arg_types = {"this": True, "decimals": False, "to": False}

arg_types = {'this': True, 'decimals': False, 'to': 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6074class FromBase64(Func):
    6075    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class FeaturesAtTime(Func): View Source

    6078class FeaturesAtTime(Func):
    6079    arg_types = {"this": True, "time": False, "num_rows": False, "ignore_feature_nulls": False}

arg_types = {'this': True, 'time': False, 'num_rows': False, 'ignore_feature_nulls': False}
key = 'featuresattime'

##### Inherited Members

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

    6082class ToBase64(Func):
    6083    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6087class FromISO8601Timestamp(Func):
    6088    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6091class GapFill(Func):
    6092    arg_types = {
    6093        "this": True,
    6094        "ts_column": True,
    6095        "bucket_width": True,
    6096        "partitioning_columns": False,
    6097        "value_columns": False,
    6098        "origin": False,
    6099        "ignore_nulls": False,
    6100    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6104class GenerateDateArray(Func):
    6105    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6109class GenerateTimestampArray(Func):
    6110    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6113class Greatest(Func):
    6114    arg_types = {"this": True, "expressions": False}
    6115    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class OverflowTruncateBehavior(Expression): View Source

    6120class OverflowTruncateBehavior(Expression):
    6121    arg_types = {"this": False, "with_count": True}

arg_types = {'this': False, 'with_count': True}
key = 'overflowtruncatebehavior'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class GroupConcat(AggFunc): View Source

    6124class GroupConcat(AggFunc):
    6125    arg_types = {"this": True, "separator": False, "on_overflow": False}

arg_types = {'this': True, 'separator': False, 'on_overflow': 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6128class Hex(Func):
    6129    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6132class LowerHex(Hex):
    6133    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class And(Connector, Func): View Source

    6136class And(Connector, Func):
    6137    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_
  update_positions
  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 Or(Connector, Func): View Source

    6140class Or(Connector, Func):
    6141    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_
  update_positions
  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 Xor(Connector, Func): View Source

    6144class Xor(Connector, Func):
    6145    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_
  update_positions
  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

    6148class If(Func):
    6149    arg_types = {"this": True, "true": True, "false": False}
    6150    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6153class Nullif(Func):
    6154    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6157class Initcap(Func):
    6158    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class IsAscii(Func): View Source

    6161class IsAscii(Func):
    6162    pass

key = 'isascii'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6165class IsNan(Func):
    6166    _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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Int64(Func): View Source

    6170class Int64(Func):
    6171    pass

key = 'int64'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6174class IsInf(Func):
    6175    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6179class JSON(Expression):
    6180    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPath(Expression): View Source

    6183class JSONPath(Expression):
    6184    arg_types = {"expressions": True, "escape": False}
    6185
    6186    @property
    6187    def output_name(self) -> str:
    6188        last_segment = self.expressions[-1].this
    6189        return last_segment if isinstance(last_segment, str) else ""

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

    6186    @property
    6187    def output_name(self) -> str:
    6188        last_segment = self.expressions[-1].this
    6189        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathPart(Expression): View Source

    6192class JSONPathPart(Expression):
    6193    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathFilter(JSONPathPart): View Source

    6196class JSONPathFilter(JSONPathPart):
    6197    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathKey(JSONPathPart): View Source

    6200class JSONPathKey(JSONPathPart):
    6201    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathRecursive(JSONPathPart): View Source

    6204class JSONPathRecursive(JSONPathPart):
    6205    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathRoot(JSONPathPart): View Source

    6208class JSONPathRoot(JSONPathPart):
    6209    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
JSONPathPart
  arg_types

class JSONPathScript(JSONPathPart): View Source

    6212class JSONPathScript(JSONPathPart):
    6213    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathSlice(JSONPathPart): View Source

    6216class JSONPathSlice(JSONPathPart):
    6217    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathSelector(JSONPathPart): View Source

    6220class JSONPathSelector(JSONPathPart):
    6221    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathSubscript(JSONPathPart): View Source

    6224class JSONPathSubscript(JSONPathPart):
    6225    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathUnion(JSONPathPart): View Source

    6228class JSONPathUnion(JSONPathPart):
    6229    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONPathWildcard(JSONPathPart): View Source

    6232class JSONPathWildcard(JSONPathPart):
    6233    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
JSONPathPart
  arg_types

class FormatJson(Expression): View Source

    6236class FormatJson(Expression):
    6237    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONKeyValue(Expression): View Source

    6240class JSONKeyValue(Expression):
    6241    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONObject(Func): View Source

    6244class JSONObject(Func):
    6245    arg_types = {
    6246        "expressions": False,
    6247        "null_handling": False,
    6248        "unique_keys": False,
    6249        "return_type": False,
    6250        "encoding": False,
    6251    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6254class JSONObjectAgg(AggFunc):
    6255    arg_types = {
    6256        "expressions": False,
    6257        "null_handling": False,
    6258        "unique_keys": False,
    6259        "return_type": False,
    6260        "encoding": False,
    6261    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONBObjectAgg(AggFunc): View Source

    6265class JSONBObjectAgg(AggFunc):
    6266    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

    6270class JSONArray(Func):
    6271    arg_types = {
    6272        "expressions": True,
    6273        "null_handling": False,
    6274        "return_type": False,
    6275        "strict": False,
    6276    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6280class JSONArrayAgg(Func):
    6281    arg_types = {
    6282        "this": True,
    6283        "order": False,
    6284        "null_handling": False,
    6285        "return_type": False,
    6286        "strict": False,
    6287    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6290class JSONExists(Func):
    6291    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6296class JSONColumnDef(Expression):
    6297    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONSchema(Expression): View Source

    6300class JSONSchema(Expression):
    6301    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONValue(Expression): View Source

    6305class JSONValue(Expression):
    6306    arg_types = {
    6307        "this": True,
    6308        "path": True,
    6309        "returning": False,
    6310        "on_condition": False,
    6311    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONValueArray(Func): View Source

    6314class JSONValueArray(Func):
    6315    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONTable(Func): View Source

    6319class JSONTable(Func):
    6320    arg_types = {
    6321        "this": True,
    6322        "schema": True,
    6323        "path": False,
    6324        "error_handling": False,
    6325        "empty_handling": False,
    6326    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6330class ObjectInsert(Func):
    6331    arg_types = {
    6332        "this": True,
    6333        "key": True,
    6334        "value": True,
    6335        "update_flag": False,
    6336    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6339class OpenJSONColumnDef(Expression):
    6340    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class OpenJSON(Func): View Source

    6343class OpenJSON(Func):
    6344    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6347class JSONBContains(Binary, Func):
    6348    _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_
  update_positions
  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 JSONBExists(Func): View Source

    6351class JSONBExists(Func):
    6352    arg_types = {"this": True, "path": True}
    6353    _sql_names = ["JSONB_EXISTS"]

arg_types = {'this': True, 'path': True}
key = 'jsonbexists'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONExtract(Binary, Func): View Source

    6356class JSONExtract(Binary, Func):
    6357    arg_types = {
    6358        "this": True,
    6359        "expression": True,
    6360        "only_json_types": False,
    6361        "expressions": False,
    6362        "variant_extract": False,
    6363        "json_query": False,
    6364        "option": False,
    6365        "quote": False,
    6366        "on_condition": False,
    6367    }
    6368    _sql_names = ["JSON_EXTRACT"]
    6369    is_var_len_args = True
    6370
    6371    @property
    6372    def output_name(self) -> str:
    6373        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, 'quote': False, 'on_condition': False}
is_var_len_args = True
output_name: str View Source

    6371    @property
    6372    def output_name(self) -> str:
    6373        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_
  update_positions
  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 JSONExtractQuote(Expression): View Source

    6377class JSONExtractQuote(Expression):
    6378    arg_types = {
    6379        "option": True,
    6380        "scalar": False,
    6381    }

arg_types = {'option': True, 'scalar': False}
key = 'jsonextractquote'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class JSONExtractArray(Func): View Source

    6384class JSONExtractArray(Func):
    6385    arg_types = {"this": True, "expression": False}
    6386    _sql_names = ["JSON_EXTRACT_ARRAY"]

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONExtractScalar(Binary, Func): View Source

    6389class JSONExtractScalar(Binary, Func):
    6390    arg_types = {"this": True, "expression": True, "only_json_types": False, "expressions": False}
    6391    _sql_names = ["JSON_EXTRACT_SCALAR"]
    6392    is_var_len_args = True
    6393
    6394    @property
    6395    def output_name(self) -> str:
    6396        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

    6394    @property
    6395    def output_name(self) -> str:
    6396        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_
  update_positions
  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

    6399class JSONBExtract(Binary, Func):
    6400    _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_
  update_positions
  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

    6403class JSONBExtractScalar(Binary, Func):
    6404    _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_
  update_positions
  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

    6407class JSONFormat(Func):
    6408    arg_types = {"this": False, "options": False, "is_json": False}
    6409    _sql_names = ["JSON_FORMAT"]

arg_types = {'this': False, 'options': False, 'is_json': 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6413class JSONArrayContains(Binary, Predicate, Func):
    6414    _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_
  update_positions
  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

    6417class ParseJSON(Func):
    6418    # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
    6419    # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
    6420    _sql_names = ["PARSE_JSON", "JSON_PARSE"]
    6421    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6424class Least(Func):
    6425    arg_types = {"this": True, "expressions": False}
    6426    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_
  update_positions
  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

    6429class Left(Func):
    6430    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6433class Right(Func):
    6434    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6437class Length(Func):
    6438    arg_types = {"this": True, "binary": False, "encoding": False}
    6439    _sql_names = ["LENGTH", "LEN", "CHAR_LENGTH", "CHARACTER_LENGTH"]

arg_types = {'this': True, 'binary': False, 'encoding': 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6442class Levenshtein(Func):
    6443    arg_types = {
    6444        "this": True,
    6445        "expression": False,
    6446        "ins_cost": False,
    6447        "del_cost": False,
    6448        "sub_cost": False,
    6449        "max_dist": False,
    6450    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6453class Ln(Func):
    6454    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6457class Log(Func):
    6458    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6461class LogicalOr(AggFunc):
    6462    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6465class LogicalAnd(AggFunc):
    6466    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6469class Lower(Func):
    6470    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6473class Map(Func):
    6474    arg_types = {"keys": False, "values": False}
    6475
    6476    @property
    6477    def keys(self) -> t.List[Expression]:
    6478        keys = self.args.get("keys")
    6479        return keys.expressions if keys else []
    6480
    6481    @property
    6482    def values(self) -> t.List[Expression]:
    6483        values = self.args.get("values")
    6484        return values.expressions if values else []

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

    6476    @property
    6477    def keys(self) -> t.List[Expression]:
    6478        keys = self.args.get("keys")
    6479        return keys.expressions if keys else []

values: List[Expression] View Source

    6481    @property
    6482    def values(self) -> t.List[Expression]:
    6483        values = self.args.get("values")
    6484        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_
  update_positions
  as_
  isin
  between
  is_
  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

    6488class ToMap(Func):
    6489    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6492class MapFromEntries(Func):
    6493    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6497class ScopeResolution(Expression):
    6498    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Stream(Expression): View Source

    6501class Stream(Expression):
    6502    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class StarMap(Func): View Source

    6505class StarMap(Func):
    6506    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6509class VarMap(Func):
    6510    arg_types = {"keys": True, "values": True}
    6511    is_var_len_args = True
    6512
    6513    @property
    6514    def keys(self) -> t.List[Expression]:
    6515        return self.args["keys"].expressions
    6516
    6517    @property
    6518    def values(self) -> t.List[Expression]:
    6519        return self.args["values"].expressions

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

    6513    @property
    6514    def keys(self) -> t.List[Expression]:
    6515        return self.args["keys"].expressions

values: List[Expression] View Source

    6517    @property
    6518    def values(self) -> t.List[Expression]:
    6519        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_
  update_positions
  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

    6523class MatchAgainst(Func):
    6524    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6527class Max(AggFunc):
    6528    arg_types = {"this": True, "expressions": False}
    6529    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_
  update_positions
  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

    6532class MD5(Func):
    6533    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6537class MD5Digest(Func):
    6538    _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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Median(AggFunc): View Source

    6541class Median(AggFunc):
    6542    pass

key = 'median'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6545class Min(AggFunc):
    6546    arg_types = {"this": True, "expressions": False}
    6547    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_
  update_positions
  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

    6550class Month(Func):
    6551    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6554class AddMonths(Func):
    6555    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6558class Nvl2(Func):
    6559    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6562class Normalize(Func):
    6563    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6566class Overlay(Func):
    6567    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6571class Predict(Func):
    6572    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6575class Pow(Binary, Func):
    6576    _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_
  update_positions
  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

    6579class PercentileCont(AggFunc):
    6580    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6583class PercentileDisc(AggFunc):
    6584    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6587class Quantile(AggFunc):
    6588    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6591class ApproxQuantile(Quantile):
    6592    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6595class Quarter(Func):
    6596    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6601class Rand(Func):
    6602    _sql_names = ["RAND", "RANDOM"]
    6603    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6606class Randn(Func):
    6607    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6610class RangeN(Func):
    6611    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6614class ReadCSV(Func):
    6615    _sql_names = ["READ_CSV"]
    6616    is_var_len_args = True
    6617    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_
  update_positions
  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

    6620class Reduce(Func):
    6621    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6624class RegexpExtract(Func):
    6625    arg_types = {
    6626        "this": True,
    6627        "expression": True,
    6628        "position": False,
    6629        "occurrence": False,
    6630        "parameters": False,
    6631        "group": False,
    6632    }

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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RegexpExtractAll(Func): View Source

    6635class RegexpExtractAll(Func):
    6636    arg_types = {
    6637        "this": True,
    6638        "expression": True,
    6639        "position": False,
    6640        "occurrence": False,
    6641        "parameters": False,
    6642        "group": False,
    6643    }

arg_types = {'this': True, 'expression': True, 'position': False, 'occurrence': False, 'parameters': False, 'group': False}
key = 'regexpextractall'

##### Inherited Members

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

    6646class RegexpReplace(Func):
    6647    arg_types = {
    6648        "this": True,
    6649        "expression": True,
    6650        "replacement": False,
    6651        "position": False,
    6652        "occurrence": False,
    6653        "modifiers": False,
    6654    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6657class RegexpLike(Binary, Func):
    6658    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_
  update_positions
  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

    6661class RegexpILike(Binary, Func):
    6662    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_
  update_positions
  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

    6667class RegexpSplit(Func):
    6668    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6671class Repeat(Func):
    6672    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Replace(Func): View Source

    6676class Replace(Func):
    6677    arg_types = {"this": True, "expression": True, "replacement": False}

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

##### Inherited Members

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

    6682class Round(Func):
    6683    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6686class RowNumber(Func):
    6687    arg_types = {"this": False}

arg_types = {'this': False}
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_
  update_positions
  as_
  isin
  between
  is_
  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

    6690class SafeDivide(Func):
    6691    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6694class SHA(Func):
    6695    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6698class SHA2(Func):
    6699    _sql_names = ["SHA2"]
    6700    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6703class Sign(Func):
    6704    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6707class SortArray(Func):
    6708    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6711class Split(Func):
    6712    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6716class SplitPart(Func):
    6717    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6722class Substring(Func):
    6723    _sql_names = ["SUBSTRING", "SUBSTR"]
    6724    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6727class StandardHash(Func):
    6728    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6731class StartsWith(Func):
    6732    _sql_names = ["STARTS_WITH", "STARTSWITH"]
    6733    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class EndsWith(Func): View Source

    6736class EndsWith(Func):
    6737    _sql_names = ["ENDS_WITH", "ENDSWITH"]
    6738    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

    6741class StrPosition(Func):
    6742    arg_types = {
    6743        "this": True,
    6744        "substr": True,
    6745        "position": False,
    6746        "occurrence": False,
    6747    }

arg_types = {'this': True, 'substr': True, 'position': False, 'occurrence': 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6750class StrToDate(Func):
    6751    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6754class StrToTime(Func):
    6755    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6760class StrToUnix(Func):
    6761    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6766class StrToMap(Func):
    6767    arg_types = {
    6768        "this": True,
    6769        "pair_delim": False,
    6770        "key_value_delim": False,
    6771        "duplicate_resolution_callback": False,
    6772    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6775class NumberToStr(Func):
    6776    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6779class FromBase(Func):
    6780    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6783class Struct(Func):
    6784    arg_types = {"expressions": False}
    6785    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_
  update_positions
  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

    6788class StructExtract(Func):
    6789    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6794class Stuff(Func):
    6795    _sql_names = ["STUFF", "INSERT"]
    6796    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6799class Sum(AggFunc):
    6800    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6803class Sqrt(Func):
    6804    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6807class Stddev(AggFunc):
    6808    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6811class StddevPop(AggFunc):
    6812    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6815class StddevSamp(AggFunc):
    6816    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6820class Time(Func):
    6821    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6824class TimeToStr(Func):
    6825    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6828class TimeToTimeStr(Func):
    6829    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6832class TimeToUnix(Func):
    6833    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6836class TimeStrToDate(Func):
    6837    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6840class TimeStrToTime(Func):
    6841    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6844class TimeStrToUnix(Func):
    6845    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6848class Trim(Func):
    6849    arg_types = {
    6850        "this": True,
    6851        "expression": False,
    6852        "position": False,
    6853        "collation": False,
    6854    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6857class TsOrDsAdd(Func, TimeUnit):
    6858    # return_type is used to correctly cast the arguments of this expression when transpiling it
    6859    arg_types = {"this": True, "expression": True, "unit": False, "return_type": False}
    6860
    6861    @property
    6862    def return_type(self) -> DataType:
    6863        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

    6861    @property
    6862    def return_type(self) -> DataType:
    6863        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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TsOrDsDiff(Func, TimeUnit): View Source

    6866class TsOrDsDiff(Func, TimeUnit):
    6867    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TsOrDsToDateStr(Func): View Source

    6870class TsOrDsToDateStr(Func):
    6871    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6874class TsOrDsToDate(Func):
    6875    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class TsOrDsToDatetime(Func): View Source

    6878class TsOrDsToDatetime(Func):
    6879    pass

key = 'tsordstodatetime'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6882class TsOrDsToTime(Func):
    6883    arg_types = {"this": True, "format": False, "safe": False}

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

##### Inherited Members

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

    6886class TsOrDsToTimestamp(Func):
    6887    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6890class TsOrDiToDi(Func):
    6891    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6894class Unhex(Func):
    6895    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Unicode(Func): View Source

    6898class Unicode(Func):
    6899    pass

key = 'unicode'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6903class UnixDate(Func):
    6904    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6907class UnixToStr(Func):
    6908    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6913class UnixToTime(Func):
    6914    arg_types = {
    6915        "this": True,
    6916        "scale": False,
    6917        "zone": False,
    6918        "hours": False,
    6919        "minutes": False,
    6920        "format": False,
    6921    }
    6922
    6923    SECONDS = Literal.number(0)
    6924    DECIS = Literal.number(1)
    6925    CENTIS = Literal.number(2)
    6926    MILLIS = Literal.number(3)
    6927    DECIMILLIS = Literal.number(4)
    6928    CENTIMILLIS = Literal.number(5)
    6929    MICROS = Literal.number(6)
    6930    DECIMICROS = Literal.number(7)
    6931    CENTIMICROS = Literal.number(8)
    6932    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6935class UnixToTimeStr(Func):
    6936    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class UnixSeconds(Func): View Source

    6939class UnixSeconds(Func):
    6940    pass

key = 'unixseconds'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  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

    6943class Uuid(Func):
    6944    _sql_names = ["UUID", "GEN_RANDOM_UUID", "GENERATE_UUID", "UUID_STRING"]
    6945
    6946    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_
  update_positions
  as_
  isin
  between
  is_
  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

    6949class TimestampFromParts(Func):
    6950    _sql_names = ["TIMESTAMP_FROM_PARTS", "TIMESTAMPFROMPARTS"]
    6951    arg_types = {
    6952        "year": True,
    6953        "month": True,
    6954        "day": True,
    6955        "hour": True,
    6956        "min": True,
    6957        "sec": True,
    6958        "nano": False,
    6959        "zone": False,
    6960        "milli": False,
    6961    }

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_
  update_positions
  as_
  isin
  between
  is_
  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

    6964class Upper(Func):
    6965    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6968class Corr(Binary, AggFunc):
    6969    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_
  update_positions
  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

    6972class Variance(AggFunc):
    6973    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6976class VariancePop(AggFunc):
    6977    _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_
  update_positions
  as_
  isin
  between
  is_
  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

    6980class CovarSamp(Binary, AggFunc):
    6981    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_
  update_positions
  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

    6984class CovarPop(Binary, AggFunc):
    6985    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_
  update_positions
  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

    6988class Week(Func):
    6989    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class XMLElement(Func): View Source

    6992class XMLElement(Func):
    6993    _sql_names = ["XMLELEMENT"]
    6994    arg_types = {"this": True, "expressions": False}

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

##### Inherited Members

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

    6997class XMLTable(Func):
    6998    arg_types = {
    6999        "this": True,
    7000        "namespaces": False,
    7001        "passing": False,
    7002        "columns": False,
    7003        "by_ref": False,
    7004    }

arg_types = {'this': True, 'namespaces': False, '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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class XMLNamespace(Expression): View Source

    7007class XMLNamespace(Expression):
    7008    pass

key = 'xmlnamespace'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class XMLKeyValueOption(Expression): View Source

    7012class XMLKeyValueOption(Expression):
    7013    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Year(Func): View Source

    7016class Year(Func):
    7017    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_
  update_positions
  as_
  isin
  between
  is_
  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

    7020class Use(Expression):
    7021    arg_types = {"this": False, "expressions": False, "kind": False}

arg_types = {'this': False, 'expressions': False, '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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Merge(DML): View Source

    7024class Merge(DML):
    7025    arg_types = {
    7026        "this": True,
    7027        "using": True,
    7028        "on": True,
    7029        "whens": True,
    7030        "with": False,
    7031        "returning": False,
    7032    }

arg_types = {'this': True, 'using': True, 'on': True, 'whens': 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc
DML
  returning

class When(Expression): View Source

    7035class When(Expression):
    7036    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class Whens(Expression): View Source

    7039class Whens(Expression):
    7040    """Wraps around one or more WHEN [NOT] MATCHED [...] clauses."""
    7041
    7042    arg_types = {"expressions": True}

Wraps around one or more WHEN [NOT] MATCHED [...] clauses.

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  index
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  to_py
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  is_type
  is_leaf
  meta
  copy
  add_comments
  pop_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  to_s
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class NextValueFor(Func): View Source

    7047class NextValueFor(Func):
    7048    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_
  update_positions
  as_
  isin
  between
  is_
  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

    7053class Semicolon(Expression):
    7054    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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

class TableColumn(Expression): View Source

    7059class TableColumn(Expression):
    7060    pass

key = 'tablecolumn'

##### 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_
  update_positions
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
  div
  asc
  desc

ALL_FUNCTIONS = [<class 'Abs'>, <class 'AddMonths'>, <class 'And'>, <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 'ArrayConcatAgg'>, <class 'ArrayConstructCompact'>, <class 'ArrayContains'>, <class 'ArrayContainsAll'>, <class 'ArrayFilter'>, <class 'ArrayIntersect'>, <class 'ArrayOverlaps'>, <class 'ArrayRemove'>, <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 'Contains'>, <class 'Convert'>, <class 'ConvertTimezone'>, <class 'ConvertToCharset'>, <class 'Corr'>, <class 'Count'>, <class 'CountIf'>, <class 'CovarPop'>, <class 'CovarSamp'>, <class 'CurrentDate'>, <class 'CurrentDatetime'>, <class 'CurrentSchema'>, <class 'CurrentTime'>, <class 'CurrentTimestamp'>, <class 'CurrentTimestampLTZ'>, <class 'CurrentUser'>, <class 'Date'>, <class 'DateAdd'>, <class 'DateBin'>, <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 'EndsWith'>, <class 'Exists'>, <class 'Exp'>, <class 'Explode'>, <class 'ExplodeOuter'>, <class 'ExplodingGenerateSeries'>, <class 'Extract'>, <class 'FeaturesAtTime'>, <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 'Int64'>, <class 'IsAscii'>, <class 'IsInf'>, <class 'IsNan'>, <class 'JSONArray'>, <class 'JSONArrayAgg'>, <class 'JSONArrayContains'>, <class 'JSONBContains'>, <class 'JSONBExists'>, <class 'JSONBExtract'>, <class 'JSONBExtractScalar'>, <class 'JSONBObjectAgg'>, <class 'JSONCast'>, <class 'JSONExists'>, <class 'JSONExtract'>, <class 'JSONExtractArray'>, <class 'JSONExtractScalar'>, <class 'JSONFormat'>, <class 'JSONObject'>, <class 'JSONObjectAgg'>, <class 'JSONTable'>, <class 'JSONValueArray'>, <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 'MakeInterval'>, <class 'Map'>, <class 'MapFromEntries'>, <class 'MatchAgainst'>, <class 'Max'>, <class 'Median'>, <class 'Min'>, <class 'Month'>, <class 'MonthsBetween'>, <class 'NextValueFor'>, <class 'Normalize'>, <class 'NthValue'>, <class 'Nullif'>, <class 'NumberToStr'>, <class 'Nvl2'>, <class 'ObjectInsert'>, <class 'OpenJSON'>, <class 'Or'>, <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 'RegexpExtractAll'>, <class 'RegexpILike'>, <class 'RegexpLike'>, <class 'RegexpReplace'>, <class 'RegexpSplit'>, <class 'Repeat'>, <class 'Replace'>, <class 'Right'>, <class 'Round'>, <class 'RowNumber'>, <class 'SHA'>, <class 'SHA2'>, <class 'SafeDivide'>, <class 'Sign'>, <class 'SortArray'>, <class 'Split'>, <class 'SplitPart'>, <class 'Sqrt'>, <class 'StDistance'>, <class 'StPoint'>, <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 'TsOrDsToDatetime'>, <class 'TsOrDsToTime'>, <class 'TsOrDsToTimestamp'>, <class 'Unhex'>, <class 'Unicode'>, <class 'UnixDate'>, <class 'UnixSeconds'>, <class 'UnixToStr'>, <class 'UnixToTime'>, <class 'UnixToTimeStr'>, <class 'Unnest'>, <class 'Upper'>, <class 'Uuid'>, <class 'VarMap'>, <class 'Variance'>, <class 'VariancePop'>, <class 'Week'>, <class 'WeekOfYear'>, <class 'XMLElement'>, <class 'XMLTable'>, <class 'Xor'>, <class 'Year'>]
FUNCTION_BY_NAME = {'ABS': <class 'Abs'>, 'ADD_MONTHS': <class 'AddMonths'>, 'AND': <class 'And'>, '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_CONCAT_AGG': <class 'ArrayConcatAgg'>, '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_INTERSECT': <class 'ArrayIntersect'>, 'ARRAY_INTERSECTION': <class 'ArrayIntersect'>, 'ARRAY_OVERLAPS': <class 'ArrayOverlaps'>, 'ARRAY_REMOVE': <class 'ArrayRemove'>, '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'>, 'CONTAINS': <class 'Contains'>, 'CONVERT': <class 'Convert'>, 'CONVERT_TIMEZONE': <class 'ConvertTimezone'>, 'CONVERT_TO_CHARSET': <class 'ConvertToCharset'>, '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_SCHEMA': <class 'CurrentSchema'>, 'CURRENT_TIME': <class 'CurrentTime'>, 'CURRENT_TIMESTAMP': <class 'CurrentTimestamp'>, 'CURRENT_TIMESTAMP_L_T_Z': <class 'CurrentTimestampLTZ'>, 'CURRENT_USER': <class 'CurrentUser'>, 'DATE': <class 'Date'>, 'DATE_ADD': <class 'DateAdd'>, 'DATE_BIN': <class 'DateBin'>, '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'>, 'ENDS_WITH': <class 'EndsWith'>, 'ENDSWITH': <class 'EndsWith'>, 'EXISTS': <class 'Exists'>, 'EXP': <class 'Exp'>, 'EXPLODE': <class 'Explode'>, 'EXPLODE_OUTER': <class 'ExplodeOuter'>, 'EXPLODING_GENERATE_SERIES': <class 'ExplodingGenerateSeries'>, 'EXTRACT': <class 'Extract'>, 'FEATURES_AT_TIME': <class 'FeaturesAtTime'>, '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'>, 'INT64': <class 'Int64'>, 'IS_ASCII': <class 'IsAscii'>, '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_EXISTS': <class 'JSONBExists'>, 'JSONB_EXTRACT': <class 'JSONBExtract'>, 'JSONB_EXTRACT_SCALAR': <class 'JSONBExtractScalar'>, 'J_S_O_N_B_OBJECT_AGG': <class 'JSONBObjectAgg'>, 'J_S_O_N_CAST': <class 'JSONCast'>, 'J_S_O_N_EXISTS': <class 'JSONExists'>, 'JSON_EXTRACT': <class 'JSONExtract'>, 'JSON_EXTRACT_ARRAY': <class 'JSONExtractArray'>, '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'>, 'J_S_O_N_VALUE_ARRAY': <class 'JSONValueArray'>, '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'>, 'CHAR_LENGTH': <class 'Length'>, 'CHARACTER_LENGTH': <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'>, 'MAKE_INTERVAL': <class 'MakeInterval'>, 'MAP': <class 'Map'>, 'MAP_FROM_ENTRIES': <class 'MapFromEntries'>, 'MATCH_AGAINST': <class 'MatchAgainst'>, 'MAX': <class 'Max'>, 'MEDIAN': <class 'Median'>, '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'>, 'OR': <class 'Or'>, '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_EXTRACT_ALL': <class 'RegexpExtractAll'>, 'REGEXP_I_LIKE': <class 'RegexpILike'>, 'REGEXP_LIKE': <class 'RegexpLike'>, 'REGEXP_REPLACE': <class 'RegexpReplace'>, 'REGEXP_SPLIT': <class 'RegexpSplit'>, 'REPEAT': <class 'Repeat'>, 'REPLACE': <class 'Replace'>, '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'>, 'ST_DISTANCE': <class 'StDistance'>, 'ST_POINT': <class 'StPoint'>, 'ST_MAKEPOINT': <class 'StPoint'>, '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'>, 'STRTOK_TO_ARRAY': <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_DATETIME': <class 'TsOrDsToDatetime'>, 'TS_OR_DS_TO_TIME': <class 'TsOrDsToTime'>, 'TS_OR_DS_TO_TIMESTAMP': <class 'TsOrDsToTimestamp'>, 'UNHEX': <class 'Unhex'>, 'UNICODE': <class 'Unicode'>, 'UNIX_DATE': <class 'UnixDate'>, 'UNIX_SECONDS': <class 'UnixSeconds'>, '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'>, 'XMLELEMENT': <class 'XMLElement'>, '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, Type[sqlglot.dialects.Dialect], NoneType] = None, prefix: Optional[str] = None, copy: bool = False, **opts) -> Expression: View Source

    7100def maybe_parse(
    7101    sql_or_expression: ExpOrStr,
    7102    *,
    7103    into: t.Optional[IntoType] = None,
    7104    dialect: DialectType = None,
    7105    prefix: t.Optional[str] = None,
    7106    copy: bool = False,
    7107    **opts,
    7108) -> Expression:
    7109    """Gracefully handle a possible string or expression.
    7110
    7111    Example:
    7112        >>> maybe_parse("1")
    7113        Literal(this=1, is_string=False)
    7114        >>> maybe_parse(to_identifier("x"))
    7115        Identifier(this=x, quoted=False)
    7116
    7117    Args:
    7118        sql_or_expression: the SQL code string or an expression
    7119        into: the SQLGlot Expression to parse into
    7120        dialect: the dialect used to parse the input expressions (in the case that an
    7121            input expression is a SQL string).
    7122        prefix: a string to prefix the sql with before it gets parsed
    7123            (automatically includes a space)
    7124        copy: whether to copy the expression.
    7125        **opts: other options to use to parse the input expressions (again, in the case
    7126            that an input expression is a SQL string).
    7127
    7128    Returns:
    7129        Expression: the parsed or given expression.
    7130    """
    7131    if isinstance(sql_or_expression, Expression):
    7132        if copy:
    7133            return sql_or_expression.copy()
    7134        return sql_or_expression
    7135
    7136    if sql_or_expression is None:
    7137        raise ParseError("SQL cannot be None")
    7138
    7139    import sqlglot
    7140
    7141    sql = str(sql_or_expression)
    7142    if prefix:
    7143        sql = f"{prefix} {sql}"
    7144
    7145    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

    7156def maybe_copy(instance, copy=True):
    7157    return instance.copy() if copy and instance else instance

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

    7412def union(
    7413    *expressions: ExpOrStr,
    7414    distinct: bool = True,
    7415    dialect: DialectType = None,
    7416    copy: bool = True,
    7417    **opts,
    7418) -> Union:
    7419    """
    7420    Initializes a syntax tree for the `UNION` operation.
    7421
    7422    Example:
    7423        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    7424        'SELECT * FROM foo UNION SELECT * FROM bla'
    7425
    7426    Args:
    7427        expressions: the SQL code strings, corresponding to the `UNION`'s operands.
    7428            If `Expression` instances are passed, they will be used as-is.
    7429        distinct: set the DISTINCT flag if and only if this is true.
    7430        dialect: the dialect used to parse the input expression.
    7431        copy: whether to copy the expression.
    7432        opts: other options to use to parse the input expressions.
    7433
    7434    Returns:
    7435        The new Union instance.
    7436    """
    7437    assert len(expressions) >= 2, "At least two expressions are required by `union`."
    7438    return _apply_set_operation(
    7439        *expressions, set_operation=Union, distinct=distinct, dialect=dialect, copy=copy, **opts
    7440    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Intersect: View Source

    7443def intersect(
    7444    *expressions: ExpOrStr,
    7445    distinct: bool = True,
    7446    dialect: DialectType = None,
    7447    copy: bool = True,
    7448    **opts,
    7449) -> Intersect:
    7450    """
    7451    Initializes a syntax tree for the `INTERSECT` operation.
    7452
    7453    Example:
    7454        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    7455        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    7456
    7457    Args:
    7458        expressions: the SQL code strings, corresponding to the `INTERSECT`'s operands.
    7459            If `Expression` instances are passed, they will be used as-is.
    7460        distinct: set the DISTINCT flag if and only if this is true.
    7461        dialect: the dialect used to parse the input expression.
    7462        copy: whether to copy the expression.
    7463        opts: other options to use to parse the input expressions.
    7464
    7465    Returns:
    7466        The new Intersect instance.
    7467    """
    7468    assert len(expressions) >= 2, "At least two expressions are required by `intersect`."
    7469    return _apply_set_operation(
    7470        *expressions, set_operation=Intersect, distinct=distinct, dialect=dialect, copy=copy, **opts
    7471    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Except: View Source

    7474def except_(
    7475    *expressions: ExpOrStr,
    7476    distinct: bool = True,
    7477    dialect: DialectType = None,
    7478    copy: bool = True,
    7479    **opts,
    7480) -> Except:
    7481    """
    7482    Initializes a syntax tree for the `EXCEPT` operation.
    7483
    7484    Example:
    7485        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    7486        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    7487
    7488    Args:
    7489        expressions: the SQL code strings, corresponding to the `EXCEPT`'s operands.
    7490            If `Expression` instances are passed, they will be used as-is.
    7491        distinct: set the DISTINCT flag if and only if this is true.
    7492        dialect: the dialect used to parse the input expression.
    7493        copy: whether to copy the expression.
    7494        opts: other options to use to parse the input expressions.
    7495
    7496    Returns:
    7497        The new Except instance.
    7498    """
    7499    assert len(expressions) >= 2, "At least two expressions are required by `except_`."
    7500    return _apply_set_operation(
    7501        *expressions, set_operation=Except, distinct=distinct, dialect=dialect, copy=copy, **opts
    7502    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Select: View Source

    7505def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    7506    """
    7507    Initializes a syntax tree from one or multiple SELECT expressions.
    7508
    7509    Example:
    7510        >>> select("col1", "col2").from_("tbl").sql()
    7511        'SELECT col1, col2 FROM tbl'
    7512
    7513    Args:
    7514        *expressions: the SQL code string to parse as the expressions of a
    7515            SELECT statement. If an Expression instance is passed, this is used as-is.
    7516        dialect: the dialect used to parse the input expressions (in the case that an
    7517            input expression is a SQL string).
    7518        **opts: other options to use to parse the input expressions (again, in the case
    7519            that an input expression is a SQL string).
    7520
    7521    Returns:
    7522        Select: the syntax tree for the SELECT statement.
    7523    """
    7524    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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Select: View Source

    7527def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    7528    """
    7529    Initializes a syntax tree from a FROM expression.
    7530
    7531    Example:
    7532        >>> from_("tbl").select("col1", "col2").sql()
    7533        'SELECT col1, col2 FROM tbl'
    7534
    7535    Args:
    7536        *expression: the SQL code string to parse as the FROM expressions of a
    7537            SELECT statement. If an Expression instance is passed, this is used as-is.
    7538        dialect: the dialect used to parse the input expression (in the case that the
    7539            input expression is a SQL string).
    7540        **opts: other options to use to parse the input expressions (again, in the case
    7541            that the input expression is a SQL string).
    7542
    7543    Returns:
    7544        Select: the syntax tree for the SELECT statement.
    7545    """
    7546    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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Update: View Source

    7549def update(
    7550    table: str | Table,
    7551    properties: t.Optional[dict] = None,
    7552    where: t.Optional[ExpOrStr] = None,
    7553    from_: t.Optional[ExpOrStr] = None,
    7554    with_: t.Optional[t.Dict[str, ExpOrStr]] = None,
    7555    dialect: DialectType = None,
    7556    **opts,
    7557) -> Update:
    7558    """
    7559    Creates an update statement.
    7560
    7561    Example:
    7562        >>> 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()
    7563        "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"
    7564
    7565    Args:
    7566        properties: dictionary of properties to SET which are
    7567            auto converted to sql objects eg None -> NULL
    7568        where: sql conditional parsed into a WHERE statement
    7569        from_: sql statement parsed into a FROM statement
    7570        with_: dictionary of CTE aliases / select statements to include in a WITH clause.
    7571        dialect: the dialect used to parse the input expressions.
    7572        **opts: other options to use to parse the input expressions.
    7573
    7574    Returns:
    7575        Update: the syntax tree for the UPDATE statement.
    7576    """
    7577    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    7578    if properties:
    7579        update_expr.set(
    7580            "expressions",
    7581            [
    7582                EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    7583                for k, v in properties.items()
    7584            ],
    7585        )
    7586    if from_:
    7587        update_expr.set(
    7588            "from",
    7589            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    7590        )
    7591    if isinstance(where, Condition):
    7592        where = Where(this=where)
    7593    if where:
    7594        update_expr.set(
    7595            "where",
    7596            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    7597        )
    7598    if with_:
    7599        cte_list = [
    7600            alias_(CTE(this=maybe_parse(qry, dialect=dialect, **opts)), alias, table=True)
    7601            for alias, qry in with_.items()
    7602        ]
    7603        update_expr.set(
    7604            "with",
    7605            With(expressions=cte_list),
    7606        )
    7607    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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Delete: View Source

    7610def delete(
    7611    table: ExpOrStr,
    7612    where: t.Optional[ExpOrStr] = None,
    7613    returning: t.Optional[ExpOrStr] = None,
    7614    dialect: DialectType = None,
    7615    **opts,
    7616) -> Delete:
    7617    """
    7618    Builds a delete statement.
    7619
    7620    Example:
    7621        >>> delete("my_table", where="id > 1").sql()
    7622        'DELETE FROM my_table WHERE id > 1'
    7623
    7624    Args:
    7625        where: sql conditional parsed into a WHERE statement
    7626        returning: sql conditional parsed into a RETURNING statement
    7627        dialect: the dialect used to parse the input expressions.
    7628        **opts: other options to use to parse the input expressions.
    7629
    7630    Returns:
    7631        Delete: the syntax tree for the DELETE statement.
    7632    """
    7633    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    7634    if where:
    7635        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    7636    if returning:
    7637        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    7638    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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Insert: View Source

    7641def insert(
    7642    expression: ExpOrStr,
    7643    into: ExpOrStr,
    7644    columns: t.Optional[t.Sequence[str | Identifier]] = None,
    7645    overwrite: t.Optional[bool] = None,
    7646    returning: t.Optional[ExpOrStr] = None,
    7647    dialect: DialectType = None,
    7648    copy: bool = True,
    7649    **opts,
    7650) -> Insert:
    7651    """
    7652    Builds an INSERT statement.
    7653
    7654    Example:
    7655        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    7656        'INSERT INTO tbl VALUES (1, 2, 3)'
    7657
    7658    Args:
    7659        expression: the sql string or expression of the INSERT statement
    7660        into: the tbl to insert data to.
    7661        columns: optionally the table's column names.
    7662        overwrite: whether to INSERT OVERWRITE or not.
    7663        returning: sql conditional parsed into a RETURNING statement
    7664        dialect: the dialect used to parse the input expressions.
    7665        copy: whether to copy the expression.
    7666        **opts: other options to use to parse the input expressions.
    7667
    7668    Returns:
    7669        Insert: the syntax tree for the INSERT statement.
    7670    """
    7671    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    7672    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    7673
    7674    if columns:
    7675        this = Schema(this=this, expressions=[to_identifier(c, copy=copy) for c in columns])
    7676
    7677    insert = Insert(this=this, expression=expr, overwrite=overwrite)
    7678
    7679    if returning:
    7680        insert = insert.returning(returning, dialect=dialect, copy=False, **opts)
    7681
    7682    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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Merge: View Source

    7685def merge(
    7686    *when_exprs: ExpOrStr,
    7687    into: ExpOrStr,
    7688    using: ExpOrStr,
    7689    on: ExpOrStr,
    7690    returning: t.Optional[ExpOrStr] = None,
    7691    dialect: DialectType = None,
    7692    copy: bool = True,
    7693    **opts,
    7694) -> Merge:
    7695    """
    7696    Builds a MERGE statement.
    7697
    7698    Example:
    7699        >>> merge("WHEN MATCHED THEN UPDATE SET col1 = source_table.col1",
    7700        ...       "WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)",
    7701        ...       into="my_table",
    7702        ...       using="source_table",
    7703        ...       on="my_table.id = source_table.id").sql()
    7704        '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)'
    7705
    7706    Args:
    7707        *when_exprs: The WHEN clauses specifying actions for matched and unmatched rows.
    7708        into: The target table to merge data into.
    7709        using: The source table to merge data from.
    7710        on: The join condition for the merge.
    7711        returning: The columns to return from the merge.
    7712        dialect: The dialect used to parse the input expressions.
    7713        copy: Whether to copy the expression.
    7714        **opts: Other options to use to parse the input expressions.
    7715
    7716    Returns:
    7717        Merge: The syntax tree for the MERGE statement.
    7718    """
    7719    expressions: t.List[Expression] = []
    7720    for when_expr in when_exprs:
    7721        expression = maybe_parse(when_expr, dialect=dialect, copy=copy, into=Whens, **opts)
    7722        expressions.extend([expression] if isinstance(expression, When) else expression.expressions)
    7723
    7724    merge = Merge(
    7725        this=maybe_parse(into, dialect=dialect, copy=copy, **opts),
    7726        using=maybe_parse(using, dialect=dialect, copy=copy, **opts),
    7727        on=maybe_parse(on, dialect=dialect, copy=copy, **opts),
    7728        whens=Whens(expressions=expressions),
    7729    )
    7730    if returning:
    7731        merge = merge.returning(returning, dialect=dialect, copy=False, **opts)
    7732
    7733    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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    7736def condition(
    7737    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    7738) -> Condition:
    7739    """
    7740    Initialize a logical condition expression.
    7741
    7742    Example:
    7743        >>> condition("x=1").sql()
    7744        'x = 1'
    7745
    7746        This is helpful for composing larger logical syntax trees:
    7747        >>> where = condition("x=1")
    7748        >>> where = where.and_("y=1")
    7749        >>> Select().from_("tbl").select("*").where(where).sql()
    7750        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    7751
    7752    Args:
    7753        *expression: the SQL code string to parse.
    7754            If an Expression instance is passed, this is used as-is.
    7755        dialect: the dialect used to parse the input expression (in the case that the
    7756            input expression is a SQL string).
    7757        copy: Whether to copy `expression` (only applies to expressions).
    7758        **opts: other options to use to parse the input expressions (again, in the case
    7759            that the input expression is a SQL string).
    7760
    7761    Returns:
    7762        The new Condition instance
    7763    """
    7764    return maybe_parse(
    7765        expression,
    7766        into=Condition,
    7767        dialect=dialect,
    7768        copy=copy,
    7769        **opts,
    7770    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, wrap: bool = True, **opts) -> Condition: View Source

    7773def and_(
    7774    *expressions: t.Optional[ExpOrStr],
    7775    dialect: DialectType = None,
    7776    copy: bool = True,
    7777    wrap: bool = True,
    7778    **opts,
    7779) -> Condition:
    7780    """
    7781    Combine multiple conditions with an AND logical operator.
    7782
    7783    Example:
    7784        >>> and_("x=1", and_("y=1", "z=1")).sql()
    7785        'x = 1 AND (y = 1 AND z = 1)'
    7786
    7787    Args:
    7788        *expressions: the SQL code strings to parse.
    7789            If an Expression instance is passed, this is used as-is.
    7790        dialect: the dialect used to parse the input expression.
    7791        copy: whether to copy `expressions` (only applies to Expressions).
    7792        wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid
    7793            precedence issues, but can be turned off when the produced AST is too deep and
    7794            causes recursion-related issues.
    7795        **opts: other options to use to parse the input expressions.
    7796
    7797    Returns:
    7798        The new condition
    7799    """
    7800    return t.cast(Condition, _combine(expressions, And, dialect, copy=copy, wrap=wrap, **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).
- wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues.
- **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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, wrap: bool = True, **opts) -> Condition: View Source

    7803def or_(
    7804    *expressions: t.Optional[ExpOrStr],
    7805    dialect: DialectType = None,
    7806    copy: bool = True,
    7807    wrap: bool = True,
    7808    **opts,
    7809) -> Condition:
    7810    """
    7811    Combine multiple conditions with an OR logical operator.
    7812
    7813    Example:
    7814        >>> or_("x=1", or_("y=1", "z=1")).sql()
    7815        'x = 1 OR (y = 1 OR z = 1)'
    7816
    7817    Args:
    7818        *expressions: the SQL code strings to parse.
    7819            If an Expression instance is passed, this is used as-is.
    7820        dialect: the dialect used to parse the input expression.
    7821        copy: whether to copy `expressions` (only applies to Expressions).
    7822        wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid
    7823            precedence issues, but can be turned off when the produced AST is too deep and
    7824            causes recursion-related issues.
    7825        **opts: other options to use to parse the input expressions.
    7826
    7827    Returns:
    7828        The new condition
    7829    """
    7830    return t.cast(Condition, _combine(expressions, Or, dialect, copy=copy, wrap=wrap, **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).
- wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues.
- **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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, wrap: bool = True, **opts) -> Condition: View Source

    7833def xor(
    7834    *expressions: t.Optional[ExpOrStr],
    7835    dialect: DialectType = None,
    7836    copy: bool = True,
    7837    wrap: bool = True,
    7838    **opts,
    7839) -> Condition:
    7840    """
    7841    Combine multiple conditions with an XOR logical operator.
    7842
    7843    Example:
    7844        >>> xor("x=1", xor("y=1", "z=1")).sql()
    7845        'x = 1 XOR (y = 1 XOR z = 1)'
    7846
    7847    Args:
    7848        *expressions: the SQL code strings to parse.
    7849            If an Expression instance is passed, this is used as-is.
    7850        dialect: the dialect used to parse the input expression.
    7851        copy: whether to copy `expressions` (only applies to Expressions).
    7852        wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid
    7853            precedence issues, but can be turned off when the produced AST is too deep and
    7854            causes recursion-related issues.
    7855        **opts: other options to use to parse the input expressions.
    7856
    7857    Returns:
    7858        The new condition
    7859    """
    7860    return t.cast(Condition, _combine(expressions, Xor, dialect, copy=copy, wrap=wrap, **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).
- wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues.
- **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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts) -> Not: View Source

    7863def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    7864    """
    7865    Wrap a condition with a NOT operator.
    7866
    7867    Example:
    7868        >>> not_("this_suit='black'").sql()
    7869        "NOT this_suit = 'black'"
    7870
    7871    Args:
    7872        expression: the SQL code string to parse.
    7873            If an Expression instance is passed, this is used as-is.
    7874        dialect: the dialect used to parse the input expression.
    7875        copy: whether to copy the expression or not.
    7876        **opts: other options to use to parse the input expressions.
    7877
    7878    Returns:
    7879        The new condition.
    7880    """
    7881    this = condition(
    7882        expression,
    7883        dialect=dialect,
    7884        copy=copy,
    7885        **opts,
    7886    )
    7887    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

    7890def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    7891    """
    7892    Wrap an expression in parentheses.
    7893
    7894    Example:
    7895        >>> paren("5 + 3").sql()
    7896        '(5 + 3)'
    7897
    7898    Args:
    7899        expression: the SQL code string to parse.
    7900            If an Expression instance is passed, this is used as-is.
    7901        copy: whether to copy the expression or not.
    7902
    7903    Returns:
    7904        The wrapped expression.
    7905    """
    7906    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

    7922def to_identifier(name, quoted=None, copy=True):
    7923    """Builds an identifier.
    7924
    7925    Args:
    7926        name: The name to turn into an identifier.
    7927        quoted: Whether to force quote the identifier.
    7928        copy: Whether to copy name if it's an Identifier.
    7929
    7930    Returns:
    7931        The identifier ast node.
    7932    """
    7933
    7934    if name is None:
    7935        return None
    7936
    7937    if isinstance(name, Identifier):
    7938        identifier = maybe_copy(name, copy)
    7939    elif isinstance(name, str):
    7940        identifier = Identifier(
    7941            this=name,
    7942            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    7943        )
    7944    else:
    7945        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    7946    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, Type[sqlglot.dialects.Dialect], NoneType] = None) -> Identifier: View Source

    7949def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Identifier:
    7950    """
    7951    Parses a given string into an identifier.
    7952
    7953    Args:
    7954        name: The name to parse into an identifier.
    7955        dialect: The dialect to parse against.
    7956
    7957    Returns:
    7958        The identifier ast node.
    7959    """
    7960    try:
    7961        expression = maybe_parse(name, dialect=dialect, into=Identifier)
    7962    except (ParseError, TokenError):
    7963        expression = to_identifier(name)
    7964
    7965    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]+(?:\\.[0-9]+)?)\\s*([a-zA-Z]+)\\s*')
def to_interval( interval: str | Literal) -> Interval: View Source

    7971def to_interval(interval: str | Literal) -> Interval:
    7972    """Builds an interval expression from a string like '1 day' or '5 months'."""
    7973    if isinstance(interval, Literal):
    7974        if not interval.is_string:
    7975            raise ValueError("Invalid interval string.")
    7976
    7977        interval = interval.this
    7978
    7979    interval = maybe_parse(f"INTERVAL {interval}")
    7980    assert isinstance(interval, Interval)
    7981    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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **kwargs) -> Table: View Source

    7984def to_table(
    7985    sql_path: str | Table, dialect: DialectType = None, copy: bool = True, **kwargs
    7986) -> Table:
    7987    """
    7988    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    7989    If a table is passed in then that table is returned.
    7990
    7991    Args:
    7992        sql_path: a `[catalog].[schema].[table]` string.
    7993        dialect: the source dialect according to which the table name will be parsed.
    7994        copy: Whether to copy a table if it is passed in.
    7995        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    7996
    7997    Returns:
    7998        A table expression.
    7999    """
    8000    if isinstance(sql_path, Table):
    8001        return maybe_copy(sql_path, copy=copy)
    8002
    8003    try:
    8004        table = maybe_parse(sql_path, into=Table, dialect=dialect)
    8005    except ParseError:
    8006        catalog, db, this = split_num_words(sql_path, ".", 3)
    8007
    8008        if not this:
    8009            raise
    8010
    8011        table = table_(this, db=db, catalog=catalog)
    8012
    8013    for k, v in kwargs.items():
    8014        table.set(k, v)
    8015
    8016    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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **kwargs) -> Column: View Source

    8019def to_column(
    8020    sql_path: str | Column,
    8021    quoted: t.Optional[bool] = None,
    8022    dialect: DialectType = None,
    8023    copy: bool = True,
    8024    **kwargs,
    8025) -> Column:
    8026    """
    8027    Create a column from a `[table].[column]` sql path. Table is optional.
    8028    If a column is passed in then that column is returned.
    8029
    8030    Args:
    8031        sql_path: a `[table].[column]` string.
    8032        quoted: Whether or not to force quote identifiers.
    8033        dialect: the source dialect according to which the column name will be parsed.
    8034        copy: Whether to copy a column if it is passed in.
    8035        kwargs: the kwargs to instantiate the resulting `Column` expression with.
    8036
    8037    Returns:
    8038        A column expression.
    8039    """
    8040    if isinstance(sql_path, Column):
    8041        return maybe_copy(sql_path, copy=copy)
    8042
    8043    try:
    8044        col = maybe_parse(sql_path, into=Column, dialect=dialect)
    8045    except ParseError:
    8046        return column(*reversed(sql_path.split(".")), quoted=quoted, **kwargs)
    8047
    8048    for k, v in kwargs.items():
    8049        col.set(k, v)
    8050
    8051    if quoted:
    8052        for i in col.find_all(Identifier):
    8053            i.set("quoted", True)
    8054
    8055    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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True, **opts): View Source

    8058def alias_(
    8059    expression: ExpOrStr,
    8060    alias: t.Optional[str | Identifier],
    8061    table: bool | t.Sequence[str | Identifier] = False,
    8062    quoted: t.Optional[bool] = None,
    8063    dialect: DialectType = None,
    8064    copy: bool = True,
    8065    **opts,
    8066):
    8067    """Create an Alias expression.
    8068
    8069    Example:
    8070        >>> alias_('foo', 'bar').sql()
    8071        'foo AS bar'
    8072
    8073        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    8074        '(SELECT 1, 2) AS bar(a, b)'
    8075
    8076    Args:
    8077        expression: the SQL code strings to parse.
    8078            If an Expression instance is passed, this is used as-is.
    8079        alias: the alias name to use. If the name has
    8080            special characters it is quoted.
    8081        table: Whether to create a table alias, can also be a list of columns.
    8082        quoted: whether to quote the alias
    8083        dialect: the dialect used to parse the input expression.
    8084        copy: Whether to copy the expression.
    8085        **opts: other options to use to parse the input expressions.
    8086
    8087    Returns:
    8088        Alias: the aliased expression
    8089    """
    8090    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    8091    alias = to_identifier(alias, quoted=quoted)
    8092
    8093    if table:
    8094        table_alias = TableAlias(this=alias)
    8095        exp.set("alias", table_alias)
    8096
    8097        if not isinstance(table, bool):
    8098            for column in table:
    8099                table_alias.append("columns", to_identifier(column, quoted=quoted))
    8100
    8101        return exp
    8102
    8103    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    8104    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    8105    # for the complete Window expression.
    8106    #
    8107    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    8108
    8109    if "alias" in exp.arg_types and not isinstance(exp, Window):
    8110        exp.set("alias", alias)
    8111        return exp
    8112    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, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Select: View Source

    8115def subquery(
    8116    expression: ExpOrStr,
    8117    alias: t.Optional[Identifier | str] = None,
    8118    dialect: DialectType = None,
    8119    **opts,
    8120) -> Select:
    8121    """
    8122    Build a subquery expression that's selected from.
    8123
    8124    Example:
    8125        >>> subquery('select x from tbl', 'bar').select('x').sql()
    8126        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    8127
    8128    Args:
    8129        expression: the SQL code strings to parse.
    8130            If an Expression instance is passed, this is used as-is.
    8131        alias: the alias name to use.
    8132        dialect: the dialect used to parse the input expression.
    8133        **opts: other options to use to parse the input expressions.
    8134
    8135    Returns:
    8136        A new Select instance with the subquery expression included.
    8137    """
    8138
    8139    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias, **opts)
    8140    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

    8171def column(
    8172    col,
    8173    table=None,
    8174    db=None,
    8175    catalog=None,
    8176    *,
    8177    fields=None,
    8178    quoted=None,
    8179    copy=True,
    8180):
    8181    """
    8182    Build a Column.
    8183
    8184    Args:
    8185        col: Column name.
    8186        table: Table name.
    8187        db: Database name.
    8188        catalog: Catalog name.
    8189        fields: Additional fields using dots.
    8190        quoted: Whether to force quotes on the column's identifiers.
    8191        copy: Whether to copy identifiers if passed in.
    8192
    8193    Returns:
    8194        The new Column instance.
    8195    """
    8196    if not isinstance(col, Star):
    8197        col = to_identifier(col, quoted=quoted, copy=copy)
    8198
    8199    this = Column(
    8200        this=col,
    8201        table=to_identifier(table, quoted=quoted, copy=copy),
    8202        db=to_identifier(db, quoted=quoted, copy=copy),
    8203        catalog=to_identifier(catalog, quoted=quoted, copy=copy),
    8204    )
    8205
    8206    if fields:
    8207        this = Dot.build(
    8208            (this, *(to_identifier(field, quoted=quoted, copy=copy) for field in fields))
    8209        )
    8210    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, Identifier, Dot, DataType, DataType.Type], copy: bool = True, dialect: Union[str, sqlglot.dialects.Dialect, Type[sqlglot.dialects.Dialect], NoneType] = None, **opts) -> Cast: View Source

    8213def cast(
    8214    expression: ExpOrStr, to: DATA_TYPE, copy: bool = True, dialect: DialectType = None, **opts
    8215) -> Cast:
    8216    """Cast an expression to a data type.
    8217
    8218    Example:
    8219        >>> cast('x + 1', 'int').sql()
    8220        'CAST(x + 1 AS INT)'
    8221
    8222    Args:
    8223        expression: The expression to cast.
    8224        to: The datatype to cast to.
    8225        copy: Whether to copy the supplied expressions.
    8226        dialect: The target dialect. This is used to prevent a re-cast in the following scenario:
    8227            - The expression to be cast is already a exp.Cast expression
    8228            - The existing cast is to a type that is logically equivalent to new type
    8229
    8230            For example, if :expression='CAST(x as DATETIME)' and :to=Type.TIMESTAMP,
    8231            but in the target dialect DATETIME is mapped to TIMESTAMP, then we will NOT return `CAST(x (as DATETIME) as TIMESTAMP)`
    8232            and instead just return the original expression `CAST(x as DATETIME)`.
    8233
    8234            This is to prevent it being output as a double cast `CAST(x (as TIMESTAMP) as TIMESTAMP)` once the DATETIME -> TIMESTAMP
    8235            mapping is applied in the target dialect generator.
    8236
    8237    Returns:
    8238        The new Cast instance.
    8239    """
    8240    expr = maybe_parse(expression, copy=copy, dialect=dialect, **opts)
    8241    data_type = DataType.build(to, copy=copy, dialect=dialect, **opts)
    8242
    8243    # dont re-cast if the expression is already a cast to the correct type
    8244    if isinstance(expr, Cast):
    8245        from sqlglot.dialects.dialect import Dialect
    8246
    8247        target_dialect = Dialect.get_or_raise(dialect)
    8248        type_mapping = target_dialect.generator_class.TYPE_MAPPING
    8249
    8250        existing_cast_type: DataType.Type = expr.to.this
    8251        new_cast_type: DataType.Type = data_type.this
    8252        types_are_equivalent = type_mapping.get(
    8253            existing_cast_type, existing_cast_type.value
    8254        ) == type_mapping.get(new_cast_type, new_cast_type.value)
    8255
    8256        if expr.is_type(data_type) or types_are_equivalent:
    8257            return expr
    8258
    8259    expr = Cast(this=expr, to=data_type)
    8260    expr.type = data_type
    8261
    8262    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

    8265def table_(
    8266    table: Identifier | str,
    8267    db: t.Optional[Identifier | str] = None,
    8268    catalog: t.Optional[Identifier | str] = None,
    8269    quoted: t.Optional[bool] = None,
    8270    alias: t.Optional[Identifier | str] = None,
    8271) -> Table:
    8272    """Build a Table.
    8273
    8274    Args:
    8275        table: Table name.
    8276        db: Database name.
    8277        catalog: Catalog name.
    8278        quote: Whether to force quotes on the table's identifiers.
    8279        alias: Table's alias.
    8280
    8281    Returns:
    8282        The new Table instance.
    8283    """
    8284    return Table(
    8285        this=to_identifier(table, quoted=quoted) if table else None,
    8286        db=to_identifier(db, quoted=quoted) if db else None,
    8287        catalog=to_identifier(catalog, quoted=quoted) if catalog else None,
    8288        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    8289    )

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

    8292def values(
    8293    values: t.Iterable[t.Tuple[t.Any, ...]],
    8294    alias: t.Optional[str] = None,
    8295    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    8296) -> Values:
    8297    """Build VALUES statement.
    8298
    8299    Example:
    8300        >>> values([(1, '2')]).sql()
    8301        "VALUES (1, '2')"
    8302
    8303    Args:
    8304        values: values statements that will be converted to SQL
    8305        alias: optional alias
    8306        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    8307         If either are provided then an alias is also required.
    8308
    8309    Returns:
    8310        Values: the Values expression object
    8311    """
    8312    if columns and not alias:
    8313        raise ValueError("Alias is required when providing columns")
    8314
    8315    return Values(
    8316        expressions=[convert(tup) for tup in values],
    8317        alias=(
    8318            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    8319            if columns
    8320            else (TableAlias(this=to_identifier(alias)) if alias else None)
    8321        ),
    8322    )

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

    8325def var(name: t.Optional[ExpOrStr]) -> Var:
    8326    """Build a SQL variable.
    8327
    8328    Example:
    8329        >>> repr(var('x'))
    8330        'Var(this=x)'
    8331
    8332        >>> repr(var(column('x', table='y')))
    8333        'Var(this=x)'
    8334
    8335    Args:
    8336        name: The name of the var or an expression who's name will become the var.
    8337
    8338    Returns:
    8339        The new variable node.
    8340    """
    8341    if not name:
    8342        raise ValueError("Cannot convert empty name into var.")
    8343
    8344    if isinstance(name, Expression):
    8345        name = name.name
    8346    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, Type[sqlglot.dialects.Dialect], NoneType] = None) -> Alter: View Source

    8349def rename_table(
    8350    old_name: str | Table,
    8351    new_name: str | Table,
    8352    dialect: DialectType = None,
    8353) -> Alter:
    8354    """Build ALTER TABLE... RENAME... expression
    8355
    8356    Args:
    8357        old_name: The old name of the table
    8358        new_name: The new name of the table
    8359        dialect: The dialect to parse the table.
    8360
    8361    Returns:
    8362        Alter table expression
    8363    """
    8364    old_table = to_table(old_name, dialect=dialect)
    8365    new_table = to_table(new_name, dialect=dialect)
    8366    return Alter(
    8367        this=old_table,
    8368        kind="TABLE",
    8369        actions=[
    8370            AlterRename(this=new_table),
    8371        ],
    8372    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None) -> Alter: View Source

    8375def rename_column(
    8376    table_name: str | Table,
    8377    old_column_name: str | Column,
    8378    new_column_name: str | Column,
    8379    exists: t.Optional[bool] = None,
    8380    dialect: DialectType = None,
    8381) -> Alter:
    8382    """Build ALTER TABLE... RENAME COLUMN... expression
    8383
    8384    Args:
    8385        table_name: Name of the table
    8386        old_column: The old name of the column
    8387        new_column: The new name of the column
    8388        exists: Whether to add the `IF EXISTS` clause
    8389        dialect: The dialect to parse the table/column.
    8390
    8391    Returns:
    8392        Alter table expression
    8393    """
    8394    table = to_table(table_name, dialect=dialect)
    8395    old_column = to_column(old_column_name, dialect=dialect)
    8396    new_column = to_column(new_column_name, dialect=dialect)
    8397    return Alter(
    8398        this=table,
    8399        kind="TABLE",
    8400        actions=[
    8401            RenameColumn(this=old_column, to=new_column, exists=exists),
    8402        ],
    8403    )

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

    8406def convert(value: t.Any, copy: bool = False) -> Expression:
    8407    """Convert a python value into an expression object.
    8408
    8409    Raises an error if a conversion is not possible.
    8410
    8411    Args:
    8412        value: A python object.
    8413        copy: Whether to copy `value` (only applies to Expressions and collections).
    8414
    8415    Returns:
    8416        The equivalent expression object.
    8417    """
    8418    if isinstance(value, Expression):
    8419        return maybe_copy(value, copy)
    8420    if isinstance(value, str):
    8421        return Literal.string(value)
    8422    if isinstance(value, bool):
    8423        return Boolean(this=value)
    8424    if value is None or (isinstance(value, float) and math.isnan(value)):
    8425        return null()
    8426    if isinstance(value, numbers.Number):
    8427        return Literal.number(value)
    8428    if isinstance(value, bytes):
    8429        return HexString(this=value.hex())
    8430    if isinstance(value, datetime.datetime):
    8431        datetime_literal = Literal.string(value.isoformat(sep=" "))
    8432
    8433        tz = None
    8434        if value.tzinfo:
    8435            # this works for zoneinfo.ZoneInfo, pytz.timezone and datetime.datetime.utc to return IANA timezone names like "America/Los_Angeles"
    8436            # instead of abbreviations like "PDT". This is for consistency with other timezone handling functions in SQLGlot
    8437            tz = Literal.string(str(value.tzinfo))
    8438
    8439        return TimeStrToTime(this=datetime_literal, zone=tz)
    8440    if isinstance(value, datetime.date):
    8441        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    8442        return DateStrToDate(this=date_literal)
    8443    if isinstance(value, tuple):
    8444        if hasattr(value, "_fields"):
    8445            return Struct(
    8446                expressions=[
    8447                    PropertyEQ(
    8448                        this=to_identifier(k), expression=convert(getattr(value, k), copy=copy)
    8449                    )
    8450                    for k in value._fields
    8451                ]
    8452            )
    8453        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    8454    if isinstance(value, list):
    8455        return Array(expressions=[convert(v, copy=copy) for v in value])
    8456    if isinstance(value, dict):
    8457        return Map(
    8458            keys=Array(expressions=[convert(k, copy=copy) for k in value]),
    8459            values=Array(expressions=[convert(v, copy=copy) for v in value.values()]),
    8460        )
    8461    if hasattr(value, "__dict__"):
    8462        return Struct(
    8463            expressions=[
    8464                PropertyEQ(this=to_identifier(k), expression=convert(v, copy=copy))
    8465                for k, v in value.__dict__.items()
    8466            ]
    8467        )
    8468    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

    8471def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    8472    """
    8473    Replace children of an expression with the result of a lambda fun(child) -> exp.
    8474    """
    8475    for k, v in tuple(expression.args.items()):
    8476        is_list_arg = type(v) is list
    8477
    8478        child_nodes = v if is_list_arg else [v]
    8479        new_child_nodes = []
    8480
    8481        for cn in child_nodes:
    8482            if isinstance(cn, Expression):
    8483                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    8484                    new_child_nodes.append(child_node)
    8485            else:
    8486                new_child_nodes.append(cn)
    8487
    8488        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

    8491def replace_tree(
    8492    expression: Expression,
    8493    fun: t.Callable,
    8494    prune: t.Optional[t.Callable[[Expression], bool]] = None,
    8495) -> Expression:
    8496    """
    8497    Replace an entire tree with the result of function calls on each node.
    8498
    8499    This will be traversed in reverse dfs, so leaves first.
    8500    If new nodes are created as a result of function calls, they will also be traversed.
    8501    """
    8502    stack = list(expression.dfs(prune=prune))
    8503
    8504    while stack:
    8505        node = stack.pop()
    8506        new_node = fun(node)
    8507
    8508        if new_node is not node:
    8509            node.replace(new_node)
    8510
    8511            if isinstance(new_node, Expression):
    8512                stack.append(new_node)
    8513
    8514    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

    8517def column_table_names(expression: Expression, exclude: str = "") -> t.Set[str]:
    8518    """
    8519    Return all table names referenced through columns in an expression.
    8520
    8521    Example:
    8522        >>> import sqlglot
    8523        >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
    8524        ['a', 'c']
    8525
    8526    Args:
    8527        expression: expression to find table names.
    8528        exclude: a table name to exclude
    8529
    8530    Returns:
    8531        A list of unique names.
    8532    """
    8533    return {
    8534        table
    8535        for table in (column.table for column in expression.find_all(Column))
    8536        if table and table != exclude
    8537    }

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, Type[sqlglot.dialects.Dialect], NoneType] = None, identify: bool = False) -> str: View Source

    8540def table_name(table: Table | str, dialect: DialectType = None, identify: bool = False) -> str:
    8541    """Get the full name of a table as a string.
    8542
    8543    Args:
    8544        table: Table expression node or string.
    8545        dialect: The dialect to generate the table name for.
    8546        identify: Determines when an identifier should be quoted. Possible values are:
    8547            False (default): Never quote, except in cases where it's mandatory by the dialect.
    8548            True: Always quote.
    8549
    8550    Examples:
    8551        >>> from sqlglot import exp, parse_one
    8552        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    8553        'a.b.c'
    8554
    8555    Returns:
    8556        The table name.
    8557    """
    8558
    8559    table = maybe_parse(table, into=Table, dialect=dialect)
    8560
    8561    if not table:
    8562        raise ValueError(f"Cannot parse {table}")
    8563
    8564    return ".".join(
    8565        (
    8566            part.sql(dialect=dialect, identify=True, copy=False, comments=False)
    8567            if identify or not SAFE_IDENTIFIER_RE.match(part.name)
    8568            else part.name
    8569        )
    8570        for part in table.parts
    8571    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True) -> str: View Source

    8574def normalize_table_name(table: str | Table, dialect: DialectType = None, copy: bool = True) -> str:
    8575    """Returns a case normalized table name without quotes.
    8576
    8577    Args:
    8578        table: the table to normalize
    8579        dialect: the dialect to use for normalization rules
    8580        copy: whether to copy the expression.
    8581
    8582    Examples:
    8583        >>> normalize_table_name("`A-B`.c", dialect="bigquery")
    8584        'A-B.c'
    8585    """
    8586    from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
    8587
    8588    return ".".join(
    8589        p.name
    8590        for p in normalize_identifiers(
    8591            to_table(table, dialect=dialect, copy=copy), dialect=dialect
    8592        ).parts
    8593    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True) -> ~E: View Source

    8596def replace_tables(
    8597    expression: E, mapping: t.Dict[str, str], dialect: DialectType = None, copy: bool = True
    8598) -> E:
    8599    """Replace all tables in expression according to the mapping.
    8600
    8601    Args:
    8602        expression: expression node to be transformed and replaced.
    8603        mapping: mapping of table names.
    8604        dialect: the dialect of the mapping table
    8605        copy: whether to copy the expression.
    8606
    8607    Examples:
    8608        >>> from sqlglot import exp, parse_one
    8609        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    8610        'SELECT * FROM c /* a.b */'
    8611
    8612    Returns:
    8613        The mapped expression.
    8614    """
    8615
    8616    mapping = {normalize_table_name(k, dialect=dialect): v for k, v in mapping.items()}
    8617
    8618    def _replace_tables(node: Expression) -> Expression:
    8619        if isinstance(node, Table) and node.meta.get("replace") is not False:
    8620            original = normalize_table_name(node, dialect=dialect)
    8621            new_name = mapping.get(original)
    8622
    8623            if new_name:
    8624                table = to_table(
    8625                    new_name,
    8626                    **{k: v for k, v in node.args.items() if k not in TABLE_PARTS},
    8627                    dialect=dialect,
    8628                )
    8629                table.add_comments([original])
    8630                return table
    8631        return node
    8632
    8633    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

    8636def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    8637    """Replace placeholders in an expression.
    8638
    8639    Args:
    8640        expression: expression node to be transformed and replaced.
    8641        args: positional names that will substitute unnamed placeholders in the given order.
    8642        kwargs: keyword arguments that will substitute named placeholders.
    8643
    8644    Examples:
    8645        >>> from sqlglot import exp, parse_one
    8646        >>> replace_placeholders(
    8647        ...     parse_one("select * from :tbl where ? = ?"),
    8648        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    8649        ... ).sql()
    8650        "SELECT * FROM foo WHERE str_col = 'b'"
    8651
    8652    Returns:
    8653        The mapped expression.
    8654    """
    8655
    8656    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    8657        if isinstance(node, Placeholder):
    8658            if node.this:
    8659                new_name = kwargs.get(node.this)
    8660                if new_name is not None:
    8661                    return convert(new_name)
    8662            else:
    8663                try:
    8664                    return convert(next(args))
    8665                except StopIteration:
    8666                    pass
    8667        return node
    8668
    8669    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, Union[Query, Callable[[], Query]]], dialect: Union[str, sqlglot.dialects.Dialect, Type[sqlglot.dialects.Dialect], NoneType] = None, copy: bool = True) -> Expression: View Source

    8672def expand(
    8673    expression: Expression,
    8674    sources: t.Dict[str, Query | t.Callable[[], Query]],
    8675    dialect: DialectType = None,
    8676    copy: bool = True,
    8677) -> Expression:
    8678    """Transforms an expression by expanding all referenced sources into subqueries.
    8679
    8680    Examples:
    8681        >>> from sqlglot import parse_one
    8682        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    8683        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    8684
    8685        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    8686        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    8687
    8688    Args:
    8689        expression: The expression to expand.
    8690        sources: A dict of name to query or a callable that provides a query on demand.
    8691        dialect: The dialect of the sources dict or the callable.
    8692        copy: Whether to copy the expression during transformation. Defaults to True.
    8693
    8694    Returns:
    8695        The transformed expression.
    8696    """
    8697    normalized_sources = {normalize_table_name(k, dialect=dialect): v for k, v in sources.items()}
    8698
    8699    def _expand(node: Expression):
    8700        if isinstance(node, Table):
    8701            name = normalize_table_name(node, dialect=dialect)
    8702            source = normalized_sources.get(name)
    8703
    8704            if source:
    8705                # Create a subquery with the same alias (or table name if no alias)
    8706                parsed_source = source() if callable(source) else source
    8707                subquery = parsed_source.subquery(node.alias or name)
    8708                subquery.comments = [f"source: {name}"]
    8709
    8710                # Continue expanding within the subquery
    8711                return subquery.transform(_expand, copy=False)
    8712
    8713        return node
    8714
    8715    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 dict of name to query or a callable that provides a query on demand.
- dialect: The dialect of the sources dict or the callable.
- 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, Type[sqlglot.dialects.Dialect], NoneType] = None, **kwargs) -> Func: View Source

    8718def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwargs) -> Func:
    8719    """
    8720    Returns a Func expression.
    8721
    8722    Examples:
    8723        >>> func("abs", 5).sql()
    8724        'ABS(5)'
    8725
    8726        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    8727        'CAST(5 AS DOUBLE)'
    8728
    8729    Args:
    8730        name: the name of the function to build.
    8731        args: the args used to instantiate the function of interest.
    8732        copy: whether to copy the argument expressions.
    8733        dialect: the source dialect.
    8734        kwargs: the kwargs used to instantiate the function of interest.
    8735
    8736    Note:
    8737        The arguments `args` and `kwargs` are mutually exclusive.
    8738
    8739    Returns:
    8740        An instance of the function of interest, or an anonymous function, if `name` doesn't
    8741        correspond to an existing `sqlglot.expressions.Func` class.
    8742    """
    8743    if args and kwargs:
    8744        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    8745
    8746    from sqlglot.dialects.dialect import Dialect
    8747
    8748    dialect = Dialect.get_or_raise(dialect)
    8749
    8750    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect, copy=copy) for arg in args]
    8751    kwargs = {key: maybe_parse(value, dialect=dialect, copy=copy) for key, value in kwargs.items()}
    8752
    8753    constructor = dialect.parser_class.FUNCTIONS.get(name.upper())
    8754    if constructor:
    8755        if converted:
    8756            if "dialect" in constructor.__code__.co_varnames:
    8757                function = constructor(converted, dialect=dialect)
    8758            else:
    8759                function = constructor(converted)
    8760        elif constructor.__name__ == "from_arg_list":
    8761            function = constructor.__self__(**kwargs)  # type: ignore
    8762        else:
    8763            constructor = FUNCTION_BY_NAME.get(name.upper())
    8764            if constructor:
    8765                function = constructor(**kwargs)
    8766            else:
    8767                raise ValueError(
    8768                    f"Unable to convert '{name}' into a Func. Either manually construct "
    8769                    "the Func expression of interest or parse the function call."
    8770                )
    8771    else:
    8772        kwargs = kwargs or {"expressions": converted}
    8773        function = Anonymous(this=name, **kwargs)
    8774
    8775    for error_message in function.error_messages(converted):
    8776        raise ValueError(error_message)
    8777
    8778    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

    8781def case(
    8782    expression: t.Optional[ExpOrStr] = None,
    8783    **opts,
    8784) -> Case:
    8785    """
    8786    Initialize a CASE statement.
    8787
    8788    Example:
    8789        case().when("a = 1", "foo").else_("bar")
    8790
    8791    Args:
    8792        expression: Optionally, the input expression (not all dialects support this)
    8793        **opts: Extra keyword arguments for parsing `expression`
    8794    """
    8795    if expression is not None:
    8796        this = maybe_parse(expression, **opts)
    8797    else:
    8798        this = None
    8799    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, Type[sqlglot.dialects.Dialect], NoneType] = None, **kwargs) -> Array: View Source

    8802def array(
    8803    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8804) -> Array:
    8805    """
    8806    Returns an array.
    8807
    8808    Examples:
    8809        >>> array(1, 'x').sql()
    8810        'ARRAY(1, x)'
    8811
    8812    Args:
    8813        expressions: the expressions to add to the array.
    8814        copy: whether to copy the argument expressions.
    8815        dialect: the source dialect.
    8816        kwargs: the kwargs used to instantiate the function of interest.
    8817
    8818    Returns:
    8819        An array expression.
    8820    """
    8821    return Array(
    8822        expressions=[
    8823            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8824            for expression in expressions
    8825        ]
    8826    )

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, Type[sqlglot.dialects.Dialect], NoneType] = None, **kwargs) -> Tuple: View Source

    8829def tuple_(
    8830    *expressions: ExpOrStr, copy: bool = True, dialect: DialectType = None, **kwargs
    8831) -> Tuple:
    8832    """
    8833    Returns an tuple.
    8834
    8835    Examples:
    8836        >>> tuple_(1, 'x').sql()
    8837        '(1, x)'
    8838
    8839    Args:
    8840        expressions: the expressions to add to the tuple.
    8841        copy: whether to copy the argument expressions.
    8842        dialect: the source dialect.
    8843        kwargs: the kwargs used to instantiate the function of interest.
    8844
    8845    Returns:
    8846        A tuple expression.
    8847    """
    8848    return Tuple(
    8849        expressions=[
    8850            maybe_parse(expression, copy=copy, dialect=dialect, **kwargs)
    8851            for expression in expressions
    8852        ]
    8853    )

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

    8856def true() -> Boolean:
    8857    """
    8858    Returns a true Boolean expression.
    8859    """
    8860    return Boolean(this=True)

Returns a true Boolean expression.

def false() -> Boolean: View Source

    8863def false() -> Boolean:
    8864    """
    8865    Returns a false Boolean expression.
    8866    """
    8867    return Boolean(this=False)

Returns a false Boolean expression.

def null() -> Null: View Source

    8870def null() -> Null:
    8871    """
    8872    Returns a Null expression.
    8873    """
    8874    return Null()

Returns a Null expression.

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