sqlglot.expressions API documentation

Edit on GitHub

## Expressions

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

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

View Source

       1"""
       2## Expressions
       3
       4Every AST node in SQLGlot is represented by a subclass of `Expression`.
       5
       6This module contains the implementation of all supported `Expression` types. Additionally,
       7it exposes a number of helper functions, which are mainly used to programmatically build
       8SQL expressions, such as `sqlglot.expressions.select`.
       9
      10----
      11"""
      12
      13from __future__ import annotations
      14
      15import datetime
      16import math
      17import numbers
      18import re
      19import typing as t
      20from collections import deque
      21from copy import deepcopy
      22from enum import auto
      23
      24from sqlglot._typing import E
      25from sqlglot.errors import ParseError
      26from sqlglot.helper import (
      27    AutoName,
      28    camel_to_snake_case,
      29    ensure_collection,
      30    ensure_list,
      31    seq_get,
      32    subclasses,
      33)
      34from sqlglot.tokens import Token
      35
      36if t.TYPE_CHECKING:
      37    from sqlglot.dialects.dialect import DialectType
      38
      39
      40class _Expression(type):
      41    def __new__(cls, clsname, bases, attrs):
      42        klass = super().__new__(cls, clsname, bases, attrs)
      43
      44        # When an Expression class is created, its key is automatically set to be
      45        # the lowercase version of the class' name.
      46        klass.key = clsname.lower()
      47
      48        # This is so that docstrings are not inherited in pdoc
      49        klass.__doc__ = klass.__doc__ or ""
      50
      51        return klass
      52
      53
      54class Expression(metaclass=_Expression):
      55    """
      56    The base class for all expressions in a syntax tree. Each Expression encapsulates any necessary
      57    context, such as its child expressions, their names (arg keys), and whether a given child expression
      58    is optional or not.
      59
      60    Attributes:
      61        key: a unique key for each class in the Expression hierarchy. This is useful for hashing
      62            and representing expressions as strings.
      63        arg_types: determines what arguments (child nodes) are supported by an expression. It
      64            maps arg keys to booleans that indicate whether the corresponding args are optional.
      65        parent: a reference to the parent expression (or None, in case of root expressions).
      66        arg_key: the arg key an expression is associated with, i.e. the name its parent expression
      67            uses to refer to it.
      68        comments: a list of comments that are associated with a given expression. This is used in
      69            order to preserve comments when transpiling SQL code.
      70        _type: the `sqlglot.expressions.DataType` type of an expression. This is inferred by the
      71            optimizer, in order to enable some transformations that require type information.
      72
      73    Example:
      74        >>> class Foo(Expression):
      75        ...     arg_types = {"this": True, "expression": False}
      76
      77        The above definition informs us that Foo is an Expression that requires an argument called
      78        "this" and may also optionally receive an argument called "expression".
      79
      80    Args:
      81        args: a mapping used for retrieving the arguments of an expression, given their arg keys.
      82    """
      83
      84    key = "expression"
      85    arg_types = {"this": True}
      86    __slots__ = ("args", "parent", "arg_key", "comments", "_type", "_meta", "_hash")
      87
      88    def __init__(self, **args: t.Any):
      89        self.args: t.Dict[str, t.Any] = args
      90        self.parent: t.Optional[Expression] = None
      91        self.arg_key: t.Optional[str] = None
      92        self.comments: t.Optional[t.List[str]] = None
      93        self._type: t.Optional[DataType] = None
      94        self._meta: t.Optional[t.Dict[str, t.Any]] = None
      95        self._hash: t.Optional[int] = None
      96
      97        for arg_key, value in self.args.items():
      98            self._set_parent(arg_key, value)
      99
     100    def __eq__(self, other) -> bool:
     101        return type(self) is type(other) and hash(self) == hash(other)
     102
     103    @property
     104    def hashable_args(self) -> t.Any:
     105        args = (self.args.get(k) for k in self.arg_types)
     106
     107        return tuple(
     108            (tuple(_norm_arg(a) for a in arg) if arg else None)
     109            if type(arg) is list
     110            else (_norm_arg(arg) if arg is not None and arg is not False else None)
     111            for arg in args
     112        )
     113
     114    def __hash__(self) -> int:
     115        if self._hash is not None:
     116            return self._hash
     117
     118        return hash((self.__class__, self.hashable_args))
     119
     120    @property
     121    def this(self):
     122        """
     123        Retrieves the argument with key "this".
     124        """
     125        return self.args.get("this")
     126
     127    @property
     128    def expression(self):
     129        """
     130        Retrieves the argument with key "expression".
     131        """
     132        return self.args.get("expression")
     133
     134    @property
     135    def expressions(self):
     136        """
     137        Retrieves the argument with key "expressions".
     138        """
     139        return self.args.get("expressions") or []
     140
     141    def text(self, key) -> str:
     142        """
     143        Returns a textual representation of the argument corresponding to "key". This can only be used
     144        for args that are strings or leaf Expression instances, such as identifiers and literals.
     145        """
     146        field = self.args.get(key)
     147        if isinstance(field, str):
     148            return field
     149        if isinstance(field, (Identifier, Literal, Var)):
     150            return field.this
     151        if isinstance(field, (Star, Null)):
     152            return field.name
     153        return ""
     154
     155    @property
     156    def is_string(self) -> bool:
     157        """
     158        Checks whether a Literal expression is a string.
     159        """
     160        return isinstance(self, Literal) and self.args["is_string"]
     161
     162    @property
     163    def is_number(self) -> bool:
     164        """
     165        Checks whether a Literal expression is a number.
     166        """
     167        return isinstance(self, Literal) and not self.args["is_string"]
     168
     169    @property
     170    def is_int(self) -> bool:
     171        """
     172        Checks whether a Literal expression is an integer.
     173        """
     174        if self.is_number:
     175            try:
     176                int(self.name)
     177                return True
     178            except ValueError:
     179                pass
     180        return False
     181
     182    @property
     183    def is_star(self) -> bool:
     184        """Checks whether an expression is a star."""
     185        return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))
     186
     187    @property
     188    def alias(self) -> str:
     189        """
     190        Returns the alias of the expression, or an empty string if it's not aliased.
     191        """
     192        if isinstance(self.args.get("alias"), TableAlias):
     193            return self.args["alias"].name
     194        return self.text("alias")
     195
     196    @property
     197    def name(self) -> str:
     198        return self.text("this")
     199
     200    @property
     201    def alias_or_name(self) -> str:
     202        return self.alias or self.name
     203
     204    @property
     205    def output_name(self) -> str:
     206        """
     207        Name of the output column if this expression is a selection.
     208
     209        If the Expression has no output name, an empty string is returned.
     210
     211        Example:
     212            >>> from sqlglot import parse_one
     213            >>> parse_one("SELECT a").expressions[0].output_name
     214            'a'
     215            >>> parse_one("SELECT b AS c").expressions[0].output_name
     216            'c'
     217            >>> parse_one("SELECT 1 + 2").expressions[0].output_name
     218            ''
     219        """
     220        return ""
     221
     222    @property
     223    def type(self) -> t.Optional[DataType]:
     224        return self._type
     225
     226    @type.setter
     227    def type(self, dtype: t.Optional[DataType | DataType.Type | str]) -> None:
     228        if dtype and not isinstance(dtype, DataType):
     229            dtype = DataType.build(dtype)
     230        self._type = dtype  # type: ignore
     231
     232    @property
     233    def meta(self) -> t.Dict[str, t.Any]:
     234        if self._meta is None:
     235            self._meta = {}
     236        return self._meta
     237
     238    def __deepcopy__(self, memo):
     239        copy = self.__class__(**deepcopy(self.args))
     240        if self.comments is not None:
     241            copy.comments = deepcopy(self.comments)
     242
     243        if self._type is not None:
     244            copy._type = self._type.copy()
     245
     246        if self._meta is not None:
     247            copy._meta = deepcopy(self._meta)
     248
     249        return copy
     250
     251    def copy(self):
     252        """
     253        Returns a deep copy of the expression.
     254        """
     255        new = deepcopy(self)
     256        new.parent = self.parent
     257        return new
     258
     259    def add_comments(self, comments: t.Optional[t.List[str]]) -> None:
     260        if self.comments is None:
     261            self.comments = []
     262        if comments:
     263            self.comments.extend(comments)
     264
     265    def append(self, arg_key: str, value: t.Any) -> None:
     266        """
     267        Appends value to arg_key if it's a list or sets it as a new list.
     268
     269        Args:
     270            arg_key (str): name of the list expression arg
     271            value (Any): value to append to the list
     272        """
     273        if not isinstance(self.args.get(arg_key), list):
     274            self.args[arg_key] = []
     275        self.args[arg_key].append(value)
     276        self._set_parent(arg_key, value)
     277
     278    def set(self, arg_key: str, value: t.Any) -> None:
     279        """
     280        Sets `arg_key` to `value`.
     281
     282        Args:
     283            arg_key (str): name of the expression arg.
     284            value: value to set the arg to.
     285        """
     286        self.args[arg_key] = value
     287        self._set_parent(arg_key, value)
     288
     289    def _set_parent(self, arg_key: str, value: t.Any) -> None:
     290        if hasattr(value, "parent"):
     291            value.parent = self
     292            value.arg_key = arg_key
     293        elif type(value) is list:
     294            for v in value:
     295                if hasattr(v, "parent"):
     296                    v.parent = self
     297                    v.arg_key = arg_key
     298
     299    @property
     300    def depth(self) -> int:
     301        """
     302        Returns the depth of this tree.
     303        """
     304        if self.parent:
     305            return self.parent.depth + 1
     306        return 0
     307
     308    def iter_expressions(self) -> t.Iterator[t.Tuple[str, Expression]]:
     309        """Yields the key and expression for all arguments, exploding list args."""
     310        for k, vs in self.args.items():
     311            if type(vs) is list:
     312                for v in vs:
     313                    if hasattr(v, "parent"):
     314                        yield k, v
     315            else:
     316                if hasattr(vs, "parent"):
     317                    yield k, vs
     318
     319    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
     320        """
     321        Returns the first node in this tree which matches at least one of
     322        the specified types.
     323
     324        Args:
     325            expression_types: the expression type(s) to match.
     326            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
     327
     328        Returns:
     329            The node which matches the criteria or None if no such node was found.
     330        """
     331        return next(self.find_all(*expression_types, bfs=bfs), None)
     332
     333    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
     334        """
     335        Returns a generator object which visits all nodes in this tree and only
     336        yields those that match at least one of the specified expression types.
     337
     338        Args:
     339            expression_types: the expression type(s) to match.
     340            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
     341
     342        Returns:
     343            The generator object.
     344        """
     345        for expression, *_ in self.walk(bfs=bfs):
     346            if isinstance(expression, expression_types):
     347                yield expression
     348
     349    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
     350        """
     351        Returns a nearest parent matching expression_types.
     352
     353        Args:
     354            expression_types: the expression type(s) to match.
     355
     356        Returns:
     357            The parent node.
     358        """
     359        ancestor = self.parent
     360        while ancestor and not isinstance(ancestor, expression_types):
     361            ancestor = ancestor.parent
     362        return t.cast(E, ancestor)
     363
     364    @property
     365    def parent_select(self) -> t.Optional[Select]:
     366        """
     367        Returns the parent select statement.
     368        """
     369        return self.find_ancestor(Select)
     370
     371    @property
     372    def same_parent(self) -> bool:
     373        """Returns if the parent is the same class as itself."""
     374        return type(self.parent) is self.__class__
     375
     376    def root(self) -> Expression:
     377        """
     378        Returns the root expression of this tree.
     379        """
     380        expression = self
     381        while expression.parent:
     382            expression = expression.parent
     383        return expression
     384
     385    def walk(self, bfs=True, prune=None):
     386        """
     387        Returns a generator object which visits all nodes in this tree.
     388
     389        Args:
     390            bfs (bool): if set to True the BFS traversal order will be applied,
     391                otherwise the DFS traversal will be used instead.
     392            prune ((node, parent, arg_key) -> bool): callable that returns True if
     393                the generator should stop traversing this branch of the tree.
     394
     395        Returns:
     396            the generator object.
     397        """
     398        if bfs:
     399            yield from self.bfs(prune=prune)
     400        else:
     401            yield from self.dfs(prune=prune)
     402
     403    def dfs(self, parent=None, key=None, prune=None):
     404        """
     405        Returns a generator object which visits all nodes in this tree in
     406        the DFS (Depth-first) order.
     407
     408        Returns:
     409            The generator object.
     410        """
     411        parent = parent or self.parent
     412        yield self, parent, key
     413        if prune and prune(self, parent, key):
     414            return
     415
     416        for k, v in self.iter_expressions():
     417            yield from v.dfs(self, k, prune)
     418
     419    def bfs(self, prune=None):
     420        """
     421        Returns a generator object which visits all nodes in this tree in
     422        the BFS (Breadth-first) order.
     423
     424        Returns:
     425            The generator object.
     426        """
     427        queue = deque([(self, self.parent, None)])
     428
     429        while queue:
     430            item, parent, key = queue.popleft()
     431
     432            yield item, parent, key
     433            if prune and prune(item, parent, key):
     434                continue
     435
     436            for k, v in item.iter_expressions():
     437                queue.append((v, item, k))
     438
     439    def unnest(self):
     440        """
     441        Returns the first non parenthesis child or self.
     442        """
     443        expression = self
     444        while type(expression) is Paren:
     445            expression = expression.this
     446        return expression
     447
     448    def unalias(self):
     449        """
     450        Returns the inner expression if this is an Alias.
     451        """
     452        if isinstance(self, Alias):
     453            return self.this
     454        return self
     455
     456    def unnest_operands(self):
     457        """
     458        Returns unnested operands as a tuple.
     459        """
     460        return tuple(arg.unnest() for _, arg in self.iter_expressions())
     461
     462    def flatten(self, unnest=True):
     463        """
     464        Returns a generator which yields child nodes who's parents are the same class.
     465
     466        A AND B AND C -> [A, B, C]
     467        """
     468        for node, _, _ in self.dfs(prune=lambda n, p, *_: p and not type(n) is self.__class__):
     469            if not type(node) is self.__class__:
     470                yield node.unnest() if unnest else node
     471
     472    def __str__(self) -> str:
     473        return self.sql()
     474
     475    def __repr__(self) -> str:
     476        return self._to_s()
     477
     478    def sql(self, dialect: DialectType = None, **opts) -> str:
     479        """
     480        Returns SQL string representation of this tree.
     481
     482        Args:
     483            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
     484            opts: other `sqlglot.generator.Generator` options.
     485
     486        Returns:
     487            The SQL string.
     488        """
     489        from sqlglot.dialects import Dialect
     490
     491        return Dialect.get_or_raise(dialect)().generate(self, **opts)
     492
     493    def _to_s(self, hide_missing: bool = True, level: int = 0) -> str:
     494        indent = "" if not level else "\n"
     495        indent += "".join(["  "] * level)
     496        left = f"({self.key.upper()} "
     497
     498        args: t.Dict[str, t.Any] = {
     499            k: ", ".join(
     500                v._to_s(hide_missing=hide_missing, level=level + 1)
     501                if hasattr(v, "_to_s")
     502                else str(v)
     503                for v in ensure_list(vs)
     504                if v is not None
     505            )
     506            for k, vs in self.args.items()
     507        }
     508        args["comments"] = self.comments
     509        args["type"] = self.type
     510        args = {k: v for k, v in args.items() if v or not hide_missing}
     511
     512        right = ", ".join(f"{k}: {v}" for k, v in args.items())
     513        right += ")"
     514
     515        return indent + left + right
     516
     517    def transform(self, fun, *args, copy=True, **kwargs):
     518        """
     519        Recursively visits all tree nodes (excluding already transformed ones)
     520        and applies the given transformation function to each node.
     521
     522        Args:
     523            fun (function): a function which takes a node as an argument and returns a
     524                new transformed node or the same node without modifications. If the function
     525                returns None, then the corresponding node will be removed from the syntax tree.
     526            copy (bool): if set to True a new tree instance is constructed, otherwise the tree is
     527                modified in place.
     528
     529        Returns:
     530            The transformed tree.
     531        """
     532        node = self.copy() if copy else self
     533        new_node = fun(node, *args, **kwargs)
     534
     535        if new_node is None or not isinstance(new_node, Expression):
     536            return new_node
     537        if new_node is not node:
     538            new_node.parent = node.parent
     539            return new_node
     540
     541        replace_children(new_node, lambda child: child.transform(fun, *args, copy=False, **kwargs))
     542        return new_node
     543
     544    @t.overload
     545    def replace(self, expression: E) -> E:
     546        ...
     547
     548    @t.overload
     549    def replace(self, expression: None) -> None:
     550        ...
     551
     552    def replace(self, expression):
     553        """
     554        Swap out this expression with a new expression.
     555
     556        For example::
     557
     558            >>> tree = Select().select("x").from_("tbl")
     559            >>> tree.find(Column).replace(Column(this="y"))
     560            (COLUMN this: y)
     561            >>> tree.sql()
     562            'SELECT y FROM tbl'
     563
     564        Args:
     565            expression: new node
     566
     567        Returns:
     568            The new expression or expressions.
     569        """
     570        if not self.parent:
     571            return expression
     572
     573        parent = self.parent
     574        self.parent = None
     575
     576        replace_children(parent, lambda child: expression if child is self else child)
     577        return expression
     578
     579    def pop(self: E) -> E:
     580        """
     581        Remove this expression from its AST.
     582
     583        Returns:
     584            The popped expression.
     585        """
     586        self.replace(None)
     587        return self
     588
     589    def assert_is(self, type_: t.Type[E]) -> E:
     590        """
     591        Assert that this `Expression` is an instance of `type_`.
     592
     593        If it is NOT an instance of `type_`, this raises an assertion error.
     594        Otherwise, this returns this expression.
     595
     596        Examples:
     597            This is useful for type security in chained expressions:
     598
     599            >>> import sqlglot
     600            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
     601            'SELECT x, z FROM y'
     602        """
     603        assert isinstance(self, type_)
     604        return self
     605
     606    def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
     607        """
     608        Checks if this expression is valid (e.g. all mandatory args are set).
     609
     610        Args:
     611            args: a sequence of values that were used to instantiate a Func expression. This is used
     612                to check that the provided arguments don't exceed the function argument limit.
     613
     614        Returns:
     615            A list of error messages for all possible errors that were found.
     616        """
     617        errors: t.List[str] = []
     618
     619        for k in self.args:
     620            if k not in self.arg_types:
     621                errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
     622        for k, mandatory in self.arg_types.items():
     623            v = self.args.get(k)
     624            if mandatory and (v is None or (isinstance(v, list) and not v)):
     625                errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
     626
     627        if (
     628            args
     629            and isinstance(self, Func)
     630            and len(args) > len(self.arg_types)
     631            and not self.is_var_len_args
     632        ):
     633            errors.append(
     634                f"The number of provided arguments ({len(args)}) is greater than "
     635                f"the maximum number of supported arguments ({len(self.arg_types)})"
     636            )
     637
     638        return errors
     639
     640    def dump(self):
     641        """
     642        Dump this Expression to a JSON-serializable dict.
     643        """
     644        from sqlglot.serde import dump
     645
     646        return dump(self)
     647
     648    @classmethod
     649    def load(cls, obj):
     650        """
     651        Load a dict (as returned by `Expression.dump`) into an Expression instance.
     652        """
     653        from sqlglot.serde import load
     654
     655        return load(obj)
     656
     657
     658IntoType = t.Union[
     659    str,
     660    t.Type[Expression],
     661    t.Collection[t.Union[str, t.Type[Expression]]],
     662]
     663ExpOrStr = t.Union[str, Expression]
     664
     665
     666class Condition(Expression):
     667    def and_(
     668        self,
     669        *expressions: t.Optional[ExpOrStr],
     670        dialect: DialectType = None,
     671        copy: bool = True,
     672        **opts,
     673    ) -> Condition:
     674        """
     675        AND this condition with one or multiple expressions.
     676
     677        Example:
     678            >>> condition("x=1").and_("y=1").sql()
     679            'x = 1 AND y = 1'
     680
     681        Args:
     682            *expressions: the SQL code strings to parse.
     683                If an `Expression` instance is passed, it will be used as-is.
     684            dialect: the dialect used to parse the input expression.
     685            copy: whether or not to copy the involved expressions (only applies to Expressions).
     686            opts: other options to use to parse the input expressions.
     687
     688        Returns:
     689            The new And condition.
     690        """
     691        return and_(self, *expressions, dialect=dialect, copy=copy, **opts)
     692
     693    def or_(
     694        self,
     695        *expressions: t.Optional[ExpOrStr],
     696        dialect: DialectType = None,
     697        copy: bool = True,
     698        **opts,
     699    ) -> Condition:
     700        """
     701        OR this condition with one or multiple expressions.
     702
     703        Example:
     704            >>> condition("x=1").or_("y=1").sql()
     705            'x = 1 OR y = 1'
     706
     707        Args:
     708            *expressions: the SQL code strings to parse.
     709                If an `Expression` instance is passed, it will be used as-is.
     710            dialect: the dialect used to parse the input expression.
     711            copy: whether or not to copy the involved expressions (only applies to Expressions).
     712            opts: other options to use to parse the input expressions.
     713
     714        Returns:
     715            The new Or condition.
     716        """
     717        return or_(self, *expressions, dialect=dialect, copy=copy, **opts)
     718
     719    def not_(self, copy: bool = True):
     720        """
     721        Wrap this condition with NOT.
     722
     723        Example:
     724            >>> condition("x=1").not_().sql()
     725            'NOT x = 1'
     726
     727        Args:
     728            copy: whether or not to copy this object.
     729
     730        Returns:
     731            The new Not instance.
     732        """
     733        return not_(self, copy=copy)
     734
     735    def as_(
     736        self,
     737        alias: str | Identifier,
     738        quoted: t.Optional[bool] = None,
     739        dialect: DialectType = None,
     740        copy: bool = True,
     741        **opts,
     742    ) -> Alias:
     743        return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)
     744
     745    def _binop(self, klass: t.Type[E], other: t.Any, reverse: bool = False) -> E:
     746        this = self.copy()
     747        other = convert(other, copy=True)
     748        if not isinstance(this, klass) and not isinstance(other, klass):
     749            this = _wrap(this, Binary)
     750            other = _wrap(other, Binary)
     751        if reverse:
     752            return klass(this=other, expression=this)
     753        return klass(this=this, expression=other)
     754
     755    def __getitem__(self, other: ExpOrStr | t.Tuple[ExpOrStr]):
     756        return Bracket(
     757            this=self.copy(), expressions=[convert(e, copy=True) for e in ensure_list(other)]
     758        )
     759
     760    def isin(
     761        self, *expressions: t.Any, query: t.Optional[ExpOrStr] = None, copy: bool = True, **opts
     762    ) -> In:
     763        return In(
     764            this=_maybe_copy(self, copy),
     765            expressions=[convert(e, copy=copy) for e in expressions],
     766            query=maybe_parse(query, copy=copy, **opts) if query else None,
     767        )
     768
     769    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
     770        return Between(
     771            this=_maybe_copy(self, copy),
     772            low=convert(low, copy=copy, **opts),
     773            high=convert(high, copy=copy, **opts),
     774        )
     775
     776    def is_(self, other: ExpOrStr) -> Is:
     777        return self._binop(Is, other)
     778
     779    def like(self, other: ExpOrStr) -> Like:
     780        return self._binop(Like, other)
     781
     782    def ilike(self, other: ExpOrStr) -> ILike:
     783        return self._binop(ILike, other)
     784
     785    def eq(self, other: t.Any) -> EQ:
     786        return self._binop(EQ, other)
     787
     788    def neq(self, other: t.Any) -> NEQ:
     789        return self._binop(NEQ, other)
     790
     791    def rlike(self, other: ExpOrStr) -> RegexpLike:
     792        return self._binop(RegexpLike, other)
     793
     794    def __lt__(self, other: t.Any) -> LT:
     795        return self._binop(LT, other)
     796
     797    def __le__(self, other: t.Any) -> LTE:
     798        return self._binop(LTE, other)
     799
     800    def __gt__(self, other: t.Any) -> GT:
     801        return self._binop(GT, other)
     802
     803    def __ge__(self, other: t.Any) -> GTE:
     804        return self._binop(GTE, other)
     805
     806    def __add__(self, other: t.Any) -> Add:
     807        return self._binop(Add, other)
     808
     809    def __radd__(self, other: t.Any) -> Add:
     810        return self._binop(Add, other, reverse=True)
     811
     812    def __sub__(self, other: t.Any) -> Sub:
     813        return self._binop(Sub, other)
     814
     815    def __rsub__(self, other: t.Any) -> Sub:
     816        return self._binop(Sub, other, reverse=True)
     817
     818    def __mul__(self, other: t.Any) -> Mul:
     819        return self._binop(Mul, other)
     820
     821    def __rmul__(self, other: t.Any) -> Mul:
     822        return self._binop(Mul, other, reverse=True)
     823
     824    def __truediv__(self, other: t.Any) -> Div:
     825        return self._binop(Div, other)
     826
     827    def __rtruediv__(self, other: t.Any) -> Div:
     828        return self._binop(Div, other, reverse=True)
     829
     830    def __floordiv__(self, other: t.Any) -> IntDiv:
     831        return self._binop(IntDiv, other)
     832
     833    def __rfloordiv__(self, other: t.Any) -> IntDiv:
     834        return self._binop(IntDiv, other, reverse=True)
     835
     836    def __mod__(self, other: t.Any) -> Mod:
     837        return self._binop(Mod, other)
     838
     839    def __rmod__(self, other: t.Any) -> Mod:
     840        return self._binop(Mod, other, reverse=True)
     841
     842    def __pow__(self, other: t.Any) -> Pow:
     843        return self._binop(Pow, other)
     844
     845    def __rpow__(self, other: t.Any) -> Pow:
     846        return self._binop(Pow, other, reverse=True)
     847
     848    def __and__(self, other: t.Any) -> And:
     849        return self._binop(And, other)
     850
     851    def __rand__(self, other: t.Any) -> And:
     852        return self._binop(And, other, reverse=True)
     853
     854    def __or__(self, other: t.Any) -> Or:
     855        return self._binop(Or, other)
     856
     857    def __ror__(self, other: t.Any) -> Or:
     858        return self._binop(Or, other, reverse=True)
     859
     860    def __neg__(self) -> Neg:
     861        return Neg(this=_wrap(self.copy(), Binary))
     862
     863    def __invert__(self) -> Not:
     864        return not_(self.copy())
     865
     866
     867class Predicate(Condition):
     868    """Relationships like x = y, x > 1, x >= y."""
     869
     870
     871class DerivedTable(Expression):
     872    @property
     873    def alias_column_names(self) -> t.List[str]:
     874        table_alias = self.args.get("alias")
     875        if not table_alias:
     876            return []
     877        return [c.name for c in table_alias.args.get("columns") or []]
     878
     879    @property
     880    def selects(self):
     881        return self.this.selects if isinstance(self.this, Subqueryable) else []
     882
     883    @property
     884    def named_selects(self):
     885        return [select.output_name for select in self.selects]
     886
     887
     888class Unionable(Expression):
     889    def union(
     890        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
     891    ) -> Unionable:
     892        """
     893        Builds a UNION expression.
     894
     895        Example:
     896            >>> import sqlglot
     897            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
     898            'SELECT * FROM foo UNION SELECT * FROM bla'
     899
     900        Args:
     901            expression: the SQL code string.
     902                If an `Expression` instance is passed, it will be used as-is.
     903            distinct: set the DISTINCT flag if and only if this is true.
     904            dialect: the dialect used to parse the input expression.
     905            opts: other options to use to parse the input expressions.
     906
     907        Returns:
     908            The new Union expression.
     909        """
     910        return union(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)
     911
     912    def intersect(
     913        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
     914    ) -> Unionable:
     915        """
     916        Builds an INTERSECT expression.
     917
     918        Example:
     919            >>> import sqlglot
     920            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
     921            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
     922
     923        Args:
     924            expression: the SQL code string.
     925                If an `Expression` instance is passed, it will be used as-is.
     926            distinct: set the DISTINCT flag if and only if this is true.
     927            dialect: the dialect used to parse the input expression.
     928            opts: other options to use to parse the input expressions.
     929
     930        Returns:
     931            The new Intersect expression.
     932        """
     933        return intersect(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)
     934
     935    def except_(
     936        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
     937    ) -> Unionable:
     938        """
     939        Builds an EXCEPT expression.
     940
     941        Example:
     942            >>> import sqlglot
     943            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
     944            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
     945
     946        Args:
     947            expression: the SQL code string.
     948                If an `Expression` instance is passed, it will be used as-is.
     949            distinct: set the DISTINCT flag if and only if this is true.
     950            dialect: the dialect used to parse the input expression.
     951            opts: other options to use to parse the input expressions.
     952
     953        Returns:
     954            The new Except expression.
     955        """
     956        return except_(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)
     957
     958
     959class UDTF(DerivedTable, Unionable):
     960    @property
     961    def selects(self):
     962        alias = self.args.get("alias")
     963        return alias.columns if alias else []
     964
     965
     966class Cache(Expression):
     967    arg_types = {
     968        "with": False,
     969        "this": True,
     970        "lazy": False,
     971        "options": False,
     972        "expression": False,
     973    }
     974
     975
     976class Uncache(Expression):
     977    arg_types = {"this": True, "exists": False}
     978
     979
     980class Create(Expression):
     981    arg_types = {
     982        "with": False,
     983        "this": True,
     984        "kind": True,
     985        "expression": False,
     986        "exists": False,
     987        "properties": False,
     988        "replace": False,
     989        "unique": False,
     990        "indexes": False,
     991        "no_schema_binding": False,
     992        "begin": False,
     993        "clone": False,
     994    }
     995
     996
     997# https://docs.snowflake.com/en/sql-reference/sql/create-clone
     998class Clone(Expression):
     999    arg_types = {
    1000        "this": True,
    1001        "when": False,
    1002        "kind": False,
    1003        "expression": False,
    1004    }
    1005
    1006
    1007class Describe(Expression):
    1008    arg_types = {"this": True, "kind": False}
    1009
    1010
    1011class Pragma(Expression):
    1012    pass
    1013
    1014
    1015class Set(Expression):
    1016    arg_types = {"expressions": False}
    1017
    1018
    1019class SetItem(Expression):
    1020    arg_types = {
    1021        "this": False,
    1022        "expressions": False,
    1023        "kind": False,
    1024        "collate": False,  # MySQL SET NAMES statement
    1025        "global": False,
    1026    }
    1027
    1028
    1029class Show(Expression):
    1030    arg_types = {
    1031        "this": True,
    1032        "target": False,
    1033        "offset": False,
    1034        "limit": False,
    1035        "like": False,
    1036        "where": False,
    1037        "db": False,
    1038        "full": False,
    1039        "mutex": False,
    1040        "query": False,
    1041        "channel": False,
    1042        "global": False,
    1043        "log": False,
    1044        "position": False,
    1045        "types": False,
    1046    }
    1047
    1048
    1049class UserDefinedFunction(Expression):
    1050    arg_types = {"this": True, "expressions": False, "wrapped": False}
    1051
    1052
    1053class CharacterSet(Expression):
    1054    arg_types = {"this": True, "default": False}
    1055
    1056
    1057class With(Expression):
    1058    arg_types = {"expressions": True, "recursive": False}
    1059
    1060    @property
    1061    def recursive(self) -> bool:
    1062        return bool(self.args.get("recursive"))
    1063
    1064
    1065class WithinGroup(Expression):
    1066    arg_types = {"this": True, "expression": False}
    1067
    1068
    1069class CTE(DerivedTable):
    1070    arg_types = {"this": True, "alias": True}
    1071
    1072
    1073class TableAlias(Expression):
    1074    arg_types = {"this": False, "columns": False}
    1075
    1076    @property
    1077    def columns(self):
    1078        return self.args.get("columns") or []
    1079
    1080
    1081class BitString(Condition):
    1082    pass
    1083
    1084
    1085class HexString(Condition):
    1086    pass
    1087
    1088
    1089class ByteString(Condition):
    1090    pass
    1091
    1092
    1093class RawString(Condition):
    1094    pass
    1095
    1096
    1097class Column(Condition):
    1098    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
    1099
    1100    @property
    1101    def table(self) -> str:
    1102        return self.text("table")
    1103
    1104    @property
    1105    def db(self) -> str:
    1106        return self.text("db")
    1107
    1108    @property
    1109    def catalog(self) -> str:
    1110        return self.text("catalog")
    1111
    1112    @property
    1113    def output_name(self) -> str:
    1114        return self.name
    1115
    1116    @property
    1117    def parts(self) -> t.List[Identifier]:
    1118        """Return the parts of a column in order catalog, db, table, name."""
    1119        return [
    1120            t.cast(Identifier, self.args[part])
    1121            for part in ("catalog", "db", "table", "this")
    1122            if self.args.get(part)
    1123        ]
    1124
    1125    def to_dot(self) -> Dot:
    1126        """Converts the column into a dot expression."""
    1127        parts = self.parts
    1128        parent = self.parent
    1129
    1130        while parent:
    1131            if isinstance(parent, Dot):
    1132                parts.append(parent.expression)
    1133            parent = parent.parent
    1134
    1135        return Dot.build(parts)
    1136
    1137
    1138class ColumnPosition(Expression):
    1139    arg_types = {"this": False, "position": True}
    1140
    1141
    1142class ColumnDef(Expression):
    1143    arg_types = {
    1144        "this": True,
    1145        "kind": False,
    1146        "constraints": False,
    1147        "exists": False,
    1148        "position": False,
    1149    }
    1150
    1151    @property
    1152    def constraints(self) -> t.List[ColumnConstraint]:
    1153        return self.args.get("constraints") or []
    1154
    1155
    1156class AlterColumn(Expression):
    1157    arg_types = {
    1158        "this": True,
    1159        "dtype": False,
    1160        "collate": False,
    1161        "using": False,
    1162        "default": False,
    1163        "drop": False,
    1164    }
    1165
    1166
    1167class RenameTable(Expression):
    1168    pass
    1169
    1170
    1171class SetTag(Expression):
    1172    arg_types = {"expressions": True, "unset": False}
    1173
    1174
    1175class Comment(Expression):
    1176    arg_types = {"this": True, "kind": True, "expression": True, "exists": False}
    1177
    1178
    1179# https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
    1180class MergeTreeTTLAction(Expression):
    1181    arg_types = {
    1182        "this": True,
    1183        "delete": False,
    1184        "recompress": False,
    1185        "to_disk": False,
    1186        "to_volume": False,
    1187    }
    1188
    1189
    1190# https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
    1191class MergeTreeTTL(Expression):
    1192    arg_types = {
    1193        "expressions": True,
    1194        "where": False,
    1195        "group": False,
    1196        "aggregates": False,
    1197    }
    1198
    1199
    1200class ColumnConstraint(Expression):
    1201    arg_types = {"this": False, "kind": True}
    1202
    1203    @property
    1204    def kind(self) -> ColumnConstraintKind:
    1205        return self.args["kind"]
    1206
    1207
    1208class ColumnConstraintKind(Expression):
    1209    pass
    1210
    1211
    1212class AutoIncrementColumnConstraint(ColumnConstraintKind):
    1213    pass
    1214
    1215
    1216class CaseSpecificColumnConstraint(ColumnConstraintKind):
    1217    arg_types = {"not_": True}
    1218
    1219
    1220class CharacterSetColumnConstraint(ColumnConstraintKind):
    1221    arg_types = {"this": True}
    1222
    1223
    1224class CheckColumnConstraint(ColumnConstraintKind):
    1225    pass
    1226
    1227
    1228class CollateColumnConstraint(ColumnConstraintKind):
    1229    pass
    1230
    1231
    1232class CommentColumnConstraint(ColumnConstraintKind):
    1233    pass
    1234
    1235
    1236class CompressColumnConstraint(ColumnConstraintKind):
    1237    pass
    1238
    1239
    1240class DateFormatColumnConstraint(ColumnConstraintKind):
    1241    arg_types = {"this": True}
    1242
    1243
    1244class DefaultColumnConstraint(ColumnConstraintKind):
    1245    pass
    1246
    1247
    1248class EncodeColumnConstraint(ColumnConstraintKind):
    1249    pass
    1250
    1251
    1252class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
    1253    # this: True -> ALWAYS, this: False -> BY DEFAULT
    1254    arg_types = {
    1255        "this": False,
    1256        "expression": False,
    1257        "on_null": False,
    1258        "start": False,
    1259        "increment": False,
    1260        "minvalue": False,
    1261        "maxvalue": False,
    1262        "cycle": False,
    1263    }
    1264
    1265
    1266class InlineLengthColumnConstraint(ColumnConstraintKind):
    1267    pass
    1268
    1269
    1270class NotNullColumnConstraint(ColumnConstraintKind):
    1271    arg_types = {"allow_null": False}
    1272
    1273
    1274# https://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html
    1275class OnUpdateColumnConstraint(ColumnConstraintKind):
    1276    pass
    1277
    1278
    1279class PrimaryKeyColumnConstraint(ColumnConstraintKind):
    1280    arg_types = {"desc": False}
    1281
    1282
    1283class TitleColumnConstraint(ColumnConstraintKind):
    1284    pass
    1285
    1286
    1287class UniqueColumnConstraint(ColumnConstraintKind):
    1288    arg_types = {"this": False}
    1289
    1290
    1291class UppercaseColumnConstraint(ColumnConstraintKind):
    1292    arg_types: t.Dict[str, t.Any] = {}
    1293
    1294
    1295class PathColumnConstraint(ColumnConstraintKind):
    1296    pass
    1297
    1298
    1299class Constraint(Expression):
    1300    arg_types = {"this": True, "expressions": True}
    1301
    1302
    1303class Delete(Expression):
    1304    arg_types = {"with": False, "this": False, "using": False, "where": False, "returning": False}
    1305
    1306    def delete(
    1307        self,
    1308        table: ExpOrStr,
    1309        dialect: DialectType = None,
    1310        copy: bool = True,
    1311        **opts,
    1312    ) -> Delete:
    1313        """
    1314        Create a DELETE expression or replace the table on an existing DELETE expression.
    1315
    1316        Example:
    1317            >>> delete("tbl").sql()
    1318            'DELETE FROM tbl'
    1319
    1320        Args:
    1321            table: the table from which to delete.
    1322            dialect: the dialect used to parse the input expression.
    1323            copy: if `False`, modify this expression instance in-place.
    1324            opts: other options to use to parse the input expressions.
    1325
    1326        Returns:
    1327            Delete: the modified expression.
    1328        """
    1329        return _apply_builder(
    1330            expression=table,
    1331            instance=self,
    1332            arg="this",
    1333            dialect=dialect,
    1334            into=Table,
    1335            copy=copy,
    1336            **opts,
    1337        )
    1338
    1339    def where(
    1340        self,
    1341        *expressions: t.Optional[ExpOrStr],
    1342        append: bool = True,
    1343        dialect: DialectType = None,
    1344        copy: bool = True,
    1345        **opts,
    1346    ) -> Delete:
    1347        """
    1348        Append to or set the WHERE expressions.
    1349
    1350        Example:
    1351            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1352            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1353
    1354        Args:
    1355            *expressions: the SQL code strings to parse.
    1356                If an `Expression` instance is passed, it will be used as-is.
    1357                Multiple expressions are combined with an AND operator.
    1358            append: if `True`, AND the new expressions to any existing expression.
    1359                Otherwise, this resets the expression.
    1360            dialect: the dialect used to parse the input expressions.
    1361            copy: if `False`, modify this expression instance in-place.
    1362            opts: other options to use to parse the input expressions.
    1363
    1364        Returns:
    1365            Delete: the modified expression.
    1366        """
    1367        return _apply_conjunction_builder(
    1368            *expressions,
    1369            instance=self,
    1370            arg="where",
    1371            append=append,
    1372            into=Where,
    1373            dialect=dialect,
    1374            copy=copy,
    1375            **opts,
    1376        )
    1377
    1378    def returning(
    1379        self,
    1380        expression: ExpOrStr,
    1381        dialect: DialectType = None,
    1382        copy: bool = True,
    1383        **opts,
    1384    ) -> Delete:
    1385        """
    1386        Set the RETURNING expression. Not supported by all dialects.
    1387
    1388        Example:
    1389            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1390            'DELETE FROM tbl RETURNING *'
    1391
    1392        Args:
    1393            expression: the SQL code strings to parse.
    1394                If an `Expression` instance is passed, it will be used as-is.
    1395            dialect: the dialect used to parse the input expressions.
    1396            copy: if `False`, modify this expression instance in-place.
    1397            opts: other options to use to parse the input expressions.
    1398
    1399        Returns:
    1400            Delete: the modified expression.
    1401        """
    1402        return _apply_builder(
    1403            expression=expression,
    1404            instance=self,
    1405            arg="returning",
    1406            prefix="RETURNING",
    1407            dialect=dialect,
    1408            copy=copy,
    1409            into=Returning,
    1410            **opts,
    1411        )
    1412
    1413
    1414class Drop(Expression):
    1415    arg_types = {
    1416        "this": False,
    1417        "kind": False,
    1418        "exists": False,
    1419        "temporary": False,
    1420        "materialized": False,
    1421        "cascade": False,
    1422        "constraints": False,
    1423        "purge": False,
    1424    }
    1425
    1426
    1427class Filter(Expression):
    1428    arg_types = {"this": True, "expression": True}
    1429
    1430
    1431class Check(Expression):
    1432    pass
    1433
    1434
    1435class Directory(Expression):
    1436    # https://spark.apache.org/docs/3.0.0-preview/sql-ref-syntax-dml-insert-overwrite-directory-hive.html
    1437    arg_types = {"this": True, "local": False, "row_format": False}
    1438
    1439
    1440class ForeignKey(Expression):
    1441    arg_types = {
    1442        "expressions": True,
    1443        "reference": False,
    1444        "delete": False,
    1445        "update": False,
    1446    }
    1447
    1448
    1449class PrimaryKey(Expression):
    1450    arg_types = {"expressions": True, "options": False}
    1451
    1452
    1453# https://www.postgresql.org/docs/9.1/sql-selectinto.html
    1454# https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_INTO.html#r_SELECT_INTO-examples
    1455class Into(Expression):
    1456    arg_types = {"this": True, "temporary": False, "unlogged": False}
    1457
    1458
    1459class From(Expression):
    1460    @property
    1461    def name(self) -> str:
    1462        return self.this.name
    1463
    1464    @property
    1465    def alias_or_name(self) -> str:
    1466        return self.this.alias_or_name
    1467
    1468
    1469class Having(Expression):
    1470    pass
    1471
    1472
    1473class Hint(Expression):
    1474    arg_types = {"expressions": True}
    1475
    1476
    1477class JoinHint(Expression):
    1478    arg_types = {"this": True, "expressions": True}
    1479
    1480
    1481class Identifier(Expression):
    1482    arg_types = {"this": True, "quoted": False}
    1483
    1484    @property
    1485    def quoted(self) -> bool:
    1486        return bool(self.args.get("quoted"))
    1487
    1488    @property
    1489    def hashable_args(self) -> t.Any:
    1490        if self.quoted and any(char.isupper() for char in self.this):
    1491            return (self.this, self.quoted)
    1492        return self.this.lower()
    1493
    1494    @property
    1495    def output_name(self) -> str:
    1496        return self.name
    1497
    1498
    1499class Index(Expression):
    1500    arg_types = {
    1501        "this": False,
    1502        "table": False,
    1503        "using": False,
    1504        "where": False,
    1505        "columns": False,
    1506        "unique": False,
    1507        "primary": False,
    1508        "amp": False,  # teradata
    1509        "partition_by": False,  # teradata
    1510    }
    1511
    1512
    1513class Insert(Expression):
    1514    arg_types = {
    1515        "with": False,
    1516        "this": True,
    1517        "expression": False,
    1518        "conflict": False,
    1519        "returning": False,
    1520        "overwrite": False,
    1521        "exists": False,
    1522        "partition": False,
    1523        "alternative": False,
    1524    }
    1525
    1526    def with_(
    1527        self,
    1528        alias: ExpOrStr,
    1529        as_: ExpOrStr,
    1530        recursive: t.Optional[bool] = None,
    1531        append: bool = True,
    1532        dialect: DialectType = None,
    1533        copy: bool = True,
    1534        **opts,
    1535    ) -> Insert:
    1536        """
    1537        Append to or set the common table expressions.
    1538
    1539        Example:
    1540            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    1541            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    1542
    1543        Args:
    1544            alias: the SQL code string to parse as the table name.
    1545                If an `Expression` instance is passed, this is used as-is.
    1546            as_: the SQL code string to parse as the table expression.
    1547                If an `Expression` instance is passed, it will be used as-is.
    1548            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1549            append: if `True`, add to any existing expressions.
    1550                Otherwise, this resets the expressions.
    1551            dialect: the dialect used to parse the input expression.
    1552            copy: if `False`, modify this expression instance in-place.
    1553            opts: other options to use to parse the input expressions.
    1554
    1555        Returns:
    1556            The modified expression.
    1557        """
    1558        return _apply_cte_builder(
    1559            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    1560        )
    1561
    1562
    1563class OnConflict(Expression):
    1564    arg_types = {
    1565        "duplicate": False,
    1566        "expressions": False,
    1567        "nothing": False,
    1568        "key": False,
    1569        "constraint": False,
    1570    }
    1571
    1572
    1573class Returning(Expression):
    1574    arg_types = {"expressions": True}
    1575
    1576
    1577# https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html
    1578class Introducer(Expression):
    1579    arg_types = {"this": True, "expression": True}
    1580
    1581
    1582# national char, like n'utf8'
    1583class National(Expression):
    1584    pass
    1585
    1586
    1587class LoadData(Expression):
    1588    arg_types = {
    1589        "this": True,
    1590        "local": False,
    1591        "overwrite": False,
    1592        "inpath": True,
    1593        "partition": False,
    1594        "input_format": False,
    1595        "serde": False,
    1596    }
    1597
    1598
    1599class Partition(Expression):
    1600    arg_types = {"expressions": True}
    1601
    1602
    1603class Fetch(Expression):
    1604    arg_types = {
    1605        "direction": False,
    1606        "count": False,
    1607        "percent": False,
    1608        "with_ties": False,
    1609    }
    1610
    1611
    1612class Group(Expression):
    1613    arg_types = {
    1614        "expressions": False,
    1615        "grouping_sets": False,
    1616        "cube": False,
    1617        "rollup": False,
    1618        "totals": False,
    1619    }
    1620
    1621
    1622class Lambda(Expression):
    1623    arg_types = {"this": True, "expressions": True}
    1624
    1625
    1626class Limit(Expression):
    1627    arg_types = {"this": False, "expression": True, "offset": False}
    1628
    1629
    1630class Literal(Condition):
    1631    arg_types = {"this": True, "is_string": True}
    1632
    1633    @property
    1634    def hashable_args(self) -> t.Any:
    1635        return (self.this, self.args.get("is_string"))
    1636
    1637    @classmethod
    1638    def number(cls, number) -> Literal:
    1639        return cls(this=str(number), is_string=False)
    1640
    1641    @classmethod
    1642    def string(cls, string) -> Literal:
    1643        return cls(this=str(string), is_string=True)
    1644
    1645    @property
    1646    def output_name(self) -> str:
    1647        return self.name
    1648
    1649
    1650class Join(Expression):
    1651    arg_types = {
    1652        "this": True,
    1653        "on": False,
    1654        "side": False,
    1655        "kind": False,
    1656        "using": False,
    1657        "method": False,
    1658        "global": False,
    1659        "hint": False,
    1660    }
    1661
    1662    @property
    1663    def method(self) -> str:
    1664        return self.text("method").upper()
    1665
    1666    @property
    1667    def kind(self) -> str:
    1668        return self.text("kind").upper()
    1669
    1670    @property
    1671    def side(self) -> str:
    1672        return self.text("side").upper()
    1673
    1674    @property
    1675    def hint(self) -> str:
    1676        return self.text("hint").upper()
    1677
    1678    @property
    1679    def alias_or_name(self) -> str:
    1680        return self.this.alias_or_name
    1681
    1682    def on(
    1683        self,
    1684        *expressions: t.Optional[ExpOrStr],
    1685        append: bool = True,
    1686        dialect: DialectType = None,
    1687        copy: bool = True,
    1688        **opts,
    1689    ) -> Join:
    1690        """
    1691        Append to or set the ON expressions.
    1692
    1693        Example:
    1694            >>> import sqlglot
    1695            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    1696            'JOIN x ON y = 1'
    1697
    1698        Args:
    1699            *expressions: the SQL code strings to parse.
    1700                If an `Expression` instance is passed, it will be used as-is.
    1701                Multiple expressions are combined with an AND operator.
    1702            append: if `True`, AND the new expressions to any existing expression.
    1703                Otherwise, this resets the expression.
    1704            dialect: the dialect used to parse the input expressions.
    1705            copy: if `False`, modify this expression instance in-place.
    1706            opts: other options to use to parse the input expressions.
    1707
    1708        Returns:
    1709            The modified Join expression.
    1710        """
    1711        join = _apply_conjunction_builder(
    1712            *expressions,
    1713            instance=self,
    1714            arg="on",
    1715            append=append,
    1716            dialect=dialect,
    1717            copy=copy,
    1718            **opts,
    1719        )
    1720
    1721        if join.kind == "CROSS":
    1722            join.set("kind", None)
    1723
    1724        return join
    1725
    1726    def using(
    1727        self,
    1728        *expressions: t.Optional[ExpOrStr],
    1729        append: bool = True,
    1730        dialect: DialectType = None,
    1731        copy: bool = True,
    1732        **opts,
    1733    ) -> Join:
    1734        """
    1735        Append to or set the USING expressions.
    1736
    1737        Example:
    1738            >>> import sqlglot
    1739            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    1740            'JOIN x USING (foo, bla)'
    1741
    1742        Args:
    1743            *expressions: the SQL code strings to parse.
    1744                If an `Expression` instance is passed, it will be used as-is.
    1745            append: if `True`, concatenate the new expressions to the existing "using" list.
    1746                Otherwise, this resets the expression.
    1747            dialect: the dialect used to parse the input expressions.
    1748            copy: if `False`, modify this expression instance in-place.
    1749            opts: other options to use to parse the input expressions.
    1750
    1751        Returns:
    1752            The modified Join expression.
    1753        """
    1754        join = _apply_list_builder(
    1755            *expressions,
    1756            instance=self,
    1757            arg="using",
    1758            append=append,
    1759            dialect=dialect,
    1760            copy=copy,
    1761            **opts,
    1762        )
    1763
    1764        if join.kind == "CROSS":
    1765            join.set("kind", None)
    1766
    1767        return join
    1768
    1769
    1770class Lateral(UDTF):
    1771    arg_types = {"this": True, "view": False, "outer": False, "alias": False}
    1772
    1773
    1774class MatchRecognize(Expression):
    1775    arg_types = {
    1776        "partition_by": False,
    1777        "order": False,
    1778        "measures": False,
    1779        "rows": False,
    1780        "after": False,
    1781        "pattern": False,
    1782        "define": False,
    1783        "alias": False,
    1784    }
    1785
    1786
    1787# Clickhouse FROM FINAL modifier
    1788# https://clickhouse.com/docs/en/sql-reference/statements/select/from/#final-modifier
    1789class Final(Expression):
    1790    pass
    1791
    1792
    1793class Offset(Expression):
    1794    arg_types = {"this": False, "expression": True}
    1795
    1796
    1797class Order(Expression):
    1798    arg_types = {"this": False, "expressions": True}
    1799
    1800
    1801# hive specific sorts
    1802# https://cwiki.apache.org/confluence/display/Hive/LanguageManual+SortBy
    1803class Cluster(Order):
    1804    pass
    1805
    1806
    1807class Distribute(Order):
    1808    pass
    1809
    1810
    1811class Sort(Order):
    1812    pass
    1813
    1814
    1815class Ordered(Expression):
    1816    arg_types = {"this": True, "desc": True, "nulls_first": True}
    1817
    1818
    1819class Property(Expression):
    1820    arg_types = {"this": True, "value": True}
    1821
    1822
    1823class AlgorithmProperty(Property):
    1824    arg_types = {"this": True}
    1825
    1826
    1827class AutoIncrementProperty(Property):
    1828    arg_types = {"this": True}
    1829
    1830
    1831class BlockCompressionProperty(Property):
    1832    arg_types = {"autotemp": False, "always": False, "default": True, "manual": True, "never": True}
    1833
    1834
    1835class CharacterSetProperty(Property):
    1836    arg_types = {"this": True, "default": True}
    1837
    1838
    1839class ChecksumProperty(Property):
    1840    arg_types = {"on": False, "default": False}
    1841
    1842
    1843class CollateProperty(Property):
    1844    arg_types = {"this": True}
    1845
    1846
    1847class DataBlocksizeProperty(Property):
    1848    arg_types = {
    1849        "size": False,
    1850        "units": False,
    1851        "minimum": False,
    1852        "maximum": False,
    1853        "default": False,
    1854    }
    1855
    1856
    1857class DefinerProperty(Property):
    1858    arg_types = {"this": True}
    1859
    1860
    1861class DistKeyProperty(Property):
    1862    arg_types = {"this": True}
    1863
    1864
    1865class DistStyleProperty(Property):
    1866    arg_types = {"this": True}
    1867
    1868
    1869class EngineProperty(Property):
    1870    arg_types = {"this": True}
    1871
    1872
    1873class ToTableProperty(Property):
    1874    arg_types = {"this": True}
    1875
    1876
    1877class ExecuteAsProperty(Property):
    1878    arg_types = {"this": True}
    1879
    1880
    1881class ExternalProperty(Property):
    1882    arg_types = {"this": False}
    1883
    1884
    1885class FallbackProperty(Property):
    1886    arg_types = {"no": True, "protection": False}
    1887
    1888
    1889class FileFormatProperty(Property):
    1890    arg_types = {"this": True}
    1891
    1892
    1893class FreespaceProperty(Property):
    1894    arg_types = {"this": True, "percent": False}
    1895
    1896
    1897class InputOutputFormat(Expression):
    1898    arg_types = {"input_format": False, "output_format": False}
    1899
    1900
    1901class IsolatedLoadingProperty(Property):
    1902    arg_types = {
    1903        "no": True,
    1904        "concurrent": True,
    1905        "for_all": True,
    1906        "for_insert": True,
    1907        "for_none": True,
    1908    }
    1909
    1910
    1911class JournalProperty(Property):
    1912    arg_types = {
    1913        "no": False,
    1914        "dual": False,
    1915        "before": False,
    1916        "local": False,
    1917        "after": False,
    1918    }
    1919
    1920
    1921class LanguageProperty(Property):
    1922    arg_types = {"this": True}
    1923
    1924
    1925class DictProperty(Property):
    1926    arg_types = {"this": True, "kind": True, "settings": False}
    1927
    1928
    1929class DictSubProperty(Property):
    1930    pass
    1931
    1932
    1933class DictRange(Property):
    1934    arg_types = {"this": True, "min": True, "max": True}
    1935
    1936
    1937# Clickhouse CREATE ... ON CLUSTER modifier
    1938# https://clickhouse.com/docs/en/sql-reference/distributed-ddl
    1939class OnCluster(Property):
    1940    arg_types = {"this": True}
    1941
    1942
    1943class LikeProperty(Property):
    1944    arg_types = {"this": True, "expressions": False}
    1945
    1946
    1947class LocationProperty(Property):
    1948    arg_types = {"this": True}
    1949
    1950
    1951class LockingProperty(Property):
    1952    arg_types = {
    1953        "this": False,
    1954        "kind": True,
    1955        "for_or_in": True,
    1956        "lock_type": True,
    1957        "override": False,
    1958    }
    1959
    1960
    1961class LogProperty(Property):
    1962    arg_types = {"no": True}
    1963
    1964
    1965class MaterializedProperty(Property):
    1966    arg_types = {"this": False}
    1967
    1968
    1969class MergeBlockRatioProperty(Property):
    1970    arg_types = {"this": False, "no": False, "default": False, "percent": False}
    1971
    1972
    1973class NoPrimaryIndexProperty(Property):
    1974    arg_types = {}
    1975
    1976
    1977class OnCommitProperty(Property):
    1978    arg_type = {"delete": False}
    1979
    1980
    1981class PartitionedByProperty(Property):
    1982    arg_types = {"this": True}
    1983
    1984
    1985class ReturnsProperty(Property):
    1986    arg_types = {"this": True, "is_table": False, "table": False}
    1987
    1988
    1989class RowFormatProperty(Property):
    1990    arg_types = {"this": True}
    1991
    1992
    1993class RowFormatDelimitedProperty(Property):
    1994    # https://cwiki.apache.org/confluence/display/hive/languagemanual+dml
    1995    arg_types = {
    1996        "fields": False,
    1997        "escaped": False,
    1998        "collection_items": False,
    1999        "map_keys": False,
    2000        "lines": False,
    2001        "null": False,
    2002        "serde": False,
    2003    }
    2004
    2005
    2006class RowFormatSerdeProperty(Property):
    2007    arg_types = {"this": True}
    2008
    2009
    2010class SchemaCommentProperty(Property):
    2011    arg_types = {"this": True}
    2012
    2013
    2014class SerdeProperties(Property):
    2015    arg_types = {"expressions": True}
    2016
    2017
    2018class SetProperty(Property):
    2019    arg_types = {"multi": True}
    2020
    2021
    2022class SettingsProperty(Property):
    2023    arg_types = {"expressions": True}
    2024
    2025
    2026class SortKeyProperty(Property):
    2027    arg_types = {"this": True, "compound": False}
    2028
    2029
    2030class SqlSecurityProperty(Property):
    2031    arg_types = {"definer": True}
    2032
    2033
    2034class StabilityProperty(Property):
    2035    arg_types = {"this": True}
    2036
    2037
    2038class TemporaryProperty(Property):
    2039    arg_types = {}
    2040
    2041
    2042class TransientProperty(Property):
    2043    arg_types = {"this": False}
    2044
    2045
    2046class VolatileProperty(Property):
    2047    arg_types = {"this": False}
    2048
    2049
    2050class WithDataProperty(Property):
    2051    arg_types = {"no": True, "statistics": False}
    2052
    2053
    2054class WithJournalTableProperty(Property):
    2055    arg_types = {"this": True}
    2056
    2057
    2058class Properties(Expression):
    2059    arg_types = {"expressions": True}
    2060
    2061    NAME_TO_PROPERTY = {
    2062        "ALGORITHM": AlgorithmProperty,
    2063        "AUTO_INCREMENT": AutoIncrementProperty,
    2064        "CHARACTER SET": CharacterSetProperty,
    2065        "COLLATE": CollateProperty,
    2066        "COMMENT": SchemaCommentProperty,
    2067        "DEFINER": DefinerProperty,
    2068        "DISTKEY": DistKeyProperty,
    2069        "DISTSTYLE": DistStyleProperty,
    2070        "ENGINE": EngineProperty,
    2071        "EXECUTE AS": ExecuteAsProperty,
    2072        "FORMAT": FileFormatProperty,
    2073        "LANGUAGE": LanguageProperty,
    2074        "LOCATION": LocationProperty,
    2075        "PARTITIONED_BY": PartitionedByProperty,
    2076        "RETURNS": ReturnsProperty,
    2077        "ROW_FORMAT": RowFormatProperty,
    2078        "SORTKEY": SortKeyProperty,
    2079    }
    2080
    2081    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    2082
    2083    # CREATE property locations
    2084    # Form: schema specified
    2085    #   create [POST_CREATE]
    2086    #     table a [POST_NAME]
    2087    #     (b int) [POST_SCHEMA]
    2088    #     with ([POST_WITH])
    2089    #     index (b) [POST_INDEX]
    2090    #
    2091    # Form: alias selection
    2092    #   create [POST_CREATE]
    2093    #     table a [POST_NAME]
    2094    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    2095    #     index (c) [POST_INDEX]
    2096    class Location(AutoName):
    2097        POST_CREATE = auto()
    2098        POST_NAME = auto()
    2099        POST_SCHEMA = auto()
    2100        POST_WITH = auto()
    2101        POST_ALIAS = auto()
    2102        POST_EXPRESSION = auto()
    2103        POST_INDEX = auto()
    2104        UNSUPPORTED = auto()
    2105
    2106    @classmethod
    2107    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    2108        expressions = []
    2109        for key, value in properties_dict.items():
    2110            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    2111            if property_cls:
    2112                expressions.append(property_cls(this=convert(value)))
    2113            else:
    2114                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    2115
    2116        return cls(expressions=expressions)
    2117
    2118
    2119class Qualify(Expression):
    2120    pass
    2121
    2122
    2123# https://www.ibm.com/docs/en/ias?topic=procedures-return-statement-in-sql
    2124class Return(Expression):
    2125    pass
    2126
    2127
    2128class Reference(Expression):
    2129    arg_types = {"this": True, "expressions": False, "options": False}
    2130
    2131
    2132class Tuple(Expression):
    2133    arg_types = {"expressions": False}
    2134
    2135    def isin(
    2136        self, *expressions: t.Any, query: t.Optional[ExpOrStr] = None, copy: bool = True, **opts
    2137    ) -> In:
    2138        return In(
    2139            this=_maybe_copy(self, copy),
    2140            expressions=[convert(e, copy=copy) for e in expressions],
    2141            query=maybe_parse(query, copy=copy, **opts) if query else None,
    2142        )
    2143
    2144
    2145class Subqueryable(Unionable):
    2146    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    2147        """
    2148        Convert this expression to an aliased expression that can be used as a Subquery.
    2149
    2150        Example:
    2151            >>> subquery = Select().select("x").from_("tbl").subquery()
    2152            >>> Select().select("x").from_(subquery).sql()
    2153            'SELECT x FROM (SELECT x FROM tbl)'
    2154
    2155        Args:
    2156            alias (str | Identifier): an optional alias for the subquery
    2157            copy (bool): if `False`, modify this expression instance in-place.
    2158
    2159        Returns:
    2160            Alias: the subquery
    2161        """
    2162        instance = _maybe_copy(self, copy)
    2163        if not isinstance(alias, Expression):
    2164            alias = TableAlias(this=to_identifier(alias)) if alias else None
    2165
    2166        return Subquery(this=instance, alias=alias)
    2167
    2168    def limit(
    2169        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2170    ) -> Select:
    2171        raise NotImplementedError
    2172
    2173    @property
    2174    def ctes(self):
    2175        with_ = self.args.get("with")
    2176        if not with_:
    2177            return []
    2178        return with_.expressions
    2179
    2180    @property
    2181    def selects(self):
    2182        raise NotImplementedError("Subqueryable objects must implement `selects`")
    2183
    2184    @property
    2185    def named_selects(self):
    2186        raise NotImplementedError("Subqueryable objects must implement `named_selects`")
    2187
    2188    def with_(
    2189        self,
    2190        alias: ExpOrStr,
    2191        as_: ExpOrStr,
    2192        recursive: t.Optional[bool] = None,
    2193        append: bool = True,
    2194        dialect: DialectType = None,
    2195        copy: bool = True,
    2196        **opts,
    2197    ) -> Subqueryable:
    2198        """
    2199        Append to or set the common table expressions.
    2200
    2201        Example:
    2202            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    2203            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    2204
    2205        Args:
    2206            alias: the SQL code string to parse as the table name.
    2207                If an `Expression` instance is passed, this is used as-is.
    2208            as_: the SQL code string to parse as the table expression.
    2209                If an `Expression` instance is passed, it will be used as-is.
    2210            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2211            append: if `True`, add to any existing expressions.
    2212                Otherwise, this resets the expressions.
    2213            dialect: the dialect used to parse the input expression.
    2214            copy: if `False`, modify this expression instance in-place.
    2215            opts: other options to use to parse the input expressions.
    2216
    2217        Returns:
    2218            The modified expression.
    2219        """
    2220        return _apply_cte_builder(
    2221            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    2222        )
    2223
    2224
    2225QUERY_MODIFIERS = {
    2226    "match": False,
    2227    "laterals": False,
    2228    "joins": False,
    2229    "pivots": False,
    2230    "where": False,
    2231    "group": False,
    2232    "having": False,
    2233    "qualify": False,
    2234    "windows": False,
    2235    "distribute": False,
    2236    "sort": False,
    2237    "cluster": False,
    2238    "order": False,
    2239    "limit": False,
    2240    "offset": False,
    2241    "locks": False,
    2242    "sample": False,
    2243    "settings": False,
    2244    "format": False,
    2245}
    2246
    2247
    2248class Table(Expression):
    2249    arg_types = {
    2250        "this": True,
    2251        "alias": False,
    2252        "db": False,
    2253        "catalog": False,
    2254        "laterals": False,
    2255        "joins": False,
    2256        "pivots": False,
    2257        "hints": False,
    2258        "system_time": False,
    2259    }
    2260
    2261    @property
    2262    def db(self) -> str:
    2263        return self.text("db")
    2264
    2265    @property
    2266    def catalog(self) -> str:
    2267        return self.text("catalog")
    2268
    2269    @property
    2270    def parts(self) -> t.List[Identifier]:
    2271        """Return the parts of a table in order catalog, db, table."""
    2272        return [
    2273            t.cast(Identifier, self.args[part])
    2274            for part in ("catalog", "db", "this")
    2275            if self.args.get(part)
    2276        ]
    2277
    2278
    2279# See the TSQL "Querying data in a system-versioned temporal table" page
    2280class SystemTime(Expression):
    2281    arg_types = {
    2282        "this": False,
    2283        "expression": False,
    2284        "kind": True,
    2285    }
    2286
    2287
    2288class Union(Subqueryable):
    2289    arg_types = {
    2290        "with": False,
    2291        "this": True,
    2292        "expression": True,
    2293        "distinct": False,
    2294        **QUERY_MODIFIERS,
    2295    }
    2296
    2297    def limit(
    2298        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2299    ) -> Select:
    2300        """
    2301        Set the LIMIT expression.
    2302
    2303        Example:
    2304            >>> select("1").union(select("1")).limit(1).sql()
    2305            'SELECT * FROM (SELECT 1 UNION SELECT 1) AS _l_0 LIMIT 1'
    2306
    2307        Args:
    2308            expression: the SQL code string to parse.
    2309                This can also be an integer.
    2310                If a `Limit` instance is passed, this is used as-is.
    2311                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2312            dialect: the dialect used to parse the input expression.
    2313            copy: if `False`, modify this expression instance in-place.
    2314            opts: other options to use to parse the input expressions.
    2315
    2316        Returns:
    2317            The limited subqueryable.
    2318        """
    2319        return (
    2320            select("*")
    2321            .from_(self.subquery(alias="_l_0", copy=copy))
    2322            .limit(expression, dialect=dialect, copy=False, **opts)
    2323        )
    2324
    2325    def select(
    2326        self,
    2327        *expressions: t.Optional[ExpOrStr],
    2328        append: bool = True,
    2329        dialect: DialectType = None,
    2330        copy: bool = True,
    2331        **opts,
    2332    ) -> Union:
    2333        """Append to or set the SELECT of the union recursively.
    2334
    2335        Example:
    2336            >>> from sqlglot import parse_one
    2337            >>> parse_one("select a from x union select a from y union select a from z").select("b").sql()
    2338            'SELECT a, b FROM x UNION SELECT a, b FROM y UNION SELECT a, b FROM z'
    2339
    2340        Args:
    2341            *expressions: the SQL code strings to parse.
    2342                If an `Expression` instance is passed, it will be used as-is.
    2343            append: if `True`, add to any existing expressions.
    2344                Otherwise, this resets the expressions.
    2345            dialect: the dialect used to parse the input expressions.
    2346            copy: if `False`, modify this expression instance in-place.
    2347            opts: other options to use to parse the input expressions.
    2348
    2349        Returns:
    2350            Union: the modified expression.
    2351        """
    2352        this = self.copy() if copy else self
    2353        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    2354        this.expression.unnest().select(
    2355            *expressions, append=append, dialect=dialect, copy=False, **opts
    2356        )
    2357        return this
    2358
    2359    @property
    2360    def named_selects(self):
    2361        return self.this.unnest().named_selects
    2362
    2363    @property
    2364    def is_star(self) -> bool:
    2365        return self.this.is_star or self.expression.is_star
    2366
    2367    @property
    2368    def selects(self):
    2369        return self.this.unnest().selects
    2370
    2371    @property
    2372    def left(self):
    2373        return self.this
    2374
    2375    @property
    2376    def right(self):
    2377        return self.expression
    2378
    2379
    2380class Except(Union):
    2381    pass
    2382
    2383
    2384class Intersect(Union):
    2385    pass
    2386
    2387
    2388class Unnest(UDTF):
    2389    arg_types = {
    2390        "expressions": True,
    2391        "ordinality": False,
    2392        "alias": False,
    2393        "offset": False,
    2394    }
    2395
    2396
    2397class Update(Expression):
    2398    arg_types = {
    2399        "with": False,
    2400        "this": False,
    2401        "expressions": True,
    2402        "from": False,
    2403        "where": False,
    2404        "returning": False,
    2405    }
    2406
    2407
    2408class Values(UDTF):
    2409    arg_types = {
    2410        "expressions": True,
    2411        "ordinality": False,
    2412        "alias": False,
    2413    }
    2414
    2415
    2416class Var(Expression):
    2417    pass
    2418
    2419
    2420class Schema(Expression):
    2421    arg_types = {"this": False, "expressions": False}
    2422
    2423
    2424# https://dev.mysql.com/doc/refman/8.0/en/select.html
    2425# https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SELECT.html
    2426class Lock(Expression):
    2427    arg_types = {"update": True, "expressions": False, "wait": False}
    2428
    2429
    2430class Select(Subqueryable):
    2431    arg_types = {
    2432        "with": False,
    2433        "kind": False,
    2434        "expressions": False,
    2435        "hint": False,
    2436        "distinct": False,
    2437        "struct": False,  # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#return_query_results_as_a_value_table
    2438        "value": False,
    2439        "into": False,
    2440        "from": False,
    2441        **QUERY_MODIFIERS,
    2442    }
    2443
    2444    def from_(
    2445        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    2446    ) -> Select:
    2447        """
    2448        Set the FROM expression.
    2449
    2450        Example:
    2451            >>> Select().from_("tbl").select("x").sql()
    2452            'SELECT x FROM tbl'
    2453
    2454        Args:
    2455            expression : the SQL code strings to parse.
    2456                If a `From` instance is passed, this is used as-is.
    2457                If another `Expression` instance is passed, it will be wrapped in a `From`.
    2458            dialect: the dialect used to parse the input expression.
    2459            copy: if `False`, modify this expression instance in-place.
    2460            opts: other options to use to parse the input expressions.
    2461
    2462        Returns:
    2463            The modified Select expression.
    2464        """
    2465        return _apply_builder(
    2466            expression=expression,
    2467            instance=self,
    2468            arg="from",
    2469            into=From,
    2470            prefix="FROM",
    2471            dialect=dialect,
    2472            copy=copy,
    2473            **opts,
    2474        )
    2475
    2476    def group_by(
    2477        self,
    2478        *expressions: t.Optional[ExpOrStr],
    2479        append: bool = True,
    2480        dialect: DialectType = None,
    2481        copy: bool = True,
    2482        **opts,
    2483    ) -> Select:
    2484        """
    2485        Set the GROUP BY expression.
    2486
    2487        Example:
    2488            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    2489            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    2490
    2491        Args:
    2492            *expressions: the SQL code strings to parse.
    2493                If a `Group` instance is passed, this is used as-is.
    2494                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    2495                If nothing is passed in then a group by is not applied to the expression
    2496            append: if `True`, add to any existing expressions.
    2497                Otherwise, this flattens all the `Group` expression into a single expression.
    2498            dialect: the dialect used to parse the input expression.
    2499            copy: if `False`, modify this expression instance in-place.
    2500            opts: other options to use to parse the input expressions.
    2501
    2502        Returns:
    2503            The modified Select expression.
    2504        """
    2505        if not expressions:
    2506            return self if not copy else self.copy()
    2507
    2508        return _apply_child_list_builder(
    2509            *expressions,
    2510            instance=self,
    2511            arg="group",
    2512            append=append,
    2513            copy=copy,
    2514            prefix="GROUP BY",
    2515            into=Group,
    2516            dialect=dialect,
    2517            **opts,
    2518        )
    2519
    2520    def order_by(
    2521        self,
    2522        *expressions: t.Optional[ExpOrStr],
    2523        append: bool = True,
    2524        dialect: DialectType = None,
    2525        copy: bool = True,
    2526        **opts,
    2527    ) -> Select:
    2528        """
    2529        Set the ORDER BY expression.
    2530
    2531        Example:
    2532            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    2533            'SELECT x FROM tbl ORDER BY x DESC'
    2534
    2535        Args:
    2536            *expressions: the SQL code strings to parse.
    2537                If a `Group` instance is passed, this is used as-is.
    2538                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    2539            append: if `True`, add to any existing expressions.
    2540                Otherwise, this flattens all the `Order` expression into a single expression.
    2541            dialect: the dialect used to parse the input expression.
    2542            copy: if `False`, modify this expression instance in-place.
    2543            opts: other options to use to parse the input expressions.
    2544
    2545        Returns:
    2546            The modified Select expression.
    2547        """
    2548        return _apply_child_list_builder(
    2549            *expressions,
    2550            instance=self,
    2551            arg="order",
    2552            append=append,
    2553            copy=copy,
    2554            prefix="ORDER BY",
    2555            into=Order,
    2556            dialect=dialect,
    2557            **opts,
    2558        )
    2559
    2560    def sort_by(
    2561        self,
    2562        *expressions: t.Optional[ExpOrStr],
    2563        append: bool = True,
    2564        dialect: DialectType = None,
    2565        copy: bool = True,
    2566        **opts,
    2567    ) -> Select:
    2568        """
    2569        Set the SORT BY expression.
    2570
    2571        Example:
    2572            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    2573            'SELECT x FROM tbl SORT BY x DESC'
    2574
    2575        Args:
    2576            *expressions: the SQL code strings to parse.
    2577                If a `Group` instance is passed, this is used as-is.
    2578                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    2579            append: if `True`, add to any existing expressions.
    2580                Otherwise, this flattens all the `Order` expression into a single expression.
    2581            dialect: the dialect used to parse the input expression.
    2582            copy: if `False`, modify this expression instance in-place.
    2583            opts: other options to use to parse the input expressions.
    2584
    2585        Returns:
    2586            The modified Select expression.
    2587        """
    2588        return _apply_child_list_builder(
    2589            *expressions,
    2590            instance=self,
    2591            arg="sort",
    2592            append=append,
    2593            copy=copy,
    2594            prefix="SORT BY",
    2595            into=Sort,
    2596            dialect=dialect,
    2597            **opts,
    2598        )
    2599
    2600    def cluster_by(
    2601        self,
    2602        *expressions: t.Optional[ExpOrStr],
    2603        append: bool = True,
    2604        dialect: DialectType = None,
    2605        copy: bool = True,
    2606        **opts,
    2607    ) -> Select:
    2608        """
    2609        Set the CLUSTER BY expression.
    2610
    2611        Example:
    2612            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    2613            'SELECT x FROM tbl CLUSTER BY x DESC'
    2614
    2615        Args:
    2616            *expressions: the SQL code strings to parse.
    2617                If a `Group` instance is passed, this is used as-is.
    2618                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    2619            append: if `True`, add to any existing expressions.
    2620                Otherwise, this flattens all the `Order` expression into a single expression.
    2621            dialect: the dialect used to parse the input expression.
    2622            copy: if `False`, modify this expression instance in-place.
    2623            opts: other options to use to parse the input expressions.
    2624
    2625        Returns:
    2626            The modified Select expression.
    2627        """
    2628        return _apply_child_list_builder(
    2629            *expressions,
    2630            instance=self,
    2631            arg="cluster",
    2632            append=append,
    2633            copy=copy,
    2634            prefix="CLUSTER BY",
    2635            into=Cluster,
    2636            dialect=dialect,
    2637            **opts,
    2638        )
    2639
    2640    def limit(
    2641        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2642    ) -> Select:
    2643        """
    2644        Set the LIMIT expression.
    2645
    2646        Example:
    2647            >>> Select().from_("tbl").select("x").limit(10).sql()
    2648            'SELECT x FROM tbl LIMIT 10'
    2649
    2650        Args:
    2651            expression: the SQL code string to parse.
    2652                This can also be an integer.
    2653                If a `Limit` instance is passed, this is used as-is.
    2654                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2655            dialect: the dialect used to parse the input expression.
    2656            copy: if `False`, modify this expression instance in-place.
    2657            opts: other options to use to parse the input expressions.
    2658
    2659        Returns:
    2660            Select: the modified expression.
    2661        """
    2662        return _apply_builder(
    2663            expression=expression,
    2664            instance=self,
    2665            arg="limit",
    2666            into=Limit,
    2667            prefix="LIMIT",
    2668            dialect=dialect,
    2669            copy=copy,
    2670            **opts,
    2671        )
    2672
    2673    def offset(
    2674        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2675    ) -> Select:
    2676        """
    2677        Set the OFFSET expression.
    2678
    2679        Example:
    2680            >>> Select().from_("tbl").select("x").offset(10).sql()
    2681            'SELECT x FROM tbl OFFSET 10'
    2682
    2683        Args:
    2684            expression: the SQL code string to parse.
    2685                This can also be an integer.
    2686                If a `Offset` instance is passed, this is used as-is.
    2687                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    2688            dialect: the dialect used to parse the input expression.
    2689            copy: if `False`, modify this expression instance in-place.
    2690            opts: other options to use to parse the input expressions.
    2691
    2692        Returns:
    2693            The modified Select expression.
    2694        """
    2695        return _apply_builder(
    2696            expression=expression,
    2697            instance=self,
    2698            arg="offset",
    2699            into=Offset,
    2700            prefix="OFFSET",
    2701            dialect=dialect,
    2702            copy=copy,
    2703            **opts,
    2704        )
    2705
    2706    def select(
    2707        self,
    2708        *expressions: t.Optional[ExpOrStr],
    2709        append: bool = True,
    2710        dialect: DialectType = None,
    2711        copy: bool = True,
    2712        **opts,
    2713    ) -> Select:
    2714        """
    2715        Append to or set the SELECT expressions.
    2716
    2717        Example:
    2718            >>> Select().select("x", "y").sql()
    2719            'SELECT x, y'
    2720
    2721        Args:
    2722            *expressions: the SQL code strings to parse.
    2723                If an `Expression` instance is passed, it will be used as-is.
    2724            append: if `True`, add to any existing expressions.
    2725                Otherwise, this resets the expressions.
    2726            dialect: the dialect used to parse the input expressions.
    2727            copy: if `False`, modify this expression instance in-place.
    2728            opts: other options to use to parse the input expressions.
    2729
    2730        Returns:
    2731            The modified Select expression.
    2732        """
    2733        return _apply_list_builder(
    2734            *expressions,
    2735            instance=self,
    2736            arg="expressions",
    2737            append=append,
    2738            dialect=dialect,
    2739            copy=copy,
    2740            **opts,
    2741        )
    2742
    2743    def lateral(
    2744        self,
    2745        *expressions: t.Optional[ExpOrStr],
    2746        append: bool = True,
    2747        dialect: DialectType = None,
    2748        copy: bool = True,
    2749        **opts,
    2750    ) -> Select:
    2751        """
    2752        Append to or set the LATERAL expressions.
    2753
    2754        Example:
    2755            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    2756            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    2757
    2758        Args:
    2759            *expressions: the SQL code strings to parse.
    2760                If an `Expression` instance is passed, it will be used as-is.
    2761            append: if `True`, add to any existing expressions.
    2762                Otherwise, this resets the expressions.
    2763            dialect: the dialect used to parse the input expressions.
    2764            copy: if `False`, modify this expression instance in-place.
    2765            opts: other options to use to parse the input expressions.
    2766
    2767        Returns:
    2768            The modified Select expression.
    2769        """
    2770        return _apply_list_builder(
    2771            *expressions,
    2772            instance=self,
    2773            arg="laterals",
    2774            append=append,
    2775            into=Lateral,
    2776            prefix="LATERAL VIEW",
    2777            dialect=dialect,
    2778            copy=copy,
    2779            **opts,
    2780        )
    2781
    2782    def join(
    2783        self,
    2784        expression: ExpOrStr,
    2785        on: t.Optional[ExpOrStr] = None,
    2786        using: t.Optional[ExpOrStr | t.List[ExpOrStr]] = None,
    2787        append: bool = True,
    2788        join_type: t.Optional[str] = None,
    2789        join_alias: t.Optional[Identifier | str] = None,
    2790        dialect: DialectType = None,
    2791        copy: bool = True,
    2792        **opts,
    2793    ) -> Select:
    2794        """
    2795        Append to or set the JOIN expressions.
    2796
    2797        Example:
    2798            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    2799            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    2800
    2801            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    2802            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    2803
    2804            Use `join_type` to change the type of join:
    2805
    2806            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    2807            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    2808
    2809        Args:
    2810            expression: the SQL code string to parse.
    2811                If an `Expression` instance is passed, it will be used as-is.
    2812            on: optionally specify the join "on" criteria as a SQL string.
    2813                If an `Expression` instance is passed, it will be used as-is.
    2814            using: optionally specify the join "using" criteria as a SQL string.
    2815                If an `Expression` instance is passed, it will be used as-is.
    2816            append: if `True`, add to any existing expressions.
    2817                Otherwise, this resets the expressions.
    2818            join_type: if set, alter the parsed join type.
    2819            join_alias: an optional alias for the joined source.
    2820            dialect: the dialect used to parse the input expressions.
    2821            copy: if `False`, modify this expression instance in-place.
    2822            opts: other options to use to parse the input expressions.
    2823
    2824        Returns:
    2825            Select: the modified expression.
    2826        """
    2827        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    2828
    2829        try:
    2830            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    2831        except ParseError:
    2832            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    2833
    2834        join = expression if isinstance(expression, Join) else Join(this=expression)
    2835
    2836        if isinstance(join.this, Select):
    2837            join.this.replace(join.this.subquery())
    2838
    2839        if join_type:
    2840            method: t.Optional[Token]
    2841            side: t.Optional[Token]
    2842            kind: t.Optional[Token]
    2843
    2844            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    2845
    2846            if method:
    2847                join.set("method", method.text)
    2848            if side:
    2849                join.set("side", side.text)
    2850            if kind:
    2851                join.set("kind", kind.text)
    2852
    2853        if on:
    2854            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    2855            join.set("on", on)
    2856
    2857        if using:
    2858            join = _apply_list_builder(
    2859                *ensure_list(using),
    2860                instance=join,
    2861                arg="using",
    2862                append=append,
    2863                copy=copy,
    2864                **opts,
    2865            )
    2866
    2867        if join_alias:
    2868            join.set("this", alias_(join.this, join_alias, table=True))
    2869
    2870        return _apply_list_builder(
    2871            join,
    2872            instance=self,
    2873            arg="joins",
    2874            append=append,
    2875            copy=copy,
    2876            **opts,
    2877        )
    2878
    2879    def where(
    2880        self,
    2881        *expressions: t.Optional[ExpOrStr],
    2882        append: bool = True,
    2883        dialect: DialectType = None,
    2884        copy: bool = True,
    2885        **opts,
    2886    ) -> Select:
    2887        """
    2888        Append to or set the WHERE expressions.
    2889
    2890        Example:
    2891            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    2892            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    2893
    2894        Args:
    2895            *expressions: the SQL code strings to parse.
    2896                If an `Expression` instance is passed, it will be used as-is.
    2897                Multiple expressions are combined with an AND operator.
    2898            append: if `True`, AND the new expressions to any existing expression.
    2899                Otherwise, this resets the expression.
    2900            dialect: the dialect used to parse the input expressions.
    2901            copy: if `False`, modify this expression instance in-place.
    2902            opts: other options to use to parse the input expressions.
    2903
    2904        Returns:
    2905            Select: the modified expression.
    2906        """
    2907        return _apply_conjunction_builder(
    2908            *expressions,
    2909            instance=self,
    2910            arg="where",
    2911            append=append,
    2912            into=Where,
    2913            dialect=dialect,
    2914            copy=copy,
    2915            **opts,
    2916        )
    2917
    2918    def having(
    2919        self,
    2920        *expressions: t.Optional[ExpOrStr],
    2921        append: bool = True,
    2922        dialect: DialectType = None,
    2923        copy: bool = True,
    2924        **opts,
    2925    ) -> Select:
    2926        """
    2927        Append to or set the HAVING expressions.
    2928
    2929        Example:
    2930            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    2931            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    2932
    2933        Args:
    2934            *expressions: the SQL code strings to parse.
    2935                If an `Expression` instance is passed, it will be used as-is.
    2936                Multiple expressions are combined with an AND operator.
    2937            append: if `True`, AND the new expressions to any existing expression.
    2938                Otherwise, this resets the expression.
    2939            dialect: the dialect used to parse the input expressions.
    2940            copy: if `False`, modify this expression instance in-place.
    2941            opts: other options to use to parse the input expressions.
    2942
    2943        Returns:
    2944            The modified Select expression.
    2945        """
    2946        return _apply_conjunction_builder(
    2947            *expressions,
    2948            instance=self,
    2949            arg="having",
    2950            append=append,
    2951            into=Having,
    2952            dialect=dialect,
    2953            copy=copy,
    2954            **opts,
    2955        )
    2956
    2957    def window(
    2958        self,
    2959        *expressions: t.Optional[ExpOrStr],
    2960        append: bool = True,
    2961        dialect: DialectType = None,
    2962        copy: bool = True,
    2963        **opts,
    2964    ) -> Select:
    2965        return _apply_list_builder(
    2966            *expressions,
    2967            instance=self,
    2968            arg="windows",
    2969            append=append,
    2970            into=Window,
    2971            dialect=dialect,
    2972            copy=copy,
    2973            **opts,
    2974        )
    2975
    2976    def qualify(
    2977        self,
    2978        *expressions: t.Optional[ExpOrStr],
    2979        append: bool = True,
    2980        dialect: DialectType = None,
    2981        copy: bool = True,
    2982        **opts,
    2983    ) -> Select:
    2984        return _apply_conjunction_builder(
    2985            *expressions,
    2986            instance=self,
    2987            arg="qualify",
    2988            append=append,
    2989            into=Qualify,
    2990            dialect=dialect,
    2991            copy=copy,
    2992            **opts,
    2993        )
    2994
    2995    def distinct(
    2996        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    2997    ) -> Select:
    2998        """
    2999        Set the OFFSET expression.
    3000
    3001        Example:
    3002            >>> Select().from_("tbl").select("x").distinct().sql()
    3003            'SELECT DISTINCT x FROM tbl'
    3004
    3005        Args:
    3006            ons: the expressions to distinct on
    3007            distinct: whether the Select should be distinct
    3008            copy: if `False`, modify this expression instance in-place.
    3009
    3010        Returns:
    3011            Select: the modified expression.
    3012        """
    3013        instance = _maybe_copy(self, copy)
    3014        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3015        instance.set("distinct", Distinct(on=on) if distinct else None)
    3016        return instance
    3017
    3018    def ctas(
    3019        self,
    3020        table: ExpOrStr,
    3021        properties: t.Optional[t.Dict] = None,
    3022        dialect: DialectType = None,
    3023        copy: bool = True,
    3024        **opts,
    3025    ) -> Create:
    3026        """
    3027        Convert this expression to a CREATE TABLE AS statement.
    3028
    3029        Example:
    3030            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3031            'CREATE TABLE x AS SELECT * FROM tbl'
    3032
    3033        Args:
    3034            table: the SQL code string to parse as the table name.
    3035                If another `Expression` instance is passed, it will be used as-is.
    3036            properties: an optional mapping of table properties
    3037            dialect: the dialect used to parse the input table.
    3038            copy: if `False`, modify this expression instance in-place.
    3039            opts: other options to use to parse the input table.
    3040
    3041        Returns:
    3042            The new Create expression.
    3043        """
    3044        instance = _maybe_copy(self, copy)
    3045        table_expression = maybe_parse(
    3046            table,
    3047            into=Table,
    3048            dialect=dialect,
    3049            **opts,
    3050        )
    3051        properties_expression = None
    3052        if properties:
    3053            properties_expression = Properties.from_dict(properties)
    3054
    3055        return Create(
    3056            this=table_expression,
    3057            kind="table",
    3058            expression=instance,
    3059            properties=properties_expression,
    3060        )
    3061
    3062    def lock(self, update: bool = True, copy: bool = True) -> Select:
    3063        """
    3064        Set the locking read mode for this expression.
    3065
    3066        Examples:
    3067            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    3068            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    3069
    3070            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    3071            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    3072
    3073        Args:
    3074            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    3075            copy: if `False`, modify this expression instance in-place.
    3076
    3077        Returns:
    3078            The modified expression.
    3079        """
    3080        inst = _maybe_copy(self, copy)
    3081        inst.set("locks", [Lock(update=update)])
    3082
    3083        return inst
    3084
    3085    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    3086        """
    3087        Set hints for this expression.
    3088
    3089        Examples:
    3090            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    3091            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    3092
    3093        Args:
    3094            hints: The SQL code strings to parse as the hints.
    3095                If an `Expression` instance is passed, it will be used as-is.
    3096            dialect: The dialect used to parse the hints.
    3097            copy: If `False`, modify this expression instance in-place.
    3098
    3099        Returns:
    3100            The modified expression.
    3101        """
    3102        inst = _maybe_copy(self, copy)
    3103        inst.set(
    3104            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    3105        )
    3106
    3107        return inst
    3108
    3109    @property
    3110    def named_selects(self) -> t.List[str]:
    3111        return [e.output_name for e in self.expressions if e.alias_or_name]
    3112
    3113    @property
    3114    def is_star(self) -> bool:
    3115        return any(expression.is_star for expression in self.expressions)
    3116
    3117    @property
    3118    def selects(self) -> t.List[Expression]:
    3119        return self.expressions
    3120
    3121
    3122class Subquery(DerivedTable, Unionable):
    3123    arg_types = {
    3124        "this": True,
    3125        "alias": False,
    3126        "with": False,
    3127        **QUERY_MODIFIERS,
    3128    }
    3129
    3130    def unnest(self):
    3131        """
    3132        Returns the first non subquery.
    3133        """
    3134        expression = self
    3135        while isinstance(expression, Subquery):
    3136            expression = expression.this
    3137        return expression
    3138
    3139    @property
    3140    def is_star(self) -> bool:
    3141        return self.this.is_star
    3142
    3143    @property
    3144    def output_name(self) -> str:
    3145        return self.alias
    3146
    3147
    3148class TableSample(Expression):
    3149    arg_types = {
    3150        "this": False,
    3151        "method": False,
    3152        "bucket_numerator": False,
    3153        "bucket_denominator": False,
    3154        "bucket_field": False,
    3155        "percent": False,
    3156        "rows": False,
    3157        "size": False,
    3158        "seed": False,
    3159        "kind": False,
    3160    }
    3161
    3162
    3163class Tag(Expression):
    3164    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    3165
    3166    arg_types = {
    3167        "this": False,
    3168        "prefix": False,
    3169        "postfix": False,
    3170    }
    3171
    3172
    3173# Represents both the standard SQL PIVOT operator and DuckDB's "simplified" PIVOT syntax
    3174# https://duckdb.org/docs/sql/statements/pivot
    3175class Pivot(Expression):
    3176    arg_types = {
    3177        "this": False,
    3178        "alias": False,
    3179        "expressions": True,
    3180        "field": False,
    3181        "unpivot": False,
    3182        "using": False,
    3183        "group": False,
    3184        "columns": False,
    3185    }
    3186
    3187
    3188class Window(Expression):
    3189    arg_types = {
    3190        "this": True,
    3191        "partition_by": False,
    3192        "order": False,
    3193        "spec": False,
    3194        "alias": False,
    3195        "over": False,
    3196        "first": False,
    3197    }
    3198
    3199
    3200class WindowSpec(Expression):
    3201    arg_types = {
    3202        "kind": False,
    3203        "start": False,
    3204        "start_side": False,
    3205        "end": False,
    3206        "end_side": False,
    3207    }
    3208
    3209
    3210class Where(Expression):
    3211    pass
    3212
    3213
    3214class Star(Expression):
    3215    arg_types = {"except": False, "replace": False}
    3216
    3217    @property
    3218    def name(self) -> str:
    3219        return "*"
    3220
    3221    @property
    3222    def output_name(self) -> str:
    3223        return self.name
    3224
    3225
    3226class Parameter(Expression):
    3227    arg_types = {"this": True, "wrapped": False}
    3228
    3229
    3230class SessionParameter(Expression):
    3231    arg_types = {"this": True, "kind": False}
    3232
    3233
    3234class Placeholder(Expression):
    3235    arg_types = {"this": False, "kind": False}
    3236
    3237
    3238class Null(Condition):
    3239    arg_types: t.Dict[str, t.Any] = {}
    3240
    3241    @property
    3242    def name(self) -> str:
    3243        return "NULL"
    3244
    3245
    3246class Boolean(Condition):
    3247    pass
    3248
    3249
    3250class DataTypeSize(Expression):
    3251    arg_types = {"this": True, "expression": False}
    3252
    3253
    3254class DataType(Expression):
    3255    arg_types = {
    3256        "this": True,
    3257        "expressions": False,
    3258        "nested": False,
    3259        "values": False,
    3260        "prefix": False,
    3261    }
    3262
    3263    class Type(AutoName):
    3264        ARRAY = auto()
    3265        BIGDECIMAL = auto()
    3266        BIGINT = auto()
    3267        BIGSERIAL = auto()
    3268        BINARY = auto()
    3269        BIT = auto()
    3270        BOOLEAN = auto()
    3271        CHAR = auto()
    3272        DATE = auto()
    3273        DATETIME = auto()
    3274        DATETIME64 = auto()
    3275        ENUM = auto()
    3276        INT4RANGE = auto()
    3277        INT4MULTIRANGE = auto()
    3278        INT8RANGE = auto()
    3279        INT8MULTIRANGE = auto()
    3280        NUMRANGE = auto()
    3281        NUMMULTIRANGE = auto()
    3282        TSRANGE = auto()
    3283        TSMULTIRANGE = auto()
    3284        TSTZRANGE = auto()
    3285        TSTZMULTIRANGE = auto()
    3286        DATERANGE = auto()
    3287        DATEMULTIRANGE = auto()
    3288        DECIMAL = auto()
    3289        DOUBLE = auto()
    3290        FLOAT = auto()
    3291        GEOGRAPHY = auto()
    3292        GEOMETRY = auto()
    3293        HLLSKETCH = auto()
    3294        HSTORE = auto()
    3295        IMAGE = auto()
    3296        INET = auto()
    3297        INT = auto()
    3298        INT128 = auto()
    3299        INT256 = auto()
    3300        INTERVAL = auto()
    3301        JSON = auto()
    3302        JSONB = auto()
    3303        LONGBLOB = auto()
    3304        LONGTEXT = auto()
    3305        MAP = auto()
    3306        MEDIUMBLOB = auto()
    3307        MEDIUMTEXT = auto()
    3308        MONEY = auto()
    3309        NCHAR = auto()
    3310        NULL = auto()
    3311        NULLABLE = auto()
    3312        NVARCHAR = auto()
    3313        OBJECT = auto()
    3314        ROWVERSION = auto()
    3315        SERIAL = auto()
    3316        SET = auto()
    3317        SMALLINT = auto()
    3318        SMALLMONEY = auto()
    3319        SMALLSERIAL = auto()
    3320        STRUCT = auto()
    3321        SUPER = auto()
    3322        TEXT = auto()
    3323        TIME = auto()
    3324        TIMESTAMP = auto()
    3325        TIMESTAMPTZ = auto()
    3326        TIMESTAMPLTZ = auto()
    3327        TINYINT = auto()
    3328        UBIGINT = auto()
    3329        UINT = auto()
    3330        USMALLINT = auto()
    3331        UTINYINT = auto()
    3332        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    3333        UINT128 = auto()
    3334        UINT256 = auto()
    3335        UNIQUEIDENTIFIER = auto()
    3336        UUID = auto()
    3337        VARBINARY = auto()
    3338        VARCHAR = auto()
    3339        VARIANT = auto()
    3340        XML = auto()
    3341
    3342    TEXT_TYPES = {
    3343        Type.CHAR,
    3344        Type.NCHAR,
    3345        Type.VARCHAR,
    3346        Type.NVARCHAR,
    3347        Type.TEXT,
    3348    }
    3349
    3350    INTEGER_TYPES = {
    3351        Type.INT,
    3352        Type.TINYINT,
    3353        Type.SMALLINT,
    3354        Type.BIGINT,
    3355        Type.INT128,
    3356        Type.INT256,
    3357    }
    3358
    3359    FLOAT_TYPES = {
    3360        Type.FLOAT,
    3361        Type.DOUBLE,
    3362    }
    3363
    3364    NUMERIC_TYPES = {*INTEGER_TYPES, *FLOAT_TYPES}
    3365
    3366    TEMPORAL_TYPES = {
    3367        Type.TIME,
    3368        Type.TIMESTAMP,
    3369        Type.TIMESTAMPTZ,
    3370        Type.TIMESTAMPLTZ,
    3371        Type.DATE,
    3372        Type.DATETIME,
    3373        Type.DATETIME64,
    3374    }
    3375
    3376    @classmethod
    3377    def build(
    3378        cls, dtype: str | DataType | DataType.Type, dialect: DialectType = None, **kwargs
    3379    ) -> DataType:
    3380        from sqlglot import parse_one
    3381
    3382        if isinstance(dtype, str):
    3383            if dtype.upper() == "UNKNOWN":
    3384                data_type_exp: t.Optional[Expression] = DataType(this=DataType.Type.UNKNOWN)
    3385            else:
    3386                data_type_exp = parse_one(dtype, read=dialect, into=DataType)
    3387
    3388            if data_type_exp is None:
    3389                raise ValueError(f"Unparsable data type value: {dtype}")
    3390        elif isinstance(dtype, DataType.Type):
    3391            data_type_exp = DataType(this=dtype)
    3392        elif isinstance(dtype, DataType):
    3393            return dtype
    3394        else:
    3395            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    3396
    3397        return DataType(**{**data_type_exp.args, **kwargs})
    3398
    3399    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3400        return any(self.this == DataType.build(dtype).this for dtype in dtypes)
    3401
    3402
    3403# https://www.postgresql.org/docs/15/datatype-pseudo.html
    3404class PseudoType(Expression):
    3405    pass
    3406
    3407
    3408# WHERE x <OP> EXISTS|ALL|ANY|SOME(SELECT ...)
    3409class SubqueryPredicate(Predicate):
    3410    pass
    3411
    3412
    3413class All(SubqueryPredicate):
    3414    pass
    3415
    3416
    3417class Any(SubqueryPredicate):
    3418    pass
    3419
    3420
    3421class Exists(SubqueryPredicate):
    3422    pass
    3423
    3424
    3425# Commands to interact with the databases or engines. For most of the command
    3426# expressions we parse whatever comes after the command's name as a string.
    3427class Command(Expression):
    3428    arg_types = {"this": True, "expression": False}
    3429
    3430
    3431class Transaction(Expression):
    3432    arg_types = {"this": False, "modes": False}
    3433
    3434
    3435class Commit(Expression):
    3436    arg_types = {"chain": False}
    3437
    3438
    3439class Rollback(Expression):
    3440    arg_types = {"savepoint": False}
    3441
    3442
    3443class AlterTable(Expression):
    3444    arg_types = {"this": True, "actions": True, "exists": False}
    3445
    3446
    3447class AddConstraint(Expression):
    3448    arg_types = {"this": False, "expression": False, "enforced": False}
    3449
    3450
    3451class DropPartition(Expression):
    3452    arg_types = {"expressions": True, "exists": False}
    3453
    3454
    3455# Binary expressions like (ADD a b)
    3456class Binary(Condition):
    3457    arg_types = {"this": True, "expression": True}
    3458
    3459    @property
    3460    def left(self):
    3461        return self.this
    3462
    3463    @property
    3464    def right(self):
    3465        return self.expression
    3466
    3467
    3468class Add(Binary):
    3469    pass
    3470
    3471
    3472class Connector(Binary):
    3473    pass
    3474
    3475
    3476class And(Connector):
    3477    pass
    3478
    3479
    3480class Or(Connector):
    3481    pass
    3482
    3483
    3484class BitwiseAnd(Binary):
    3485    pass
    3486
    3487
    3488class BitwiseLeftShift(Binary):
    3489    pass
    3490
    3491
    3492class BitwiseOr(Binary):
    3493    pass
    3494
    3495
    3496class BitwiseRightShift(Binary):
    3497    pass
    3498
    3499
    3500class BitwiseXor(Binary):
    3501    pass
    3502
    3503
    3504class Div(Binary):
    3505    pass
    3506
    3507
    3508class Overlaps(Binary):
    3509    pass
    3510
    3511
    3512class Dot(Binary):
    3513    @property
    3514    def name(self) -> str:
    3515        return self.expression.name
    3516
    3517    @property
    3518    def output_name(self) -> str:
    3519        return self.name
    3520
    3521    @classmethod
    3522    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    3523        """Build a Dot object with a sequence of expressions."""
    3524        if len(expressions) < 2:
    3525            raise ValueError(f"Dot requires >= 2 expressions.")
    3526
    3527        a, b, *expressions = expressions
    3528        dot = Dot(this=a, expression=b)
    3529
    3530        for expression in expressions:
    3531            dot = Dot(this=dot, expression=expression)
    3532
    3533        return dot
    3534
    3535
    3536class DPipe(Binary):
    3537    pass
    3538
    3539
    3540class SafeDPipe(DPipe):
    3541    pass
    3542
    3543
    3544class EQ(Binary, Predicate):
    3545    pass
    3546
    3547
    3548class NullSafeEQ(Binary, Predicate):
    3549    pass
    3550
    3551
    3552class NullSafeNEQ(Binary, Predicate):
    3553    pass
    3554
    3555
    3556class Distance(Binary):
    3557    pass
    3558
    3559
    3560class Escape(Binary):
    3561    pass
    3562
    3563
    3564class Glob(Binary, Predicate):
    3565    pass
    3566
    3567
    3568class GT(Binary, Predicate):
    3569    pass
    3570
    3571
    3572class GTE(Binary, Predicate):
    3573    pass
    3574
    3575
    3576class ILike(Binary, Predicate):
    3577    pass
    3578
    3579
    3580class ILikeAny(Binary, Predicate):
    3581    pass
    3582
    3583
    3584class IntDiv(Binary):
    3585    pass
    3586
    3587
    3588class Is(Binary, Predicate):
    3589    pass
    3590
    3591
    3592class Kwarg(Binary):
    3593    """Kwarg in special functions like func(kwarg => y)."""
    3594
    3595
    3596class Like(Binary, Predicate):
    3597    pass
    3598
    3599
    3600class LikeAny(Binary, Predicate):
    3601    pass
    3602
    3603
    3604class LT(Binary, Predicate):
    3605    pass
    3606
    3607
    3608class LTE(Binary, Predicate):
    3609    pass
    3610
    3611
    3612class Mod(Binary):
    3613    pass
    3614
    3615
    3616class Mul(Binary):
    3617    pass
    3618
    3619
    3620class NEQ(Binary, Predicate):
    3621    pass
    3622
    3623
    3624class SimilarTo(Binary, Predicate):
    3625    pass
    3626
    3627
    3628class Slice(Binary):
    3629    arg_types = {"this": False, "expression": False}
    3630
    3631
    3632class Sub(Binary):
    3633    pass
    3634
    3635
    3636class ArrayOverlaps(Binary):
    3637    pass
    3638
    3639
    3640# Unary Expressions
    3641# (NOT a)
    3642class Unary(Condition):
    3643    pass
    3644
    3645
    3646class BitwiseNot(Unary):
    3647    pass
    3648
    3649
    3650class Not(Unary):
    3651    pass
    3652
    3653
    3654class Paren(Unary):
    3655    arg_types = {"this": True, "with": False}
    3656
    3657    @property
    3658    def output_name(self) -> str:
    3659        return self.this.name
    3660
    3661
    3662class Neg(Unary):
    3663    pass
    3664
    3665
    3666class Alias(Expression):
    3667    arg_types = {"this": True, "alias": False}
    3668
    3669    @property
    3670    def output_name(self) -> str:
    3671        return self.alias
    3672
    3673
    3674class Aliases(Expression):
    3675    arg_types = {"this": True, "expressions": True}
    3676
    3677    @property
    3678    def aliases(self):
    3679        return self.expressions
    3680
    3681
    3682class AtTimeZone(Expression):
    3683    arg_types = {"this": True, "zone": True}
    3684
    3685
    3686class Between(Predicate):
    3687    arg_types = {"this": True, "low": True, "high": True}
    3688
    3689
    3690class Bracket(Condition):
    3691    arg_types = {"this": True, "expressions": True}
    3692
    3693
    3694class Distinct(Expression):
    3695    arg_types = {"expressions": False, "on": False}
    3696
    3697
    3698class In(Predicate):
    3699    arg_types = {
    3700        "this": True,
    3701        "expressions": False,
    3702        "query": False,
    3703        "unnest": False,
    3704        "field": False,
    3705        "is_global": False,
    3706    }
    3707
    3708
    3709class TimeUnit(Expression):
    3710    """Automatically converts unit arg into a var."""
    3711
    3712    arg_types = {"unit": False}
    3713
    3714    def __init__(self, **args):
    3715        unit = args.get("unit")
    3716        if isinstance(unit, (Column, Literal)):
    3717            args["unit"] = Var(this=unit.name)
    3718        elif isinstance(unit, Week):
    3719            unit.set("this", Var(this=unit.this.name))
    3720
    3721        super().__init__(**args)
    3722
    3723
    3724class Interval(TimeUnit):
    3725    arg_types = {"this": False, "unit": False}
    3726
    3727    @property
    3728    def unit(self) -> t.Optional[Var]:
    3729        return self.args.get("unit")
    3730
    3731
    3732class IgnoreNulls(Expression):
    3733    pass
    3734
    3735
    3736class RespectNulls(Expression):
    3737    pass
    3738
    3739
    3740# Functions
    3741class Func(Condition):
    3742    """
    3743    The base class for all function expressions.
    3744
    3745    Attributes:
    3746        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    3747            treated as a variable length argument and the argument's value will be stored as a list.
    3748        _sql_names (list): determines the SQL name (1st item in the list) and aliases (subsequent items)
    3749            for this function expression. These values are used to map this node to a name during parsing
    3750            as well as to provide the function's name during SQL string generation. By default the SQL
    3751            name is set to the expression's class name transformed to snake case.
    3752    """
    3753
    3754    is_var_len_args = False
    3755
    3756    @classmethod
    3757    def from_arg_list(cls, args):
    3758        if cls.is_var_len_args:
    3759            all_arg_keys = list(cls.arg_types)
    3760            # If this function supports variable length argument treat the last argument as such.
    3761            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    3762            num_non_var = len(non_var_len_arg_keys)
    3763
    3764            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    3765            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    3766        else:
    3767            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    3768
    3769        return cls(**args_dict)
    3770
    3771    @classmethod
    3772    def sql_names(cls):
    3773        if cls is Func:
    3774            raise NotImplementedError(
    3775                "SQL name is only supported by concrete function implementations"
    3776            )
    3777        if "_sql_names" not in cls.__dict__:
    3778            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    3779        return cls._sql_names
    3780
    3781    @classmethod
    3782    def sql_name(cls):
    3783        return cls.sql_names()[0]
    3784
    3785    @classmethod
    3786    def default_parser_mappings(cls):
    3787        return {name: cls.from_arg_list for name in cls.sql_names()}
    3788
    3789
    3790class AggFunc(Func):
    3791    pass
    3792
    3793
    3794class ParameterizedAgg(AggFunc):
    3795    arg_types = {"this": True, "expressions": True, "params": True}
    3796
    3797
    3798class Abs(Func):
    3799    pass
    3800
    3801
    3802class Anonymous(Func):
    3803    arg_types = {"this": True, "expressions": False}
    3804    is_var_len_args = True
    3805
    3806
    3807# https://docs.snowflake.com/en/sql-reference/functions/hll
    3808# https://docs.aws.amazon.com/redshift/latest/dg/r_HLL_function.html
    3809class Hll(AggFunc):
    3810    arg_types = {"this": True, "expressions": False}
    3811    is_var_len_args = True
    3812
    3813
    3814class ApproxDistinct(AggFunc):
    3815    arg_types = {"this": True, "accuracy": False}
    3816    _sql_names = ["APPROX_DISTINCT", "APPROX_COUNT_DISTINCT"]
    3817
    3818
    3819class Array(Func):
    3820    arg_types = {"expressions": False}
    3821    is_var_len_args = True
    3822
    3823
    3824# https://docs.snowflake.com/en/sql-reference/functions/to_char
    3825class ToChar(Func):
    3826    arg_types = {"this": True, "format": False}
    3827
    3828
    3829class GenerateSeries(Func):
    3830    arg_types = {"start": True, "end": True, "step": False}
    3831
    3832
    3833class ArrayAgg(AggFunc):
    3834    pass
    3835
    3836
    3837class ArrayAll(Func):
    3838    arg_types = {"this": True, "expression": True}
    3839
    3840
    3841class ArrayAny(Func):
    3842    arg_types = {"this": True, "expression": True}
    3843
    3844
    3845class ArrayConcat(Func):
    3846    arg_types = {"this": True, "expressions": False}
    3847    is_var_len_args = True
    3848
    3849
    3850class ArrayContains(Binary, Func):
    3851    pass
    3852
    3853
    3854class ArrayContained(Binary):
    3855    pass
    3856
    3857
    3858class ArrayFilter(Func):
    3859    arg_types = {"this": True, "expression": True}
    3860    _sql_names = ["FILTER", "ARRAY_FILTER"]
    3861
    3862
    3863class ArrayJoin(Func):
    3864    arg_types = {"this": True, "expression": True, "null": False}
    3865
    3866
    3867class ArraySize(Func):
    3868    arg_types = {"this": True, "expression": False}
    3869
    3870
    3871class ArraySort(Func):
    3872    arg_types = {"this": True, "expression": False}
    3873
    3874
    3875class ArraySum(Func):
    3876    pass
    3877
    3878
    3879class ArrayUnionAgg(AggFunc):
    3880    pass
    3881
    3882
    3883class Avg(AggFunc):
    3884    pass
    3885
    3886
    3887class AnyValue(AggFunc):
    3888    pass
    3889
    3890
    3891class Case(Func):
    3892    arg_types = {"this": False, "ifs": True, "default": False}
    3893
    3894    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    3895        instance = _maybe_copy(self, copy)
    3896        instance.append(
    3897            "ifs",
    3898            If(
    3899                this=maybe_parse(condition, copy=copy, **opts),
    3900                true=maybe_parse(then, copy=copy, **opts),
    3901            ),
    3902        )
    3903        return instance
    3904
    3905    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    3906        instance = _maybe_copy(self, copy)
    3907        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    3908        return instance
    3909
    3910
    3911class Cast(Func):
    3912    arg_types = {"this": True, "to": True}
    3913
    3914    @property
    3915    def name(self) -> str:
    3916        return self.this.name
    3917
    3918    @property
    3919    def to(self) -> DataType:
    3920        return self.args["to"]
    3921
    3922    @property
    3923    def output_name(self) -> str:
    3924        return self.name
    3925
    3926    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3927        return self.to.is_type(*dtypes)
    3928
    3929
    3930class CastToStrType(Func):
    3931    arg_types = {"this": True, "expression": True}
    3932
    3933
    3934class Collate(Binary):
    3935    pass
    3936
    3937
    3938class TryCast(Cast):
    3939    pass
    3940
    3941
    3942class Ceil(Func):
    3943    arg_types = {"this": True, "decimals": False}
    3944    _sql_names = ["CEIL", "CEILING"]
    3945
    3946
    3947class Coalesce(Func):
    3948    arg_types = {"this": True, "expressions": False}
    3949    is_var_len_args = True
    3950    _sql_names = ["COALESCE", "IFNULL", "NVL"]
    3951
    3952
    3953class Concat(Func):
    3954    arg_types = {"expressions": True}
    3955    is_var_len_args = True
    3956
    3957
    3958class SafeConcat(Concat):
    3959    pass
    3960
    3961
    3962class ConcatWs(Concat):
    3963    _sql_names = ["CONCAT_WS"]
    3964
    3965
    3966class Count(AggFunc):
    3967    arg_types = {"this": False, "expressions": False}
    3968    is_var_len_args = True
    3969
    3970
    3971class CountIf(AggFunc):
    3972    pass
    3973
    3974
    3975class CurrentDate(Func):
    3976    arg_types = {"this": False}
    3977
    3978
    3979class CurrentDatetime(Func):
    3980    arg_types = {"this": False}
    3981
    3982
    3983class CurrentTime(Func):
    3984    arg_types = {"this": False}
    3985
    3986
    3987class CurrentTimestamp(Func):
    3988    arg_types = {"this": False}
    3989
    3990
    3991class CurrentUser(Func):
    3992    arg_types = {"this": False}
    3993
    3994
    3995class DateAdd(Func, TimeUnit):
    3996    arg_types = {"this": True, "expression": True, "unit": False}
    3997
    3998
    3999class DateSub(Func, TimeUnit):
    4000    arg_types = {"this": True, "expression": True, "unit": False}
    4001
    4002
    4003class DateDiff(Func, TimeUnit):
    4004    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    4005    arg_types = {"this": True, "expression": True, "unit": False}
    4006
    4007
    4008class DateTrunc(Func):
    4009    arg_types = {"unit": True, "this": True, "zone": False}
    4010
    4011
    4012class DatetimeAdd(Func, TimeUnit):
    4013    arg_types = {"this": True, "expression": True, "unit": False}
    4014
    4015
    4016class DatetimeSub(Func, TimeUnit):
    4017    arg_types = {"this": True, "expression": True, "unit": False}
    4018
    4019
    4020class DatetimeDiff(Func, TimeUnit):
    4021    arg_types = {"this": True, "expression": True, "unit": False}
    4022
    4023
    4024class DatetimeTrunc(Func, TimeUnit):
    4025    arg_types = {"this": True, "unit": True, "zone": False}
    4026
    4027
    4028class DayOfWeek(Func):
    4029    _sql_names = ["DAY_OF_WEEK", "DAYOFWEEK"]
    4030
    4031
    4032class DayOfMonth(Func):
    4033    _sql_names = ["DAY_OF_MONTH", "DAYOFMONTH"]
    4034
    4035
    4036class DayOfYear(Func):
    4037    _sql_names = ["DAY_OF_YEAR", "DAYOFYEAR"]
    4038
    4039
    4040class WeekOfYear(Func):
    4041    _sql_names = ["WEEK_OF_YEAR", "WEEKOFYEAR"]
    4042
    4043
    4044class LastDateOfMonth(Func):
    4045    pass
    4046
    4047
    4048class Extract(Func):
    4049    arg_types = {"this": True, "expression": True}
    4050
    4051
    4052class TimestampAdd(Func, TimeUnit):
    4053    arg_types = {"this": True, "expression": True, "unit": False}
    4054
    4055
    4056class TimestampSub(Func, TimeUnit):
    4057    arg_types = {"this": True, "expression": True, "unit": False}
    4058
    4059
    4060class TimestampDiff(Func, TimeUnit):
    4061    arg_types = {"this": True, "expression": True, "unit": False}
    4062
    4063
    4064class TimestampTrunc(Func, TimeUnit):
    4065    arg_types = {"this": True, "unit": True, "zone": False}
    4066
    4067
    4068class TimeAdd(Func, TimeUnit):
    4069    arg_types = {"this": True, "expression": True, "unit": False}
    4070
    4071
    4072class TimeSub(Func, TimeUnit):
    4073    arg_types = {"this": True, "expression": True, "unit": False}
    4074
    4075
    4076class TimeDiff(Func, TimeUnit):
    4077    arg_types = {"this": True, "expression": True, "unit": False}
    4078
    4079
    4080class TimeTrunc(Func, TimeUnit):
    4081    arg_types = {"this": True, "unit": True, "zone": False}
    4082
    4083
    4084class DateFromParts(Func):
    4085    _sql_names = ["DATEFROMPARTS"]
    4086    arg_types = {"year": True, "month": True, "day": True}
    4087
    4088
    4089class DateStrToDate(Func):
    4090    pass
    4091
    4092
    4093class DateToDateStr(Func):
    4094    pass
    4095
    4096
    4097class DateToDi(Func):
    4098    pass
    4099
    4100
    4101class Date(Func):
    4102    arg_types = {"expressions": True}
    4103    is_var_len_args = True
    4104
    4105
    4106class Day(Func):
    4107    pass
    4108
    4109
    4110class Decode(Func):
    4111    arg_types = {"this": True, "charset": True, "replace": False}
    4112
    4113
    4114class DiToDate(Func):
    4115    pass
    4116
    4117
    4118class Encode(Func):
    4119    arg_types = {"this": True, "charset": True}
    4120
    4121
    4122class Exp(Func):
    4123    pass
    4124
    4125
    4126class Explode(Func):
    4127    pass
    4128
    4129
    4130class Floor(Func):
    4131    arg_types = {"this": True, "decimals": False}
    4132
    4133
    4134class FromBase64(Func):
    4135    pass
    4136
    4137
    4138class ToBase64(Func):
    4139    pass
    4140
    4141
    4142class Greatest(Func):
    4143    arg_types = {"this": True, "expressions": False}
    4144    is_var_len_args = True
    4145
    4146
    4147class GroupConcat(Func):
    4148    arg_types = {"this": True, "separator": False}
    4149
    4150
    4151class Hex(Func):
    4152    pass
    4153
    4154
    4155class If(Func):
    4156    arg_types = {"this": True, "true": True, "false": False}
    4157
    4158
    4159class Initcap(Func):
    4160    arg_types = {"this": True, "expression": False}
    4161
    4162
    4163class JSONKeyValue(Expression):
    4164    arg_types = {"this": True, "expression": True}
    4165
    4166
    4167class JSONObject(Func):
    4168    arg_types = {
    4169        "expressions": False,
    4170        "null_handling": False,
    4171        "unique_keys": False,
    4172        "return_type": False,
    4173        "format_json": False,
    4174        "encoding": False,
    4175    }
    4176
    4177
    4178class OpenJSONColumnDef(Expression):
    4179    arg_types = {"this": True, "kind": True, "path": False, "as_json": False}
    4180
    4181
    4182class OpenJSON(Func):
    4183    arg_types = {"this": True, "path": False, "expressions": False}
    4184
    4185
    4186class JSONBContains(Binary):
    4187    _sql_names = ["JSONB_CONTAINS"]
    4188
    4189
    4190class JSONExtract(Binary, Func):
    4191    _sql_names = ["JSON_EXTRACT"]
    4192
    4193
    4194class JSONExtractScalar(JSONExtract):
    4195    _sql_names = ["JSON_EXTRACT_SCALAR"]
    4196
    4197
    4198class JSONBExtract(JSONExtract):
    4199    _sql_names = ["JSONB_EXTRACT"]
    4200
    4201
    4202class JSONBExtractScalar(JSONExtract):
    4203    _sql_names = ["JSONB_EXTRACT_SCALAR"]
    4204
    4205
    4206class JSONFormat(Func):
    4207    arg_types = {"this": False, "options": False}
    4208    _sql_names = ["JSON_FORMAT"]
    4209
    4210
    4211class Least(Func):
    4212    arg_types = {"expressions": False}
    4213    is_var_len_args = True
    4214
    4215
    4216class Left(Func):
    4217    arg_types = {"this": True, "expression": True}
    4218
    4219
    4220class Right(Func):
    4221    arg_types = {"this": True, "expression": True}
    4222
    4223
    4224class Length(Func):
    4225    _sql_names = ["LENGTH", "LEN"]
    4226
    4227
    4228class Levenshtein(Func):
    4229    arg_types = {
    4230        "this": True,
    4231        "expression": False,
    4232        "ins_cost": False,
    4233        "del_cost": False,
    4234        "sub_cost": False,
    4235    }
    4236
    4237
    4238class Ln(Func):
    4239    pass
    4240
    4241
    4242class Log(Func):
    4243    arg_types = {"this": True, "expression": False}
    4244
    4245
    4246class Log2(Func):
    4247    pass
    4248
    4249
    4250class Log10(Func):
    4251    pass
    4252
    4253
    4254class LogicalOr(AggFunc):
    4255    _sql_names = ["LOGICAL_OR", "BOOL_OR", "BOOLOR_AGG"]
    4256
    4257
    4258class LogicalAnd(AggFunc):
    4259    _sql_names = ["LOGICAL_AND", "BOOL_AND", "BOOLAND_AGG"]
    4260
    4261
    4262class Lower(Func):
    4263    _sql_names = ["LOWER", "LCASE"]
    4264
    4265
    4266class Map(Func):
    4267    arg_types = {"keys": False, "values": False}
    4268
    4269
    4270class StarMap(Func):
    4271    pass
    4272
    4273
    4274class VarMap(Func):
    4275    arg_types = {"keys": True, "values": True}
    4276    is_var_len_args = True
    4277
    4278    @property
    4279    def keys(self) -> t.List[Expression]:
    4280        return self.args["keys"].expressions
    4281
    4282    @property
    4283    def values(self) -> t.List[Expression]:
    4284        return self.args["values"].expressions
    4285
    4286
    4287# https://dev.mysql.com/doc/refman/8.0/en/fulltext-search.html
    4288class MatchAgainst(Func):
    4289    arg_types = {"this": True, "expressions": True, "modifier": False}
    4290
    4291
    4292class Max(AggFunc):
    4293    arg_types = {"this": True, "expressions": False}
    4294    is_var_len_args = True
    4295
    4296
    4297class MD5(Func):
    4298    _sql_names = ["MD5"]
    4299
    4300
    4301class Min(AggFunc):
    4302    arg_types = {"this": True, "expressions": False}
    4303    is_var_len_args = True
    4304
    4305
    4306class Month(Func):
    4307    pass
    4308
    4309
    4310class Nvl2(Func):
    4311    arg_types = {"this": True, "true": True, "false": False}
    4312
    4313
    4314class Posexplode(Func):
    4315    pass
    4316
    4317
    4318class Pow(Binary, Func):
    4319    _sql_names = ["POWER", "POW"]
    4320
    4321
    4322class PercentileCont(AggFunc):
    4323    arg_types = {"this": True, "expression": False}
    4324
    4325
    4326class PercentileDisc(AggFunc):
    4327    arg_types = {"this": True, "expression": False}
    4328
    4329
    4330class Quantile(AggFunc):
    4331    arg_types = {"this": True, "quantile": True}
    4332
    4333
    4334class ApproxQuantile(Quantile):
    4335    arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}
    4336
    4337
    4338class RangeN(Func):
    4339    arg_types = {"this": True, "expressions": True, "each": False}
    4340
    4341
    4342class ReadCSV(Func):
    4343    _sql_names = ["READ_CSV"]
    4344    is_var_len_args = True
    4345    arg_types = {"this": True, "expressions": False}
    4346
    4347
    4348class Reduce(Func):
    4349    arg_types = {"this": True, "initial": True, "merge": True, "finish": False}
    4350
    4351
    4352class RegexpExtract(Func):
    4353    arg_types = {
    4354        "this": True,
    4355        "expression": True,
    4356        "position": False,
    4357        "occurrence": False,
    4358        "group": False,
    4359    }
    4360
    4361
    4362class RegexpLike(Func):
    4363    arg_types = {"this": True, "expression": True, "flag": False}
    4364
    4365
    4366class RegexpILike(Func):
    4367    arg_types = {"this": True, "expression": True, "flag": False}
    4368
    4369
    4370# https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.split.html
    4371# limit is the number of times a pattern is applied
    4372class RegexpSplit(Func):
    4373    arg_types = {"this": True, "expression": True, "limit": False}
    4374
    4375
    4376class Repeat(Func):
    4377    arg_types = {"this": True, "times": True}
    4378
    4379
    4380class Round(Func):
    4381    arg_types = {"this": True, "decimals": False}
    4382
    4383
    4384class RowNumber(Func):
    4385    arg_types: t.Dict[str, t.Any] = {}
    4386
    4387
    4388class SafeDivide(Func):
    4389    arg_types = {"this": True, "expression": True}
    4390
    4391
    4392class SetAgg(AggFunc):
    4393    pass
    4394
    4395
    4396class SHA(Func):
    4397    _sql_names = ["SHA", "SHA1"]
    4398
    4399
    4400class SHA2(Func):
    4401    _sql_names = ["SHA2"]
    4402    arg_types = {"this": True, "length": False}
    4403
    4404
    4405class SortArray(Func):
    4406    arg_types = {"this": True, "asc": False}
    4407
    4408
    4409class Split(Func):
    4410    arg_types = {"this": True, "expression": True, "limit": False}
    4411
    4412
    4413# Start may be omitted in the case of postgres
    4414# https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
    4415class Substring(Func):
    4416    arg_types = {"this": True, "start": False, "length": False}
    4417
    4418
    4419class StandardHash(Func):
    4420    arg_types = {"this": True, "expression": False}
    4421
    4422
    4423class StrPosition(Func):
    4424    arg_types = {
    4425        "this": True,
    4426        "substr": True,
    4427        "position": False,
    4428        "instance": False,
    4429    }
    4430
    4431
    4432class StrToDate(Func):
    4433    arg_types = {"this": True, "format": True}
    4434
    4435
    4436class StrToTime(Func):
    4437    arg_types = {"this": True, "format": True}
    4438
    4439
    4440# Spark allows unix_timestamp()
    4441# https://spark.apache.org/docs/3.1.3/api/python/reference/api/pyspark.sql.functions.unix_timestamp.html
    4442class StrToUnix(Func):
    4443    arg_types = {"this": False, "format": False}
    4444
    4445
    4446class NumberToStr(Func):
    4447    arg_types = {"this": True, "format": True}
    4448
    4449
    4450class FromBase(Func):
    4451    arg_types = {"this": True, "expression": True}
    4452
    4453
    4454class Struct(Func):
    4455    arg_types = {"expressions": True}
    4456    is_var_len_args = True
    4457
    4458
    4459class StructExtract(Func):
    4460    arg_types = {"this": True, "expression": True}
    4461
    4462
    4463class Sum(AggFunc):
    4464    pass
    4465
    4466
    4467class Sqrt(Func):
    4468    pass
    4469
    4470
    4471class Stddev(AggFunc):
    4472    pass
    4473
    4474
    4475class StddevPop(AggFunc):
    4476    pass
    4477
    4478
    4479class StddevSamp(AggFunc):
    4480    pass
    4481
    4482
    4483class TimeToStr(Func):
    4484    arg_types = {"this": True, "format": True}
    4485
    4486
    4487class TimeToTimeStr(Func):
    4488    pass
    4489
    4490
    4491class TimeToUnix(Func):
    4492    pass
    4493
    4494
    4495class TimeStrToDate(Func):
    4496    pass
    4497
    4498
    4499class TimeStrToTime(Func):
    4500    pass
    4501
    4502
    4503class TimeStrToUnix(Func):
    4504    pass
    4505
    4506
    4507class Trim(Func):
    4508    arg_types = {
    4509        "this": True,
    4510        "expression": False,
    4511        "position": False,
    4512        "collation": False,
    4513    }
    4514
    4515
    4516class TsOrDsAdd(Func, TimeUnit):
    4517    arg_types = {"this": True, "expression": True, "unit": False}
    4518
    4519
    4520class TsOrDsToDateStr(Func):
    4521    pass
    4522
    4523
    4524class TsOrDsToDate(Func):
    4525    arg_types = {"this": True, "format": False}
    4526
    4527
    4528class TsOrDiToDi(Func):
    4529    pass
    4530
    4531
    4532class Unhex(Func):
    4533    pass
    4534
    4535
    4536class UnixToStr(Func):
    4537    arg_types = {"this": True, "format": False}
    4538
    4539
    4540# https://prestodb.io/docs/current/functions/datetime.html
    4541# presto has weird zone/hours/minutes
    4542class UnixToTime(Func):
    4543    arg_types = {"this": True, "scale": False, "zone": False, "hours": False, "minutes": False}
    4544
    4545    SECONDS = Literal.string("seconds")
    4546    MILLIS = Literal.string("millis")
    4547    MICROS = Literal.string("micros")
    4548
    4549
    4550class UnixToTimeStr(Func):
    4551    pass
    4552
    4553
    4554class Upper(Func):
    4555    _sql_names = ["UPPER", "UCASE"]
    4556
    4557
    4558class Variance(AggFunc):
    4559    _sql_names = ["VARIANCE", "VARIANCE_SAMP", "VAR_SAMP"]
    4560
    4561
    4562class VariancePop(AggFunc):
    4563    _sql_names = ["VARIANCE_POP", "VAR_POP"]
    4564
    4565
    4566class Week(Func):
    4567    arg_types = {"this": True, "mode": False}
    4568
    4569
    4570class XMLTable(Func):
    4571    arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}
    4572
    4573
    4574class Year(Func):
    4575    pass
    4576
    4577
    4578class Use(Expression):
    4579    arg_types = {"this": True, "kind": False}
    4580
    4581
    4582class Merge(Expression):
    4583    arg_types = {"this": True, "using": True, "on": True, "expressions": True}
    4584
    4585
    4586class When(Func):
    4587    arg_types = {"matched": True, "source": False, "condition": False, "then": True}
    4588
    4589
    4590# https://docs.oracle.com/javadb/10.8.3.0/ref/rrefsqljnextvaluefor.html
    4591# https://learn.microsoft.com/en-us/sql/t-sql/functions/next-value-for-transact-sql?view=sql-server-ver16
    4592class NextValueFor(Func):
    4593    arg_types = {"this": True, "order": False}
    4594
    4595
    4596def _norm_arg(arg):
    4597    return arg.lower() if type(arg) is str else arg
    4598
    4599
    4600ALL_FUNCTIONS = subclasses(__name__, Func, (AggFunc, Anonymous, Func))
    4601
    4602
    4603# Helpers
    4604@t.overload
    4605def maybe_parse(
    4606    sql_or_expression: ExpOrStr,
    4607    *,
    4608    into: t.Type[E],
    4609    dialect: DialectType = None,
    4610    prefix: t.Optional[str] = None,
    4611    copy: bool = False,
    4612    **opts,
    4613) -> E:
    4614    ...
    4615
    4616
    4617@t.overload
    4618def maybe_parse(
    4619    sql_or_expression: str | E,
    4620    *,
    4621    into: t.Optional[IntoType] = None,
    4622    dialect: DialectType = None,
    4623    prefix: t.Optional[str] = None,
    4624    copy: bool = False,
    4625    **opts,
    4626) -> E:
    4627    ...
    4628
    4629
    4630def maybe_parse(
    4631    sql_or_expression: ExpOrStr,
    4632    *,
    4633    into: t.Optional[IntoType] = None,
    4634    dialect: DialectType = None,
    4635    prefix: t.Optional[str] = None,
    4636    copy: bool = False,
    4637    **opts,
    4638) -> Expression:
    4639    """Gracefully handle a possible string or expression.
    4640
    4641    Example:
    4642        >>> maybe_parse("1")
    4643        (LITERAL this: 1, is_string: False)
    4644        >>> maybe_parse(to_identifier("x"))
    4645        (IDENTIFIER this: x, quoted: False)
    4646
    4647    Args:
    4648        sql_or_expression: the SQL code string or an expression
    4649        into: the SQLGlot Expression to parse into
    4650        dialect: the dialect used to parse the input expressions (in the case that an
    4651            input expression is a SQL string).
    4652        prefix: a string to prefix the sql with before it gets parsed
    4653            (automatically includes a space)
    4654        copy: whether or not to copy the expression.
    4655        **opts: other options to use to parse the input expressions (again, in the case
    4656            that an input expression is a SQL string).
    4657
    4658    Returns:
    4659        Expression: the parsed or given expression.
    4660    """
    4661    if isinstance(sql_or_expression, Expression):
    4662        if copy:
    4663            return sql_or_expression.copy()
    4664        return sql_or_expression
    4665
    4666    if sql_or_expression is None:
    4667        raise ParseError(f"SQL cannot be None")
    4668
    4669    import sqlglot
    4670
    4671    sql = str(sql_or_expression)
    4672    if prefix:
    4673        sql = f"{prefix} {sql}"
    4674
    4675    return sqlglot.parse_one(sql, read=dialect, into=into, **opts)
    4676
    4677
    4678def _maybe_copy(instance: E, copy: bool = True) -> E:
    4679    return instance.copy() if copy else instance
    4680
    4681
    4682def _is_wrong_expression(expression, into):
    4683    return isinstance(expression, Expression) and not isinstance(expression, into)
    4684
    4685
    4686def _apply_builder(
    4687    expression,
    4688    instance,
    4689    arg,
    4690    copy=True,
    4691    prefix=None,
    4692    into=None,
    4693    dialect=None,
    4694    **opts,
    4695):
    4696    if _is_wrong_expression(expression, into):
    4697        expression = into(this=expression)
    4698    instance = _maybe_copy(instance, copy)
    4699    expression = maybe_parse(
    4700        sql_or_expression=expression,
    4701        prefix=prefix,
    4702        into=into,
    4703        dialect=dialect,
    4704        **opts,
    4705    )
    4706    instance.set(arg, expression)
    4707    return instance
    4708
    4709
    4710def _apply_child_list_builder(
    4711    *expressions,
    4712    instance,
    4713    arg,
    4714    append=True,
    4715    copy=True,
    4716    prefix=None,
    4717    into=None,
    4718    dialect=None,
    4719    properties=None,
    4720    **opts,
    4721):
    4722    instance = _maybe_copy(instance, copy)
    4723    parsed = []
    4724    for expression in expressions:
    4725        if expression is not None:
    4726            if _is_wrong_expression(expression, into):
    4727                expression = into(expressions=[expression])
    4728
    4729            expression = maybe_parse(
    4730                expression,
    4731                into=into,
    4732                dialect=dialect,
    4733                prefix=prefix,
    4734                **opts,
    4735            )
    4736            parsed.extend(expression.expressions)
    4737
    4738    existing = instance.args.get(arg)
    4739    if append and existing:
    4740        parsed = existing.expressions + parsed
    4741
    4742    child = into(expressions=parsed)
    4743    for k, v in (properties or {}).items():
    4744        child.set(k, v)
    4745    instance.set(arg, child)
    4746
    4747    return instance
    4748
    4749
    4750def _apply_list_builder(
    4751    *expressions,
    4752    instance,
    4753    arg,
    4754    append=True,
    4755    copy=True,
    4756    prefix=None,
    4757    into=None,
    4758    dialect=None,
    4759    **opts,
    4760):
    4761    inst = _maybe_copy(instance, copy)
    4762
    4763    expressions = [
    4764        maybe_parse(
    4765            sql_or_expression=expression,
    4766            into=into,
    4767            prefix=prefix,
    4768            dialect=dialect,
    4769            **opts,
    4770        )
    4771        for expression in expressions
    4772        if expression is not None
    4773    ]
    4774
    4775    existing_expressions = inst.args.get(arg)
    4776    if append and existing_expressions:
    4777        expressions = existing_expressions + expressions
    4778
    4779    inst.set(arg, expressions)
    4780    return inst
    4781
    4782
    4783def _apply_conjunction_builder(
    4784    *expressions,
    4785    instance,
    4786    arg,
    4787    into=None,
    4788    append=True,
    4789    copy=True,
    4790    dialect=None,
    4791    **opts,
    4792):
    4793    expressions = [exp for exp in expressions if exp is not None and exp != ""]
    4794    if not expressions:
    4795        return instance
    4796
    4797    inst = _maybe_copy(instance, copy)
    4798
    4799    existing = inst.args.get(arg)
    4800    if append and existing is not None:
    4801        expressions = [existing.this if into else existing] + list(expressions)
    4802
    4803    node = and_(*expressions, dialect=dialect, copy=copy, **opts)
    4804
    4805    inst.set(arg, into(this=node) if into else node)
    4806    return inst
    4807
    4808
    4809def _apply_cte_builder(
    4810    instance: E,
    4811    alias: ExpOrStr,
    4812    as_: ExpOrStr,
    4813    recursive: t.Optional[bool] = None,
    4814    append: bool = True,
    4815    dialect: DialectType = None,
    4816    copy: bool = True,
    4817    **opts,
    4818) -> E:
    4819    alias_expression = maybe_parse(alias, dialect=dialect, into=TableAlias, **opts)
    4820    as_expression = maybe_parse(as_, dialect=dialect, **opts)
    4821    cte = CTE(this=as_expression, alias=alias_expression)
    4822    return _apply_child_list_builder(
    4823        cte,
    4824        instance=instance,
    4825        arg="with",
    4826        append=append,
    4827        copy=copy,
    4828        into=With,
    4829        properties={"recursive": recursive or False},
    4830    )
    4831
    4832
    4833def _combine(
    4834    expressions: t.Sequence[t.Optional[ExpOrStr]],
    4835    operator: t.Type[Connector],
    4836    dialect: DialectType = None,
    4837    copy: bool = True,
    4838    **opts,
    4839) -> Expression:
    4840    conditions = [
    4841        condition(expression, dialect=dialect, copy=copy, **opts)
    4842        for expression in expressions
    4843        if expression is not None
    4844    ]
    4845
    4846    this, *rest = conditions
    4847    if rest:
    4848        this = _wrap(this, Connector)
    4849    for expression in rest:
    4850        this = operator(this=this, expression=_wrap(expression, Connector))
    4851
    4852    return this
    4853
    4854
    4855def _wrap(expression: E, kind: t.Type[Expression]) -> E | Paren:
    4856    return Paren(this=expression) if isinstance(expression, kind) else expression
    4857
    4858
    4859def union(
    4860    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    4861) -> Union:
    4862    """
    4863    Initializes a syntax tree from one UNION expression.
    4864
    4865    Example:
    4866        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    4867        'SELECT * FROM foo UNION SELECT * FROM bla'
    4868
    4869    Args:
    4870        left: the SQL code string corresponding to the left-hand side.
    4871            If an `Expression` instance is passed, it will be used as-is.
    4872        right: the SQL code string corresponding to the right-hand side.
    4873            If an `Expression` instance is passed, it will be used as-is.
    4874        distinct: set the DISTINCT flag if and only if this is true.
    4875        dialect: the dialect used to parse the input expression.
    4876        opts: other options to use to parse the input expressions.
    4877
    4878    Returns:
    4879        The new Union instance.
    4880    """
    4881    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    4882    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    4883
    4884    return Union(this=left, expression=right, distinct=distinct)
    4885
    4886
    4887def intersect(
    4888    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    4889) -> Intersect:
    4890    """
    4891    Initializes a syntax tree from one INTERSECT expression.
    4892
    4893    Example:
    4894        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    4895        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    4896
    4897    Args:
    4898        left: the SQL code string corresponding to the left-hand side.
    4899            If an `Expression` instance is passed, it will be used as-is.
    4900        right: the SQL code string corresponding to the right-hand side.
    4901            If an `Expression` instance is passed, it will be used as-is.
    4902        distinct: set the DISTINCT flag if and only if this is true.
    4903        dialect: the dialect used to parse the input expression.
    4904        opts: other options to use to parse the input expressions.
    4905
    4906    Returns:
    4907        The new Intersect instance.
    4908    """
    4909    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    4910    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    4911
    4912    return Intersect(this=left, expression=right, distinct=distinct)
    4913
    4914
    4915def except_(
    4916    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    4917) -> Except:
    4918    """
    4919    Initializes a syntax tree from one EXCEPT expression.
    4920
    4921    Example:
    4922        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    4923        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    4924
    4925    Args:
    4926        left: the SQL code string corresponding to the left-hand side.
    4927            If an `Expression` instance is passed, it will be used as-is.
    4928        right: the SQL code string corresponding to the right-hand side.
    4929            If an `Expression` instance is passed, it will be used as-is.
    4930        distinct: set the DISTINCT flag if and only if this is true.
    4931        dialect: the dialect used to parse the input expression.
    4932        opts: other options to use to parse the input expressions.
    4933
    4934    Returns:
    4935        The new Except instance.
    4936    """
    4937    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    4938    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    4939
    4940    return Except(this=left, expression=right, distinct=distinct)
    4941
    4942
    4943def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    4944    """
    4945    Initializes a syntax tree from one or multiple SELECT expressions.
    4946
    4947    Example:
    4948        >>> select("col1", "col2").from_("tbl").sql()
    4949        'SELECT col1, col2 FROM tbl'
    4950
    4951    Args:
    4952        *expressions: the SQL code string to parse as the expressions of a
    4953            SELECT statement. If an Expression instance is passed, this is used as-is.
    4954        dialect: the dialect used to parse the input expressions (in the case that an
    4955            input expression is a SQL string).
    4956        **opts: other options to use to parse the input expressions (again, in the case
    4957            that an input expression is a SQL string).
    4958
    4959    Returns:
    4960        Select: the syntax tree for the SELECT statement.
    4961    """
    4962    return Select().select(*expressions, dialect=dialect, **opts)
    4963
    4964
    4965def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    4966    """
    4967    Initializes a syntax tree from a FROM expression.
    4968
    4969    Example:
    4970        >>> from_("tbl").select("col1", "col2").sql()
    4971        'SELECT col1, col2 FROM tbl'
    4972
    4973    Args:
    4974        *expression: the SQL code string to parse as the FROM expressions of a
    4975            SELECT statement. If an Expression instance is passed, this is used as-is.
    4976        dialect: the dialect used to parse the input expression (in the case that the
    4977            input expression is a SQL string).
    4978        **opts: other options to use to parse the input expressions (again, in the case
    4979            that the input expression is a SQL string).
    4980
    4981    Returns:
    4982        Select: the syntax tree for the SELECT statement.
    4983    """
    4984    return Select().from_(expression, dialect=dialect, **opts)
    4985
    4986
    4987def update(
    4988    table: str | Table,
    4989    properties: dict,
    4990    where: t.Optional[ExpOrStr] = None,
    4991    from_: t.Optional[ExpOrStr] = None,
    4992    dialect: DialectType = None,
    4993    **opts,
    4994) -> Update:
    4995    """
    4996    Creates an update statement.
    4997
    4998    Example:
    4999        >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz", where="id > 1").sql()
    5000        "UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz WHERE id > 1"
    5001
    5002    Args:
    5003        *properties: dictionary of properties to set which are
    5004            auto converted to sql objects eg None -> NULL
    5005        where: sql conditional parsed into a WHERE statement
    5006        from_: sql statement parsed into a FROM statement
    5007        dialect: the dialect used to parse the input expressions.
    5008        **opts: other options to use to parse the input expressions.
    5009
    5010    Returns:
    5011        Update: the syntax tree for the UPDATE statement.
    5012    """
    5013    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    5014    update_expr.set(
    5015        "expressions",
    5016        [
    5017            EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    5018            for k, v in properties.items()
    5019        ],
    5020    )
    5021    if from_:
    5022        update_expr.set(
    5023            "from",
    5024            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    5025        )
    5026    if isinstance(where, Condition):
    5027        where = Where(this=where)
    5028    if where:
    5029        update_expr.set(
    5030            "where",
    5031            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    5032        )
    5033    return update_expr
    5034
    5035
    5036def delete(
    5037    table: ExpOrStr,
    5038    where: t.Optional[ExpOrStr] = None,
    5039    returning: t.Optional[ExpOrStr] = None,
    5040    dialect: DialectType = None,
    5041    **opts,
    5042) -> Delete:
    5043    """
    5044    Builds a delete statement.
    5045
    5046    Example:
    5047        >>> delete("my_table", where="id > 1").sql()
    5048        'DELETE FROM my_table WHERE id > 1'
    5049
    5050    Args:
    5051        where: sql conditional parsed into a WHERE statement
    5052        returning: sql conditional parsed into a RETURNING statement
    5053        dialect: the dialect used to parse the input expressions.
    5054        **opts: other options to use to parse the input expressions.
    5055
    5056    Returns:
    5057        Delete: the syntax tree for the DELETE statement.
    5058    """
    5059    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    5060    if where:
    5061        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    5062    if returning:
    5063        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    5064    return delete_expr
    5065
    5066
    5067def insert(
    5068    expression: ExpOrStr,
    5069    into: ExpOrStr,
    5070    columns: t.Optional[t.Sequence[ExpOrStr]] = None,
    5071    overwrite: t.Optional[bool] = None,
    5072    dialect: DialectType = None,
    5073    copy: bool = True,
    5074    **opts,
    5075) -> Insert:
    5076    """
    5077    Builds an INSERT statement.
    5078
    5079    Example:
    5080        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    5081        'INSERT INTO tbl VALUES (1, 2, 3)'
    5082
    5083    Args:
    5084        expression: the sql string or expression of the INSERT statement
    5085        into: the tbl to insert data to.
    5086        columns: optionally the table's column names.
    5087        overwrite: whether to INSERT OVERWRITE or not.
    5088        dialect: the dialect used to parse the input expressions.
    5089        copy: whether or not to copy the expression.
    5090        **opts: other options to use to parse the input expressions.
    5091
    5092    Returns:
    5093        Insert: the syntax tree for the INSERT statement.
    5094    """
    5095    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    5096    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    5097
    5098    if columns:
    5099        this = _apply_list_builder(
    5100            *columns,
    5101            instance=Schema(this=this),
    5102            arg="expressions",
    5103            into=Identifier,
    5104            copy=False,
    5105            dialect=dialect,
    5106            **opts,
    5107        )
    5108
    5109    return Insert(this=this, expression=expr, overwrite=overwrite)
    5110
    5111
    5112def condition(
    5113    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    5114) -> Condition:
    5115    """
    5116    Initialize a logical condition expression.
    5117
    5118    Example:
    5119        >>> condition("x=1").sql()
    5120        'x = 1'
    5121
    5122        This is helpful for composing larger logical syntax trees:
    5123        >>> where = condition("x=1")
    5124        >>> where = where.and_("y=1")
    5125        >>> Select().from_("tbl").select("*").where(where).sql()
    5126        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    5127
    5128    Args:
    5129        *expression: the SQL code string to parse.
    5130            If an Expression instance is passed, this is used as-is.
    5131        dialect: the dialect used to parse the input expression (in the case that the
    5132            input expression is a SQL string).
    5133        copy: Whether or not to copy `expression` (only applies to expressions).
    5134        **opts: other options to use to parse the input expressions (again, in the case
    5135            that the input expression is a SQL string).
    5136
    5137    Returns:
    5138        The new Condition instance
    5139    """
    5140    return maybe_parse(
    5141        expression,
    5142        into=Condition,
    5143        dialect=dialect,
    5144        copy=copy,
    5145        **opts,
    5146    )
    5147
    5148
    5149def and_(
    5150    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    5151) -> Condition:
    5152    """
    5153    Combine multiple conditions with an AND logical operator.
    5154
    5155    Example:
    5156        >>> and_("x=1", and_("y=1", "z=1")).sql()
    5157        'x = 1 AND (y = 1 AND z = 1)'
    5158
    5159    Args:
    5160        *expressions: the SQL code strings to parse.
    5161            If an Expression instance is passed, this is used as-is.
    5162        dialect: the dialect used to parse the input expression.
    5163        copy: whether or not to copy `expressions` (only applies to Expressions).
    5164        **opts: other options to use to parse the input expressions.
    5165
    5166    Returns:
    5167        And: the new condition
    5168    """
    5169    return t.cast(Condition, _combine(expressions, And, dialect, copy=copy, **opts))
    5170
    5171
    5172def or_(
    5173    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    5174) -> Condition:
    5175    """
    5176    Combine multiple conditions with an OR logical operator.
    5177
    5178    Example:
    5179        >>> or_("x=1", or_("y=1", "z=1")).sql()
    5180        'x = 1 OR (y = 1 OR z = 1)'
    5181
    5182    Args:
    5183        *expressions: the SQL code strings to parse.
    5184            If an Expression instance is passed, this is used as-is.
    5185        dialect: the dialect used to parse the input expression.
    5186        copy: whether or not to copy `expressions` (only applies to Expressions).
    5187        **opts: other options to use to parse the input expressions.
    5188
    5189    Returns:
    5190        Or: the new condition
    5191    """
    5192    return t.cast(Condition, _combine(expressions, Or, dialect, copy=copy, **opts))
    5193
    5194
    5195def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    5196    """
    5197    Wrap a condition with a NOT operator.
    5198
    5199    Example:
    5200        >>> not_("this_suit='black'").sql()
    5201        "NOT this_suit = 'black'"
    5202
    5203    Args:
    5204        expression: the SQL code string to parse.
    5205            If an Expression instance is passed, this is used as-is.
    5206        dialect: the dialect used to parse the input expression.
    5207        copy: whether to copy the expression or not.
    5208        **opts: other options to use to parse the input expressions.
    5209
    5210    Returns:
    5211        The new condition.
    5212    """
    5213    this = condition(
    5214        expression,
    5215        dialect=dialect,
    5216        copy=copy,
    5217        **opts,
    5218    )
    5219    return Not(this=_wrap(this, Connector))
    5220
    5221
    5222def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    5223    """
    5224    Wrap an expression in parentheses.
    5225
    5226    Example:
    5227        >>> paren("5 + 3").sql()
    5228        '(5 + 3)'
    5229
    5230    Args:
    5231        expression: the SQL code string to parse.
    5232            If an Expression instance is passed, this is used as-is.
    5233        copy: whether to copy the expression or not.
    5234
    5235    Returns:
    5236        The wrapped expression.
    5237    """
    5238    return Paren(this=maybe_parse(expression, copy=copy))
    5239
    5240
    5241SAFE_IDENTIFIER_RE = re.compile(r"^[_a-zA-Z][\w]*$")
    5242
    5243
    5244@t.overload
    5245def to_identifier(name: None, quoted: t.Optional[bool] = None, copy: bool = True) -> None:
    5246    ...
    5247
    5248
    5249@t.overload
    5250def to_identifier(
    5251    name: str | Identifier, quoted: t.Optional[bool] = None, copy: bool = True
    5252) -> Identifier:
    5253    ...
    5254
    5255
    5256def to_identifier(name, quoted=None, copy=True):
    5257    """Builds an identifier.
    5258
    5259    Args:
    5260        name: The name to turn into an identifier.
    5261        quoted: Whether or not force quote the identifier.
    5262        copy: Whether or not to copy a passed in Identefier node.
    5263
    5264    Returns:
    5265        The identifier ast node.
    5266    """
    5267
    5268    if name is None:
    5269        return None
    5270
    5271    if isinstance(name, Identifier):
    5272        identifier = _maybe_copy(name, copy)
    5273    elif isinstance(name, str):
    5274        identifier = Identifier(
    5275            this=name,
    5276            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    5277        )
    5278    else:
    5279        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    5280    return identifier
    5281
    5282
    5283INTERVAL_STRING_RE = re.compile(r"\s*([0-9]+)\s*([a-zA-Z]+)\s*")
    5284
    5285
    5286def to_interval(interval: str | Literal) -> Interval:
    5287    """Builds an interval expression from a string like '1 day' or '5 months'."""
    5288    if isinstance(interval, Literal):
    5289        if not interval.is_string:
    5290            raise ValueError("Invalid interval string.")
    5291
    5292        interval = interval.this
    5293
    5294    interval_parts = INTERVAL_STRING_RE.match(interval)  # type: ignore
    5295
    5296    if not interval_parts:
    5297        raise ValueError("Invalid interval string.")
    5298
    5299    return Interval(
    5300        this=Literal.string(interval_parts.group(1)),
    5301        unit=Var(this=interval_parts.group(2)),
    5302    )
    5303
    5304
    5305@t.overload
    5306def to_table(sql_path: str | Table, **kwargs) -> Table:
    5307    ...
    5308
    5309
    5310@t.overload
    5311def to_table(sql_path: None, **kwargs) -> None:
    5312    ...
    5313
    5314
    5315def to_table(
    5316    sql_path: t.Optional[str | Table], dialect: DialectType = None, **kwargs
    5317) -> t.Optional[Table]:
    5318    """
    5319    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    5320    If a table is passed in then that table is returned.
    5321
    5322    Args:
    5323        sql_path: a `[catalog].[schema].[table]` string.
    5324        dialect: the source dialect according to which the table name will be parsed.
    5325        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    5326
    5327    Returns:
    5328        A table expression.
    5329    """
    5330    if sql_path is None or isinstance(sql_path, Table):
    5331        return sql_path
    5332    if not isinstance(sql_path, str):
    5333        raise ValueError(f"Invalid type provided for a table: {type(sql_path)}")
    5334
    5335    table = maybe_parse(sql_path, into=Table, dialect=dialect)
    5336    if table:
    5337        for k, v in kwargs.items():
    5338            table.set(k, v)
    5339
    5340    return table
    5341
    5342
    5343def to_column(sql_path: str | Column, **kwargs) -> Column:
    5344    """
    5345    Create a column from a `[table].[column]` sql path. Schema is optional.
    5346
    5347    If a column is passed in then that column is returned.
    5348
    5349    Args:
    5350        sql_path: `[table].[column]` string
    5351    Returns:
    5352        Table: A column expression
    5353    """
    5354    if sql_path is None or isinstance(sql_path, Column):
    5355        return sql_path
    5356    if not isinstance(sql_path, str):
    5357        raise ValueError(f"Invalid type provided for column: {type(sql_path)}")
    5358    return column(*reversed(sql_path.split(".")), **kwargs)  # type: ignore
    5359
    5360
    5361def alias_(
    5362    expression: ExpOrStr,
    5363    alias: str | Identifier,
    5364    table: bool | t.Sequence[str | Identifier] = False,
    5365    quoted: t.Optional[bool] = None,
    5366    dialect: DialectType = None,
    5367    copy: bool = True,
    5368    **opts,
    5369):
    5370    """Create an Alias expression.
    5371
    5372    Example:
    5373        >>> alias_('foo', 'bar').sql()
    5374        'foo AS bar'
    5375
    5376        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    5377        '(SELECT 1, 2) AS bar(a, b)'
    5378
    5379    Args:
    5380        expression: the SQL code strings to parse.
    5381            If an Expression instance is passed, this is used as-is.
    5382        alias: the alias name to use. If the name has
    5383            special characters it is quoted.
    5384        table: Whether or not to create a table alias, can also be a list of columns.
    5385        quoted: whether or not to quote the alias
    5386        dialect: the dialect used to parse the input expression.
    5387        copy: Whether or not to copy the expression.
    5388        **opts: other options to use to parse the input expressions.
    5389
    5390    Returns:
    5391        Alias: the aliased expression
    5392    """
    5393    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    5394    alias = to_identifier(alias, quoted=quoted)
    5395
    5396    if table:
    5397        table_alias = TableAlias(this=alias)
    5398        exp.set("alias", table_alias)
    5399
    5400        if not isinstance(table, bool):
    5401            for column in table:
    5402                table_alias.append("columns", to_identifier(column, quoted=quoted))
    5403
    5404        return exp
    5405
    5406    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    5407    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    5408    # for the complete Window expression.
    5409    #
    5410    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    5411
    5412    if "alias" in exp.arg_types and not isinstance(exp, Window):
    5413        exp.set("alias", alias)
    5414        return exp
    5415    return Alias(this=exp, alias=alias)
    5416
    5417
    5418def subquery(
    5419    expression: ExpOrStr,
    5420    alias: t.Optional[Identifier | str] = None,
    5421    dialect: DialectType = None,
    5422    **opts,
    5423) -> Select:
    5424    """
    5425    Build a subquery expression.
    5426
    5427    Example:
    5428        >>> subquery('select x from tbl', 'bar').select('x').sql()
    5429        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    5430
    5431    Args:
    5432        expression: the SQL code strings to parse.
    5433            If an Expression instance is passed, this is used as-is.
    5434        alias: the alias name to use.
    5435        dialect: the dialect used to parse the input expression.
    5436        **opts: other options to use to parse the input expressions.
    5437
    5438    Returns:
    5439        A new Select instance with the subquery expression included.
    5440    """
    5441
    5442    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias)
    5443    return Select().from_(expression, dialect=dialect, **opts)
    5444
    5445
    5446def column(
    5447    col: str | Identifier,
    5448    table: t.Optional[str | Identifier] = None,
    5449    db: t.Optional[str | Identifier] = None,
    5450    catalog: t.Optional[str | Identifier] = None,
    5451    quoted: t.Optional[bool] = None,
    5452) -> Column:
    5453    """
    5454    Build a Column.
    5455
    5456    Args:
    5457        col: Column name.
    5458        table: Table name.
    5459        db: Database name.
    5460        catalog: Catalog name.
    5461        quoted: Whether to force quotes on the column's identifiers.
    5462
    5463    Returns:
    5464        The new Column instance.
    5465    """
    5466    return Column(
    5467        this=to_identifier(col, quoted=quoted),
    5468        table=to_identifier(table, quoted=quoted),
    5469        db=to_identifier(db, quoted=quoted),
    5470        catalog=to_identifier(catalog, quoted=quoted),
    5471    )
    5472
    5473
    5474def cast(expression: ExpOrStr, to: str | DataType | DataType.Type, **opts) -> Cast:
    5475    """Cast an expression to a data type.
    5476
    5477    Example:
    5478        >>> cast('x + 1', 'int').sql()
    5479        'CAST(x + 1 AS INT)'
    5480
    5481    Args:
    5482        expression: The expression to cast.
    5483        to: The datatype to cast to.
    5484
    5485    Returns:
    5486        The new Cast instance.
    5487    """
    5488    expression = maybe_parse(expression, **opts)
    5489    return Cast(this=expression, to=DataType.build(to, **opts))
    5490
    5491
    5492def table_(
    5493    table: Identifier | str,
    5494    db: t.Optional[Identifier | str] = None,
    5495    catalog: t.Optional[Identifier | str] = None,
    5496    quoted: t.Optional[bool] = None,
    5497    alias: t.Optional[Identifier | str] = None,
    5498) -> Table:
    5499    """Build a Table.
    5500
    5501    Args:
    5502        table: Table name.
    5503        db: Database name.
    5504        catalog: Catalog name.
    5505        quote: Whether to force quotes on the table's identifiers.
    5506        alias: Table's alias.
    5507
    5508    Returns:
    5509        The new Table instance.
    5510    """
    5511    return Table(
    5512        this=to_identifier(table, quoted=quoted),
    5513        db=to_identifier(db, quoted=quoted),
    5514        catalog=to_identifier(catalog, quoted=quoted),
    5515        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    5516    )
    5517
    5518
    5519def values(
    5520    values: t.Iterable[t.Tuple[t.Any, ...]],
    5521    alias: t.Optional[str] = None,
    5522    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    5523) -> Values:
    5524    """Build VALUES statement.
    5525
    5526    Example:
    5527        >>> values([(1, '2')]).sql()
    5528        "VALUES (1, '2')"
    5529
    5530    Args:
    5531        values: values statements that will be converted to SQL
    5532        alias: optional alias
    5533        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    5534         If either are provided then an alias is also required.
    5535
    5536    Returns:
    5537        Values: the Values expression object
    5538    """
    5539    if columns and not alias:
    5540        raise ValueError("Alias is required when providing columns")
    5541
    5542    return Values(
    5543        expressions=[convert(tup) for tup in values],
    5544        alias=(
    5545            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    5546            if columns
    5547            else (TableAlias(this=to_identifier(alias)) if alias else None)
    5548        ),
    5549    )
    5550
    5551
    5552def var(name: t.Optional[ExpOrStr]) -> Var:
    5553    """Build a SQL variable.
    5554
    5555    Example:
    5556        >>> repr(var('x'))
    5557        '(VAR this: x)'
    5558
    5559        >>> repr(var(column('x', table='y')))
    5560        '(VAR this: x)'
    5561
    5562    Args:
    5563        name: The name of the var or an expression who's name will become the var.
    5564
    5565    Returns:
    5566        The new variable node.
    5567    """
    5568    if not name:
    5569        raise ValueError("Cannot convert empty name into var.")
    5570
    5571    if isinstance(name, Expression):
    5572        name = name.name
    5573    return Var(this=name)
    5574
    5575
    5576def rename_table(old_name: str | Table, new_name: str | Table) -> AlterTable:
    5577    """Build ALTER TABLE... RENAME... expression
    5578
    5579    Args:
    5580        old_name: The old name of the table
    5581        new_name: The new name of the table
    5582
    5583    Returns:
    5584        Alter table expression
    5585    """
    5586    old_table = to_table(old_name)
    5587    new_table = to_table(new_name)
    5588    return AlterTable(
    5589        this=old_table,
    5590        actions=[
    5591            RenameTable(this=new_table),
    5592        ],
    5593    )
    5594
    5595
    5596def convert(value: t.Any, copy: bool = False) -> Expression:
    5597    """Convert a python value into an expression object.
    5598
    5599    Raises an error if a conversion is not possible.
    5600
    5601    Args:
    5602        value: A python object.
    5603        copy: Whether or not to copy `value` (only applies to Expressions and collections).
    5604
    5605    Returns:
    5606        Expression: the equivalent expression object.
    5607    """
    5608    if isinstance(value, Expression):
    5609        return _maybe_copy(value, copy)
    5610    if isinstance(value, str):
    5611        return Literal.string(value)
    5612    if isinstance(value, bool):
    5613        return Boolean(this=value)
    5614    if value is None or (isinstance(value, float) and math.isnan(value)):
    5615        return NULL
    5616    if isinstance(value, numbers.Number):
    5617        return Literal.number(value)
    5618    if isinstance(value, datetime.datetime):
    5619        datetime_literal = Literal.string(
    5620            (value if value.tzinfo else value.replace(tzinfo=datetime.timezone.utc)).isoformat()
    5621        )
    5622        return TimeStrToTime(this=datetime_literal)
    5623    if isinstance(value, datetime.date):
    5624        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    5625        return DateStrToDate(this=date_literal)
    5626    if isinstance(value, tuple):
    5627        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    5628    if isinstance(value, list):
    5629        return Array(expressions=[convert(v, copy=copy) for v in value])
    5630    if isinstance(value, dict):
    5631        return Map(
    5632            keys=[convert(k, copy=copy) for k in value],
    5633            values=[convert(v, copy=copy) for v in value.values()],
    5634        )
    5635    raise ValueError(f"Cannot convert {value}")
    5636
    5637
    5638def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    5639    """
    5640    Replace children of an expression with the result of a lambda fun(child) -> exp.
    5641    """
    5642    for k, v in expression.args.items():
    5643        is_list_arg = type(v) is list
    5644
    5645        child_nodes = v if is_list_arg else [v]
    5646        new_child_nodes = []
    5647
    5648        for cn in child_nodes:
    5649            if isinstance(cn, Expression):
    5650                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    5651                    new_child_nodes.append(child_node)
    5652                    child_node.parent = expression
    5653                    child_node.arg_key = k
    5654            else:
    5655                new_child_nodes.append(cn)
    5656
    5657        expression.args[k] = new_child_nodes if is_list_arg else seq_get(new_child_nodes, 0)
    5658
    5659
    5660def column_table_names(expression: Expression) -> t.List[str]:
    5661    """
    5662    Return all table names referenced through columns in an expression.
    5663
    5664    Example:
    5665        >>> import sqlglot
    5666        >>> column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e"))
    5667        ['c', 'a']
    5668
    5669    Args:
    5670        expression: expression to find table names.
    5671
    5672    Returns:
    5673        A list of unique names.
    5674    """
    5675    return list(dict.fromkeys(column.table for column in expression.find_all(Column)))
    5676
    5677
    5678def table_name(table: Table | str) -> str:
    5679    """Get the full name of a table as a string.
    5680
    5681    Args:
    5682        table: table expression node or string.
    5683
    5684    Examples:
    5685        >>> from sqlglot import exp, parse_one
    5686        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    5687        'a.b.c'
    5688
    5689    Returns:
    5690        The table name.
    5691    """
    5692
    5693    table = maybe_parse(table, into=Table)
    5694
    5695    if not table:
    5696        raise ValueError(f"Cannot parse {table}")
    5697
    5698    return ".".join(part for part in (table.text("catalog"), table.text("db"), table.name) if part)
    5699
    5700
    5701def replace_tables(expression: E, mapping: t.Dict[str, str], copy: bool = True) -> E:
    5702    """Replace all tables in expression according to the mapping.
    5703
    5704    Args:
    5705        expression: expression node to be transformed and replaced.
    5706        mapping: mapping of table names.
    5707        copy: whether or not to copy the expression.
    5708
    5709    Examples:
    5710        >>> from sqlglot import exp, parse_one
    5711        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    5712        'SELECT * FROM c'
    5713
    5714    Returns:
    5715        The mapped expression.
    5716    """
    5717
    5718    def _replace_tables(node: Expression) -> Expression:
    5719        if isinstance(node, Table):
    5720            new_name = mapping.get(table_name(node))
    5721            if new_name:
    5722                return to_table(
    5723                    new_name,
    5724                    **{k: v for k, v in node.args.items() if k not in ("this", "db", "catalog")},
    5725                )
    5726        return node
    5727
    5728    return expression.transform(_replace_tables, copy=copy)
    5729
    5730
    5731def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    5732    """Replace placeholders in an expression.
    5733
    5734    Args:
    5735        expression: expression node to be transformed and replaced.
    5736        args: positional names that will substitute unnamed placeholders in the given order.
    5737        kwargs: keyword arguments that will substitute named placeholders.
    5738
    5739    Examples:
    5740        >>> from sqlglot import exp, parse_one
    5741        >>> replace_placeholders(
    5742        ...     parse_one("select * from :tbl where ? = ?"),
    5743        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    5744        ... ).sql()
    5745        "SELECT * FROM foo WHERE str_col = 'b'"
    5746
    5747    Returns:
    5748        The mapped expression.
    5749    """
    5750
    5751    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    5752        if isinstance(node, Placeholder):
    5753            if node.name:
    5754                new_name = kwargs.get(node.name)
    5755                if new_name:
    5756                    return convert(new_name)
    5757            else:
    5758                try:
    5759                    return convert(next(args))
    5760                except StopIteration:
    5761                    pass
    5762        return node
    5763
    5764    return expression.transform(_replace_placeholders, iter(args), **kwargs)
    5765
    5766
    5767def expand(
    5768    expression: Expression, sources: t.Dict[str, Subqueryable], copy: bool = True
    5769) -> Expression:
    5770    """Transforms an expression by expanding all referenced sources into subqueries.
    5771
    5772    Examples:
    5773        >>> from sqlglot import parse_one
    5774        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    5775        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    5776
    5777        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    5778        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    5779
    5780    Args:
    5781        expression: The expression to expand.
    5782        sources: A dictionary of name to Subqueryables.
    5783        copy: Whether or not to copy the expression during transformation. Defaults to True.
    5784
    5785    Returns:
    5786        The transformed expression.
    5787    """
    5788
    5789    def _expand(node: Expression):
    5790        if isinstance(node, Table):
    5791            name = table_name(node)
    5792            source = sources.get(name)
    5793            if source:
    5794                subquery = source.subquery(node.alias or name)
    5795                subquery.comments = [f"source: {name}"]
    5796                return subquery.transform(_expand, copy=False)
    5797        return node
    5798
    5799    return expression.transform(_expand, copy=copy)
    5800
    5801
    5802def func(name: str, *args, dialect: DialectType = None, **kwargs) -> Func:
    5803    """
    5804    Returns a Func expression.
    5805
    5806    Examples:
    5807        >>> func("abs", 5).sql()
    5808        'ABS(5)'
    5809
    5810        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    5811        'CAST(5 AS DOUBLE)'
    5812
    5813    Args:
    5814        name: the name of the function to build.
    5815        args: the args used to instantiate the function of interest.
    5816        dialect: the source dialect.
    5817        kwargs: the kwargs used to instantiate the function of interest.
    5818
    5819    Note:
    5820        The arguments `args` and `kwargs` are mutually exclusive.
    5821
    5822    Returns:
    5823        An instance of the function of interest, or an anonymous function, if `name` doesn't
    5824        correspond to an existing `sqlglot.expressions.Func` class.
    5825    """
    5826    if args and kwargs:
    5827        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    5828
    5829    from sqlglot.dialects.dialect import Dialect
    5830
    5831    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect) for arg in args]
    5832    kwargs = {key: maybe_parse(value, dialect=dialect) for key, value in kwargs.items()}
    5833
    5834    parser = Dialect.get_or_raise(dialect)().parser()
    5835    from_args_list = parser.FUNCTIONS.get(name.upper())
    5836
    5837    if from_args_list:
    5838        function = from_args_list(converted) if converted else from_args_list.__self__(**kwargs)  # type: ignore
    5839    else:
    5840        kwargs = kwargs or {"expressions": converted}
    5841        function = Anonymous(this=name, **kwargs)
    5842
    5843    for error_message in function.error_messages(converted):
    5844        raise ValueError(error_message)
    5845
    5846    return function
    5847
    5848
    5849def true() -> Boolean:
    5850    """
    5851    Returns a true Boolean expression.
    5852    """
    5853    return Boolean(this=True)
    5854
    5855
    5856def false() -> Boolean:
    5857    """
    5858    Returns a false Boolean expression.
    5859    """
    5860    return Boolean(this=False)
    5861
    5862
    5863def null() -> Null:
    5864    """
    5865    Returns a Null expression.
    5866    """
    5867    return Null()
    5868
    5869
    5870# TODO: deprecate this
    5871TRUE = Boolean(this=True)
    5872FALSE = Boolean(this=False)
    5873NULL = Null()

class Expression: View Source

     55class Expression(metaclass=_Expression):
     56    """
     57    The base class for all expressions in a syntax tree. Each Expression encapsulates any necessary
     58    context, such as its child expressions, their names (arg keys), and whether a given child expression
     59    is optional or not.
     60
     61    Attributes:
     62        key: a unique key for each class in the Expression hierarchy. This is useful for hashing
     63            and representing expressions as strings.
     64        arg_types: determines what arguments (child nodes) are supported by an expression. It
     65            maps arg keys to booleans that indicate whether the corresponding args are optional.
     66        parent: a reference to the parent expression (or None, in case of root expressions).
     67        arg_key: the arg key an expression is associated with, i.e. the name its parent expression
     68            uses to refer to it.
     69        comments: a list of comments that are associated with a given expression. This is used in
     70            order to preserve comments when transpiling SQL code.
     71        _type: the `sqlglot.expressions.DataType` type of an expression. This is inferred by the
     72            optimizer, in order to enable some transformations that require type information.
     73
     74    Example:
     75        >>> class Foo(Expression):
     76        ...     arg_types = {"this": True, "expression": False}
     77
     78        The above definition informs us that Foo is an Expression that requires an argument called
     79        "this" and may also optionally receive an argument called "expression".
     80
     81    Args:
     82        args: a mapping used for retrieving the arguments of an expression, given their arg keys.
     83    """
     84
     85    key = "expression"
     86    arg_types = {"this": True}
     87    __slots__ = ("args", "parent", "arg_key", "comments", "_type", "_meta", "_hash")
     88
     89    def __init__(self, **args: t.Any):
     90        self.args: t.Dict[str, t.Any] = args
     91        self.parent: t.Optional[Expression] = None
     92        self.arg_key: t.Optional[str] = None
     93        self.comments: t.Optional[t.List[str]] = None
     94        self._type: t.Optional[DataType] = None
     95        self._meta: t.Optional[t.Dict[str, t.Any]] = None
     96        self._hash: t.Optional[int] = None
     97
     98        for arg_key, value in self.args.items():
     99            self._set_parent(arg_key, value)
    100
    101    def __eq__(self, other) -> bool:
    102        return type(self) is type(other) and hash(self) == hash(other)
    103
    104    @property
    105    def hashable_args(self) -> t.Any:
    106        args = (self.args.get(k) for k in self.arg_types)
    107
    108        return tuple(
    109            (tuple(_norm_arg(a) for a in arg) if arg else None)
    110            if type(arg) is list
    111            else (_norm_arg(arg) if arg is not None and arg is not False else None)
    112            for arg in args
    113        )
    114
    115    def __hash__(self) -> int:
    116        if self._hash is not None:
    117            return self._hash
    118
    119        return hash((self.__class__, self.hashable_args))
    120
    121    @property
    122    def this(self):
    123        """
    124        Retrieves the argument with key "this".
    125        """
    126        return self.args.get("this")
    127
    128    @property
    129    def expression(self):
    130        """
    131        Retrieves the argument with key "expression".
    132        """
    133        return self.args.get("expression")
    134
    135    @property
    136    def expressions(self):
    137        """
    138        Retrieves the argument with key "expressions".
    139        """
    140        return self.args.get("expressions") or []
    141
    142    def text(self, key) -> str:
    143        """
    144        Returns a textual representation of the argument corresponding to "key". This can only be used
    145        for args that are strings or leaf Expression instances, such as identifiers and literals.
    146        """
    147        field = self.args.get(key)
    148        if isinstance(field, str):
    149            return field
    150        if isinstance(field, (Identifier, Literal, Var)):
    151            return field.this
    152        if isinstance(field, (Star, Null)):
    153            return field.name
    154        return ""
    155
    156    @property
    157    def is_string(self) -> bool:
    158        """
    159        Checks whether a Literal expression is a string.
    160        """
    161        return isinstance(self, Literal) and self.args["is_string"]
    162
    163    @property
    164    def is_number(self) -> bool:
    165        """
    166        Checks whether a Literal expression is a number.
    167        """
    168        return isinstance(self, Literal) and not self.args["is_string"]
    169
    170    @property
    171    def is_int(self) -> bool:
    172        """
    173        Checks whether a Literal expression is an integer.
    174        """
    175        if self.is_number:
    176            try:
    177                int(self.name)
    178                return True
    179            except ValueError:
    180                pass
    181        return False
    182
    183    @property
    184    def is_star(self) -> bool:
    185        """Checks whether an expression is a star."""
    186        return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))
    187
    188    @property
    189    def alias(self) -> str:
    190        """
    191        Returns the alias of the expression, or an empty string if it's not aliased.
    192        """
    193        if isinstance(self.args.get("alias"), TableAlias):
    194            return self.args["alias"].name
    195        return self.text("alias")
    196
    197    @property
    198    def name(self) -> str:
    199        return self.text("this")
    200
    201    @property
    202    def alias_or_name(self) -> str:
    203        return self.alias or self.name
    204
    205    @property
    206    def output_name(self) -> str:
    207        """
    208        Name of the output column if this expression is a selection.
    209
    210        If the Expression has no output name, an empty string is returned.
    211
    212        Example:
    213            >>> from sqlglot import parse_one
    214            >>> parse_one("SELECT a").expressions[0].output_name
    215            'a'
    216            >>> parse_one("SELECT b AS c").expressions[0].output_name
    217            'c'
    218            >>> parse_one("SELECT 1 + 2").expressions[0].output_name
    219            ''
    220        """
    221        return ""
    222
    223    @property
    224    def type(self) -> t.Optional[DataType]:
    225        return self._type
    226
    227    @type.setter
    228    def type(self, dtype: t.Optional[DataType | DataType.Type | str]) -> None:
    229        if dtype and not isinstance(dtype, DataType):
    230            dtype = DataType.build(dtype)
    231        self._type = dtype  # type: ignore
    232
    233    @property
    234    def meta(self) -> t.Dict[str, t.Any]:
    235        if self._meta is None:
    236            self._meta = {}
    237        return self._meta
    238
    239    def __deepcopy__(self, memo):
    240        copy = self.__class__(**deepcopy(self.args))
    241        if self.comments is not None:
    242            copy.comments = deepcopy(self.comments)
    243
    244        if self._type is not None:
    245            copy._type = self._type.copy()
    246
    247        if self._meta is not None:
    248            copy._meta = deepcopy(self._meta)
    249
    250        return copy
    251
    252    def copy(self):
    253        """
    254        Returns a deep copy of the expression.
    255        """
    256        new = deepcopy(self)
    257        new.parent = self.parent
    258        return new
    259
    260    def add_comments(self, comments: t.Optional[t.List[str]]) -> None:
    261        if self.comments is None:
    262            self.comments = []
    263        if comments:
    264            self.comments.extend(comments)
    265
    266    def append(self, arg_key: str, value: t.Any) -> None:
    267        """
    268        Appends value to arg_key if it's a list or sets it as a new list.
    269
    270        Args:
    271            arg_key (str): name of the list expression arg
    272            value (Any): value to append to the list
    273        """
    274        if not isinstance(self.args.get(arg_key), list):
    275            self.args[arg_key] = []
    276        self.args[arg_key].append(value)
    277        self._set_parent(arg_key, value)
    278
    279    def set(self, arg_key: str, value: t.Any) -> None:
    280        """
    281        Sets `arg_key` to `value`.
    282
    283        Args:
    284            arg_key (str): name of the expression arg.
    285            value: value to set the arg to.
    286        """
    287        self.args[arg_key] = value
    288        self._set_parent(arg_key, value)
    289
    290    def _set_parent(self, arg_key: str, value: t.Any) -> None:
    291        if hasattr(value, "parent"):
    292            value.parent = self
    293            value.arg_key = arg_key
    294        elif type(value) is list:
    295            for v in value:
    296                if hasattr(v, "parent"):
    297                    v.parent = self
    298                    v.arg_key = arg_key
    299
    300    @property
    301    def depth(self) -> int:
    302        """
    303        Returns the depth of this tree.
    304        """
    305        if self.parent:
    306            return self.parent.depth + 1
    307        return 0
    308
    309    def iter_expressions(self) -> t.Iterator[t.Tuple[str, Expression]]:
    310        """Yields the key and expression for all arguments, exploding list args."""
    311        for k, vs in self.args.items():
    312            if type(vs) is list:
    313                for v in vs:
    314                    if hasattr(v, "parent"):
    315                        yield k, v
    316            else:
    317                if hasattr(vs, "parent"):
    318                    yield k, vs
    319
    320    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
    321        """
    322        Returns the first node in this tree which matches at least one of
    323        the specified types.
    324
    325        Args:
    326            expression_types: the expression type(s) to match.
    327            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    328
    329        Returns:
    330            The node which matches the criteria or None if no such node was found.
    331        """
    332        return next(self.find_all(*expression_types, bfs=bfs), None)
    333
    334    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
    335        """
    336        Returns a generator object which visits all nodes in this tree and only
    337        yields those that match at least one of the specified expression types.
    338
    339        Args:
    340            expression_types: the expression type(s) to match.
    341            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    342
    343        Returns:
    344            The generator object.
    345        """
    346        for expression, *_ in self.walk(bfs=bfs):
    347            if isinstance(expression, expression_types):
    348                yield expression
    349
    350    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
    351        """
    352        Returns a nearest parent matching expression_types.
    353
    354        Args:
    355            expression_types: the expression type(s) to match.
    356
    357        Returns:
    358            The parent node.
    359        """
    360        ancestor = self.parent
    361        while ancestor and not isinstance(ancestor, expression_types):
    362            ancestor = ancestor.parent
    363        return t.cast(E, ancestor)
    364
    365    @property
    366    def parent_select(self) -> t.Optional[Select]:
    367        """
    368        Returns the parent select statement.
    369        """
    370        return self.find_ancestor(Select)
    371
    372    @property
    373    def same_parent(self) -> bool:
    374        """Returns if the parent is the same class as itself."""
    375        return type(self.parent) is self.__class__
    376
    377    def root(self) -> Expression:
    378        """
    379        Returns the root expression of this tree.
    380        """
    381        expression = self
    382        while expression.parent:
    383            expression = expression.parent
    384        return expression
    385
    386    def walk(self, bfs=True, prune=None):
    387        """
    388        Returns a generator object which visits all nodes in this tree.
    389
    390        Args:
    391            bfs (bool): if set to True the BFS traversal order will be applied,
    392                otherwise the DFS traversal will be used instead.
    393            prune ((node, parent, arg_key) -> bool): callable that returns True if
    394                the generator should stop traversing this branch of the tree.
    395
    396        Returns:
    397            the generator object.
    398        """
    399        if bfs:
    400            yield from self.bfs(prune=prune)
    401        else:
    402            yield from self.dfs(prune=prune)
    403
    404    def dfs(self, parent=None, key=None, prune=None):
    405        """
    406        Returns a generator object which visits all nodes in this tree in
    407        the DFS (Depth-first) order.
    408
    409        Returns:
    410            The generator object.
    411        """
    412        parent = parent or self.parent
    413        yield self, parent, key
    414        if prune and prune(self, parent, key):
    415            return
    416
    417        for k, v in self.iter_expressions():
    418            yield from v.dfs(self, k, prune)
    419
    420    def bfs(self, prune=None):
    421        """
    422        Returns a generator object which visits all nodes in this tree in
    423        the BFS (Breadth-first) order.
    424
    425        Returns:
    426            The generator object.
    427        """
    428        queue = deque([(self, self.parent, None)])
    429
    430        while queue:
    431            item, parent, key = queue.popleft()
    432
    433            yield item, parent, key
    434            if prune and prune(item, parent, key):
    435                continue
    436
    437            for k, v in item.iter_expressions():
    438                queue.append((v, item, k))
    439
    440    def unnest(self):
    441        """
    442        Returns the first non parenthesis child or self.
    443        """
    444        expression = self
    445        while type(expression) is Paren:
    446            expression = expression.this
    447        return expression
    448
    449    def unalias(self):
    450        """
    451        Returns the inner expression if this is an Alias.
    452        """
    453        if isinstance(self, Alias):
    454            return self.this
    455        return self
    456
    457    def unnest_operands(self):
    458        """
    459        Returns unnested operands as a tuple.
    460        """
    461        return tuple(arg.unnest() for _, arg in self.iter_expressions())
    462
    463    def flatten(self, unnest=True):
    464        """
    465        Returns a generator which yields child nodes who's parents are the same class.
    466
    467        A AND B AND C -> [A, B, C]
    468        """
    469        for node, _, _ in self.dfs(prune=lambda n, p, *_: p and not type(n) is self.__class__):
    470            if not type(node) is self.__class__:
    471                yield node.unnest() if unnest else node
    472
    473    def __str__(self) -> str:
    474        return self.sql()
    475
    476    def __repr__(self) -> str:
    477        return self._to_s()
    478
    479    def sql(self, dialect: DialectType = None, **opts) -> str:
    480        """
    481        Returns SQL string representation of this tree.
    482
    483        Args:
    484            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
    485            opts: other `sqlglot.generator.Generator` options.
    486
    487        Returns:
    488            The SQL string.
    489        """
    490        from sqlglot.dialects import Dialect
    491
    492        return Dialect.get_or_raise(dialect)().generate(self, **opts)
    493
    494    def _to_s(self, hide_missing: bool = True, level: int = 0) -> str:
    495        indent = "" if not level else "\n"
    496        indent += "".join(["  "] * level)
    497        left = f"({self.key.upper()} "
    498
    499        args: t.Dict[str, t.Any] = {
    500            k: ", ".join(
    501                v._to_s(hide_missing=hide_missing, level=level + 1)
    502                if hasattr(v, "_to_s")
    503                else str(v)
    504                for v in ensure_list(vs)
    505                if v is not None
    506            )
    507            for k, vs in self.args.items()
    508        }
    509        args["comments"] = self.comments
    510        args["type"] = self.type
    511        args = {k: v for k, v in args.items() if v or not hide_missing}
    512
    513        right = ", ".join(f"{k}: {v}" for k, v in args.items())
    514        right += ")"
    515
    516        return indent + left + right
    517
    518    def transform(self, fun, *args, copy=True, **kwargs):
    519        """
    520        Recursively visits all tree nodes (excluding already transformed ones)
    521        and applies the given transformation function to each node.
    522
    523        Args:
    524            fun (function): a function which takes a node as an argument and returns a
    525                new transformed node or the same node without modifications. If the function
    526                returns None, then the corresponding node will be removed from the syntax tree.
    527            copy (bool): if set to True a new tree instance is constructed, otherwise the tree is
    528                modified in place.
    529
    530        Returns:
    531            The transformed tree.
    532        """
    533        node = self.copy() if copy else self
    534        new_node = fun(node, *args, **kwargs)
    535
    536        if new_node is None or not isinstance(new_node, Expression):
    537            return new_node
    538        if new_node is not node:
    539            new_node.parent = node.parent
    540            return new_node
    541
    542        replace_children(new_node, lambda child: child.transform(fun, *args, copy=False, **kwargs))
    543        return new_node
    544
    545    @t.overload
    546    def replace(self, expression: E) -> E:
    547        ...
    548
    549    @t.overload
    550    def replace(self, expression: None) -> None:
    551        ...
    552
    553    def replace(self, expression):
    554        """
    555        Swap out this expression with a new expression.
    556
    557        For example::
    558
    559            >>> tree = Select().select("x").from_("tbl")
    560            >>> tree.find(Column).replace(Column(this="y"))
    561            (COLUMN this: y)
    562            >>> tree.sql()
    563            'SELECT y FROM tbl'
    564
    565        Args:
    566            expression: new node
    567
    568        Returns:
    569            The new expression or expressions.
    570        """
    571        if not self.parent:
    572            return expression
    573
    574        parent = self.parent
    575        self.parent = None
    576
    577        replace_children(parent, lambda child: expression if child is self else child)
    578        return expression
    579
    580    def pop(self: E) -> E:
    581        """
    582        Remove this expression from its AST.
    583
    584        Returns:
    585            The popped expression.
    586        """
    587        self.replace(None)
    588        return self
    589
    590    def assert_is(self, type_: t.Type[E]) -> E:
    591        """
    592        Assert that this `Expression` is an instance of `type_`.
    593
    594        If it is NOT an instance of `type_`, this raises an assertion error.
    595        Otherwise, this returns this expression.
    596
    597        Examples:
    598            This is useful for type security in chained expressions:
    599
    600            >>> import sqlglot
    601            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
    602            'SELECT x, z FROM y'
    603        """
    604        assert isinstance(self, type_)
    605        return self
    606
    607    def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
    608        """
    609        Checks if this expression is valid (e.g. all mandatory args are set).
    610
    611        Args:
    612            args: a sequence of values that were used to instantiate a Func expression. This is used
    613                to check that the provided arguments don't exceed the function argument limit.
    614
    615        Returns:
    616            A list of error messages for all possible errors that were found.
    617        """
    618        errors: t.List[str] = []
    619
    620        for k in self.args:
    621            if k not in self.arg_types:
    622                errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
    623        for k, mandatory in self.arg_types.items():
    624            v = self.args.get(k)
    625            if mandatory and (v is None or (isinstance(v, list) and not v)):
    626                errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
    627
    628        if (
    629            args
    630            and isinstance(self, Func)
    631            and len(args) > len(self.arg_types)
    632            and not self.is_var_len_args
    633        ):
    634            errors.append(
    635                f"The number of provided arguments ({len(args)}) is greater than "
    636                f"the maximum number of supported arguments ({len(self.arg_types)})"
    637            )
    638
    639        return errors
    640
    641    def dump(self):
    642        """
    643        Dump this Expression to a JSON-serializable dict.
    644        """
    645        from sqlglot.serde import dump
    646
    647        return dump(self)
    648
    649    @classmethod
    650    def load(cls, obj):
    651        """
    652        Load a dict (as returned by `Expression.dump`) into an Expression instance.
    653        """
    654        from sqlglot.serde import load
    655
    656        return load(obj)

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 what arguments (child nodes) are 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.
- 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.

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

    89    def __init__(self, **args: t.Any):
    90        self.args: t.Dict[str, t.Any] = args
    91        self.parent: t.Optional[Expression] = None
    92        self.arg_key: t.Optional[str] = None
    93        self.comments: t.Optional[t.List[str]] = None
    94        self._type: t.Optional[DataType] = None
    95        self._meta: t.Optional[t.Dict[str, t.Any]] = None
    96        self._hash: t.Optional[int] = None
    97
    98        for arg_key, value in self.args.items():
    99            self._set_parent(arg_key, value)

this

Retrieves the argument with key "this".

expression

Retrieves the argument with key "expression".

expressions

Retrieves the argument with key "expressions".

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

    142    def text(self, key) -> str:
    143        """
    144        Returns a textual representation of the argument corresponding to "key". This can only be used
    145        for args that are strings or leaf Expression instances, such as identifiers and literals.
    146        """
    147        field = self.args.get(key)
    148        if isinstance(field, str):
    149            return field
    150        if isinstance(field, (Identifier, Literal, Var)):
    151            return field.this
    152        if isinstance(field, (Star, Null)):
    153            return field.name
    154        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

Checks whether a Literal expression is a string.

is_number: bool

Checks whether a Literal expression is a number.

is_int: bool

Checks whether a Literal expression is an integer.

is_star: bool

Checks whether an expression is a star.

alias: str

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

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

def copy(self): View Source

    252    def copy(self):
    253        """
    254        Returns a deep copy of the expression.
    255        """
    256        new = deepcopy(self)
    257        new.parent = self.parent
    258        return new

Returns a deep copy of the expression.

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

    260    def add_comments(self, comments: t.Optional[t.List[str]]) -> None:
    261        if self.comments is None:
    262            self.comments = []
    263        if comments:
    264            self.comments.extend(comments)

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

    266    def append(self, arg_key: str, value: t.Any) -> None:
    267        """
    268        Appends value to arg_key if it's a list or sets it as a new list.
    269
    270        Args:
    271            arg_key (str): name of the list expression arg
    272            value (Any): value to append to the list
    273        """
    274        if not isinstance(self.args.get(arg_key), list):
    275            self.args[arg_key] = []
    276        self.args[arg_key].append(value)
    277        self._set_parent(arg_key, 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) -> None: View Source

    279    def set(self, arg_key: str, value: t.Any) -> None:
    280        """
    281        Sets `arg_key` to `value`.
    282
    283        Args:
    284            arg_key (str): name of the expression arg.
    285            value: value to set the arg to.
    286        """
    287        self.args[arg_key] = value
    288        self._set_parent(arg_key, value)

Sets `arg_key` to `value`.

###### Arguments:

- arg_key (str): name of the expression arg.
- value: value to set the arg to.

depth: int

Returns the depth of this tree.

def iter_expressions(self) -> Iterator[Tuple[str, sqlglot.expressions.Expression]]: View Source

    309    def iter_expressions(self) -> t.Iterator[t.Tuple[str, Expression]]:
    310        """Yields the key and expression for all arguments, exploding list args."""
    311        for k, vs in self.args.items():
    312            if type(vs) is list:
    313                for v in vs:
    314                    if hasattr(v, "parent"):
    315                        yield k, v
    316            else:
    317                if hasattr(vs, "parent"):
    318                    yield k, 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

    320    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
    321        """
    322        Returns the first node in this tree which matches at least one of
    323        the specified types.
    324
    325        Args:
    326            expression_types: the expression type(s) to match.
    327            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    328
    329        Returns:
    330            The node which matches the criteria or None if no such node was found.
    331        """
    332        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

    334    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
    335        """
    336        Returns a generator object which visits all nodes in this tree and only
    337        yields those that match at least one of the specified expression types.
    338
    339        Args:
    340            expression_types: the expression type(s) to match.
    341            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    342
    343        Returns:
    344            The generator object.
    345        """
    346        for expression, *_ in self.walk(bfs=bfs):
    347            if isinstance(expression, expression_types):
    348                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

    350    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
    351        """
    352        Returns a nearest parent matching expression_types.
    353
    354        Args:
    355            expression_types: the expression type(s) to match.
    356
    357        Returns:
    358            The parent node.
    359        """
    360        ancestor = self.parent
    361        while ancestor and not isinstance(ancestor, expression_types):
    362            ancestor = ancestor.parent
    363        return t.cast(E, ancestor)

Returns a nearest parent matching expression_types.

###### Arguments:

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

###### Returns:

> The parent node.

parent_select: Optional[sqlglot.expressions.Select]

Returns the parent select statement.

same_parent: bool

Returns if the parent is the same class as itself.

def root(self) -> sqlglot.expressions.Expression: View Source

    377    def root(self) -> Expression:
    378        """
    379        Returns the root expression of this tree.
    380        """
    381        expression = self
    382        while expression.parent:
    383            expression = expression.parent
    384        return expression

Returns the root expression of this tree.

def walk(self, bfs=True, prune=None): View Source

    386    def walk(self, bfs=True, prune=None):
    387        """
    388        Returns a generator object which visits all nodes in this tree.
    389
    390        Args:
    391            bfs (bool): if set to True the BFS traversal order will be applied,
    392                otherwise the DFS traversal will be used instead.
    393            prune ((node, parent, arg_key) -> bool): callable that returns True if
    394                the generator should stop traversing this branch of the tree.
    395
    396        Returns:
    397            the generator object.
    398        """
    399        if bfs:
    400            yield from self.bfs(prune=prune)
    401        else:
    402            yield from self.dfs(prune=prune)

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

###### Arguments:

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

###### Returns:

> the generator object.

def dfs(self, parent=None, key=None, prune=None): View Source

    404    def dfs(self, parent=None, key=None, prune=None):
    405        """
    406        Returns a generator object which visits all nodes in this tree in
    407        the DFS (Depth-first) order.
    408
    409        Returns:
    410            The generator object.
    411        """
    412        parent = parent or self.parent
    413        yield self, parent, key
    414        if prune and prune(self, parent, key):
    415            return
    416
    417        for k, v in self.iter_expressions():
    418            yield from v.dfs(self, k, prune)

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=None): View Source

    420    def bfs(self, prune=None):
    421        """
    422        Returns a generator object which visits all nodes in this tree in
    423        the BFS (Breadth-first) order.
    424
    425        Returns:
    426            The generator object.
    427        """
    428        queue = deque([(self, self.parent, None)])
    429
    430        while queue:
    431            item, parent, key = queue.popleft()
    432
    433            yield item, parent, key
    434            if prune and prune(item, parent, key):
    435                continue
    436
    437            for k, v in item.iter_expressions():
    438                queue.append((v, item, k))

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

    440    def unnest(self):
    441        """
    442        Returns the first non parenthesis child or self.
    443        """
    444        expression = self
    445        while type(expression) is Paren:
    446            expression = expression.this
    447        return expression

Returns the first non parenthesis child or self.

def unalias(self): View Source

    449    def unalias(self):
    450        """
    451        Returns the inner expression if this is an Alias.
    452        """
    453        if isinstance(self, Alias):
    454            return self.this
    455        return self

Returns the inner expression if this is an Alias.

def unnest_operands(self): View Source

    457    def unnest_operands(self):
    458        """
    459        Returns unnested operands as a tuple.
    460        """
    461        return tuple(arg.unnest() for _, arg in self.iter_expressions())

Returns unnested operands as a tuple.

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

    463    def flatten(self, unnest=True):
    464        """
    465        Returns a generator which yields child nodes who's parents are the same class.
    466
    467        A AND B AND C -> [A, B, C]
    468        """
    469        for node, _, _ in self.dfs(prune=lambda n, p, *_: p and not type(n) is self.__class__):
    470            if not type(node) is self.__class__:
    471                yield node.unnest() if unnest else node

Returns a generator which yields child nodes who's parents are the same class.

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

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

    479    def sql(self, dialect: DialectType = None, **opts) -> str:
    480        """
    481        Returns SQL string representation of this tree.
    482
    483        Args:
    484            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
    485            opts: other `sqlglot.generator.Generator` options.
    486
    487        Returns:
    488            The SQL string.
    489        """
    490        from sqlglot.dialects import Dialect
    491
    492        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, *args, copy=True, **kwargs): View Source

    518    def transform(self, fun, *args, copy=True, **kwargs):
    519        """
    520        Recursively visits all tree nodes (excluding already transformed ones)
    521        and applies the given transformation function to each node.
    522
    523        Args:
    524            fun (function): a function which takes a node as an argument and returns a
    525                new transformed node or the same node without modifications. If the function
    526                returns None, then the corresponding node will be removed from the syntax tree.
    527            copy (bool): if set to True a new tree instance is constructed, otherwise the tree is
    528                modified in place.
    529
    530        Returns:
    531            The transformed tree.
    532        """
    533        node = self.copy() if copy else self
    534        new_node = fun(node, *args, **kwargs)
    535
    536        if new_node is None or not isinstance(new_node, Expression):
    537            return new_node
    538        if new_node is not node:
    539            new_node.parent = node.parent
    540            return new_node
    541
    542        replace_children(new_node, lambda child: child.transform(fun, *args, copy=False, **kwargs))
    543        return new_node

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

###### Arguments:

- fun (function): 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 (bool): 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

    553    def replace(self, expression):
    554        """
    555        Swap out this expression with a new expression.
    556
    557        For example::
    558
    559            >>> tree = Select().select("x").from_("tbl")
    560            >>> tree.find(Column).replace(Column(this="y"))
    561            (COLUMN this: y)
    562            >>> tree.sql()
    563            'SELECT y FROM tbl'
    564
    565        Args:
    566            expression: new node
    567
    568        Returns:
    569            The new expression or expressions.
    570        """
    571        if not self.parent:
    572            return expression
    573
    574        parent = self.parent
    575        self.parent = None
    576
    577        replace_children(parent, lambda child: expression if child is self else child)
    578        return expression

Swap out this expression with a new expression.

For example::

    >>> tree = Select().select("x").from_("tbl")
    >>> tree.find(Column).replace(Column(this="y"))
    (COLUMN this: y)
    >>> tree.sql()
    'SELECT y FROM tbl'

###### Arguments:

- expression: new node

###### Returns:

> The new expression or expressions.

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

    580    def pop(self: E) -> E:
    581        """
    582        Remove this expression from its AST.
    583
    584        Returns:
    585            The popped expression.
    586        """
    587        self.replace(None)
    588        return self

Remove this expression from its AST.

###### Returns:

> The popped expression.

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

    590    def assert_is(self, type_: t.Type[E]) -> E:
    591        """
    592        Assert that this `Expression` is an instance of `type_`.
    593
    594        If it is NOT an instance of `type_`, this raises an assertion error.
    595        Otherwise, this returns this expression.
    596
    597        Examples:
    598            This is useful for type security in chained expressions:
    599
    600            >>> import sqlglot
    601            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
    602            'SELECT x, z FROM y'
    603        """
    604        assert isinstance(self, type_)
    605        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

    607    def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
    608        """
    609        Checks if this expression is valid (e.g. all mandatory args are set).
    610
    611        Args:
    612            args: a sequence of values that were used to instantiate a Func expression. This is used
    613                to check that the provided arguments don't exceed the function argument limit.
    614
    615        Returns:
    616            A list of error messages for all possible errors that were found.
    617        """
    618        errors: t.List[str] = []
    619
    620        for k in self.args:
    621            if k not in self.arg_types:
    622                errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
    623        for k, mandatory in self.arg_types.items():
    624            v = self.args.get(k)
    625            if mandatory and (v is None or (isinstance(v, list) and not v)):
    626                errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
    627
    628        if (
    629            args
    630            and isinstance(self, Func)
    631            and len(args) > len(self.arg_types)
    632            and not self.is_var_len_args
    633        ):
    634            errors.append(
    635                f"The number of provided arguments ({len(args)}) is greater than "
    636                f"the maximum number of supported arguments ({len(self.arg_types)})"
    637            )
    638
    639        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

    641    def dump(self):
    642        """
    643        Dump this Expression to a JSON-serializable dict.
    644        """
    645        from sqlglot.serde import dump
    646
    647        return dump(self)

Dump this Expression to a JSON-serializable dict.

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

    649    @classmethod
    650    def load(cls, obj):
    651        """
    652        Load a dict (as returned by `Expression.dump`) into an Expression instance.
    653        """
    654        from sqlglot.serde import load
    655
    656        return load(obj)

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

class Condition(Expression): View Source

    667class Condition(Expression):
    668    def and_(
    669        self,
    670        *expressions: t.Optional[ExpOrStr],
    671        dialect: DialectType = None,
    672        copy: bool = True,
    673        **opts,
    674    ) -> Condition:
    675        """
    676        AND this condition with one or multiple expressions.
    677
    678        Example:
    679            >>> condition("x=1").and_("y=1").sql()
    680            'x = 1 AND y = 1'
    681
    682        Args:
    683            *expressions: the SQL code strings to parse.
    684                If an `Expression` instance is passed, it will be used as-is.
    685            dialect: the dialect used to parse the input expression.
    686            copy: whether or not to copy the involved expressions (only applies to Expressions).
    687            opts: other options to use to parse the input expressions.
    688
    689        Returns:
    690            The new And condition.
    691        """
    692        return and_(self, *expressions, dialect=dialect, copy=copy, **opts)
    693
    694    def or_(
    695        self,
    696        *expressions: t.Optional[ExpOrStr],
    697        dialect: DialectType = None,
    698        copy: bool = True,
    699        **opts,
    700    ) -> Condition:
    701        """
    702        OR this condition with one or multiple expressions.
    703
    704        Example:
    705            >>> condition("x=1").or_("y=1").sql()
    706            'x = 1 OR y = 1'
    707
    708        Args:
    709            *expressions: the SQL code strings to parse.
    710                If an `Expression` instance is passed, it will be used as-is.
    711            dialect: the dialect used to parse the input expression.
    712            copy: whether or not to copy the involved expressions (only applies to Expressions).
    713            opts: other options to use to parse the input expressions.
    714
    715        Returns:
    716            The new Or condition.
    717        """
    718        return or_(self, *expressions, dialect=dialect, copy=copy, **opts)
    719
    720    def not_(self, copy: bool = True):
    721        """
    722        Wrap this condition with NOT.
    723
    724        Example:
    725            >>> condition("x=1").not_().sql()
    726            'NOT x = 1'
    727
    728        Args:
    729            copy: whether or not to copy this object.
    730
    731        Returns:
    732            The new Not instance.
    733        """
    734        return not_(self, copy=copy)
    735
    736    def as_(
    737        self,
    738        alias: str | Identifier,
    739        quoted: t.Optional[bool] = None,
    740        dialect: DialectType = None,
    741        copy: bool = True,
    742        **opts,
    743    ) -> Alias:
    744        return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)
    745
    746    def _binop(self, klass: t.Type[E], other: t.Any, reverse: bool = False) -> E:
    747        this = self.copy()
    748        other = convert(other, copy=True)
    749        if not isinstance(this, klass) and not isinstance(other, klass):
    750            this = _wrap(this, Binary)
    751            other = _wrap(other, Binary)
    752        if reverse:
    753            return klass(this=other, expression=this)
    754        return klass(this=this, expression=other)
    755
    756    def __getitem__(self, other: ExpOrStr | t.Tuple[ExpOrStr]):
    757        return Bracket(
    758            this=self.copy(), expressions=[convert(e, copy=True) for e in ensure_list(other)]
    759        )
    760
    761    def isin(
    762        self, *expressions: t.Any, query: t.Optional[ExpOrStr] = None, copy: bool = True, **opts
    763    ) -> In:
    764        return In(
    765            this=_maybe_copy(self, copy),
    766            expressions=[convert(e, copy=copy) for e in expressions],
    767            query=maybe_parse(query, copy=copy, **opts) if query else None,
    768        )
    769
    770    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
    771        return Between(
    772            this=_maybe_copy(self, copy),
    773            low=convert(low, copy=copy, **opts),
    774            high=convert(high, copy=copy, **opts),
    775        )
    776
    777    def is_(self, other: ExpOrStr) -> Is:
    778        return self._binop(Is, other)
    779
    780    def like(self, other: ExpOrStr) -> Like:
    781        return self._binop(Like, other)
    782
    783    def ilike(self, other: ExpOrStr) -> ILike:
    784        return self._binop(ILike, other)
    785
    786    def eq(self, other: t.Any) -> EQ:
    787        return self._binop(EQ, other)
    788
    789    def neq(self, other: t.Any) -> NEQ:
    790        return self._binop(NEQ, other)
    791
    792    def rlike(self, other: ExpOrStr) -> RegexpLike:
    793        return self._binop(RegexpLike, other)
    794
    795    def __lt__(self, other: t.Any) -> LT:
    796        return self._binop(LT, other)
    797
    798    def __le__(self, other: t.Any) -> LTE:
    799        return self._binop(LTE, other)
    800
    801    def __gt__(self, other: t.Any) -> GT:
    802        return self._binop(GT, other)
    803
    804    def __ge__(self, other: t.Any) -> GTE:
    805        return self._binop(GTE, other)
    806
    807    def __add__(self, other: t.Any) -> Add:
    808        return self._binop(Add, other)
    809
    810    def __radd__(self, other: t.Any) -> Add:
    811        return self._binop(Add, other, reverse=True)
    812
    813    def __sub__(self, other: t.Any) -> Sub:
    814        return self._binop(Sub, other)
    815
    816    def __rsub__(self, other: t.Any) -> Sub:
    817        return self._binop(Sub, other, reverse=True)
    818
    819    def __mul__(self, other: t.Any) -> Mul:
    820        return self._binop(Mul, other)
    821
    822    def __rmul__(self, other: t.Any) -> Mul:
    823        return self._binop(Mul, other, reverse=True)
    824
    825    def __truediv__(self, other: t.Any) -> Div:
    826        return self._binop(Div, other)
    827
    828    def __rtruediv__(self, other: t.Any) -> Div:
    829        return self._binop(Div, other, reverse=True)
    830
    831    def __floordiv__(self, other: t.Any) -> IntDiv:
    832        return self._binop(IntDiv, other)
    833
    834    def __rfloordiv__(self, other: t.Any) -> IntDiv:
    835        return self._binop(IntDiv, other, reverse=True)
    836
    837    def __mod__(self, other: t.Any) -> Mod:
    838        return self._binop(Mod, other)
    839
    840    def __rmod__(self, other: t.Any) -> Mod:
    841        return self._binop(Mod, other, reverse=True)
    842
    843    def __pow__(self, other: t.Any) -> Pow:
    844        return self._binop(Pow, other)
    845
    846    def __rpow__(self, other: t.Any) -> Pow:
    847        return self._binop(Pow, other, reverse=True)
    848
    849    def __and__(self, other: t.Any) -> And:
    850        return self._binop(And, other)
    851
    852    def __rand__(self, other: t.Any) -> And:
    853        return self._binop(And, other, reverse=True)
    854
    855    def __or__(self, other: t.Any) -> Or:
    856        return self._binop(Or, other)
    857
    858    def __ror__(self, other: t.Any) -> Or:
    859        return self._binop(Or, other, reverse=True)
    860
    861    def __neg__(self) -> Neg:
    862        return Neg(this=_wrap(self.copy(), Binary))
    863
    864    def __invert__(self) -> Not:
    865        return not_(self.copy())

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

    668    def and_(
    669        self,
    670        *expressions: t.Optional[ExpOrStr],
    671        dialect: DialectType = None,
    672        copy: bool = True,
    673        **opts,
    674    ) -> Condition:
    675        """
    676        AND this condition with one or multiple expressions.
    677
    678        Example:
    679            >>> condition("x=1").and_("y=1").sql()
    680            'x = 1 AND y = 1'
    681
    682        Args:
    683            *expressions: the SQL code strings to parse.
    684                If an `Expression` instance is passed, it will be used as-is.
    685            dialect: the dialect used to parse the input expression.
    686            copy: whether or not to copy the involved expressions (only applies to Expressions).
    687            opts: other options to use to parse the input expressions.
    688
    689        Returns:
    690            The new And condition.
    691        """
    692        return and_(self, *expressions, dialect=dialect, copy=copy, **opts)

AND this condition with one or multiple expressions.

###### Example:

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

###### Arguments:

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

###### Returns:

> The new And condition.

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

    694    def or_(
    695        self,
    696        *expressions: t.Optional[ExpOrStr],
    697        dialect: DialectType = None,
    698        copy: bool = True,
    699        **opts,
    700    ) -> Condition:
    701        """
    702        OR this condition with one or multiple expressions.
    703
    704        Example:
    705            >>> condition("x=1").or_("y=1").sql()
    706            'x = 1 OR y = 1'
    707
    708        Args:
    709            *expressions: the SQL code strings to parse.
    710                If an `Expression` instance is passed, it will be used as-is.
    711            dialect: the dialect used to parse the input expression.
    712            copy: whether or not to copy the involved expressions (only applies to Expressions).
    713            opts: other options to use to parse the input expressions.
    714
    715        Returns:
    716            The new Or condition.
    717        """
    718        return or_(self, *expressions, dialect=dialect, copy=copy, **opts)

OR this condition with one or multiple expressions.

###### Example:

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

###### Arguments:

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

###### Returns:

> The new Or condition.

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

    720    def not_(self, copy: bool = True):
    721        """
    722        Wrap this condition with NOT.
    723
    724        Example:
    725            >>> condition("x=1").not_().sql()
    726            'NOT x = 1'
    727
    728        Args:
    729            copy: whether or not to copy this object.
    730
    731        Returns:
    732            The new Not instance.
    733        """
    734        return not_(self, copy=copy)

Wrap this condition with NOT.

###### Example:

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

###### Arguments:

- copy: whether or not to copy this object.

###### Returns:

> The new Not instance.

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

    736    def as_(
    737        self,
    738        alias: str | Identifier,
    739        quoted: t.Optional[bool] = None,
    740        dialect: DialectType = None,
    741        copy: bool = True,
    742        **opts,
    743    ) -> Alias:
    744        return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)

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

    761    def isin(
    762        self, *expressions: t.Any, query: t.Optional[ExpOrStr] = None, copy: bool = True, **opts
    763    ) -> In:
    764        return In(
    765            this=_maybe_copy(self, copy),
    766            expressions=[convert(e, copy=copy) for e in expressions],
    767            query=maybe_parse(query, copy=copy, **opts) if query else None,
    768        )

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

    770    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
    771        return Between(
    772            this=_maybe_copy(self, copy),
    773            low=convert(low, copy=copy, **opts),
    774            high=convert(high, copy=copy, **opts),
    775        )

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

    777    def is_(self, other: ExpOrStr) -> Is:
    778        return self._binop(Is, other)

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

    780    def like(self, other: ExpOrStr) -> Like:
    781        return self._binop(Like, other)

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

    783    def ilike(self, other: ExpOrStr) -> ILike:
    784        return self._binop(ILike, other)

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

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

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

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

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

    792    def rlike(self, other: ExpOrStr) -> RegexpLike:
    793        return self._binop(RegexpLike, other)

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Predicate(Condition): View Source

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

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DerivedTable(Expression): View Source

    872class DerivedTable(Expression):
    873    @property
    874    def alias_column_names(self) -> t.List[str]:
    875        table_alias = self.args.get("alias")
    876        if not table_alias:
    877            return []
    878        return [c.name for c in table_alias.args.get("columns") or []]
    879
    880    @property
    881    def selects(self):
    882        return self.this.selects if isinstance(self.this, Subqueryable) else []
    883
    884    @property
    885    def named_selects(self):
    886        return [select.output_name for select in self.selects]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Unionable(Expression): View Source

    889class Unionable(Expression):
    890    def union(
    891        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    892    ) -> Unionable:
    893        """
    894        Builds a UNION expression.
    895
    896        Example:
    897            >>> import sqlglot
    898            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    899            'SELECT * FROM foo UNION SELECT * FROM bla'
    900
    901        Args:
    902            expression: the SQL code string.
    903                If an `Expression` instance is passed, it will be used as-is.
    904            distinct: set the DISTINCT flag if and only if this is true.
    905            dialect: the dialect used to parse the input expression.
    906            opts: other options to use to parse the input expressions.
    907
    908        Returns:
    909            The new Union expression.
    910        """
    911        return union(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)
    912
    913    def intersect(
    914        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    915    ) -> Unionable:
    916        """
    917        Builds an INTERSECT expression.
    918
    919        Example:
    920            >>> import sqlglot
    921            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    922            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    923
    924        Args:
    925            expression: the SQL code string.
    926                If an `Expression` instance is passed, it will be used as-is.
    927            distinct: set the DISTINCT flag if and only if this is true.
    928            dialect: the dialect used to parse the input expression.
    929            opts: other options to use to parse the input expressions.
    930
    931        Returns:
    932            The new Intersect expression.
    933        """
    934        return intersect(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)
    935
    936    def except_(
    937        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    938    ) -> Unionable:
    939        """
    940        Builds an EXCEPT expression.
    941
    942        Example:
    943            >>> import sqlglot
    944            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    945            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    946
    947        Args:
    948            expression: the SQL code string.
    949                If an `Expression` instance is passed, it will be used as-is.
    950            distinct: set the DISTINCT flag if and only if this is true.
    951            dialect: the dialect used to parse the input expression.
    952            opts: other options to use to parse the input expressions.
    953
    954        Returns:
    955            The new Except expression.
    956        """
    957        return except_(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)

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

    890    def union(
    891        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    892    ) -> Unionable:
    893        """
    894        Builds a UNION expression.
    895
    896        Example:
    897            >>> import sqlglot
    898            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    899            'SELECT * FROM foo UNION SELECT * FROM bla'
    900
    901        Args:
    902            expression: the SQL code string.
    903                If an `Expression` instance is passed, it will be used as-is.
    904            distinct: set the DISTINCT flag if and only if this is true.
    905            dialect: the dialect used to parse the input expression.
    906            opts: other options to use to parse the input expressions.
    907
    908        Returns:
    909            The new Union expression.
    910        """
    911        return union(left=self, right=expression, 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:

- expression: the SQL code string. If an `Expression` instance is passed, it 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, expression: Union[str, sqlglot.expressions.Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> sqlglot.expressions.Unionable: View Source

    913    def intersect(
    914        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    915    ) -> Unionable:
    916        """
    917        Builds an INTERSECT expression.
    918
    919        Example:
    920            >>> import sqlglot
    921            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    922            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    923
    924        Args:
    925            expression: the SQL code string.
    926                If an `Expression` instance is passed, it will be used as-is.
    927            distinct: set the DISTINCT flag if and only if this is true.
    928            dialect: the dialect used to parse the input expression.
    929            opts: other options to use to parse the input expressions.
    930
    931        Returns:
    932            The new Intersect expression.
    933        """
    934        return intersect(left=self, right=expression, 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:

- expression: the SQL code string. If an `Expression` instance is passed, it 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, expression: Union[str, sqlglot.expressions.Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> sqlglot.expressions.Unionable: View Source

    936    def except_(
    937        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    938    ) -> Unionable:
    939        """
    940        Builds an EXCEPT expression.
    941
    942        Example:
    943            >>> import sqlglot
    944            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    945            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    946
    947        Args:
    948            expression: the SQL code string.
    949                If an `Expression` instance is passed, it will be used as-is.
    950            distinct: set the DISTINCT flag if and only if this is true.
    951            dialect: the dialect used to parse the input expression.
    952            opts: other options to use to parse the input expressions.
    953
    954        Returns:
    955            The new Except expression.
    956        """
    957        return except_(left=self, right=expression, 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:

- expression: the SQL code string. If an `Expression` instance is passed, it 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.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class UDTF(DerivedTable, Unionable): View Source

    960class UDTF(DerivedTable, Unionable):
    961    @property
    962    def selects(self):
    963        alias = self.args.get("alias")
    964        return alias.columns if alias else []

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Unionable
  union
  intersect
  except_

class Cache(Expression): View Source

    967class Cache(Expression):
    968    arg_types = {
    969        "with": False,
    970        "this": True,
    971        "lazy": False,
    972        "options": False,
    973        "expression": False,
    974    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Uncache(Expression): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Create(Expression): View Source

    981class Create(Expression):
    982    arg_types = {
    983        "with": False,
    984        "this": True,
    985        "kind": True,
    986        "expression": False,
    987        "exists": False,
    988        "properties": False,
    989        "replace": False,
    990        "unique": False,
    991        "indexes": False,
    992        "no_schema_binding": False,
    993        "begin": False,
    994        "clone": False,
    995    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Clone(Expression): View Source

     999class Clone(Expression):
    1000    arg_types = {
    1001        "this": True,
    1002        "when": False,
    1003        "kind": False,
    1004        "expression": False,
    1005    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Describe(Expression): View Source

    1008class Describe(Expression):
    1009    arg_types = {"this": True, "kind": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Pragma(Expression): View Source

    1012class Pragma(Expression):
    1013    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Set(Expression): View Source

    1016class Set(Expression):
    1017    arg_types = {"expressions": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SetItem(Expression): View Source

    1020class SetItem(Expression):
    1021    arg_types = {
    1022        "this": False,
    1023        "expressions": False,
    1024        "kind": False,
    1025        "collate": False,  # MySQL SET NAMES statement
    1026        "global": False,
    1027    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Show(Expression): View Source

    1030class Show(Expression):
    1031    arg_types = {
    1032        "this": True,
    1033        "target": False,
    1034        "offset": False,
    1035        "limit": False,
    1036        "like": False,
    1037        "where": False,
    1038        "db": False,
    1039        "full": False,
    1040        "mutex": False,
    1041        "query": False,
    1042        "channel": False,
    1043        "global": False,
    1044        "log": False,
    1045        "position": False,
    1046        "types": False,
    1047    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class UserDefinedFunction(Expression): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CharacterSet(Expression): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class With(Expression): View Source

    1058class With(Expression):
    1059    arg_types = {"expressions": True, "recursive": False}
    1060
    1061    @property
    1062    def recursive(self) -> bool:
    1063        return bool(self.args.get("recursive"))

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class WithinGroup(Expression): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CTE(DerivedTable): View Source

    1070class CTE(DerivedTable):
    1071    arg_types = {"this": True, "alias": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TableAlias(Expression): View Source

    1074class TableAlias(Expression):
    1075    arg_types = {"this": False, "columns": False}
    1076
    1077    @property
    1078    def columns(self):
    1079        return self.args.get("columns") or []

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class BitString(Condition): View Source

    1082class BitString(Condition):
    1083    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class HexString(Condition): View Source

    1086class HexString(Condition):
    1087    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ByteString(Condition): View Source

    1090class ByteString(Condition):
    1091    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class RawString(Condition): View Source

    1094class RawString(Condition):
    1095    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Column(Condition): View Source

    1098class Column(Condition):
    1099    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
    1100
    1101    @property
    1102    def table(self) -> str:
    1103        return self.text("table")
    1104
    1105    @property
    1106    def db(self) -> str:
    1107        return self.text("db")
    1108
    1109    @property
    1110    def catalog(self) -> str:
    1111        return self.text("catalog")
    1112
    1113    @property
    1114    def output_name(self) -> str:
    1115        return self.name
    1116
    1117    @property
    1118    def parts(self) -> t.List[Identifier]:
    1119        """Return the parts of a column in order catalog, db, table, name."""
    1120        return [
    1121            t.cast(Identifier, self.args[part])
    1122            for part in ("catalog", "db", "table", "this")
    1123            if self.args.get(part)
    1124        ]
    1125
    1126    def to_dot(self) -> Dot:
    1127        """Converts the column into a dot expression."""
    1128        parts = self.parts
    1129        parent = self.parent
    1130
    1131        while parent:
    1132            if isinstance(parent, Dot):
    1133                parts.append(parent.expression)
    1134            parent = parent.parent
    1135
    1136        return Dot.build(parts)

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

parts: List[sqlglot.expressions.Identifier]

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

def to_dot(self) -> sqlglot.expressions.Dot: View Source

    1126    def to_dot(self) -> Dot:
    1127        """Converts the column into a dot expression."""
    1128        parts = self.parts
    1129        parent = self.parent
    1130
    1131        while parent:
    1132            if isinstance(parent, Dot):
    1133                parts.append(parent.expression)
    1134            parent = parent.parent
    1135
    1136        return Dot.build(parts)

Converts the column into a dot expression.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ColumnPosition(Expression): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ColumnDef(Expression): View Source

    1143class ColumnDef(Expression):
    1144    arg_types = {
    1145        "this": True,
    1146        "kind": False,
    1147        "constraints": False,
    1148        "exists": False,
    1149        "position": False,
    1150    }
    1151
    1152    @property
    1153    def constraints(self) -> t.List[ColumnConstraint]:
    1154        return self.args.get("constraints") or []

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class AlterColumn(Expression): View Source

    1157class AlterColumn(Expression):
    1158    arg_types = {
    1159        "this": True,
    1160        "dtype": False,
    1161        "collate": False,
    1162        "using": False,
    1163        "default": False,
    1164        "drop": False,
    1165    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class RenameTable(Expression): View Source

    1168class RenameTable(Expression):
    1169    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SetTag(Expression): View Source

    1172class SetTag(Expression):
    1173    arg_types = {"expressions": True, "unset": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Comment(Expression): View Source

    1176class Comment(Expression):
    1177    arg_types = {"this": True, "kind": True, "expression": True, "exists": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class MergeTreeTTLAction(Expression): View Source

    1181class MergeTreeTTLAction(Expression):
    1182    arg_types = {
    1183        "this": True,
    1184        "delete": False,
    1185        "recompress": False,
    1186        "to_disk": False,
    1187        "to_volume": False,
    1188    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class MergeTreeTTL(Expression): View Source

    1192class MergeTreeTTL(Expression):
    1193    arg_types = {
    1194        "expressions": True,
    1195        "where": False,
    1196        "group": False,
    1197        "aggregates": False,
    1198    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ColumnConstraint(Expression): View Source

    1201class ColumnConstraint(Expression):
    1202    arg_types = {"this": False, "kind": True}
    1203
    1204    @property
    1205    def kind(self) -> ColumnConstraintKind:
    1206        return self.args["kind"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ColumnConstraintKind(Expression): View Source

    1209class ColumnConstraintKind(Expression):
    1210    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class AutoIncrementColumnConstraint(ColumnConstraintKind): View Source

    1213class AutoIncrementColumnConstraint(ColumnConstraintKind):
    1214    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CaseSpecificColumnConstraint(ColumnConstraintKind): View Source

    1217class CaseSpecificColumnConstraint(ColumnConstraintKind):
    1218    arg_types = {"not_": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CharacterSetColumnConstraint(ColumnConstraintKind): View Source

    1221class CharacterSetColumnConstraint(ColumnConstraintKind):
    1222    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CheckColumnConstraint(ColumnConstraintKind): View Source

    1225class CheckColumnConstraint(ColumnConstraintKind):
    1226    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CollateColumnConstraint(ColumnConstraintKind): View Source

    1229class CollateColumnConstraint(ColumnConstraintKind):
    1230    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CommentColumnConstraint(ColumnConstraintKind): View Source

    1233class CommentColumnConstraint(ColumnConstraintKind):
    1234    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CompressColumnConstraint(ColumnConstraintKind): View Source

    1237class CompressColumnConstraint(ColumnConstraintKind):
    1238    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DateFormatColumnConstraint(ColumnConstraintKind): View Source

    1241class DateFormatColumnConstraint(ColumnConstraintKind):
    1242    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DefaultColumnConstraint(ColumnConstraintKind): View Source

    1245class DefaultColumnConstraint(ColumnConstraintKind):
    1246    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class EncodeColumnConstraint(ColumnConstraintKind): View Source

    1249class EncodeColumnConstraint(ColumnConstraintKind):
    1250    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind): View Source

    1253class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
    1254    # this: True -> ALWAYS, this: False -> BY DEFAULT
    1255    arg_types = {
    1256        "this": False,
    1257        "expression": False,
    1258        "on_null": False,
    1259        "start": False,
    1260        "increment": False,
    1261        "minvalue": False,
    1262        "maxvalue": False,
    1263        "cycle": False,
    1264    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class InlineLengthColumnConstraint(ColumnConstraintKind): View Source

    1267class InlineLengthColumnConstraint(ColumnConstraintKind):
    1268    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class NotNullColumnConstraint(ColumnConstraintKind): View Source

    1271class NotNullColumnConstraint(ColumnConstraintKind):
    1272    arg_types = {"allow_null": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class OnUpdateColumnConstraint(ColumnConstraintKind): View Source

    1276class OnUpdateColumnConstraint(ColumnConstraintKind):
    1277    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class PrimaryKeyColumnConstraint(ColumnConstraintKind): View Source

    1280class PrimaryKeyColumnConstraint(ColumnConstraintKind):
    1281    arg_types = {"desc": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TitleColumnConstraint(ColumnConstraintKind): View Source

    1284class TitleColumnConstraint(ColumnConstraintKind):
    1285    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class UniqueColumnConstraint(ColumnConstraintKind): View Source

    1288class UniqueColumnConstraint(ColumnConstraintKind):
    1289    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class UppercaseColumnConstraint(ColumnConstraintKind): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class PathColumnConstraint(ColumnConstraintKind): View Source

    1296class PathColumnConstraint(ColumnConstraintKind):
    1297    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Constraint(Expression): View Source

    1300class Constraint(Expression):
    1301    arg_types = {"this": True, "expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Delete(Expression): View Source

    1304class Delete(Expression):
    1305    arg_types = {"with": False, "this": False, "using": False, "where": False, "returning": False}
    1306
    1307    def delete(
    1308        self,
    1309        table: ExpOrStr,
    1310        dialect: DialectType = None,
    1311        copy: bool = True,
    1312        **opts,
    1313    ) -> Delete:
    1314        """
    1315        Create a DELETE expression or replace the table on an existing DELETE expression.
    1316
    1317        Example:
    1318            >>> delete("tbl").sql()
    1319            'DELETE FROM tbl'
    1320
    1321        Args:
    1322            table: the table from which to delete.
    1323            dialect: the dialect used to parse the input expression.
    1324            copy: if `False`, modify this expression instance in-place.
    1325            opts: other options to use to parse the input expressions.
    1326
    1327        Returns:
    1328            Delete: the modified expression.
    1329        """
    1330        return _apply_builder(
    1331            expression=table,
    1332            instance=self,
    1333            arg="this",
    1334            dialect=dialect,
    1335            into=Table,
    1336            copy=copy,
    1337            **opts,
    1338        )
    1339
    1340    def where(
    1341        self,
    1342        *expressions: t.Optional[ExpOrStr],
    1343        append: bool = True,
    1344        dialect: DialectType = None,
    1345        copy: bool = True,
    1346        **opts,
    1347    ) -> Delete:
    1348        """
    1349        Append to or set the WHERE expressions.
    1350
    1351        Example:
    1352            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1353            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1354
    1355        Args:
    1356            *expressions: the SQL code strings to parse.
    1357                If an `Expression` instance is passed, it will be used as-is.
    1358                Multiple expressions are combined with an AND operator.
    1359            append: if `True`, AND the new expressions to any existing expression.
    1360                Otherwise, this resets the expression.
    1361            dialect: the dialect used to parse the input expressions.
    1362            copy: if `False`, modify this expression instance in-place.
    1363            opts: other options to use to parse the input expressions.
    1364
    1365        Returns:
    1366            Delete: the modified expression.
    1367        """
    1368        return _apply_conjunction_builder(
    1369            *expressions,
    1370            instance=self,
    1371            arg="where",
    1372            append=append,
    1373            into=Where,
    1374            dialect=dialect,
    1375            copy=copy,
    1376            **opts,
    1377        )
    1378
    1379    def returning(
    1380        self,
    1381        expression: ExpOrStr,
    1382        dialect: DialectType = None,
    1383        copy: bool = True,
    1384        **opts,
    1385    ) -> Delete:
    1386        """
    1387        Set the RETURNING expression. Not supported by all dialects.
    1388
    1389        Example:
    1390            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1391            'DELETE FROM tbl RETURNING *'
    1392
    1393        Args:
    1394            expression: the SQL code strings to parse.
    1395                If an `Expression` instance is passed, it will be used as-is.
    1396            dialect: the dialect used to parse the input expressions.
    1397            copy: if `False`, modify this expression instance in-place.
    1398            opts: other options to use to parse the input expressions.
    1399
    1400        Returns:
    1401            Delete: the modified expression.
    1402        """
    1403        return _apply_builder(
    1404            expression=expression,
    1405            instance=self,
    1406            arg="returning",
    1407            prefix="RETURNING",
    1408            dialect=dialect,
    1409            copy=copy,
    1410            into=Returning,
    1411            **opts,
    1412        )

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

    1307    def delete(
    1308        self,
    1309        table: ExpOrStr,
    1310        dialect: DialectType = None,
    1311        copy: bool = True,
    1312        **opts,
    1313    ) -> Delete:
    1314        """
    1315        Create a DELETE expression or replace the table on an existing DELETE expression.
    1316
    1317        Example:
    1318            >>> delete("tbl").sql()
    1319            'DELETE FROM tbl'
    1320
    1321        Args:
    1322            table: the table from which to delete.
    1323            dialect: the dialect used to parse the input expression.
    1324            copy: if `False`, modify this expression instance in-place.
    1325            opts: other options to use to parse the input expressions.
    1326
    1327        Returns:
    1328            Delete: the modified expression.
    1329        """
    1330        return _apply_builder(
    1331            expression=table,
    1332            instance=self,
    1333            arg="this",
    1334            dialect=dialect,
    1335            into=Table,
    1336            copy=copy,
    1337            **opts,
    1338        )

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

    1340    def where(
    1341        self,
    1342        *expressions: t.Optional[ExpOrStr],
    1343        append: bool = True,
    1344        dialect: DialectType = None,
    1345        copy: bool = True,
    1346        **opts,
    1347    ) -> Delete:
    1348        """
    1349        Append to or set the WHERE expressions.
    1350
    1351        Example:
    1352            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1353            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1354
    1355        Args:
    1356            *expressions: the SQL code strings to parse.
    1357                If an `Expression` instance is passed, it will be used as-is.
    1358                Multiple expressions are combined with an AND operator.
    1359            append: if `True`, AND the new expressions to any existing expression.
    1360                Otherwise, this resets the expression.
    1361            dialect: the dialect used to parse the input expressions.
    1362            copy: if `False`, modify this expression instance in-place.
    1363            opts: other options to use to parse the input expressions.
    1364
    1365        Returns:
    1366            Delete: the modified expression.
    1367        """
    1368        return _apply_conjunction_builder(
    1369            *expressions,
    1370            instance=self,
    1371            arg="where",
    1372            append=append,
    1373            into=Where,
    1374            dialect=dialect,
    1375            copy=copy,
    1376            **opts,
    1377        )

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.

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

    1379    def returning(
    1380        self,
    1381        expression: ExpOrStr,
    1382        dialect: DialectType = None,
    1383        copy: bool = True,
    1384        **opts,
    1385    ) -> Delete:
    1386        """
    1387        Set the RETURNING expression. Not supported by all dialects.
    1388
    1389        Example:
    1390            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1391            'DELETE FROM tbl RETURNING *'
    1392
    1393        Args:
    1394            expression: the SQL code strings to parse.
    1395                If an `Expression` instance is passed, it will be used as-is.
    1396            dialect: the dialect used to parse the input expressions.
    1397            copy: if `False`, modify this expression instance in-place.
    1398            opts: other options to use to parse the input expressions.
    1399
    1400        Returns:
    1401            Delete: the modified expression.
    1402        """
    1403        return _apply_builder(
    1404            expression=expression,
    1405            instance=self,
    1406            arg="returning",
    1407            prefix="RETURNING",
    1408            dialect=dialect,
    1409            copy=copy,
    1410            into=Returning,
    1411            **opts,
    1412        )

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.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Drop(Expression): View Source

    1415class Drop(Expression):
    1416    arg_types = {
    1417        "this": False,
    1418        "kind": False,
    1419        "exists": False,
    1420        "temporary": False,
    1421        "materialized": False,
    1422        "cascade": False,
    1423        "constraints": False,
    1424        "purge": False,
    1425    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Filter(Expression): View Source

    1428class Filter(Expression):
    1429    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Check(Expression): View Source

    1432class Check(Expression):
    1433    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Directory(Expression): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ForeignKey(Expression): View Source

    1441class ForeignKey(Expression):
    1442    arg_types = {
    1443        "expressions": True,
    1444        "reference": False,
    1445        "delete": False,
    1446        "update": False,
    1447    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class PrimaryKey(Expression): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Into(Expression): View Source

    1456class Into(Expression):
    1457    arg_types = {"this": True, "temporary": False, "unlogged": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class From(Expression): View Source

    1460class From(Expression):
    1461    @property
    1462    def name(self) -> str:
    1463        return self.this.name
    1464
    1465    @property
    1466    def alias_or_name(self) -> str:
    1467        return self.this.alias_or_name

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Having(Expression): View Source

    1470class Having(Expression):
    1471    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Hint(Expression): View Source

    1474class Hint(Expression):
    1475    arg_types = {"expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class JoinHint(Expression): View Source

    1478class JoinHint(Expression):
    1479    arg_types = {"this": True, "expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Identifier(Expression): View Source

    1482class Identifier(Expression):
    1483    arg_types = {"this": True, "quoted": False}
    1484
    1485    @property
    1486    def quoted(self) -> bool:
    1487        return bool(self.args.get("quoted"))
    1488
    1489    @property
    1490    def hashable_args(self) -> t.Any:
    1491        if self.quoted and any(char.isupper() for char in self.this):
    1492            return (self.this, self.quoted)
    1493        return self.this.lower()
    1494
    1495    @property
    1496    def output_name(self) -> str:
    1497        return self.name

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Index(Expression): View Source

    1500class Index(Expression):
    1501    arg_types = {
    1502        "this": False,
    1503        "table": False,
    1504        "using": False,
    1505        "where": False,
    1506        "columns": False,
    1507        "unique": False,
    1508        "primary": False,
    1509        "amp": False,  # teradata
    1510        "partition_by": False,  # teradata
    1511    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Insert(Expression): View Source

    1514class Insert(Expression):
    1515    arg_types = {
    1516        "with": False,
    1517        "this": True,
    1518        "expression": False,
    1519        "conflict": False,
    1520        "returning": False,
    1521        "overwrite": False,
    1522        "exists": False,
    1523        "partition": False,
    1524        "alternative": False,
    1525    }
    1526
    1527    def with_(
    1528        self,
    1529        alias: ExpOrStr,
    1530        as_: ExpOrStr,
    1531        recursive: t.Optional[bool] = None,
    1532        append: bool = True,
    1533        dialect: DialectType = None,
    1534        copy: bool = True,
    1535        **opts,
    1536    ) -> Insert:
    1537        """
    1538        Append to or set the common table expressions.
    1539
    1540        Example:
    1541            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    1542            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    1543
    1544        Args:
    1545            alias: the SQL code string to parse as the table name.
    1546                If an `Expression` instance is passed, this is used as-is.
    1547            as_: the SQL code string to parse as the table expression.
    1548                If an `Expression` instance is passed, it will be used as-is.
    1549            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1550            append: if `True`, add to any existing expressions.
    1551                Otherwise, this resets the expressions.
    1552            dialect: the dialect used to parse the input expression.
    1553            copy: if `False`, modify this expression instance in-place.
    1554            opts: other options to use to parse the input expressions.
    1555
    1556        Returns:
    1557            The modified expression.
    1558        """
    1559        return _apply_cte_builder(
    1560            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    1561        )

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

    1527    def with_(
    1528        self,
    1529        alias: ExpOrStr,
    1530        as_: ExpOrStr,
    1531        recursive: t.Optional[bool] = None,
    1532        append: bool = True,
    1533        dialect: DialectType = None,
    1534        copy: bool = True,
    1535        **opts,
    1536    ) -> Insert:
    1537        """
    1538        Append to or set the common table expressions.
    1539
    1540        Example:
    1541            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    1542            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    1543
    1544        Args:
    1545            alias: the SQL code string to parse as the table name.
    1546                If an `Expression` instance is passed, this is used as-is.
    1547            as_: the SQL code string to parse as the table expression.
    1548                If an `Expression` instance is passed, it will be used as-is.
    1549            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1550            append: if `True`, add to any existing expressions.
    1551                Otherwise, this resets the expressions.
    1552            dialect: the dialect used to parse the input expression.
    1553            copy: if `False`, modify this expression instance in-place.
    1554            opts: other options to use to parse the input expressions.
    1555
    1556        Returns:
    1557            The modified expression.
    1558        """
    1559        return _apply_cte_builder(
    1560            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    1561        )

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`.
- 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.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class OnConflict(Expression): View Source

    1564class OnConflict(Expression):
    1565    arg_types = {
    1566        "duplicate": False,
    1567        "expressions": False,
    1568        "nothing": False,
    1569        "key": False,
    1570        "constraint": False,
    1571    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Returning(Expression): View Source

    1574class Returning(Expression):
    1575    arg_types = {"expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Introducer(Expression): View Source

    1579class Introducer(Expression):
    1580    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class National(Expression): View Source

    1584class National(Expression):
    1585    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class LoadData(Expression): View Source

    1588class LoadData(Expression):
    1589    arg_types = {
    1590        "this": True,
    1591        "local": False,
    1592        "overwrite": False,
    1593        "inpath": True,
    1594        "partition": False,
    1595        "input_format": False,
    1596        "serde": False,
    1597    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Partition(Expression): View Source

    1600class Partition(Expression):
    1601    arg_types = {"expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Fetch(Expression): View Source

    1604class Fetch(Expression):
    1605    arg_types = {
    1606        "direction": False,
    1607        "count": False,
    1608        "percent": False,
    1609        "with_ties": False,
    1610    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Group(Expression): View Source

    1613class Group(Expression):
    1614    arg_types = {
    1615        "expressions": False,
    1616        "grouping_sets": False,
    1617        "cube": False,
    1618        "rollup": False,
    1619        "totals": False,
    1620    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Lambda(Expression): View Source

    1623class Lambda(Expression):
    1624    arg_types = {"this": True, "expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Limit(Expression): View Source

    1627class Limit(Expression):
    1628    arg_types = {"this": False, "expression": True, "offset": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Literal(Condition): View Source

    1631class Literal(Condition):
    1632    arg_types = {"this": True, "is_string": True}
    1633
    1634    @property
    1635    def hashable_args(self) -> t.Any:
    1636        return (self.this, self.args.get("is_string"))
    1637
    1638    @classmethod
    1639    def number(cls, number) -> Literal:
    1640        return cls(this=str(number), is_string=False)
    1641
    1642    @classmethod
    1643    def string(cls, string) -> Literal:
    1644        return cls(this=str(string), is_string=True)
    1645
    1646    @property
    1647    def output_name(self) -> str:
    1648        return self.name

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

    1638    @classmethod
    1639    def number(cls, number) -> Literal:
    1640        return cls(this=str(number), is_string=False)

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

    1642    @classmethod
    1643    def string(cls, string) -> Literal:
    1644        return cls(this=str(string), is_string=True)

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Join(Expression): View Source

    1651class Join(Expression):
    1652    arg_types = {
    1653        "this": True,
    1654        "on": False,
    1655        "side": False,
    1656        "kind": False,
    1657        "using": False,
    1658        "method": False,
    1659        "global": False,
    1660        "hint": False,
    1661    }
    1662
    1663    @property
    1664    def method(self) -> str:
    1665        return self.text("method").upper()
    1666
    1667    @property
    1668    def kind(self) -> str:
    1669        return self.text("kind").upper()
    1670
    1671    @property
    1672    def side(self) -> str:
    1673        return self.text("side").upper()
    1674
    1675    @property
    1676    def hint(self) -> str:
    1677        return self.text("hint").upper()
    1678
    1679    @property
    1680    def alias_or_name(self) -> str:
    1681        return self.this.alias_or_name
    1682
    1683    def on(
    1684        self,
    1685        *expressions: t.Optional[ExpOrStr],
    1686        append: bool = True,
    1687        dialect: DialectType = None,
    1688        copy: bool = True,
    1689        **opts,
    1690    ) -> Join:
    1691        """
    1692        Append to or set the ON expressions.
    1693
    1694        Example:
    1695            >>> import sqlglot
    1696            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    1697            'JOIN x ON y = 1'
    1698
    1699        Args:
    1700            *expressions: the SQL code strings to parse.
    1701                If an `Expression` instance is passed, it will be used as-is.
    1702                Multiple expressions are combined with an AND operator.
    1703            append: if `True`, AND the new expressions to any existing expression.
    1704                Otherwise, this resets the expression.
    1705            dialect: the dialect used to parse the input expressions.
    1706            copy: if `False`, modify this expression instance in-place.
    1707            opts: other options to use to parse the input expressions.
    1708
    1709        Returns:
    1710            The modified Join expression.
    1711        """
    1712        join = _apply_conjunction_builder(
    1713            *expressions,
    1714            instance=self,
    1715            arg="on",
    1716            append=append,
    1717            dialect=dialect,
    1718            copy=copy,
    1719            **opts,
    1720        )
    1721
    1722        if join.kind == "CROSS":
    1723            join.set("kind", None)
    1724
    1725        return join
    1726
    1727    def using(
    1728        self,
    1729        *expressions: t.Optional[ExpOrStr],
    1730        append: bool = True,
    1731        dialect: DialectType = None,
    1732        copy: bool = True,
    1733        **opts,
    1734    ) -> Join:
    1735        """
    1736        Append to or set the USING expressions.
    1737
    1738        Example:
    1739            >>> import sqlglot
    1740            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    1741            'JOIN x USING (foo, bla)'
    1742
    1743        Args:
    1744            *expressions: the SQL code strings to parse.
    1745                If an `Expression` instance is passed, it will be used as-is.
    1746            append: if `True`, concatenate the new expressions to the existing "using" list.
    1747                Otherwise, this resets the expression.
    1748            dialect: the dialect used to parse the input expressions.
    1749            copy: if `False`, modify this expression instance in-place.
    1750            opts: other options to use to parse the input expressions.
    1751
    1752        Returns:
    1753            The modified Join expression.
    1754        """
    1755        join = _apply_list_builder(
    1756            *expressions,
    1757            instance=self,
    1758            arg="using",
    1759            append=append,
    1760            dialect=dialect,
    1761            copy=copy,
    1762            **opts,
    1763        )
    1764
    1765        if join.kind == "CROSS":
    1766            join.set("kind", None)
    1767
    1768        return join

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

    1683    def on(
    1684        self,
    1685        *expressions: t.Optional[ExpOrStr],
    1686        append: bool = True,
    1687        dialect: DialectType = None,
    1688        copy: bool = True,
    1689        **opts,
    1690    ) -> Join:
    1691        """
    1692        Append to or set the ON expressions.
    1693
    1694        Example:
    1695            >>> import sqlglot
    1696            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    1697            'JOIN x ON y = 1'
    1698
    1699        Args:
    1700            *expressions: the SQL code strings to parse.
    1701                If an `Expression` instance is passed, it will be used as-is.
    1702                Multiple expressions are combined with an AND operator.
    1703            append: if `True`, AND the new expressions to any existing expression.
    1704                Otherwise, this resets the expression.
    1705            dialect: the dialect used to parse the input expressions.
    1706            copy: if `False`, modify this expression instance in-place.
    1707            opts: other options to use to parse the input expressions.
    1708
    1709        Returns:
    1710            The modified Join expression.
    1711        """
    1712        join = _apply_conjunction_builder(
    1713            *expressions,
    1714            instance=self,
    1715            arg="on",
    1716            append=append,
    1717            dialect=dialect,
    1718            copy=copy,
    1719            **opts,
    1720        )
    1721
    1722        if join.kind == "CROSS":
    1723            join.set("kind", None)
    1724
    1725        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, sqlglot.expressions.Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> sqlglot.expressions.Join: View Source

    1727    def using(
    1728        self,
    1729        *expressions: t.Optional[ExpOrStr],
    1730        append: bool = True,
    1731        dialect: DialectType = None,
    1732        copy: bool = True,
    1733        **opts,
    1734    ) -> Join:
    1735        """
    1736        Append to or set the USING expressions.
    1737
    1738        Example:
    1739            >>> import sqlglot
    1740            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    1741            'JOIN x USING (foo, bla)'
    1742
    1743        Args:
    1744            *expressions: the SQL code strings to parse.
    1745                If an `Expression` instance is passed, it will be used as-is.
    1746            append: if `True`, concatenate the new expressions to the existing "using" list.
    1747                Otherwise, this resets the expression.
    1748            dialect: the dialect used to parse the input expressions.
    1749            copy: if `False`, modify this expression instance in-place.
    1750            opts: other options to use to parse the input expressions.
    1751
    1752        Returns:
    1753            The modified Join expression.
    1754        """
    1755        join = _apply_list_builder(
    1756            *expressions,
    1757            instance=self,
    1758            arg="using",
    1759            append=append,
    1760            dialect=dialect,
    1761            copy=copy,
    1762            **opts,
    1763        )
    1764
    1765        if join.kind == "CROSS":
    1766            join.set("kind", None)
    1767
    1768        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.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Lateral(UDTF): View Source

    1771class Lateral(UDTF):
    1772    arg_types = {"this": True, "view": False, "outer": False, "alias": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Unionable
  union
  intersect
  except_

class MatchRecognize(Expression): View Source

    1775class MatchRecognize(Expression):
    1776    arg_types = {
    1777        "partition_by": False,
    1778        "order": False,
    1779        "measures": False,
    1780        "rows": False,
    1781        "after": False,
    1782        "pattern": False,
    1783        "define": False,
    1784        "alias": False,
    1785    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Final(Expression): View Source

    1790class Final(Expression):
    1791    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Offset(Expression): View Source

    1794class Offset(Expression):
    1795    arg_types = {"this": False, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Order(Expression): View Source

    1798class Order(Expression):
    1799    arg_types = {"this": False, "expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Cluster(Order): View Source

    1804class Cluster(Order):
    1805    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Distribute(Order): View Source

    1808class Distribute(Order):
    1809    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Sort(Order): View Source

    1812class Sort(Order):
    1813    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Ordered(Expression): View Source

    1816class Ordered(Expression):
    1817    arg_types = {"this": True, "desc": True, "nulls_first": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Property(Expression): View Source

    1820class Property(Expression):
    1821    arg_types = {"this": True, "value": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class AlgorithmProperty(Property): View Source

    1824class AlgorithmProperty(Property):
    1825    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class AutoIncrementProperty(Property): View Source

    1828class AutoIncrementProperty(Property):
    1829    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class BlockCompressionProperty(Property): View Source

    1832class BlockCompressionProperty(Property):
    1833    arg_types = {"autotemp": False, "always": False, "default": True, "manual": True, "never": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CharacterSetProperty(Property): View Source

    1836class CharacterSetProperty(Property):
    1837    arg_types = {"this": True, "default": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ChecksumProperty(Property): View Source

    1840class ChecksumProperty(Property):
    1841    arg_types = {"on": False, "default": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class CollateProperty(Property): View Source

    1844class CollateProperty(Property):
    1845    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DataBlocksizeProperty(Property): View Source

    1848class DataBlocksizeProperty(Property):
    1849    arg_types = {
    1850        "size": False,
    1851        "units": False,
    1852        "minimum": False,
    1853        "maximum": False,
    1854        "default": False,
    1855    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DefinerProperty(Property): View Source

    1858class DefinerProperty(Property):
    1859    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DistKeyProperty(Property): View Source

    1862class DistKeyProperty(Property):
    1863    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DistStyleProperty(Property): View Source

    1866class DistStyleProperty(Property):
    1867    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class EngineProperty(Property): View Source

    1870class EngineProperty(Property):
    1871    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ToTableProperty(Property): View Source

    1874class ToTableProperty(Property):
    1875    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ExecuteAsProperty(Property): View Source

    1878class ExecuteAsProperty(Property):
    1879    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ExternalProperty(Property): View Source

    1882class ExternalProperty(Property):
    1883    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class FallbackProperty(Property): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class FileFormatProperty(Property): View Source

    1890class FileFormatProperty(Property):
    1891    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class FreespaceProperty(Property): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class InputOutputFormat(Expression): View Source

    1898class InputOutputFormat(Expression):
    1899    arg_types = {"input_format": False, "output_format": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class IsolatedLoadingProperty(Property): View Source

    1902class IsolatedLoadingProperty(Property):
    1903    arg_types = {
    1904        "no": True,
    1905        "concurrent": True,
    1906        "for_all": True,
    1907        "for_insert": True,
    1908        "for_none": True,
    1909    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class JournalProperty(Property): View Source

    1912class JournalProperty(Property):
    1913    arg_types = {
    1914        "no": False,
    1915        "dual": False,
    1916        "before": False,
    1917        "local": False,
    1918        "after": False,
    1919    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class LanguageProperty(Property): View Source

    1922class LanguageProperty(Property):
    1923    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DictProperty(Property): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DictSubProperty(Property): View Source

    1930class DictSubProperty(Property):
    1931    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DictRange(Property): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class OnCluster(Property): View Source

    1940class OnCluster(Property):
    1941    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class LikeProperty(Property): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class LocationProperty(Property): View Source

    1948class LocationProperty(Property):
    1949    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class LockingProperty(Property): View Source

    1952class LockingProperty(Property):
    1953    arg_types = {
    1954        "this": False,
    1955        "kind": True,
    1956        "for_or_in": True,
    1957        "lock_type": True,
    1958        "override": False,
    1959    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class LogProperty(Property): View Source

    1962class LogProperty(Property):
    1963    arg_types = {"no": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class MaterializedProperty(Property): View Source

    1966class MaterializedProperty(Property):
    1967    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class MergeBlockRatioProperty(Property): View Source

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class NoPrimaryIndexProperty(Property): View Source

    1974class NoPrimaryIndexProperty(Property):
    1975    arg_types = {}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class OnCommitProperty(Property): View Source

    1978class OnCommitProperty(Property):
    1979    arg_type = {"delete": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class PartitionedByProperty(Property): View Source

    1982class PartitionedByProperty(Property):
    1983    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class ReturnsProperty(Property): View Source

    1986class ReturnsProperty(Property):
    1987    arg_types = {"this": True, "is_table": False, "table": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class RowFormatProperty(Property): View Source

    1990class RowFormatProperty(Property):
    1991    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class RowFormatDelimitedProperty(Property): View Source

    1994class RowFormatDelimitedProperty(Property):
    1995    # https://cwiki.apache.org/confluence/display/hive/languagemanual+dml
    1996    arg_types = {
    1997        "fields": False,
    1998        "escaped": False,
    1999        "collection_items": False,
    2000        "map_keys": False,
    2001        "lines": False,
    2002        "null": False,
    2003        "serde": False,
    2004    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class RowFormatSerdeProperty(Property): View Source

    2007class RowFormatSerdeProperty(Property):
    2008    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SchemaCommentProperty(Property): View Source

    2011class SchemaCommentProperty(Property):
    2012    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SerdeProperties(Property): View Source

    2015class SerdeProperties(Property):
    2016    arg_types = {"expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SetProperty(Property): View Source

    2019class SetProperty(Property):
    2020    arg_types = {"multi": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SettingsProperty(Property): View Source

    2023class SettingsProperty(Property):
    2024    arg_types = {"expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SortKeyProperty(Property): View Source

    2027class SortKeyProperty(Property):
    2028    arg_types = {"this": True, "compound": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SqlSecurityProperty(Property): View Source

    2031class SqlSecurityProperty(Property):
    2032    arg_types = {"definer": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class StabilityProperty(Property): View Source

    2035class StabilityProperty(Property):
    2036    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TemporaryProperty(Property): View Source

    2039class TemporaryProperty(Property):
    2040    arg_types = {}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TransientProperty(Property): View Source

    2043class TransientProperty(Property):
    2044    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class VolatileProperty(Property): View Source

    2047class VolatileProperty(Property):
    2048    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class WithDataProperty(Property): View Source

    2051class WithDataProperty(Property):
    2052    arg_types = {"no": True, "statistics": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class WithJournalTableProperty(Property): View Source

    2055class WithJournalTableProperty(Property):
    2056    arg_types = {"this": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Properties(Expression): View Source

    2059class Properties(Expression):
    2060    arg_types = {"expressions": True}
    2061
    2062    NAME_TO_PROPERTY = {
    2063        "ALGORITHM": AlgorithmProperty,
    2064        "AUTO_INCREMENT": AutoIncrementProperty,
    2065        "CHARACTER SET": CharacterSetProperty,
    2066        "COLLATE": CollateProperty,
    2067        "COMMENT": SchemaCommentProperty,
    2068        "DEFINER": DefinerProperty,
    2069        "DISTKEY": DistKeyProperty,
    2070        "DISTSTYLE": DistStyleProperty,
    2071        "ENGINE": EngineProperty,
    2072        "EXECUTE AS": ExecuteAsProperty,
    2073        "FORMAT": FileFormatProperty,
    2074        "LANGUAGE": LanguageProperty,
    2075        "LOCATION": LocationProperty,
    2076        "PARTITIONED_BY": PartitionedByProperty,
    2077        "RETURNS": ReturnsProperty,
    2078        "ROW_FORMAT": RowFormatProperty,
    2079        "SORTKEY": SortKeyProperty,
    2080    }
    2081
    2082    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    2083
    2084    # CREATE property locations
    2085    # Form: schema specified
    2086    #   create [POST_CREATE]
    2087    #     table a [POST_NAME]
    2088    #     (b int) [POST_SCHEMA]
    2089    #     with ([POST_WITH])
    2090    #     index (b) [POST_INDEX]
    2091    #
    2092    # Form: alias selection
    2093    #   create [POST_CREATE]
    2094    #     table a [POST_NAME]
    2095    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    2096    #     index (c) [POST_INDEX]
    2097    class Location(AutoName):
    2098        POST_CREATE = auto()
    2099        POST_NAME = auto()
    2100        POST_SCHEMA = auto()
    2101        POST_WITH = auto()
    2102        POST_ALIAS = auto()
    2103        POST_EXPRESSION = auto()
    2104        POST_INDEX = auto()
    2105        UNSUPPORTED = auto()
    2106
    2107    @classmethod
    2108    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    2109        expressions = []
    2110        for key, value in properties_dict.items():
    2111            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    2112            if property_cls:
    2113                expressions.append(property_cls(this=convert(value)))
    2114            else:
    2115                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    2116
    2117        return cls(expressions=expressions)

@classmethod
def from_dict(cls, properties_dict: Dict) -> sqlglot.expressions.Properties: View Source

    2107    @classmethod
    2108    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    2109        expressions = []
    2110        for key, value in properties_dict.items():
    2111            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    2112            if property_cls:
    2113                expressions.append(property_cls(this=convert(value)))
    2114            else:
    2115                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    2116
    2117        return cls(expressions=expressions)

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

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

    2097    class Location(AutoName):
    2098        POST_CREATE = auto()
    2099        POST_NAME = auto()
    2100        POST_SCHEMA = auto()
    2101        POST_WITH = auto()
    2102        POST_ALIAS = auto()
    2103        POST_EXPRESSION = auto()
    2104        POST_INDEX = auto()
    2105        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'>

##### Inherited Members

enum.Enum
  name
  value

class Qualify(Expression): View Source

    2120class Qualify(Expression):
    2121    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Return(Expression): View Source

    2125class Return(Expression):
    2126    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Reference(Expression): View Source

    2129class Reference(Expression):
    2130    arg_types = {"this": True, "expressions": False, "options": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Tuple(Expression): View Source

    2133class Tuple(Expression):
    2134    arg_types = {"expressions": False}
    2135
    2136    def isin(
    2137        self, *expressions: t.Any, query: t.Optional[ExpOrStr] = None, copy: bool = True, **opts
    2138    ) -> In:
    2139        return In(
    2140            this=_maybe_copy(self, copy),
    2141            expressions=[convert(e, copy=copy) for e in expressions],
    2142            query=maybe_parse(query, copy=copy, **opts) if query else None,
    2143        )

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

    2136    def isin(
    2137        self, *expressions: t.Any, query: t.Optional[ExpOrStr] = None, copy: bool = True, **opts
    2138    ) -> In:
    2139        return In(
    2140            this=_maybe_copy(self, copy),
    2141            expressions=[convert(e, copy=copy) for e in expressions],
    2142            query=maybe_parse(query, copy=copy, **opts) if query else None,
    2143        )

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Subqueryable(Unionable): View Source

    2146class Subqueryable(Unionable):
    2147    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    2148        """
    2149        Convert this expression to an aliased expression that can be used as a Subquery.
    2150
    2151        Example:
    2152            >>> subquery = Select().select("x").from_("tbl").subquery()
    2153            >>> Select().select("x").from_(subquery).sql()
    2154            'SELECT x FROM (SELECT x FROM tbl)'
    2155
    2156        Args:
    2157            alias (str | Identifier): an optional alias for the subquery
    2158            copy (bool): if `False`, modify this expression instance in-place.
    2159
    2160        Returns:
    2161            Alias: the subquery
    2162        """
    2163        instance = _maybe_copy(self, copy)
    2164        if not isinstance(alias, Expression):
    2165            alias = TableAlias(this=to_identifier(alias)) if alias else None
    2166
    2167        return Subquery(this=instance, alias=alias)
    2168
    2169    def limit(
    2170        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2171    ) -> Select:
    2172        raise NotImplementedError
    2173
    2174    @property
    2175    def ctes(self):
    2176        with_ = self.args.get("with")
    2177        if not with_:
    2178            return []
    2179        return with_.expressions
    2180
    2181    @property
    2182    def selects(self):
    2183        raise NotImplementedError("Subqueryable objects must implement `selects`")
    2184
    2185    @property
    2186    def named_selects(self):
    2187        raise NotImplementedError("Subqueryable objects must implement `named_selects`")
    2188
    2189    def with_(
    2190        self,
    2191        alias: ExpOrStr,
    2192        as_: ExpOrStr,
    2193        recursive: t.Optional[bool] = None,
    2194        append: bool = True,
    2195        dialect: DialectType = None,
    2196        copy: bool = True,
    2197        **opts,
    2198    ) -> Subqueryable:
    2199        """
    2200        Append to or set the common table expressions.
    2201
    2202        Example:
    2203            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    2204            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    2205
    2206        Args:
    2207            alias: the SQL code string to parse as the table name.
    2208                If an `Expression` instance is passed, this is used as-is.
    2209            as_: the SQL code string to parse as the table expression.
    2210                If an `Expression` instance is passed, it will be used as-is.
    2211            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2212            append: if `True`, add to any existing expressions.
    2213                Otherwise, this resets the expressions.
    2214            dialect: the dialect used to parse the input expression.
    2215            copy: if `False`, modify this expression instance in-place.
    2216            opts: other options to use to parse the input expressions.
    2217
    2218        Returns:
    2219            The modified expression.
    2220        """
    2221        return _apply_cte_builder(
    2222            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    2223        )

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

    2147    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    2148        """
    2149        Convert this expression to an aliased expression that can be used as a Subquery.
    2150
    2151        Example:
    2152            >>> subquery = Select().select("x").from_("tbl").subquery()
    2153            >>> Select().select("x").from_(subquery).sql()
    2154            'SELECT x FROM (SELECT x FROM tbl)'
    2155
    2156        Args:
    2157            alias (str | Identifier): an optional alias for the subquery
    2158            copy (bool): if `False`, modify this expression instance in-place.
    2159
    2160        Returns:
    2161            Alias: the subquery
    2162        """
    2163        instance = _maybe_copy(self, copy)
    2164        if not isinstance(alias, Expression):
    2165            alias = TableAlias(this=to_identifier(alias)) if alias else None
    2166
    2167        return Subquery(this=instance, alias=alias)

Convert this expression to an aliased expression that can be used as a Subquery.

###### Example:

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

###### Arguments:

- alias (str | Identifier): an optional alias for the subquery
- copy (bool): if `False`, modify this expression instance in-place.

###### Returns:

> Alias: the subquery

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

    2169    def limit(
    2170        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2171    ) -> Select:
    2172        raise NotImplementedError

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

    2189    def with_(
    2190        self,
    2191        alias: ExpOrStr,
    2192        as_: ExpOrStr,
    2193        recursive: t.Optional[bool] = None,
    2194        append: bool = True,
    2195        dialect: DialectType = None,
    2196        copy: bool = True,
    2197        **opts,
    2198    ) -> Subqueryable:
    2199        """
    2200        Append to or set the common table expressions.
    2201
    2202        Example:
    2203            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    2204            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    2205
    2206        Args:
    2207            alias: the SQL code string to parse as the table name.
    2208                If an `Expression` instance is passed, this is used as-is.
    2209            as_: the SQL code string to parse as the table expression.
    2210                If an `Expression` instance is passed, it will be used as-is.
    2211            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2212            append: if `True`, add to any existing expressions.
    2213                Otherwise, this resets the expressions.
    2214            dialect: the dialect used to parse the input expression.
    2215            copy: if `False`, modify this expression instance in-place.
    2216            opts: other options to use to parse the input expressions.
    2217
    2218        Returns:
    2219            The modified expression.
    2220        """
    2221        return _apply_cte_builder(
    2222            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    2223        )

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`.
- 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.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Unionable
  union
  intersect
  except_

class Table(Expression): View Source

    2249class Table(Expression):
    2250    arg_types = {
    2251        "this": True,
    2252        "alias": False,
    2253        "db": False,
    2254        "catalog": False,
    2255        "laterals": False,
    2256        "joins": False,
    2257        "pivots": False,
    2258        "hints": False,
    2259        "system_time": False,
    2260    }
    2261
    2262    @property
    2263    def db(self) -> str:
    2264        return self.text("db")
    2265
    2266    @property
    2267    def catalog(self) -> str:
    2268        return self.text("catalog")
    2269
    2270    @property
    2271    def parts(self) -> t.List[Identifier]:
    2272        """Return the parts of a table in order catalog, db, table."""
    2273        return [
    2274            t.cast(Identifier, self.args[part])
    2275            for part in ("catalog", "db", "this")
    2276            if self.args.get(part)
    2277        ]

parts: List[sqlglot.expressions.Identifier]

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

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SystemTime(Expression): View Source

    2281class SystemTime(Expression):
    2282    arg_types = {
    2283        "this": False,
    2284        "expression": False,
    2285        "kind": True,
    2286    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Union(Subqueryable): View Source

    2289class Union(Subqueryable):
    2290    arg_types = {
    2291        "with": False,
    2292        "this": True,
    2293        "expression": True,
    2294        "distinct": False,
    2295        **QUERY_MODIFIERS,
    2296    }
    2297
    2298    def limit(
    2299        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2300    ) -> Select:
    2301        """
    2302        Set the LIMIT expression.
    2303
    2304        Example:
    2305            >>> select("1").union(select("1")).limit(1).sql()
    2306            'SELECT * FROM (SELECT 1 UNION SELECT 1) AS _l_0 LIMIT 1'
    2307
    2308        Args:
    2309            expression: the SQL code string to parse.
    2310                This can also be an integer.
    2311                If a `Limit` instance is passed, this is used as-is.
    2312                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2313            dialect: the dialect used to parse the input expression.
    2314            copy: if `False`, modify this expression instance in-place.
    2315            opts: other options to use to parse the input expressions.
    2316
    2317        Returns:
    2318            The limited subqueryable.
    2319        """
    2320        return (
    2321            select("*")
    2322            .from_(self.subquery(alias="_l_0", copy=copy))
    2323            .limit(expression, dialect=dialect, copy=False, **opts)
    2324        )
    2325
    2326    def select(
    2327        self,
    2328        *expressions: t.Optional[ExpOrStr],
    2329        append: bool = True,
    2330        dialect: DialectType = None,
    2331        copy: bool = True,
    2332        **opts,
    2333    ) -> Union:
    2334        """Append to or set the SELECT of the union recursively.
    2335
    2336        Example:
    2337            >>> from sqlglot import parse_one
    2338            >>> parse_one("select a from x union select a from y union select a from z").select("b").sql()
    2339            'SELECT a, b FROM x UNION SELECT a, b FROM y UNION SELECT a, b FROM z'
    2340
    2341        Args:
    2342            *expressions: the SQL code strings to parse.
    2343                If an `Expression` instance is passed, it will be used as-is.
    2344            append: if `True`, add to any existing expressions.
    2345                Otherwise, this resets the expressions.
    2346            dialect: the dialect used to parse the input expressions.
    2347            copy: if `False`, modify this expression instance in-place.
    2348            opts: other options to use to parse the input expressions.
    2349
    2350        Returns:
    2351            Union: the modified expression.
    2352        """
    2353        this = self.copy() if copy else self
    2354        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    2355        this.expression.unnest().select(
    2356            *expressions, append=append, dialect=dialect, copy=False, **opts
    2357        )
    2358        return this
    2359
    2360    @property
    2361    def named_selects(self):
    2362        return self.this.unnest().named_selects
    2363
    2364    @property
    2365    def is_star(self) -> bool:
    2366        return self.this.is_star or self.expression.is_star
    2367
    2368    @property
    2369    def selects(self):
    2370        return self.this.unnest().selects
    2371
    2372    @property
    2373    def left(self):
    2374        return self.this
    2375
    2376    @property
    2377    def right(self):
    2378        return self.expression

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

    2298    def limit(
    2299        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2300    ) -> Select:
    2301        """
    2302        Set the LIMIT expression.
    2303
    2304        Example:
    2305            >>> select("1").union(select("1")).limit(1).sql()
    2306            'SELECT * FROM (SELECT 1 UNION SELECT 1) AS _l_0 LIMIT 1'
    2307
    2308        Args:
    2309            expression: the SQL code string to parse.
    2310                This can also be an integer.
    2311                If a `Limit` instance is passed, this is used as-is.
    2312                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2313            dialect: the dialect used to parse the input expression.
    2314            copy: if `False`, modify this expression instance in-place.
    2315            opts: other options to use to parse the input expressions.
    2316
    2317        Returns:
    2318            The limited subqueryable.
    2319        """
    2320        return (
    2321            select("*")
    2322            .from_(self.subquery(alias="_l_0", copy=copy))
    2323            .limit(expression, dialect=dialect, copy=False, **opts)
    2324        )

Set the LIMIT expression.

###### Example:

>     >>> select("1").union(select("1")).limit(1).sql()
>     'SELECT * FROM (SELECT 1 UNION SELECT 1) AS _l_0 LIMIT 1'

###### Arguments:

- expression: the SQL code string to parse. This can also be an integer. If a `Limit` instance is passed, this is 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:

> The limited subqueryable.

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

    2326    def select(
    2327        self,
    2328        *expressions: t.Optional[ExpOrStr],
    2329        append: bool = True,
    2330        dialect: DialectType = None,
    2331        copy: bool = True,
    2332        **opts,
    2333    ) -> Union:
    2334        """Append to or set the SELECT of the union recursively.
    2335
    2336        Example:
    2337            >>> from sqlglot import parse_one
    2338            >>> parse_one("select a from x union select a from y union select a from z").select("b").sql()
    2339            'SELECT a, b FROM x UNION SELECT a, b FROM y UNION SELECT a, b FROM z'
    2340
    2341        Args:
    2342            *expressions: the SQL code strings to parse.
    2343                If an `Expression` instance is passed, it will be used as-is.
    2344            append: if `True`, add to any existing expressions.
    2345                Otherwise, this resets the expressions.
    2346            dialect: the dialect used to parse the input expressions.
    2347            copy: if `False`, modify this expression instance in-place.
    2348            opts: other options to use to parse the input expressions.
    2349
    2350        Returns:
    2351            Union: the modified expression.
    2352        """
    2353        this = self.copy() if copy else self
    2354        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    2355        this.expression.unnest().select(
    2356            *expressions, append=append, dialect=dialect, copy=False, **opts
    2357        )
    2358        return this

Append to or set the SELECT of the union recursively.

###### Example:

>     >>> from sqlglot import parse_one
>     >>> parse_one("select a from x union select a from y union select a from z").select("b").sql()
>     'SELECT a, b FROM x UNION SELECT a, b FROM y UNION SELECT a, b FROM 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:

> Union: the modified expression.

is_star: bool

Checks whether an expression is a star.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Subqueryable
  subquery
  with_
Unionable
  union
  intersect
  except_

class Except(Union): View Source

    2381class Except(Union):
    2382    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Union
  limit
  select
  is_star
Subqueryable
  subquery
  with_
Unionable
  union
  intersect
  except_

class Intersect(Union): View Source

    2385class Intersect(Union):
    2386    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Union
  limit
  select
  is_star
Subqueryable
  subquery
  with_
Unionable
  union
  intersect
  except_

class Unnest(UDTF): View Source

    2389class Unnest(UDTF):
    2390    arg_types = {
    2391        "expressions": True,
    2392        "ordinality": False,
    2393        "alias": False,
    2394        "offset": False,
    2395    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Unionable
  union
  intersect
  except_

class Update(Expression): View Source

    2398class Update(Expression):
    2399    arg_types = {
    2400        "with": False,
    2401        "this": False,
    2402        "expressions": True,
    2403        "from": False,
    2404        "where": False,
    2405        "returning": False,
    2406    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Values(UDTF): View Source

    2409class Values(UDTF):
    2410    arg_types = {
    2411        "expressions": True,
    2412        "ordinality": False,
    2413        "alias": False,
    2414    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Unionable
  union
  intersect
  except_

class Var(Expression): View Source

    2417class Var(Expression):
    2418    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Schema(Expression): View Source

    2421class Schema(Expression):
    2422    arg_types = {"this": False, "expressions": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Lock(Expression): View Source

    2427class Lock(Expression):
    2428    arg_types = {"update": True, "expressions": False, "wait": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Select(Subqueryable): View Source

    2431class Select(Subqueryable):
    2432    arg_types = {
    2433        "with": False,
    2434        "kind": False,
    2435        "expressions": False,
    2436        "hint": False,
    2437        "distinct": False,
    2438        "struct": False,  # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#return_query_results_as_a_value_table
    2439        "value": False,
    2440        "into": False,
    2441        "from": False,
    2442        **QUERY_MODIFIERS,
    2443    }
    2444
    2445    def from_(
    2446        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    2447    ) -> Select:
    2448        """
    2449        Set the FROM expression.
    2450
    2451        Example:
    2452            >>> Select().from_("tbl").select("x").sql()
    2453            'SELECT x FROM tbl'
    2454
    2455        Args:
    2456            expression : the SQL code strings to parse.
    2457                If a `From` instance is passed, this is used as-is.
    2458                If another `Expression` instance is passed, it will be wrapped in a `From`.
    2459            dialect: the dialect used to parse the input expression.
    2460            copy: if `False`, modify this expression instance in-place.
    2461            opts: other options to use to parse the input expressions.
    2462
    2463        Returns:
    2464            The modified Select expression.
    2465        """
    2466        return _apply_builder(
    2467            expression=expression,
    2468            instance=self,
    2469            arg="from",
    2470            into=From,
    2471            prefix="FROM",
    2472            dialect=dialect,
    2473            copy=copy,
    2474            **opts,
    2475        )
    2476
    2477    def group_by(
    2478        self,
    2479        *expressions: t.Optional[ExpOrStr],
    2480        append: bool = True,
    2481        dialect: DialectType = None,
    2482        copy: bool = True,
    2483        **opts,
    2484    ) -> Select:
    2485        """
    2486        Set the GROUP BY expression.
    2487
    2488        Example:
    2489            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    2490            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    2491
    2492        Args:
    2493            *expressions: the SQL code strings to parse.
    2494                If a `Group` instance is passed, this is used as-is.
    2495                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    2496                If nothing is passed in then a group by is not applied to the expression
    2497            append: if `True`, add to any existing expressions.
    2498                Otherwise, this flattens all the `Group` expression into a single expression.
    2499            dialect: the dialect used to parse the input expression.
    2500            copy: if `False`, modify this expression instance in-place.
    2501            opts: other options to use to parse the input expressions.
    2502
    2503        Returns:
    2504            The modified Select expression.
    2505        """
    2506        if not expressions:
    2507            return self if not copy else self.copy()
    2508
    2509        return _apply_child_list_builder(
    2510            *expressions,
    2511            instance=self,
    2512            arg="group",
    2513            append=append,
    2514            copy=copy,
    2515            prefix="GROUP BY",
    2516            into=Group,
    2517            dialect=dialect,
    2518            **opts,
    2519        )
    2520
    2521    def order_by(
    2522        self,
    2523        *expressions: t.Optional[ExpOrStr],
    2524        append: bool = True,
    2525        dialect: DialectType = None,
    2526        copy: bool = True,
    2527        **opts,
    2528    ) -> Select:
    2529        """
    2530        Set the ORDER BY expression.
    2531
    2532        Example:
    2533            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    2534            'SELECT x FROM tbl ORDER BY x DESC'
    2535
    2536        Args:
    2537            *expressions: the SQL code strings to parse.
    2538                If a `Group` instance is passed, this is used as-is.
    2539                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    2540            append: if `True`, add to any existing expressions.
    2541                Otherwise, this flattens all the `Order` expression into a single expression.
    2542            dialect: the dialect used to parse the input expression.
    2543            copy: if `False`, modify this expression instance in-place.
    2544            opts: other options to use to parse the input expressions.
    2545
    2546        Returns:
    2547            The modified Select expression.
    2548        """
    2549        return _apply_child_list_builder(
    2550            *expressions,
    2551            instance=self,
    2552            arg="order",
    2553            append=append,
    2554            copy=copy,
    2555            prefix="ORDER BY",
    2556            into=Order,
    2557            dialect=dialect,
    2558            **opts,
    2559        )
    2560
    2561    def sort_by(
    2562        self,
    2563        *expressions: t.Optional[ExpOrStr],
    2564        append: bool = True,
    2565        dialect: DialectType = None,
    2566        copy: bool = True,
    2567        **opts,
    2568    ) -> Select:
    2569        """
    2570        Set the SORT BY expression.
    2571
    2572        Example:
    2573            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    2574            'SELECT x FROM tbl SORT BY x DESC'
    2575
    2576        Args:
    2577            *expressions: the SQL code strings to parse.
    2578                If a `Group` instance is passed, this is used as-is.
    2579                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    2580            append: if `True`, add to any existing expressions.
    2581                Otherwise, this flattens all the `Order` expression into a single expression.
    2582            dialect: the dialect used to parse the input expression.
    2583            copy: if `False`, modify this expression instance in-place.
    2584            opts: other options to use to parse the input expressions.
    2585
    2586        Returns:
    2587            The modified Select expression.
    2588        """
    2589        return _apply_child_list_builder(
    2590            *expressions,
    2591            instance=self,
    2592            arg="sort",
    2593            append=append,
    2594            copy=copy,
    2595            prefix="SORT BY",
    2596            into=Sort,
    2597            dialect=dialect,
    2598            **opts,
    2599        )
    2600
    2601    def cluster_by(
    2602        self,
    2603        *expressions: t.Optional[ExpOrStr],
    2604        append: bool = True,
    2605        dialect: DialectType = None,
    2606        copy: bool = True,
    2607        **opts,
    2608    ) -> Select:
    2609        """
    2610        Set the CLUSTER BY expression.
    2611
    2612        Example:
    2613            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    2614            'SELECT x FROM tbl CLUSTER BY x DESC'
    2615
    2616        Args:
    2617            *expressions: the SQL code strings to parse.
    2618                If a `Group` instance is passed, this is used as-is.
    2619                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    2620            append: if `True`, add to any existing expressions.
    2621                Otherwise, this flattens all the `Order` expression into a single expression.
    2622            dialect: the dialect used to parse the input expression.
    2623            copy: if `False`, modify this expression instance in-place.
    2624            opts: other options to use to parse the input expressions.
    2625
    2626        Returns:
    2627            The modified Select expression.
    2628        """
    2629        return _apply_child_list_builder(
    2630            *expressions,
    2631            instance=self,
    2632            arg="cluster",
    2633            append=append,
    2634            copy=copy,
    2635            prefix="CLUSTER BY",
    2636            into=Cluster,
    2637            dialect=dialect,
    2638            **opts,
    2639        )
    2640
    2641    def limit(
    2642        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2643    ) -> Select:
    2644        """
    2645        Set the LIMIT expression.
    2646
    2647        Example:
    2648            >>> Select().from_("tbl").select("x").limit(10).sql()
    2649            'SELECT x FROM tbl LIMIT 10'
    2650
    2651        Args:
    2652            expression: the SQL code string to parse.
    2653                This can also be an integer.
    2654                If a `Limit` instance is passed, this is used as-is.
    2655                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2656            dialect: the dialect used to parse the input expression.
    2657            copy: if `False`, modify this expression instance in-place.
    2658            opts: other options to use to parse the input expressions.
    2659
    2660        Returns:
    2661            Select: the modified expression.
    2662        """
    2663        return _apply_builder(
    2664            expression=expression,
    2665            instance=self,
    2666            arg="limit",
    2667            into=Limit,
    2668            prefix="LIMIT",
    2669            dialect=dialect,
    2670            copy=copy,
    2671            **opts,
    2672        )
    2673
    2674    def offset(
    2675        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2676    ) -> Select:
    2677        """
    2678        Set the OFFSET expression.
    2679
    2680        Example:
    2681            >>> Select().from_("tbl").select("x").offset(10).sql()
    2682            'SELECT x FROM tbl OFFSET 10'
    2683
    2684        Args:
    2685            expression: the SQL code string to parse.
    2686                This can also be an integer.
    2687                If a `Offset` instance is passed, this is used as-is.
    2688                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    2689            dialect: the dialect used to parse the input expression.
    2690            copy: if `False`, modify this expression instance in-place.
    2691            opts: other options to use to parse the input expressions.
    2692
    2693        Returns:
    2694            The modified Select expression.
    2695        """
    2696        return _apply_builder(
    2697            expression=expression,
    2698            instance=self,
    2699            arg="offset",
    2700            into=Offset,
    2701            prefix="OFFSET",
    2702            dialect=dialect,
    2703            copy=copy,
    2704            **opts,
    2705        )
    2706
    2707    def select(
    2708        self,
    2709        *expressions: t.Optional[ExpOrStr],
    2710        append: bool = True,
    2711        dialect: DialectType = None,
    2712        copy: bool = True,
    2713        **opts,
    2714    ) -> Select:
    2715        """
    2716        Append to or set the SELECT expressions.
    2717
    2718        Example:
    2719            >>> Select().select("x", "y").sql()
    2720            'SELECT x, y'
    2721
    2722        Args:
    2723            *expressions: the SQL code strings to parse.
    2724                If an `Expression` instance is passed, it will be used as-is.
    2725            append: if `True`, add to any existing expressions.
    2726                Otherwise, this resets the expressions.
    2727            dialect: the dialect used to parse the input expressions.
    2728            copy: if `False`, modify this expression instance in-place.
    2729            opts: other options to use to parse the input expressions.
    2730
    2731        Returns:
    2732            The modified Select expression.
    2733        """
    2734        return _apply_list_builder(
    2735            *expressions,
    2736            instance=self,
    2737            arg="expressions",
    2738            append=append,
    2739            dialect=dialect,
    2740            copy=copy,
    2741            **opts,
    2742        )
    2743
    2744    def lateral(
    2745        self,
    2746        *expressions: t.Optional[ExpOrStr],
    2747        append: bool = True,
    2748        dialect: DialectType = None,
    2749        copy: bool = True,
    2750        **opts,
    2751    ) -> Select:
    2752        """
    2753        Append to or set the LATERAL expressions.
    2754
    2755        Example:
    2756            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    2757            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    2758
    2759        Args:
    2760            *expressions: the SQL code strings to parse.
    2761                If an `Expression` instance is passed, it will be used as-is.
    2762            append: if `True`, add to any existing expressions.
    2763                Otherwise, this resets the expressions.
    2764            dialect: the dialect used to parse the input expressions.
    2765            copy: if `False`, modify this expression instance in-place.
    2766            opts: other options to use to parse the input expressions.
    2767
    2768        Returns:
    2769            The modified Select expression.
    2770        """
    2771        return _apply_list_builder(
    2772            *expressions,
    2773            instance=self,
    2774            arg="laterals",
    2775            append=append,
    2776            into=Lateral,
    2777            prefix="LATERAL VIEW",
    2778            dialect=dialect,
    2779            copy=copy,
    2780            **opts,
    2781        )
    2782
    2783    def join(
    2784        self,
    2785        expression: ExpOrStr,
    2786        on: t.Optional[ExpOrStr] = None,
    2787        using: t.Optional[ExpOrStr | t.List[ExpOrStr]] = None,
    2788        append: bool = True,
    2789        join_type: t.Optional[str] = None,
    2790        join_alias: t.Optional[Identifier | str] = None,
    2791        dialect: DialectType = None,
    2792        copy: bool = True,
    2793        **opts,
    2794    ) -> Select:
    2795        """
    2796        Append to or set the JOIN expressions.
    2797
    2798        Example:
    2799            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    2800            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    2801
    2802            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    2803            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    2804
    2805            Use `join_type` to change the type of join:
    2806
    2807            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    2808            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    2809
    2810        Args:
    2811            expression: the SQL code string to parse.
    2812                If an `Expression` instance is passed, it will be used as-is.
    2813            on: optionally specify the join "on" criteria as a SQL string.
    2814                If an `Expression` instance is passed, it will be used as-is.
    2815            using: optionally specify the join "using" criteria as a SQL string.
    2816                If an `Expression` instance is passed, it will be used as-is.
    2817            append: if `True`, add to any existing expressions.
    2818                Otherwise, this resets the expressions.
    2819            join_type: if set, alter the parsed join type.
    2820            join_alias: an optional alias for the joined source.
    2821            dialect: the dialect used to parse the input expressions.
    2822            copy: if `False`, modify this expression instance in-place.
    2823            opts: other options to use to parse the input expressions.
    2824
    2825        Returns:
    2826            Select: the modified expression.
    2827        """
    2828        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    2829
    2830        try:
    2831            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    2832        except ParseError:
    2833            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    2834
    2835        join = expression if isinstance(expression, Join) else Join(this=expression)
    2836
    2837        if isinstance(join.this, Select):
    2838            join.this.replace(join.this.subquery())
    2839
    2840        if join_type:
    2841            method: t.Optional[Token]
    2842            side: t.Optional[Token]
    2843            kind: t.Optional[Token]
    2844
    2845            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    2846
    2847            if method:
    2848                join.set("method", method.text)
    2849            if side:
    2850                join.set("side", side.text)
    2851            if kind:
    2852                join.set("kind", kind.text)
    2853
    2854        if on:
    2855            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    2856            join.set("on", on)
    2857
    2858        if using:
    2859            join = _apply_list_builder(
    2860                *ensure_list(using),
    2861                instance=join,
    2862                arg="using",
    2863                append=append,
    2864                copy=copy,
    2865                **opts,
    2866            )
    2867
    2868        if join_alias:
    2869            join.set("this", alias_(join.this, join_alias, table=True))
    2870
    2871        return _apply_list_builder(
    2872            join,
    2873            instance=self,
    2874            arg="joins",
    2875            append=append,
    2876            copy=copy,
    2877            **opts,
    2878        )
    2879
    2880    def where(
    2881        self,
    2882        *expressions: t.Optional[ExpOrStr],
    2883        append: bool = True,
    2884        dialect: DialectType = None,
    2885        copy: bool = True,
    2886        **opts,
    2887    ) -> Select:
    2888        """
    2889        Append to or set the WHERE expressions.
    2890
    2891        Example:
    2892            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    2893            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    2894
    2895        Args:
    2896            *expressions: the SQL code strings to parse.
    2897                If an `Expression` instance is passed, it will be used as-is.
    2898                Multiple expressions are combined with an AND operator.
    2899            append: if `True`, AND the new expressions to any existing expression.
    2900                Otherwise, this resets the expression.
    2901            dialect: the dialect used to parse the input expressions.
    2902            copy: if `False`, modify this expression instance in-place.
    2903            opts: other options to use to parse the input expressions.
    2904
    2905        Returns:
    2906            Select: the modified expression.
    2907        """
    2908        return _apply_conjunction_builder(
    2909            *expressions,
    2910            instance=self,
    2911            arg="where",
    2912            append=append,
    2913            into=Where,
    2914            dialect=dialect,
    2915            copy=copy,
    2916            **opts,
    2917        )
    2918
    2919    def having(
    2920        self,
    2921        *expressions: t.Optional[ExpOrStr],
    2922        append: bool = True,
    2923        dialect: DialectType = None,
    2924        copy: bool = True,
    2925        **opts,
    2926    ) -> Select:
    2927        """
    2928        Append to or set the HAVING expressions.
    2929
    2930        Example:
    2931            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    2932            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    2933
    2934        Args:
    2935            *expressions: the SQL code strings to parse.
    2936                If an `Expression` instance is passed, it will be used as-is.
    2937                Multiple expressions are combined with an AND operator.
    2938            append: if `True`, AND the new expressions to any existing expression.
    2939                Otherwise, this resets the expression.
    2940            dialect: the dialect used to parse the input expressions.
    2941            copy: if `False`, modify this expression instance in-place.
    2942            opts: other options to use to parse the input expressions.
    2943
    2944        Returns:
    2945            The modified Select expression.
    2946        """
    2947        return _apply_conjunction_builder(
    2948            *expressions,
    2949            instance=self,
    2950            arg="having",
    2951            append=append,
    2952            into=Having,
    2953            dialect=dialect,
    2954            copy=copy,
    2955            **opts,
    2956        )
    2957
    2958    def window(
    2959        self,
    2960        *expressions: t.Optional[ExpOrStr],
    2961        append: bool = True,
    2962        dialect: DialectType = None,
    2963        copy: bool = True,
    2964        **opts,
    2965    ) -> Select:
    2966        return _apply_list_builder(
    2967            *expressions,
    2968            instance=self,
    2969            arg="windows",
    2970            append=append,
    2971            into=Window,
    2972            dialect=dialect,
    2973            copy=copy,
    2974            **opts,
    2975        )
    2976
    2977    def qualify(
    2978        self,
    2979        *expressions: t.Optional[ExpOrStr],
    2980        append: bool = True,
    2981        dialect: DialectType = None,
    2982        copy: bool = True,
    2983        **opts,
    2984    ) -> Select:
    2985        return _apply_conjunction_builder(
    2986            *expressions,
    2987            instance=self,
    2988            arg="qualify",
    2989            append=append,
    2990            into=Qualify,
    2991            dialect=dialect,
    2992            copy=copy,
    2993            **opts,
    2994        )
    2995
    2996    def distinct(
    2997        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    2998    ) -> Select:
    2999        """
    3000        Set the OFFSET expression.
    3001
    3002        Example:
    3003            >>> Select().from_("tbl").select("x").distinct().sql()
    3004            'SELECT DISTINCT x FROM tbl'
    3005
    3006        Args:
    3007            ons: the expressions to distinct on
    3008            distinct: whether the Select should be distinct
    3009            copy: if `False`, modify this expression instance in-place.
    3010
    3011        Returns:
    3012            Select: the modified expression.
    3013        """
    3014        instance = _maybe_copy(self, copy)
    3015        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3016        instance.set("distinct", Distinct(on=on) if distinct else None)
    3017        return instance
    3018
    3019    def ctas(
    3020        self,
    3021        table: ExpOrStr,
    3022        properties: t.Optional[t.Dict] = None,
    3023        dialect: DialectType = None,
    3024        copy: bool = True,
    3025        **opts,
    3026    ) -> Create:
    3027        """
    3028        Convert this expression to a CREATE TABLE AS statement.
    3029
    3030        Example:
    3031            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3032            'CREATE TABLE x AS SELECT * FROM tbl'
    3033
    3034        Args:
    3035            table: the SQL code string to parse as the table name.
    3036                If another `Expression` instance is passed, it will be used as-is.
    3037            properties: an optional mapping of table properties
    3038            dialect: the dialect used to parse the input table.
    3039            copy: if `False`, modify this expression instance in-place.
    3040            opts: other options to use to parse the input table.
    3041
    3042        Returns:
    3043            The new Create expression.
    3044        """
    3045        instance = _maybe_copy(self, copy)
    3046        table_expression = maybe_parse(
    3047            table,
    3048            into=Table,
    3049            dialect=dialect,
    3050            **opts,
    3051        )
    3052        properties_expression = None
    3053        if properties:
    3054            properties_expression = Properties.from_dict(properties)
    3055
    3056        return Create(
    3057            this=table_expression,
    3058            kind="table",
    3059            expression=instance,
    3060            properties=properties_expression,
    3061        )
    3062
    3063    def lock(self, update: bool = True, copy: bool = True) -> Select:
    3064        """
    3065        Set the locking read mode for this expression.
    3066
    3067        Examples:
    3068            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    3069            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    3070
    3071            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    3072            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    3073
    3074        Args:
    3075            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    3076            copy: if `False`, modify this expression instance in-place.
    3077
    3078        Returns:
    3079            The modified expression.
    3080        """
    3081        inst = _maybe_copy(self, copy)
    3082        inst.set("locks", [Lock(update=update)])
    3083
    3084        return inst
    3085
    3086    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    3087        """
    3088        Set hints for this expression.
    3089
    3090        Examples:
    3091            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    3092            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    3093
    3094        Args:
    3095            hints: The SQL code strings to parse as the hints.
    3096                If an `Expression` instance is passed, it will be used as-is.
    3097            dialect: The dialect used to parse the hints.
    3098            copy: If `False`, modify this expression instance in-place.
    3099
    3100        Returns:
    3101            The modified expression.
    3102        """
    3103        inst = _maybe_copy(self, copy)
    3104        inst.set(
    3105            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    3106        )
    3107
    3108        return inst
    3109
    3110    @property
    3111    def named_selects(self) -> t.List[str]:
    3112        return [e.output_name for e in self.expressions if e.alias_or_name]
    3113
    3114    @property
    3115    def is_star(self) -> bool:
    3116        return any(expression.is_star for expression in self.expressions)
    3117
    3118    @property
    3119    def selects(self) -> t.List[Expression]:
    3120        return self.expressions

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

    2445    def from_(
    2446        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    2447    ) -> Select:
    2448        """
    2449        Set the FROM expression.
    2450
    2451        Example:
    2452            >>> Select().from_("tbl").select("x").sql()
    2453            'SELECT x FROM tbl'
    2454
    2455        Args:
    2456            expression : the SQL code strings to parse.
    2457                If a `From` instance is passed, this is used as-is.
    2458                If another `Expression` instance is passed, it will be wrapped in a `From`.
    2459            dialect: the dialect used to parse the input expression.
    2460            copy: if `False`, modify this expression instance in-place.
    2461            opts: other options to use to parse the input expressions.
    2462
    2463        Returns:
    2464            The modified Select expression.
    2465        """
    2466        return _apply_builder(
    2467            expression=expression,
    2468            instance=self,
    2469            arg="from",
    2470            into=From,
    2471            prefix="FROM",
    2472            dialect=dialect,
    2473            copy=copy,
    2474            **opts,
    2475        )

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

    2477    def group_by(
    2478        self,
    2479        *expressions: t.Optional[ExpOrStr],
    2480        append: bool = True,
    2481        dialect: DialectType = None,
    2482        copy: bool = True,
    2483        **opts,
    2484    ) -> Select:
    2485        """
    2486        Set the GROUP BY expression.
    2487
    2488        Example:
    2489            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    2490            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    2491
    2492        Args:
    2493            *expressions: the SQL code strings to parse.
    2494                If a `Group` instance is passed, this is used as-is.
    2495                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    2496                If nothing is passed in then a group by is not applied to the expression
    2497            append: if `True`, add to any existing expressions.
    2498                Otherwise, this flattens all the `Group` expression into a single expression.
    2499            dialect: the dialect used to parse the input expression.
    2500            copy: if `False`, modify this expression instance in-place.
    2501            opts: other options to use to parse the input expressions.
    2502
    2503        Returns:
    2504            The modified Select expression.
    2505        """
    2506        if not expressions:
    2507            return self if not copy else self.copy()
    2508
    2509        return _apply_child_list_builder(
    2510            *expressions,
    2511            instance=self,
    2512            arg="group",
    2513            append=append,
    2514            copy=copy,
    2515            prefix="GROUP BY",
    2516            into=Group,
    2517            dialect=dialect,
    2518            **opts,
    2519        )

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

    2521    def order_by(
    2522        self,
    2523        *expressions: t.Optional[ExpOrStr],
    2524        append: bool = True,
    2525        dialect: DialectType = None,
    2526        copy: bool = True,
    2527        **opts,
    2528    ) -> Select:
    2529        """
    2530        Set the ORDER BY expression.
    2531
    2532        Example:
    2533            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    2534            'SELECT x FROM tbl ORDER BY x DESC'
    2535
    2536        Args:
    2537            *expressions: the SQL code strings to parse.
    2538                If a `Group` instance is passed, this is used as-is.
    2539                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    2540            append: if `True`, add to any existing expressions.
    2541                Otherwise, this flattens all the `Order` expression into a single expression.
    2542            dialect: the dialect used to parse the input expression.
    2543            copy: if `False`, modify this expression instance in-place.
    2544            opts: other options to use to parse the input expressions.
    2545
    2546        Returns:
    2547            The modified Select expression.
    2548        """
    2549        return _apply_child_list_builder(
    2550            *expressions,
    2551            instance=self,
    2552            arg="order",
    2553            append=append,
    2554            copy=copy,
    2555            prefix="ORDER BY",
    2556            into=Order,
    2557            dialect=dialect,
    2558            **opts,
    2559        )

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.

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

    2561    def sort_by(
    2562        self,
    2563        *expressions: t.Optional[ExpOrStr],
    2564        append: bool = True,
    2565        dialect: DialectType = None,
    2566        copy: bool = True,
    2567        **opts,
    2568    ) -> Select:
    2569        """
    2570        Set the SORT BY expression.
    2571
    2572        Example:
    2573            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    2574            'SELECT x FROM tbl SORT BY x DESC'
    2575
    2576        Args:
    2577            *expressions: the SQL code strings to parse.
    2578                If a `Group` instance is passed, this is used as-is.
    2579                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    2580            append: if `True`, add to any existing expressions.
    2581                Otherwise, this flattens all the `Order` expression into a single expression.
    2582            dialect: the dialect used to parse the input expression.
    2583            copy: if `False`, modify this expression instance in-place.
    2584            opts: other options to use to parse the input expressions.
    2585
    2586        Returns:
    2587            The modified Select expression.
    2588        """
    2589        return _apply_child_list_builder(
    2590            *expressions,
    2591            instance=self,
    2592            arg="sort",
    2593            append=append,
    2594            copy=copy,
    2595            prefix="SORT BY",
    2596            into=Sort,
    2597            dialect=dialect,
    2598            **opts,
    2599        )

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

    2601    def cluster_by(
    2602        self,
    2603        *expressions: t.Optional[ExpOrStr],
    2604        append: bool = True,
    2605        dialect: DialectType = None,
    2606        copy: bool = True,
    2607        **opts,
    2608    ) -> Select:
    2609        """
    2610        Set the CLUSTER BY expression.
    2611
    2612        Example:
    2613            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    2614            'SELECT x FROM tbl CLUSTER BY x DESC'
    2615
    2616        Args:
    2617            *expressions: the SQL code strings to parse.
    2618                If a `Group` instance is passed, this is used as-is.
    2619                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    2620            append: if `True`, add to any existing expressions.
    2621                Otherwise, this flattens all the `Order` expression into a single expression.
    2622            dialect: the dialect used to parse the input expression.
    2623            copy: if `False`, modify this expression instance in-place.
    2624            opts: other options to use to parse the input expressions.
    2625
    2626        Returns:
    2627            The modified Select expression.
    2628        """
    2629        return _apply_child_list_builder(
    2630            *expressions,
    2631            instance=self,
    2632            arg="cluster",
    2633            append=append,
    2634            copy=copy,
    2635            prefix="CLUSTER BY",
    2636            into=Cluster,
    2637            dialect=dialect,
    2638            **opts,
    2639        )

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

    2641    def limit(
    2642        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2643    ) -> Select:
    2644        """
    2645        Set the LIMIT expression.
    2646
    2647        Example:
    2648            >>> Select().from_("tbl").select("x").limit(10).sql()
    2649            'SELECT x FROM tbl LIMIT 10'
    2650
    2651        Args:
    2652            expression: the SQL code string to parse.
    2653                This can also be an integer.
    2654                If a `Limit` instance is passed, this is used as-is.
    2655                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2656            dialect: the dialect used to parse the input expression.
    2657            copy: if `False`, modify this expression instance in-place.
    2658            opts: other options to use to parse the input expressions.
    2659
    2660        Returns:
    2661            Select: the modified expression.
    2662        """
    2663        return _apply_builder(
    2664            expression=expression,
    2665            instance=self,
    2666            arg="limit",
    2667            into=Limit,
    2668            prefix="LIMIT",
    2669            dialect=dialect,
    2670            copy=copy,
    2671            **opts,
    2672        )

Set the LIMIT expression.

###### Example:

>     >>> Select().from_("tbl").select("x").limit(10).sql()
>     'SELECT x FROM tbl LIMIT 10'

###### Arguments:

- expression: the SQL code string to parse. This can also be an integer. If a `Limit` instance is passed, this is 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:

> Select: the modified expression.

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

    2674    def offset(
    2675        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2676    ) -> Select:
    2677        """
    2678        Set the OFFSET expression.
    2679
    2680        Example:
    2681            >>> Select().from_("tbl").select("x").offset(10).sql()
    2682            'SELECT x FROM tbl OFFSET 10'
    2683
    2684        Args:
    2685            expression: the SQL code string to parse.
    2686                This can also be an integer.
    2687                If a `Offset` instance is passed, this is used as-is.
    2688                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    2689            dialect: the dialect used to parse the input expression.
    2690            copy: if `False`, modify this expression instance in-place.
    2691            opts: other options to use to parse the input expressions.
    2692
    2693        Returns:
    2694            The modified Select expression.
    2695        """
    2696        return _apply_builder(
    2697            expression=expression,
    2698            instance=self,
    2699            arg="offset",
    2700            into=Offset,
    2701            prefix="OFFSET",
    2702            dialect=dialect,
    2703            copy=copy,
    2704            **opts,
    2705        )

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

    2707    def select(
    2708        self,
    2709        *expressions: t.Optional[ExpOrStr],
    2710        append: bool = True,
    2711        dialect: DialectType = None,
    2712        copy: bool = True,
    2713        **opts,
    2714    ) -> Select:
    2715        """
    2716        Append to or set the SELECT expressions.
    2717
    2718        Example:
    2719            >>> Select().select("x", "y").sql()
    2720            'SELECT x, y'
    2721
    2722        Args:
    2723            *expressions: the SQL code strings to parse.
    2724                If an `Expression` instance is passed, it will be used as-is.
    2725            append: if `True`, add to any existing expressions.
    2726                Otherwise, this resets the expressions.
    2727            dialect: the dialect used to parse the input expressions.
    2728            copy: if `False`, modify this expression instance in-place.
    2729            opts: other options to use to parse the input expressions.
    2730
    2731        Returns:
    2732            The modified Select expression.
    2733        """
    2734        return _apply_list_builder(
    2735            *expressions,
    2736            instance=self,
    2737            arg="expressions",
    2738            append=append,
    2739            dialect=dialect,
    2740            copy=copy,
    2741            **opts,
    2742        )

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 Select expression.

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

    2744    def lateral(
    2745        self,
    2746        *expressions: t.Optional[ExpOrStr],
    2747        append: bool = True,
    2748        dialect: DialectType = None,
    2749        copy: bool = True,
    2750        **opts,
    2751    ) -> Select:
    2752        """
    2753        Append to or set the LATERAL expressions.
    2754
    2755        Example:
    2756            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    2757            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    2758
    2759        Args:
    2760            *expressions: the SQL code strings to parse.
    2761                If an `Expression` instance is passed, it will be used as-is.
    2762            append: if `True`, add to any existing expressions.
    2763                Otherwise, this resets the expressions.
    2764            dialect: the dialect used to parse the input expressions.
    2765            copy: if `False`, modify this expression instance in-place.
    2766            opts: other options to use to parse the input expressions.
    2767
    2768        Returns:
    2769            The modified Select expression.
    2770        """
    2771        return _apply_list_builder(
    2772            *expressions,
    2773            instance=self,
    2774            arg="laterals",
    2775            append=append,
    2776            into=Lateral,
    2777            prefix="LATERAL VIEW",
    2778            dialect=dialect,
    2779            copy=copy,
    2780            **opts,
    2781        )

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, sqlglot.expressions.Expression], on: Union[str, sqlglot.expressions.Expression, NoneType] = None, using: Union[str, sqlglot.expressions.Expression, List[Union[str, sqlglot.expressions.Expression]], NoneType] = None, append: bool = True, join_type: Optional[str] = None, join_alias: Union[sqlglot.expressions.Identifier, str, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> sqlglot.expressions.Select: View Source

    2783    def join(
    2784        self,
    2785        expression: ExpOrStr,
    2786        on: t.Optional[ExpOrStr] = None,
    2787        using: t.Optional[ExpOrStr | t.List[ExpOrStr]] = None,
    2788        append: bool = True,
    2789        join_type: t.Optional[str] = None,
    2790        join_alias: t.Optional[Identifier | str] = None,
    2791        dialect: DialectType = None,
    2792        copy: bool = True,
    2793        **opts,
    2794    ) -> Select:
    2795        """
    2796        Append to or set the JOIN expressions.
    2797
    2798        Example:
    2799            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    2800            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    2801
    2802            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    2803            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    2804
    2805            Use `join_type` to change the type of join:
    2806
    2807            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    2808            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    2809
    2810        Args:
    2811            expression: the SQL code string to parse.
    2812                If an `Expression` instance is passed, it will be used as-is.
    2813            on: optionally specify the join "on" criteria as a SQL string.
    2814                If an `Expression` instance is passed, it will be used as-is.
    2815            using: optionally specify the join "using" criteria as a SQL string.
    2816                If an `Expression` instance is passed, it will be used as-is.
    2817            append: if `True`, add to any existing expressions.
    2818                Otherwise, this resets the expressions.
    2819            join_type: if set, alter the parsed join type.
    2820            join_alias: an optional alias for the joined source.
    2821            dialect: the dialect used to parse the input expressions.
    2822            copy: if `False`, modify this expression instance in-place.
    2823            opts: other options to use to parse the input expressions.
    2824
    2825        Returns:
    2826            Select: the modified expression.
    2827        """
    2828        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    2829
    2830        try:
    2831            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    2832        except ParseError:
    2833            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    2834
    2835        join = expression if isinstance(expression, Join) else Join(this=expression)
    2836
    2837        if isinstance(join.this, Select):
    2838            join.this.replace(join.this.subquery())
    2839
    2840        if join_type:
    2841            method: t.Optional[Token]
    2842            side: t.Optional[Token]
    2843            kind: t.Optional[Token]
    2844
    2845            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    2846
    2847            if method:
    2848                join.set("method", method.text)
    2849            if side:
    2850                join.set("side", side.text)
    2851            if kind:
    2852                join.set("kind", kind.text)
    2853
    2854        if on:
    2855            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    2856            join.set("on", on)
    2857
    2858        if using:
    2859            join = _apply_list_builder(
    2860                *ensure_list(using),
    2861                instance=join,
    2862                arg="using",
    2863                append=append,
    2864                copy=copy,
    2865                **opts,
    2866            )
    2867
    2868        if join_alias:
    2869            join.set("this", alias_(join.this, join_alias, table=True))
    2870
    2871        return _apply_list_builder(
    2872            join,
    2873            instance=self,
    2874            arg="joins",
    2875            append=append,
    2876            copy=copy,
    2877            **opts,
    2878        )

Append to or set the JOIN expressions.

###### Example:

>     >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
>     'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'

>     >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
>     'SELECT 1 FROM a JOIN b USING (x, y, z)'

> Use `join_type` to change the type of join:

>     >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
>     'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'

###### Arguments:

- expression: the SQL code string to parse. If an `Expression` instance is passed, it will be used as-is.
- on: optionally specify the join "on" criteria as a SQL string. If an `Expression` instance is passed, it will be used as-is.
- using: optionally specify the join "using" criteria as a SQL string. If an `Expression` instance is passed, it will be used as-is.
- append: if `True`, add to any existing expressions. Otherwise, this resets the expressions.
- join_type: if set, alter the parsed join type.
- join_alias: an optional alias for the joined source.
- dialect: the dialect used to parse the input expressions.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> Select: the modified expression.

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

    2880    def where(
    2881        self,
    2882        *expressions: t.Optional[ExpOrStr],
    2883        append: bool = True,
    2884        dialect: DialectType = None,
    2885        copy: bool = True,
    2886        **opts,
    2887    ) -> Select:
    2888        """
    2889        Append to or set the WHERE expressions.
    2890
    2891        Example:
    2892            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    2893            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    2894
    2895        Args:
    2896            *expressions: the SQL code strings to parse.
    2897                If an `Expression` instance is passed, it will be used as-is.
    2898                Multiple expressions are combined with an AND operator.
    2899            append: if `True`, AND the new expressions to any existing expression.
    2900                Otherwise, this resets the expression.
    2901            dialect: the dialect used to parse the input expressions.
    2902            copy: if `False`, modify this expression instance in-place.
    2903            opts: other options to use to parse the input expressions.
    2904
    2905        Returns:
    2906            Select: the modified expression.
    2907        """
    2908        return _apply_conjunction_builder(
    2909            *expressions,
    2910            instance=self,
    2911            arg="where",
    2912            append=append,
    2913            into=Where,
    2914            dialect=dialect,
    2915            copy=copy,
    2916            **opts,
    2917        )

Append to or set the WHERE expressions.

###### Example:

>     >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
>     "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"

###### Arguments:

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

###### Returns:

> Select: the modified expression.

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

    2919    def having(
    2920        self,
    2921        *expressions: t.Optional[ExpOrStr],
    2922        append: bool = True,
    2923        dialect: DialectType = None,
    2924        copy: bool = True,
    2925        **opts,
    2926    ) -> Select:
    2927        """
    2928        Append to or set the HAVING expressions.
    2929
    2930        Example:
    2931            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    2932            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    2933
    2934        Args:
    2935            *expressions: the SQL code strings to parse.
    2936                If an `Expression` instance is passed, it will be used as-is.
    2937                Multiple expressions are combined with an AND operator.
    2938            append: if `True`, AND the new expressions to any existing expression.
    2939                Otherwise, this resets the expression.
    2940            dialect: the dialect used to parse the input expressions.
    2941            copy: if `False`, modify this expression instance in-place.
    2942            opts: other options to use to parse the input expressions.
    2943
    2944        Returns:
    2945            The modified Select expression.
    2946        """
    2947        return _apply_conjunction_builder(
    2948            *expressions,
    2949            instance=self,
    2950            arg="having",
    2951            append=append,
    2952            into=Having,
    2953            dialect=dialect,
    2954            copy=copy,
    2955            **opts,
    2956        )

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

    2958    def window(
    2959        self,
    2960        *expressions: t.Optional[ExpOrStr],
    2961        append: bool = True,
    2962        dialect: DialectType = None,
    2963        copy: bool = True,
    2964        **opts,
    2965    ) -> Select:
    2966        return _apply_list_builder(
    2967            *expressions,
    2968            instance=self,
    2969            arg="windows",
    2970            append=append,
    2971            into=Window,
    2972            dialect=dialect,
    2973            copy=copy,
    2974            **opts,
    2975        )

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

    2977    def qualify(
    2978        self,
    2979        *expressions: t.Optional[ExpOrStr],
    2980        append: bool = True,
    2981        dialect: DialectType = None,
    2982        copy: bool = True,
    2983        **opts,
    2984    ) -> Select:
    2985        return _apply_conjunction_builder(
    2986            *expressions,
    2987            instance=self,
    2988            arg="qualify",
    2989            append=append,
    2990            into=Qualify,
    2991            dialect=dialect,
    2992            copy=copy,
    2993            **opts,
    2994        )

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

    2996    def distinct(
    2997        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    2998    ) -> Select:
    2999        """
    3000        Set the OFFSET expression.
    3001
    3002        Example:
    3003            >>> Select().from_("tbl").select("x").distinct().sql()
    3004            'SELECT DISTINCT x FROM tbl'
    3005
    3006        Args:
    3007            ons: the expressions to distinct on
    3008            distinct: whether the Select should be distinct
    3009            copy: if `False`, modify this expression instance in-place.
    3010
    3011        Returns:
    3012            Select: the modified expression.
    3013        """
    3014        instance = _maybe_copy(self, copy)
    3015        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3016        instance.set("distinct", Distinct(on=on) if distinct else None)
    3017        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, sqlglot.expressions.Expression], properties: Optional[Dict] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> sqlglot.expressions.Create: View Source

    3019    def ctas(
    3020        self,
    3021        table: ExpOrStr,
    3022        properties: t.Optional[t.Dict] = None,
    3023        dialect: DialectType = None,
    3024        copy: bool = True,
    3025        **opts,
    3026    ) -> Create:
    3027        """
    3028        Convert this expression to a CREATE TABLE AS statement.
    3029
    3030        Example:
    3031            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3032            'CREATE TABLE x AS SELECT * FROM tbl'
    3033
    3034        Args:
    3035            table: the SQL code string to parse as the table name.
    3036                If another `Expression` instance is passed, it will be used as-is.
    3037            properties: an optional mapping of table properties
    3038            dialect: the dialect used to parse the input table.
    3039            copy: if `False`, modify this expression instance in-place.
    3040            opts: other options to use to parse the input table.
    3041
    3042        Returns:
    3043            The new Create expression.
    3044        """
    3045        instance = _maybe_copy(self, copy)
    3046        table_expression = maybe_parse(
    3047            table,
    3048            into=Table,
    3049            dialect=dialect,
    3050            **opts,
    3051        )
    3052        properties_expression = None
    3053        if properties:
    3054            properties_expression = Properties.from_dict(properties)
    3055
    3056        return Create(
    3057            this=table_expression,
    3058            kind="table",
    3059            expression=instance,
    3060            properties=properties_expression,
    3061        )

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) -> sqlglot.expressions.Select: View Source

    3063    def lock(self, update: bool = True, copy: bool = True) -> Select:
    3064        """
    3065        Set the locking read mode for this expression.
    3066
    3067        Examples:
    3068            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    3069            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    3070
    3071            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    3072            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    3073
    3074        Args:
    3075            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    3076            copy: if `False`, modify this expression instance in-place.
    3077
    3078        Returns:
    3079            The modified expression.
    3080        """
    3081        inst = _maybe_copy(self, copy)
    3082        inst.set("locks", [Lock(update=update)])
    3083
    3084        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, sqlglot.expressions.Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True) -> sqlglot.expressions.Select: View Source

    3086    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    3087        """
    3088        Set hints for this expression.
    3089
    3090        Examples:
    3091            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    3092            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    3093
    3094        Args:
    3095            hints: The SQL code strings to parse as the hints.
    3096                If an `Expression` instance is passed, it will be used as-is.
    3097            dialect: The dialect used to parse the hints.
    3098            copy: If `False`, modify this expression instance in-place.
    3099
    3100        Returns:
    3101            The modified expression.
    3102        """
    3103        inst = _maybe_copy(self, copy)
    3104        inst.set(
    3105            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    3106        )
    3107
    3108        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.

is_star: bool

Checks whether an expression is a star.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Subqueryable
  subquery
  with_
Unionable
  union
  intersect
  except_

class Subquery(DerivedTable, Unionable): View Source

    3123class Subquery(DerivedTable, Unionable):
    3124    arg_types = {
    3125        "this": True,
    3126        "alias": False,
    3127        "with": False,
    3128        **QUERY_MODIFIERS,
    3129    }
    3130
    3131    def unnest(self):
    3132        """
    3133        Returns the first non subquery.
    3134        """
    3135        expression = self
    3136        while isinstance(expression, Subquery):
    3137            expression = expression.this
    3138        return expression
    3139
    3140    @property
    3141    def is_star(self) -> bool:
    3142        return self.this.is_star
    3143
    3144    @property
    3145    def output_name(self) -> str:
    3146        return self.alias

def unnest(self): View Source

    3131    def unnest(self):
    3132        """
    3133        Returns the first non subquery.
    3134        """
    3135        expression = self
    3136        while isinstance(expression, Subquery):
    3137            expression = expression.this
    3138        return expression

Returns the first non subquery.

is_star: bool

Checks whether an expression is a star.

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Unionable
  union
  intersect
  except_

class TableSample(Expression): View Source

    3149class TableSample(Expression):
    3150    arg_types = {
    3151        "this": False,
    3152        "method": False,
    3153        "bucket_numerator": False,
    3154        "bucket_denominator": False,
    3155        "bucket_field": False,
    3156        "percent": False,
    3157        "rows": False,
    3158        "size": False,
    3159        "seed": False,
    3160        "kind": False,
    3161    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Tag(Expression): View Source

    3164class Tag(Expression):
    3165    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    3166
    3167    arg_types = {
    3168        "this": False,
    3169        "prefix": False,
    3170        "postfix": False,
    3171    }

Tags are used for generating arbitrary sql like SELECT x.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Pivot(Expression): View Source

    3176class Pivot(Expression):
    3177    arg_types = {
    3178        "this": False,
    3179        "alias": False,
    3180        "expressions": True,
    3181        "field": False,
    3182        "unpivot": False,
    3183        "using": False,
    3184        "group": False,
    3185        "columns": False,
    3186    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Window(Expression): View Source

    3189class Window(Expression):
    3190    arg_types = {
    3191        "this": True,
    3192        "partition_by": False,
    3193        "order": False,
    3194        "spec": False,
    3195        "alias": False,
    3196        "over": False,
    3197        "first": False,
    3198    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class WindowSpec(Expression): View Source

    3201class WindowSpec(Expression):
    3202    arg_types = {
    3203        "kind": False,
    3204        "start": False,
    3205        "start_side": False,
    3206        "end": False,
    3207        "end_side": False,
    3208    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Where(Expression): View Source

    3211class Where(Expression):
    3212    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Star(Expression): View Source

    3215class Star(Expression):
    3216    arg_types = {"except": False, "replace": False}
    3217
    3218    @property
    3219    def name(self) -> str:
    3220        return "*"
    3221
    3222    @property
    3223    def output_name(self) -> str:
    3224        return self.name

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Parameter(Expression): View Source

    3227class Parameter(Expression):
    3228    arg_types = {"this": True, "wrapped": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SessionParameter(Expression): View Source

    3231class SessionParameter(Expression):
    3232    arg_types = {"this": True, "kind": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Placeholder(Expression): View Source

    3235class Placeholder(Expression):
    3236    arg_types = {"this": False, "kind": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Null(Condition): View Source

    3239class Null(Condition):
    3240    arg_types: t.Dict[str, t.Any] = {}
    3241
    3242    @property
    3243    def name(self) -> str:
    3244        return "NULL"

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Boolean(Condition): View Source

    3247class Boolean(Condition):
    3248    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DataTypeSize(Expression): View Source

    3251class DataTypeSize(Expression):
    3252    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DataType(Expression): View Source

    3255class DataType(Expression):
    3256    arg_types = {
    3257        "this": True,
    3258        "expressions": False,
    3259        "nested": False,
    3260        "values": False,
    3261        "prefix": False,
    3262    }
    3263
    3264    class Type(AutoName):
    3265        ARRAY = auto()
    3266        BIGDECIMAL = auto()
    3267        BIGINT = auto()
    3268        BIGSERIAL = auto()
    3269        BINARY = auto()
    3270        BIT = auto()
    3271        BOOLEAN = auto()
    3272        CHAR = auto()
    3273        DATE = auto()
    3274        DATETIME = auto()
    3275        DATETIME64 = auto()
    3276        ENUM = auto()
    3277        INT4RANGE = auto()
    3278        INT4MULTIRANGE = auto()
    3279        INT8RANGE = auto()
    3280        INT8MULTIRANGE = auto()
    3281        NUMRANGE = auto()
    3282        NUMMULTIRANGE = auto()
    3283        TSRANGE = auto()
    3284        TSMULTIRANGE = auto()
    3285        TSTZRANGE = auto()
    3286        TSTZMULTIRANGE = auto()
    3287        DATERANGE = auto()
    3288        DATEMULTIRANGE = auto()
    3289        DECIMAL = auto()
    3290        DOUBLE = auto()
    3291        FLOAT = auto()
    3292        GEOGRAPHY = auto()
    3293        GEOMETRY = auto()
    3294        HLLSKETCH = auto()
    3295        HSTORE = auto()
    3296        IMAGE = auto()
    3297        INET = auto()
    3298        INT = auto()
    3299        INT128 = auto()
    3300        INT256 = auto()
    3301        INTERVAL = auto()
    3302        JSON = auto()
    3303        JSONB = auto()
    3304        LONGBLOB = auto()
    3305        LONGTEXT = auto()
    3306        MAP = auto()
    3307        MEDIUMBLOB = auto()
    3308        MEDIUMTEXT = auto()
    3309        MONEY = auto()
    3310        NCHAR = auto()
    3311        NULL = auto()
    3312        NULLABLE = auto()
    3313        NVARCHAR = auto()
    3314        OBJECT = auto()
    3315        ROWVERSION = auto()
    3316        SERIAL = auto()
    3317        SET = auto()
    3318        SMALLINT = auto()
    3319        SMALLMONEY = auto()
    3320        SMALLSERIAL = auto()
    3321        STRUCT = auto()
    3322        SUPER = auto()
    3323        TEXT = auto()
    3324        TIME = auto()
    3325        TIMESTAMP = auto()
    3326        TIMESTAMPTZ = auto()
    3327        TIMESTAMPLTZ = auto()
    3328        TINYINT = auto()
    3329        UBIGINT = auto()
    3330        UINT = auto()
    3331        USMALLINT = auto()
    3332        UTINYINT = auto()
    3333        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    3334        UINT128 = auto()
    3335        UINT256 = auto()
    3336        UNIQUEIDENTIFIER = auto()
    3337        UUID = auto()
    3338        VARBINARY = auto()
    3339        VARCHAR = auto()
    3340        VARIANT = auto()
    3341        XML = auto()
    3342
    3343    TEXT_TYPES = {
    3344        Type.CHAR,
    3345        Type.NCHAR,
    3346        Type.VARCHAR,
    3347        Type.NVARCHAR,
    3348        Type.TEXT,
    3349    }
    3350
    3351    INTEGER_TYPES = {
    3352        Type.INT,
    3353        Type.TINYINT,
    3354        Type.SMALLINT,
    3355        Type.BIGINT,
    3356        Type.INT128,
    3357        Type.INT256,
    3358    }
    3359
    3360    FLOAT_TYPES = {
    3361        Type.FLOAT,
    3362        Type.DOUBLE,
    3363    }
    3364
    3365    NUMERIC_TYPES = {*INTEGER_TYPES, *FLOAT_TYPES}
    3366
    3367    TEMPORAL_TYPES = {
    3368        Type.TIME,
    3369        Type.TIMESTAMP,
    3370        Type.TIMESTAMPTZ,
    3371        Type.TIMESTAMPLTZ,
    3372        Type.DATE,
    3373        Type.DATETIME,
    3374        Type.DATETIME64,
    3375    }
    3376
    3377    @classmethod
    3378    def build(
    3379        cls, dtype: str | DataType | DataType.Type, dialect: DialectType = None, **kwargs
    3380    ) -> DataType:
    3381        from sqlglot import parse_one
    3382
    3383        if isinstance(dtype, str):
    3384            if dtype.upper() == "UNKNOWN":
    3385                data_type_exp: t.Optional[Expression] = DataType(this=DataType.Type.UNKNOWN)
    3386            else:
    3387                data_type_exp = parse_one(dtype, read=dialect, into=DataType)
    3388
    3389            if data_type_exp is None:
    3390                raise ValueError(f"Unparsable data type value: {dtype}")
    3391        elif isinstance(dtype, DataType.Type):
    3392            data_type_exp = DataType(this=dtype)
    3393        elif isinstance(dtype, DataType):
    3394            return dtype
    3395        else:
    3396            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    3397
    3398        return DataType(**{**data_type_exp.args, **kwargs})
    3399
    3400    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3401        return any(self.this == DataType.build(dtype).this for dtype in dtypes)

@classmethod
def build( cls, dtype: str | sqlglot.expressions.DataType | sqlglot.expressions.DataType.Type, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **kwargs) -> sqlglot.expressions.DataType: View Source

    3377    @classmethod
    3378    def build(
    3379        cls, dtype: str | DataType | DataType.Type, dialect: DialectType = None, **kwargs
    3380    ) -> DataType:
    3381        from sqlglot import parse_one
    3382
    3383        if isinstance(dtype, str):
    3384            if dtype.upper() == "UNKNOWN":
    3385                data_type_exp: t.Optional[Expression] = DataType(this=DataType.Type.UNKNOWN)
    3386            else:
    3387                data_type_exp = parse_one(dtype, read=dialect, into=DataType)
    3388
    3389            if data_type_exp is None:
    3390                raise ValueError(f"Unparsable data type value: {dtype}")
    3391        elif isinstance(dtype, DataType.Type):
    3392            data_type_exp = DataType(this=dtype)
    3393        elif isinstance(dtype, DataType):
    3394            return dtype
    3395        else:
    3396            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    3397
    3398        return DataType(**{**data_type_exp.args, **kwargs})

def is_type( self, *dtypes: str | sqlglot.expressions.DataType | sqlglot.expressions.DataType.Type) -> bool: View Source

    3400    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3401        return any(self.this == DataType.build(dtype).this for dtype in dtypes)

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

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

    3264    class Type(AutoName):
    3265        ARRAY = auto()
    3266        BIGDECIMAL = auto()
    3267        BIGINT = auto()
    3268        BIGSERIAL = auto()
    3269        BINARY = auto()
    3270        BIT = auto()
    3271        BOOLEAN = auto()
    3272        CHAR = auto()
    3273        DATE = auto()
    3274        DATETIME = auto()
    3275        DATETIME64 = auto()
    3276        ENUM = auto()
    3277        INT4RANGE = auto()
    3278        INT4MULTIRANGE = auto()
    3279        INT8RANGE = auto()
    3280        INT8MULTIRANGE = auto()
    3281        NUMRANGE = auto()
    3282        NUMMULTIRANGE = auto()
    3283        TSRANGE = auto()
    3284        TSMULTIRANGE = auto()
    3285        TSTZRANGE = auto()
    3286        TSTZMULTIRANGE = auto()
    3287        DATERANGE = auto()
    3288        DATEMULTIRANGE = auto()
    3289        DECIMAL = auto()
    3290        DOUBLE = auto()
    3291        FLOAT = auto()
    3292        GEOGRAPHY = auto()
    3293        GEOMETRY = auto()
    3294        HLLSKETCH = auto()
    3295        HSTORE = auto()
    3296        IMAGE = auto()
    3297        INET = auto()
    3298        INT = auto()
    3299        INT128 = auto()
    3300        INT256 = auto()
    3301        INTERVAL = auto()
    3302        JSON = auto()
    3303        JSONB = auto()
    3304        LONGBLOB = auto()
    3305        LONGTEXT = auto()
    3306        MAP = auto()
    3307        MEDIUMBLOB = auto()
    3308        MEDIUMTEXT = auto()
    3309        MONEY = auto()
    3310        NCHAR = auto()
    3311        NULL = auto()
    3312        NULLABLE = auto()
    3313        NVARCHAR = auto()
    3314        OBJECT = auto()
    3315        ROWVERSION = auto()
    3316        SERIAL = auto()
    3317        SET = auto()
    3318        SMALLINT = auto()
    3319        SMALLMONEY = auto()
    3320        SMALLSERIAL = auto()
    3321        STRUCT = auto()
    3322        SUPER = auto()
    3323        TEXT = auto()
    3324        TIME = auto()
    3325        TIMESTAMP = auto()
    3326        TIMESTAMPTZ = auto()
    3327        TIMESTAMPLTZ = auto()
    3328        TINYINT = auto()
    3329        UBIGINT = auto()
    3330        UINT = auto()
    3331        USMALLINT = auto()
    3332        UTINYINT = auto()
    3333        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    3334        UINT128 = auto()
    3335        UINT256 = auto()
    3336        UNIQUEIDENTIFIER = auto()
    3337        UUID = auto()
    3338        VARBINARY = auto()
    3339        VARCHAR = auto()
    3340        VARIANT = auto()
    3341        XML = auto()

An enumeration.

ARRAY = <Type.ARRAY: 'ARRAY'>
BIGDECIMAL = <Type.BIGDECIMAL: 'BIGDECIMAL'>
BIGINT = <Type.BIGINT: 'BIGINT'>
BIGSERIAL = <Type.BIGSERIAL: 'BIGSERIAL'>
BINARY = <Type.BINARY: 'BINARY'>
BIT = <Type.BIT: 'BIT'>
BOOLEAN = <Type.BOOLEAN: 'BOOLEAN'>
CHAR = <Type.CHAR: 'CHAR'>
DATE = <Type.DATE: 'DATE'>
DATETIME = <Type.DATETIME: 'DATETIME'>
DATETIME64 = <Type.DATETIME64: 'DATETIME64'>
ENUM = <Type.ENUM: 'ENUM'>
INT4RANGE = <Type.INT4RANGE: 'INT4RANGE'>
INT4MULTIRANGE = <Type.INT4MULTIRANGE: 'INT4MULTIRANGE'>
INT8RANGE = <Type.INT8RANGE: 'INT8RANGE'>
INT8MULTIRANGE = <Type.INT8MULTIRANGE: 'INT8MULTIRANGE'>
NUMRANGE = <Type.NUMRANGE: 'NUMRANGE'>
NUMMULTIRANGE = <Type.NUMMULTIRANGE: 'NUMMULTIRANGE'>
TSRANGE = <Type.TSRANGE: 'TSRANGE'>
TSMULTIRANGE = <Type.TSMULTIRANGE: 'TSMULTIRANGE'>
TSTZRANGE = <Type.TSTZRANGE: 'TSTZRANGE'>
TSTZMULTIRANGE = <Type.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>
DATERANGE = <Type.DATERANGE: 'DATERANGE'>
DATEMULTIRANGE = <Type.DATEMULTIRANGE: 'DATEMULTIRANGE'>
DECIMAL = <Type.DECIMAL: 'DECIMAL'>
DOUBLE = <Type.DOUBLE: 'DOUBLE'>
FLOAT = <Type.FLOAT: 'FLOAT'>
GEOGRAPHY = <Type.GEOGRAPHY: 'GEOGRAPHY'>
GEOMETRY = <Type.GEOMETRY: 'GEOMETRY'>
HLLSKETCH = <Type.HLLSKETCH: 'HLLSKETCH'>
HSTORE = <Type.HSTORE: 'HSTORE'>
IMAGE = <Type.IMAGE: 'IMAGE'>
INET = <Type.INET: 'INET'>
INT = <Type.INT: 'INT'>
INT128 = <Type.INT128: 'INT128'>
INT256 = <Type.INT256: 'INT256'>
INTERVAL = <Type.INTERVAL: 'INTERVAL'>
JSON = <Type.JSON: 'JSON'>
JSONB = <Type.JSONB: 'JSONB'>
LONGBLOB = <Type.LONGBLOB: 'LONGBLOB'>
LONGTEXT = <Type.LONGTEXT: 'LONGTEXT'>
MAP = <Type.MAP: 'MAP'>
MEDIUMBLOB = <Type.MEDIUMBLOB: 'MEDIUMBLOB'>
MEDIUMTEXT = <Type.MEDIUMTEXT: 'MEDIUMTEXT'>
MONEY = <Type.MONEY: 'MONEY'>
NCHAR = <Type.NCHAR: 'NCHAR'>
NULL = <Type.NULL: 'NULL'>
NULLABLE = <Type.NULLABLE: 'NULLABLE'>
NVARCHAR = <Type.NVARCHAR: 'NVARCHAR'>
OBJECT = <Type.OBJECT: 'OBJECT'>
ROWVERSION = <Type.ROWVERSION: 'ROWVERSION'>
SERIAL = <Type.SERIAL: 'SERIAL'>
SET = <Type.SET: 'SET'>
SMALLINT = <Type.SMALLINT: 'SMALLINT'>
SMALLMONEY = <Type.SMALLMONEY: 'SMALLMONEY'>
SMALLSERIAL = <Type.SMALLSERIAL: 'SMALLSERIAL'>
STRUCT = <Type.STRUCT: 'STRUCT'>
SUPER = <Type.SUPER: 'SUPER'>
TEXT = <Type.TEXT: 'TEXT'>
TIME = <Type.TIME: 'TIME'>
TIMESTAMP = <Type.TIMESTAMP: 'TIMESTAMP'>
TIMESTAMPTZ = <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>
TIMESTAMPLTZ = <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>
TINYINT = <Type.TINYINT: 'TINYINT'>
UBIGINT = <Type.UBIGINT: 'UBIGINT'>
UINT = <Type.UINT: 'UINT'>
USMALLINT = <Type.USMALLINT: 'USMALLINT'>
UTINYINT = <Type.UTINYINT: 'UTINYINT'>
UNKNOWN = <Type.UNKNOWN: 'UNKNOWN'>
UINT128 = <Type.UINT128: 'UINT128'>
UINT256 = <Type.UINT256: 'UINT256'>
UNIQUEIDENTIFIER = <Type.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>
UUID = <Type.UUID: 'UUID'>
VARBINARY = <Type.VARBINARY: 'VARBINARY'>
VARCHAR = <Type.VARCHAR: 'VARCHAR'>
VARIANT = <Type.VARIANT: 'VARIANT'>
XML = <Type.XML: 'XML'>

##### Inherited Members

enum.Enum
  name
  value

class PseudoType(Expression): View Source

    3405class PseudoType(Expression):
    3406    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class SubqueryPredicate(Predicate): View Source

    3410class SubqueryPredicate(Predicate):
    3411    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class All(SubqueryPredicate): View Source

    3414class All(SubqueryPredicate):
    3415    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Any(SubqueryPredicate): View Source

    3418class Any(SubqueryPredicate):
    3419    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Exists(SubqueryPredicate): View Source

    3422class Exists(SubqueryPredicate):
    3423    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Command(Expression): View Source

    3428class Command(Expression):
    3429    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Transaction(Expression): View Source

    3432class Transaction(Expression):
    3433    arg_types = {"this": False, "modes": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Commit(Expression): View Source

    3436class Commit(Expression):
    3437    arg_types = {"chain": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Rollback(Expression): View Source

    3440class Rollback(Expression):
    3441    arg_types = {"savepoint": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class AlterTable(Expression): View Source

    3444class AlterTable(Expression):
    3445    arg_types = {"this": True, "actions": True, "exists": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class AddConstraint(Expression): View Source

    3448class AddConstraint(Expression):
    3449    arg_types = {"this": False, "expression": False, "enforced": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DropPartition(Expression): View Source

    3452class DropPartition(Expression):
    3453    arg_types = {"expressions": True, "exists": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Binary(Condition): View Source

    3457class Binary(Condition):
    3458    arg_types = {"this": True, "expression": True}
    3459
    3460    @property
    3461    def left(self):
    3462        return self.this
    3463
    3464    @property
    3465    def right(self):
    3466        return self.expression

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Add(Binary): View Source

    3469class Add(Binary):
    3470    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Connector(Binary): View Source

    3473class Connector(Binary):
    3474    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class And(Connector): View Source

    3477class And(Connector):
    3478    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Or(Connector): View Source

    3481class Or(Connector):
    3482    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class BitwiseAnd(Binary): View Source

    3485class BitwiseAnd(Binary):
    3486    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class BitwiseLeftShift(Binary): View Source

    3489class BitwiseLeftShift(Binary):
    3490    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class BitwiseOr(Binary): View Source

    3493class BitwiseOr(Binary):
    3494    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class BitwiseRightShift(Binary): View Source

    3497class BitwiseRightShift(Binary):
    3498    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class BitwiseXor(Binary): View Source

    3501class BitwiseXor(Binary):
    3502    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Div(Binary): View Source

    3505class Div(Binary):
    3506    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Overlaps(Binary): View Source

    3509class Overlaps(Binary):
    3510    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Dot(Binary): View Source

    3513class Dot(Binary):
    3514    @property
    3515    def name(self) -> str:
    3516        return self.expression.name
    3517
    3518    @property
    3519    def output_name(self) -> str:
    3520        return self.name
    3521
    3522    @classmethod
    3523    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    3524        """Build a Dot object with a sequence of expressions."""
    3525        if len(expressions) < 2:
    3526            raise ValueError(f"Dot requires >= 2 expressions.")
    3527
    3528        a, b, *expressions = expressions
    3529        dot = Dot(this=a, expression=b)
    3530
    3531        for expression in expressions:
    3532            dot = Dot(this=dot, expression=expression)
    3533
    3534        return dot

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

@classmethod
def build( self, expressions: Sequence[sqlglot.expressions.Expression]) -> sqlglot.expressions.Dot: View Source

    3522    @classmethod
    3523    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    3524        """Build a Dot object with a sequence of expressions."""
    3525        if len(expressions) < 2:
    3526            raise ValueError(f"Dot requires >= 2 expressions.")
    3527
    3528        a, b, *expressions = expressions
    3529        dot = Dot(this=a, expression=b)
    3530
    3531        for expression in expressions:
    3532            dot = Dot(this=dot, expression=expression)
    3533
    3534        return dot

Build a Dot object with a sequence of expressions.

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DPipe(Binary): View Source

    3537class DPipe(Binary):
    3538    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SafeDPipe(DPipe): View Source

    3541class SafeDPipe(DPipe):
    3542    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class EQ(Binary, Predicate): View Source

    3545class EQ(Binary, Predicate):
    3546    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class NullSafeEQ(Binary, Predicate): View Source

    3549class NullSafeEQ(Binary, Predicate):
    3550    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class NullSafeNEQ(Binary, Predicate): View Source

    3553class NullSafeNEQ(Binary, Predicate):
    3554    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Distance(Binary): View Source

    3557class Distance(Binary):
    3558    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Escape(Binary): View Source

    3561class Escape(Binary):
    3562    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Glob(Binary, Predicate): View Source

    3565class Glob(Binary, Predicate):
    3566    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class GT(Binary, Predicate): View Source

    3569class GT(Binary, Predicate):
    3570    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class GTE(Binary, Predicate): View Source

    3573class GTE(Binary, Predicate):
    3574    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ILike(Binary, Predicate): View Source

    3577class ILike(Binary, Predicate):
    3578    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ILikeAny(Binary, Predicate): View Source

    3581class ILikeAny(Binary, Predicate):
    3582    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class IntDiv(Binary): View Source

    3585class IntDiv(Binary):
    3586    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Is(Binary, Predicate): View Source

    3589class Is(Binary, Predicate):
    3590    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Kwarg(Binary): View Source

    3593class Kwarg(Binary):
    3594    """Kwarg in special functions like func(kwarg => y)."""

Kwarg in special functions like func(kwarg => y).

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Like(Binary, Predicate): View Source

    3597class Like(Binary, Predicate):
    3598    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class LikeAny(Binary, Predicate): View Source

    3601class LikeAny(Binary, Predicate):
    3602    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class LT(Binary, Predicate): View Source

    3605class LT(Binary, Predicate):
    3606    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class LTE(Binary, Predicate): View Source

    3609class LTE(Binary, Predicate):
    3610    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Mod(Binary): View Source

    3613class Mod(Binary):
    3614    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Mul(Binary): View Source

    3617class Mul(Binary):
    3618    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class NEQ(Binary, Predicate): View Source

    3621class NEQ(Binary, Predicate):
    3622    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SimilarTo(Binary, Predicate): View Source

    3625class SimilarTo(Binary, Predicate):
    3626    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Slice(Binary): View Source

    3629class Slice(Binary):
    3630    arg_types = {"this": False, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Sub(Binary): View Source

    3633class Sub(Binary):
    3634    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayOverlaps(Binary): View Source

    3637class ArrayOverlaps(Binary):
    3638    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Unary(Condition): View Source

    3643class Unary(Condition):
    3644    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class BitwiseNot(Unary): View Source

    3647class BitwiseNot(Unary):
    3648    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Not(Unary): View Source

    3651class Not(Unary):
    3652    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Paren(Unary): View Source

    3655class Paren(Unary):
    3656    arg_types = {"this": True, "with": False}
    3657
    3658    @property
    3659    def output_name(self) -> str:
    3660        return self.this.name

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Neg(Unary): View Source

    3663class Neg(Unary):
    3664    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Alias(Expression): View Source

    3667class Alias(Expression):
    3668    arg_types = {"this": True, "alias": False}
    3669
    3670    @property
    3671    def output_name(self) -> str:
    3672        return self.alias

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Aliases(Expression): View Source

    3675class Aliases(Expression):
    3676    arg_types = {"this": True, "expressions": True}
    3677
    3678    @property
    3679    def aliases(self):
    3680        return self.expressions

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class AtTimeZone(Expression): View Source

    3683class AtTimeZone(Expression):
    3684    arg_types = {"this": True, "zone": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Between(Predicate): View Source

    3687class Between(Predicate):
    3688    arg_types = {"this": True, "low": True, "high": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Bracket(Condition): View Source

    3691class Bracket(Condition):
    3692    arg_types = {"this": True, "expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Distinct(Expression): View Source

    3695class Distinct(Expression):
    3696    arg_types = {"expressions": False, "on": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class In(Predicate): View Source

    3699class In(Predicate):
    3700    arg_types = {
    3701        "this": True,
    3702        "expressions": False,
    3703        "query": False,
    3704        "unnest": False,
    3705        "field": False,
    3706        "is_global": False,
    3707    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimeUnit(Expression): View Source

    3710class TimeUnit(Expression):
    3711    """Automatically converts unit arg into a var."""
    3712
    3713    arg_types = {"unit": False}
    3714
    3715    def __init__(self, **args):
    3716        unit = args.get("unit")
    3717        if isinstance(unit, (Column, Literal)):
    3718            args["unit"] = Var(this=unit.name)
    3719        elif isinstance(unit, Week):
    3720            unit.set("this", Var(this=unit.this.name))
    3721
    3722        super().__init__(**args)

Automatically converts unit arg into a var.

TimeUnit(**args) View Source

    3715    def __init__(self, **args):
    3716        unit = args.get("unit")
    3717        if isinstance(unit, (Column, Literal)):
    3718            args["unit"] = Var(this=unit.name)
    3719        elif isinstance(unit, Week):
    3720            unit.set("this", Var(this=unit.this.name))
    3721
    3722        super().__init__(**args)

##### Inherited Members

Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Interval(TimeUnit): View Source

    3725class Interval(TimeUnit):
    3726    arg_types = {"this": False, "unit": False}
    3727
    3728    @property
    3729    def unit(self) -> t.Optional[Var]:
    3730        return self.args.get("unit")

##### Inherited Members

TimeUnit
  TimeUnit
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class IgnoreNulls(Expression): View Source

    3733class IgnoreNulls(Expression):
    3734    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class RespectNulls(Expression): View Source

    3737class RespectNulls(Expression):
    3738    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Func(Condition): View Source

    3742class Func(Condition):
    3743    """
    3744    The base class for all function expressions.
    3745
    3746    Attributes:
    3747        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    3748            treated as a variable length argument and the argument's value will be stored as a list.
    3749        _sql_names (list): determines the SQL name (1st item in the list) and aliases (subsequent items)
    3750            for this function expression. These values are used to map this node to a name during parsing
    3751            as well as to provide the function's name during SQL string generation. By default the SQL
    3752            name is set to the expression's class name transformed to snake case.
    3753    """
    3754
    3755    is_var_len_args = False
    3756
    3757    @classmethod
    3758    def from_arg_list(cls, args):
    3759        if cls.is_var_len_args:
    3760            all_arg_keys = list(cls.arg_types)
    3761            # If this function supports variable length argument treat the last argument as such.
    3762            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    3763            num_non_var = len(non_var_len_arg_keys)
    3764
    3765            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    3766            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    3767        else:
    3768            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    3769
    3770        return cls(**args_dict)
    3771
    3772    @classmethod
    3773    def sql_names(cls):
    3774        if cls is Func:
    3775            raise NotImplementedError(
    3776                "SQL name is only supported by concrete function implementations"
    3777            )
    3778        if "_sql_names" not in cls.__dict__:
    3779            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    3780        return cls._sql_names
    3781
    3782    @classmethod
    3783    def sql_name(cls):
    3784        return cls.sql_names()[0]
    3785
    3786    @classmethod
    3787    def default_parser_mappings(cls):
    3788        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): determines 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.

@classmethod
def from_arg_list(cls, args): View Source

    3757    @classmethod
    3758    def from_arg_list(cls, args):
    3759        if cls.is_var_len_args:
    3760            all_arg_keys = list(cls.arg_types)
    3761            # If this function supports variable length argument treat the last argument as such.
    3762            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    3763            num_non_var = len(non_var_len_arg_keys)
    3764
    3765            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    3766            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    3767        else:
    3768            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    3769
    3770        return cls(**args_dict)

@classmethod
def sql_names(cls): View Source

    3772    @classmethod
    3773    def sql_names(cls):
    3774        if cls is Func:
    3775            raise NotImplementedError(
    3776                "SQL name is only supported by concrete function implementations"
    3777            )
    3778        if "_sql_names" not in cls.__dict__:
    3779            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    3780        return cls._sql_names

@classmethod
def sql_name(cls): View Source

    3782    @classmethod
    3783    def sql_name(cls):
    3784        return cls.sql_names()[0]

@classmethod
def default_parser_mappings(cls): View Source

    3786    @classmethod
    3787    def default_parser_mappings(cls):
    3788        return {name: cls.from_arg_list for name in cls.sql_names()}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class AggFunc(Func): View Source

    3791class AggFunc(Func):
    3792    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ParameterizedAgg(AggFunc): View Source

    3795class ParameterizedAgg(AggFunc):
    3796    arg_types = {"this": True, "expressions": True, "params": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Abs(Func): View Source

    3799class Abs(Func):
    3800    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Anonymous(Func): View Source

    3803class Anonymous(Func):
    3804    arg_types = {"this": True, "expressions": False}
    3805    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Hll(AggFunc): View Source

    3810class Hll(AggFunc):
    3811    arg_types = {"this": True, "expressions": False}
    3812    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ApproxDistinct(AggFunc): View Source

    3815class ApproxDistinct(AggFunc):
    3816    arg_types = {"this": True, "accuracy": False}
    3817    _sql_names = ["APPROX_DISTINCT", "APPROX_COUNT_DISTINCT"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Array(Func): View Source

    3820class Array(Func):
    3821    arg_types = {"expressions": False}
    3822    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ToChar(Func): View Source

    3826class ToChar(Func):
    3827    arg_types = {"this": True, "format": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class GenerateSeries(Func): View Source

    3830class GenerateSeries(Func):
    3831    arg_types = {"start": True, "end": True, "step": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayAgg(AggFunc): View Source

    3834class ArrayAgg(AggFunc):
    3835    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayAll(Func): View Source

    3838class ArrayAll(Func):
    3839    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayAny(Func): View Source

    3842class ArrayAny(Func):
    3843    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayConcat(Func): View Source

    3846class ArrayConcat(Func):
    3847    arg_types = {"this": True, "expressions": False}
    3848    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayContains(Binary, Func): View Source

    3851class ArrayContains(Binary, Func):
    3852    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayContained(Binary): View Source

    3855class ArrayContained(Binary):
    3856    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayFilter(Func): View Source

    3859class ArrayFilter(Func):
    3860    arg_types = {"this": True, "expression": True}
    3861    _sql_names = ["FILTER", "ARRAY_FILTER"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayJoin(Func): View Source

    3864class ArrayJoin(Func):
    3865    arg_types = {"this": True, "expression": True, "null": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArraySize(Func): View Source

    3868class ArraySize(Func):
    3869    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArraySort(Func): View Source

    3872class ArraySort(Func):
    3873    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArraySum(Func): View Source

    3876class ArraySum(Func):
    3877    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ArrayUnionAgg(AggFunc): View Source

    3880class ArrayUnionAgg(AggFunc):
    3881    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Avg(AggFunc): View Source

    3884class Avg(AggFunc):
    3885    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class AnyValue(AggFunc): View Source

    3888class AnyValue(AggFunc):
    3889    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Case(Func): View Source

    3892class Case(Func):
    3893    arg_types = {"this": False, "ifs": True, "default": False}
    3894
    3895    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    3896        instance = _maybe_copy(self, copy)
    3897        instance.append(
    3898            "ifs",
    3899            If(
    3900                this=maybe_parse(condition, copy=copy, **opts),
    3901                true=maybe_parse(then, copy=copy, **opts),
    3902            ),
    3903        )
    3904        return instance
    3905
    3906    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    3907        instance = _maybe_copy(self, copy)
    3908        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    3909        return instance

def when( self, condition: Union[str, sqlglot.expressions.Expression], then: Union[str, sqlglot.expressions.Expression], copy: bool = True, **opts) -> sqlglot.expressions.Case: View Source

    3895    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    3896        instance = _maybe_copy(self, copy)
    3897        instance.append(
    3898            "ifs",
    3899            If(
    3900                this=maybe_parse(condition, copy=copy, **opts),
    3901                true=maybe_parse(then, copy=copy, **opts),
    3902            ),
    3903        )
    3904        return instance

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

    3906    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    3907        instance = _maybe_copy(self, copy)
    3908        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    3909        return instance

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Cast(Func): View Source

    3912class Cast(Func):
    3913    arg_types = {"this": True, "to": True}
    3914
    3915    @property
    3916    def name(self) -> str:
    3917        return self.this.name
    3918
    3919    @property
    3920    def to(self) -> DataType:
    3921        return self.args["to"]
    3922
    3923    @property
    3924    def output_name(self) -> str:
    3925        return self.name
    3926
    3927    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3928        return self.to.is_type(*dtypes)

output_name: str

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").expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c").expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2").expressions[0].output_name
>     ''

def is_type( self, *dtypes: str | sqlglot.expressions.DataType | sqlglot.expressions.DataType.Type) -> bool: View Source

    3927    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3928        return self.to.is_type(*dtypes)

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class CastToStrType(Func): View Source

    3931class CastToStrType(Func):
    3932    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Collate(Binary): View Source

    3935class Collate(Binary):
    3936    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TryCast(Cast): View Source

    3939class TryCast(Cast):
    3940    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Cast
  output_name
  is_type
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Ceil(Func): View Source

    3943class Ceil(Func):
    3944    arg_types = {"this": True, "decimals": False}
    3945    _sql_names = ["CEIL", "CEILING"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Coalesce(Func): View Source

    3948class Coalesce(Func):
    3949    arg_types = {"this": True, "expressions": False}
    3950    is_var_len_args = True
    3951    _sql_names = ["COALESCE", "IFNULL", "NVL"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Concat(Func): View Source

    3954class Concat(Func):
    3955    arg_types = {"expressions": True}
    3956    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SafeConcat(Concat): View Source

    3959class SafeConcat(Concat):
    3960    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ConcatWs(Concat): View Source

    3963class ConcatWs(Concat):
    3964    _sql_names = ["CONCAT_WS"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Count(AggFunc): View Source

    3967class Count(AggFunc):
    3968    arg_types = {"this": False, "expressions": False}
    3969    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class CountIf(AggFunc): View Source

    3972class CountIf(AggFunc):
    3973    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class CurrentDate(Func): View Source

    3976class CurrentDate(Func):
    3977    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class CurrentDatetime(Func): View Source

    3980class CurrentDatetime(Func):
    3981    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class CurrentTime(Func): View Source

    3984class CurrentTime(Func):
    3985    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class CurrentTimestamp(Func): View Source

    3988class CurrentTimestamp(Func):
    3989    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class CurrentUser(Func): View Source

    3992class CurrentUser(Func):
    3993    arg_types = {"this": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DateAdd(Func, TimeUnit): View Source

    3996class DateAdd(Func, TimeUnit):
    3997    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DateSub(Func, TimeUnit): View Source

    4000class DateSub(Func, TimeUnit):
    4001    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DateDiff(Func, TimeUnit): View Source

    4004class DateDiff(Func, TimeUnit):
    4005    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    4006    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DateTrunc(Func): View Source

    4009class DateTrunc(Func):
    4010    arg_types = {"unit": True, "this": True, "zone": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DatetimeAdd(Func, TimeUnit): View Source

    4013class DatetimeAdd(Func, TimeUnit):
    4014    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DatetimeSub(Func, TimeUnit): View Source

    4017class DatetimeSub(Func, TimeUnit):
    4018    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DatetimeDiff(Func, TimeUnit): View Source

    4021class DatetimeDiff(Func, TimeUnit):
    4022    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DatetimeTrunc(Func, TimeUnit): View Source

    4025class DatetimeTrunc(Func, TimeUnit):
    4026    arg_types = {"this": True, "unit": True, "zone": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DayOfWeek(Func): View Source

    4029class DayOfWeek(Func):
    4030    _sql_names = ["DAY_OF_WEEK", "DAYOFWEEK"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DayOfMonth(Func): View Source

    4033class DayOfMonth(Func):
    4034    _sql_names = ["DAY_OF_MONTH", "DAYOFMONTH"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DayOfYear(Func): View Source

    4037class DayOfYear(Func):
    4038    _sql_names = ["DAY_OF_YEAR", "DAYOFYEAR"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class WeekOfYear(Func): View Source

    4041class WeekOfYear(Func):
    4042    _sql_names = ["WEEK_OF_YEAR", "WEEKOFYEAR"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class LastDateOfMonth(Func): View Source

    4045class LastDateOfMonth(Func):
    4046    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Extract(Func): View Source

    4049class Extract(Func):
    4050    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimestampAdd(Func, TimeUnit): View Source

    4053class TimestampAdd(Func, TimeUnit):
    4054    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TimestampSub(Func, TimeUnit): View Source

    4057class TimestampSub(Func, TimeUnit):
    4058    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TimestampDiff(Func, TimeUnit): View Source

    4061class TimestampDiff(Func, TimeUnit):
    4062    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TimestampTrunc(Func, TimeUnit): View Source

    4065class TimestampTrunc(Func, TimeUnit):
    4066    arg_types = {"this": True, "unit": True, "zone": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TimeAdd(Func, TimeUnit): View Source

    4069class TimeAdd(Func, TimeUnit):
    4070    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TimeSub(Func, TimeUnit): View Source

    4073class TimeSub(Func, TimeUnit):
    4074    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TimeDiff(Func, TimeUnit): View Source

    4077class TimeDiff(Func, TimeUnit):
    4078    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TimeTrunc(Func, TimeUnit): View Source

    4081class TimeTrunc(Func, TimeUnit):
    4082    arg_types = {"this": True, "unit": True, "zone": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class DateFromParts(Func): View Source

    4085class DateFromParts(Func):
    4086    _sql_names = ["DATEFROMPARTS"]
    4087    arg_types = {"year": True, "month": True, "day": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DateStrToDate(Func): View Source

    4090class DateStrToDate(Func):
    4091    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DateToDateStr(Func): View Source

    4094class DateToDateStr(Func):
    4095    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DateToDi(Func): View Source

    4098class DateToDi(Func):
    4099    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Date(Func): View Source

    4102class Date(Func):
    4103    arg_types = {"expressions": True}
    4104    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Day(Func): View Source

    4107class Day(Func):
    4108    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Decode(Func): View Source

    4111class Decode(Func):
    4112    arg_types = {"this": True, "charset": True, "replace": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DiToDate(Func): View Source

    4115class DiToDate(Func):
    4116    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Encode(Func): View Source

    4119class Encode(Func):
    4120    arg_types = {"this": True, "charset": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Exp(Func): View Source

    4123class Exp(Func):
    4124    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Explode(Func): View Source

    4127class Explode(Func):
    4128    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Floor(Func): View Source

    4131class Floor(Func):
    4132    arg_types = {"this": True, "decimals": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class FromBase64(Func): View Source

    4135class FromBase64(Func):
    4136    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ToBase64(Func): View Source

    4139class ToBase64(Func):
    4140    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Greatest(Func): View Source

    4143class Greatest(Func):
    4144    arg_types = {"this": True, "expressions": False}
    4145    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class GroupConcat(Func): View Source

    4148class GroupConcat(Func):
    4149    arg_types = {"this": True, "separator": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Hex(Func): View Source

    4152class Hex(Func):
    4153    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class If(Func): View Source

    4156class If(Func):
    4157    arg_types = {"this": True, "true": True, "false": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Initcap(Func): View Source

    4160class Initcap(Func):
    4161    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class JSONKeyValue(Expression): View Source

    4164class JSONKeyValue(Expression):
    4165    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class JSONObject(Func): View Source

    4168class JSONObject(Func):
    4169    arg_types = {
    4170        "expressions": False,
    4171        "null_handling": False,
    4172        "unique_keys": False,
    4173        "return_type": False,
    4174        "format_json": False,
    4175        "encoding": False,
    4176    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class OpenJSONColumnDef(Expression): View Source

    4179class OpenJSONColumnDef(Expression):
    4180    arg_types = {"this": True, "kind": True, "path": False, "as_json": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class OpenJSON(Func): View Source

    4183class OpenJSON(Func):
    4184    arg_types = {"this": True, "path": False, "expressions": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class JSONBContains(Binary): View Source

    4187class JSONBContains(Binary):
    4188    _sql_names = ["JSONB_CONTAINS"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class JSONExtract(Binary, Func): View Source

    4191class JSONExtract(Binary, Func):
    4192    _sql_names = ["JSON_EXTRACT"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class JSONExtractScalar(JSONExtract): View Source

    4195class JSONExtractScalar(JSONExtract):
    4196    _sql_names = ["JSON_EXTRACT_SCALAR"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class JSONBExtract(JSONExtract): View Source

    4199class JSONBExtract(JSONExtract):
    4200    _sql_names = ["JSONB_EXTRACT"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class JSONBExtractScalar(JSONExtract): View Source

    4203class JSONBExtractScalar(JSONExtract):
    4204    _sql_names = ["JSONB_EXTRACT_SCALAR"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class JSONFormat(Func): View Source

    4207class JSONFormat(Func):
    4208    arg_types = {"this": False, "options": False}
    4209    _sql_names = ["JSON_FORMAT"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Least(Func): View Source

    4212class Least(Func):
    4213    arg_types = {"expressions": False}
    4214    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Left(Func): View Source

    4217class Left(Func):
    4218    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Right(Func): View Source

    4221class Right(Func):
    4222    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Length(Func): View Source

    4225class Length(Func):
    4226    _sql_names = ["LENGTH", "LEN"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Levenshtein(Func): View Source

    4229class Levenshtein(Func):
    4230    arg_types = {
    4231        "this": True,
    4232        "expression": False,
    4233        "ins_cost": False,
    4234        "del_cost": False,
    4235        "sub_cost": False,
    4236    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Ln(Func): View Source

    4239class Ln(Func):
    4240    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Log(Func): View Source

    4243class Log(Func):
    4244    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Log2(Func): View Source

    4247class Log2(Func):
    4248    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Log10(Func): View Source

    4251class Log10(Func):
    4252    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class LogicalOr(AggFunc): View Source

    4255class LogicalOr(AggFunc):
    4256    _sql_names = ["LOGICAL_OR", "BOOL_OR", "BOOLOR_AGG"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class LogicalAnd(AggFunc): View Source

    4259class LogicalAnd(AggFunc):
    4260    _sql_names = ["LOGICAL_AND", "BOOL_AND", "BOOLAND_AGG"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Lower(Func): View Source

    4263class Lower(Func):
    4264    _sql_names = ["LOWER", "LCASE"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Map(Func): View Source

    4267class Map(Func):
    4268    arg_types = {"keys": False, "values": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StarMap(Func): View Source

    4271class StarMap(Func):
    4272    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class VarMap(Func): View Source

    4275class VarMap(Func):
    4276    arg_types = {"keys": True, "values": True}
    4277    is_var_len_args = True
    4278
    4279    @property
    4280    def keys(self) -> t.List[Expression]:
    4281        return self.args["keys"].expressions
    4282
    4283    @property
    4284    def values(self) -> t.List[Expression]:
    4285        return self.args["values"].expressions

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class MatchAgainst(Func): View Source

    4289class MatchAgainst(Func):
    4290    arg_types = {"this": True, "expressions": True, "modifier": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Max(AggFunc): View Source

    4293class Max(AggFunc):
    4294    arg_types = {"this": True, "expressions": False}
    4295    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class MD5(Func): View Source

    4298class MD5(Func):
    4299    _sql_names = ["MD5"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Min(AggFunc): View Source

    4302class Min(AggFunc):
    4303    arg_types = {"this": True, "expressions": False}
    4304    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Month(Func): View Source

    4307class Month(Func):
    4308    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Nvl2(Func): View Source

    4311class Nvl2(Func):
    4312    arg_types = {"this": True, "true": True, "false": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Posexplode(Func): View Source

    4315class Posexplode(Func):
    4316    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Pow(Binary, Func): View Source

    4319class Pow(Binary, Func):
    4320    _sql_names = ["POWER", "POW"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class PercentileCont(AggFunc): View Source

    4323class PercentileCont(AggFunc):
    4324    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class PercentileDisc(AggFunc): View Source

    4327class PercentileDisc(AggFunc):
    4328    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Quantile(AggFunc): View Source

    4331class Quantile(AggFunc):
    4332    arg_types = {"this": True, "quantile": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ApproxQuantile(Quantile): View Source

    4335class ApproxQuantile(Quantile):
    4336    arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class RangeN(Func): View Source

    4339class RangeN(Func):
    4340    arg_types = {"this": True, "expressions": True, "each": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class ReadCSV(Func): View Source

    4343class ReadCSV(Func):
    4344    _sql_names = ["READ_CSV"]
    4345    is_var_len_args = True
    4346    arg_types = {"this": True, "expressions": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Reduce(Func): View Source

    4349class Reduce(Func):
    4350    arg_types = {"this": True, "initial": True, "merge": True, "finish": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class RegexpExtract(Func): View Source

    4353class RegexpExtract(Func):
    4354    arg_types = {
    4355        "this": True,
    4356        "expression": True,
    4357        "position": False,
    4358        "occurrence": False,
    4359        "group": False,
    4360    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class RegexpLike(Func): View Source

    4363class RegexpLike(Func):
    4364    arg_types = {"this": True, "expression": True, "flag": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class RegexpILike(Func): View Source

    4367class RegexpILike(Func):
    4368    arg_types = {"this": True, "expression": True, "flag": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class RegexpSplit(Func): View Source

    4373class RegexpSplit(Func):
    4374    arg_types = {"this": True, "expression": True, "limit": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Repeat(Func): View Source

    4377class Repeat(Func):
    4378    arg_types = {"this": True, "times": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Round(Func): View Source

    4381class Round(Func):
    4382    arg_types = {"this": True, "decimals": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class RowNumber(Func): View Source

    4385class RowNumber(Func):
    4386    arg_types: t.Dict[str, t.Any] = {}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SafeDivide(Func): View Source

    4389class SafeDivide(Func):
    4390    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SetAgg(AggFunc): View Source

    4393class SetAgg(AggFunc):
    4394    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SHA(Func): View Source

    4397class SHA(Func):
    4398    _sql_names = ["SHA", "SHA1"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SHA2(Func): View Source

    4401class SHA2(Func):
    4402    _sql_names = ["SHA2"]
    4403    arg_types = {"this": True, "length": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class SortArray(Func): View Source

    4406class SortArray(Func):
    4407    arg_types = {"this": True, "asc": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Split(Func): View Source

    4410class Split(Func):
    4411    arg_types = {"this": True, "expression": True, "limit": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Substring(Func): View Source

    4416class Substring(Func):
    4417    arg_types = {"this": True, "start": False, "length": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StandardHash(Func): View Source

    4420class StandardHash(Func):
    4421    arg_types = {"this": True, "expression": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StrPosition(Func): View Source

    4424class StrPosition(Func):
    4425    arg_types = {
    4426        "this": True,
    4427        "substr": True,
    4428        "position": False,
    4429        "instance": False,
    4430    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StrToDate(Func): View Source

    4433class StrToDate(Func):
    4434    arg_types = {"this": True, "format": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StrToTime(Func): View Source

    4437class StrToTime(Func):
    4438    arg_types = {"this": True, "format": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StrToUnix(Func): View Source

    4443class StrToUnix(Func):
    4444    arg_types = {"this": False, "format": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class NumberToStr(Func): View Source

    4447class NumberToStr(Func):
    4448    arg_types = {"this": True, "format": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class FromBase(Func): View Source

    4451class FromBase(Func):
    4452    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Struct(Func): View Source

    4455class Struct(Func):
    4456    arg_types = {"expressions": True}
    4457    is_var_len_args = True

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StructExtract(Func): View Source

    4460class StructExtract(Func):
    4461    arg_types = {"this": True, "expression": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Sum(AggFunc): View Source

    4464class Sum(AggFunc):
    4465    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Sqrt(Func): View Source

    4468class Sqrt(Func):
    4469    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Stddev(AggFunc): View Source

    4472class Stddev(AggFunc):
    4473    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StddevPop(AggFunc): View Source

    4476class StddevPop(AggFunc):
    4477    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class StddevSamp(AggFunc): View Source

    4480class StddevSamp(AggFunc):
    4481    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimeToStr(Func): View Source

    4484class TimeToStr(Func):
    4485    arg_types = {"this": True, "format": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimeToTimeStr(Func): View Source

    4488class TimeToTimeStr(Func):
    4489    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimeToUnix(Func): View Source

    4492class TimeToUnix(Func):
    4493    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimeStrToDate(Func): View Source

    4496class TimeStrToDate(Func):
    4497    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimeStrToTime(Func): View Source

    4500class TimeStrToTime(Func):
    4501    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TimeStrToUnix(Func): View Source

    4504class TimeStrToUnix(Func):
    4505    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Trim(Func): View Source

    4508class Trim(Func):
    4509    arg_types = {
    4510        "this": True,
    4511        "expression": False,
    4512        "position": False,
    4513        "collation": False,
    4514    }

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TsOrDsAdd(Func, TimeUnit): View Source

    4517class TsOrDsAdd(Func, TimeUnit):
    4518    arg_types = {"this": True, "expression": True, "unit": False}

##### Inherited Members

TimeUnit
  TimeUnit
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class TsOrDsToDateStr(Func): View Source

    4521class TsOrDsToDateStr(Func):
    4522    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TsOrDsToDate(Func): View Source

    4525class TsOrDsToDate(Func):
    4526    arg_types = {"this": True, "format": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class TsOrDiToDi(Func): View Source

    4529class TsOrDiToDi(Func):
    4530    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Unhex(Func): View Source

    4533class Unhex(Func):
    4534    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class UnixToStr(Func): View Source

    4537class UnixToStr(Func):
    4538    arg_types = {"this": True, "format": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class UnixToTime(Func): View Source

    4543class UnixToTime(Func):
    4544    arg_types = {"this": True, "scale": False, "zone": False, "hours": False, "minutes": False}
    4545
    4546    SECONDS = Literal.string("seconds")
    4547    MILLIS = Literal.string("millis")
    4548    MICROS = Literal.string("micros")

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class UnixToTimeStr(Func): View Source

    4551class UnixToTimeStr(Func):
    4552    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Upper(Func): View Source

    4555class Upper(Func):
    4556    _sql_names = ["UPPER", "UCASE"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Variance(AggFunc): View Source

    4559class Variance(AggFunc):
    4560    _sql_names = ["VARIANCE", "VARIANCE_SAMP", "VAR_SAMP"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class VariancePop(AggFunc): View Source

    4563class VariancePop(AggFunc):
    4564    _sql_names = ["VARIANCE_POP", "VAR_POP"]

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Week(Func): View Source

    4567class Week(Func):
    4568    arg_types = {"this": True, "mode": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class XMLTable(Func): View Source

    4571class XMLTable(Func):
    4572    arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Year(Func): View Source

    4575class Year(Func):
    4576    pass

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class Use(Expression): View Source

    4579class Use(Expression):
    4580    arg_types = {"this": True, "kind": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class Merge(Expression): View Source

    4583class Merge(Expression):
    4584    arg_types = {"this": True, "using": True, "on": True, "expressions": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load

class When(Func): View Source

    4587class When(Func):
    4588    arg_types = {"matched": True, "source": False, "condition": False, "then": True}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class NextValueFor(Func): View Source

    4593class NextValueFor(Func):
    4594    arg_types = {"this": True, "order": False}

##### Inherited Members

Expression
  Expression
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  output_name
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
Condition
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

def maybe_parse( sql_or_expression: Union[str, sqlglot.expressions.Expression], *, into: Union[str, Type[sqlglot.expressions.Expression], Collection[Union[str, Type[sqlglot.expressions.Expression]]], NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, prefix: Optional[str] = None, copy: bool = False, **opts) -> sqlglot.expressions.Expression: View Source

    4631def maybe_parse(
    4632    sql_or_expression: ExpOrStr,
    4633    *,
    4634    into: t.Optional[IntoType] = None,
    4635    dialect: DialectType = None,
    4636    prefix: t.Optional[str] = None,
    4637    copy: bool = False,
    4638    **opts,
    4639) -> Expression:
    4640    """Gracefully handle a possible string or expression.
    4641
    4642    Example:
    4643        >>> maybe_parse("1")
    4644        (LITERAL this: 1, is_string: False)
    4645        >>> maybe_parse(to_identifier("x"))
    4646        (IDENTIFIER this: x, quoted: False)
    4647
    4648    Args:
    4649        sql_or_expression: the SQL code string or an expression
    4650        into: the SQLGlot Expression to parse into
    4651        dialect: the dialect used to parse the input expressions (in the case that an
    4652            input expression is a SQL string).
    4653        prefix: a string to prefix the sql with before it gets parsed
    4654            (automatically includes a space)
    4655        copy: whether or not to copy the expression.
    4656        **opts: other options to use to parse the input expressions (again, in the case
    4657            that an input expression is a SQL string).
    4658
    4659    Returns:
    4660        Expression: the parsed or given expression.
    4661    """
    4662    if isinstance(sql_or_expression, Expression):
    4663        if copy:
    4664            return sql_or_expression.copy()
    4665        return sql_or_expression
    4666
    4667    if sql_or_expression is None:
    4668        raise ParseError(f"SQL cannot be None")
    4669
    4670    import sqlglot
    4671
    4672    sql = str(sql_or_expression)
    4673    if prefix:
    4674        sql = f"{prefix} {sql}"
    4675
    4676    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 or not 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 union( left: Union[str, sqlglot.expressions.Expression], right: Union[str, sqlglot.expressions.Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> sqlglot.expressions.Union: View Source

    4860def union(
    4861    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    4862) -> Union:
    4863    """
    4864    Initializes a syntax tree from one UNION expression.
    4865
    4866    Example:
    4867        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    4868        'SELECT * FROM foo UNION SELECT * FROM bla'
    4869
    4870    Args:
    4871        left: the SQL code string corresponding to the left-hand side.
    4872            If an `Expression` instance is passed, it will be used as-is.
    4873        right: the SQL code string corresponding to the right-hand side.
    4874            If an `Expression` instance is passed, it will be used as-is.
    4875        distinct: set the DISTINCT flag if and only if this is true.
    4876        dialect: the dialect used to parse the input expression.
    4877        opts: other options to use to parse the input expressions.
    4878
    4879    Returns:
    4880        The new Union instance.
    4881    """
    4882    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    4883    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    4884
    4885    return Union(this=left, expression=right, distinct=distinct)

Initializes a syntax tree from one UNION expression.

###### Example:

>     >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
>     'SELECT * FROM foo UNION SELECT * FROM bla'

###### Arguments:

- left: the SQL code string corresponding to the left-hand side. If an `Expression` instance is passed, it will be used as-is.
- right: the SQL code string corresponding to the right-hand side. If an `Expression` instance is passed, it 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 instance.

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

    4888def intersect(
    4889    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    4890) -> Intersect:
    4891    """
    4892    Initializes a syntax tree from one INTERSECT expression.
    4893
    4894    Example:
    4895        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    4896        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    4897
    4898    Args:
    4899        left: the SQL code string corresponding to the left-hand side.
    4900            If an `Expression` instance is passed, it will be used as-is.
    4901        right: the SQL code string corresponding to the right-hand side.
    4902            If an `Expression` instance is passed, it will be used as-is.
    4903        distinct: set the DISTINCT flag if and only if this is true.
    4904        dialect: the dialect used to parse the input expression.
    4905        opts: other options to use to parse the input expressions.
    4906
    4907    Returns:
    4908        The new Intersect instance.
    4909    """
    4910    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    4911    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    4912
    4913    return Intersect(this=left, expression=right, distinct=distinct)

Initializes a syntax tree from one INTERSECT expression.

###### Example:

>     >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
>     'SELECT * FROM foo INTERSECT SELECT * FROM bla'

###### Arguments:

- left: the SQL code string corresponding to the left-hand side. If an `Expression` instance is passed, it will be used as-is.
- right: the SQL code string corresponding to the right-hand side. If an `Expression` instance is passed, it 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 instance.

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

    4916def except_(
    4917    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    4918) -> Except:
    4919    """
    4920    Initializes a syntax tree from one EXCEPT expression.
    4921
    4922    Example:
    4923        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    4924        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    4925
    4926    Args:
    4927        left: the SQL code string corresponding to the left-hand side.
    4928            If an `Expression` instance is passed, it will be used as-is.
    4929        right: the SQL code string corresponding to the right-hand side.
    4930            If an `Expression` instance is passed, it will be used as-is.
    4931        distinct: set the DISTINCT flag if and only if this is true.
    4932        dialect: the dialect used to parse the input expression.
    4933        opts: other options to use to parse the input expressions.
    4934
    4935    Returns:
    4936        The new Except instance.
    4937    """
    4938    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    4939    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    4940
    4941    return Except(this=left, expression=right, distinct=distinct)

Initializes a syntax tree from one EXCEPT expression.

###### Example:

>     >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
>     'SELECT * FROM foo EXCEPT SELECT * FROM bla'

###### Arguments:

- left: the SQL code string corresponding to the left-hand side. If an `Expression` instance is passed, it will be used as-is.
- right: the SQL code string corresponding to the right-hand side. If an `Expression` instance is passed, it 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 instance.

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

    4944def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    4945    """
    4946    Initializes a syntax tree from one or multiple SELECT expressions.
    4947
    4948    Example:
    4949        >>> select("col1", "col2").from_("tbl").sql()
    4950        'SELECT col1, col2 FROM tbl'
    4951
    4952    Args:
    4953        *expressions: the SQL code string to parse as the expressions of a
    4954            SELECT statement. If an Expression instance is passed, this is used as-is.
    4955        dialect: the dialect used to parse the input expressions (in the case that an
    4956            input expression is a SQL string).
    4957        **opts: other options to use to parse the input expressions (again, in the case
    4958            that an input expression is a SQL string).
    4959
    4960    Returns:
    4961        Select: the syntax tree for the SELECT statement.
    4962    """
    4963    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, sqlglot.expressions.Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> sqlglot.expressions.Select: View Source

    4966def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    4967    """
    4968    Initializes a syntax tree from a FROM expression.
    4969
    4970    Example:
    4971        >>> from_("tbl").select("col1", "col2").sql()
    4972        'SELECT col1, col2 FROM tbl'
    4973
    4974    Args:
    4975        *expression: the SQL code string to parse as the FROM expressions of a
    4976            SELECT statement. If an Expression instance is passed, this is used as-is.
    4977        dialect: the dialect used to parse the input expression (in the case that the
    4978            input expression is a SQL string).
    4979        **opts: other options to use to parse the input expressions (again, in the case
    4980            that the input expression is a SQL string).
    4981
    4982    Returns:
    4983        Select: the syntax tree for the SELECT statement.
    4984    """
    4985    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 | sqlglot.expressions.Table, properties: dict, where: Union[str, sqlglot.expressions.Expression, NoneType] = None, from_: Union[str, sqlglot.expressions.Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> sqlglot.expressions.Update: View Source

    4988def update(
    4989    table: str | Table,
    4990    properties: dict,
    4991    where: t.Optional[ExpOrStr] = None,
    4992    from_: t.Optional[ExpOrStr] = None,
    4993    dialect: DialectType = None,
    4994    **opts,
    4995) -> Update:
    4996    """
    4997    Creates an update statement.
    4998
    4999    Example:
    5000        >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz", where="id > 1").sql()
    5001        "UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz WHERE id > 1"
    5002
    5003    Args:
    5004        *properties: dictionary of properties to set which are
    5005            auto converted to sql objects eg None -> NULL
    5006        where: sql conditional parsed into a WHERE statement
    5007        from_: sql statement parsed into a FROM statement
    5008        dialect: the dialect used to parse the input expressions.
    5009        **opts: other options to use to parse the input expressions.
    5010
    5011    Returns:
    5012        Update: the syntax tree for the UPDATE statement.
    5013    """
    5014    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    5015    update_expr.set(
    5016        "expressions",
    5017        [
    5018            EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    5019            for k, v in properties.items()
    5020        ],
    5021    )
    5022    if from_:
    5023        update_expr.set(
    5024            "from",
    5025            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    5026        )
    5027    if isinstance(where, Condition):
    5028        where = Where(this=where)
    5029    if where:
    5030        update_expr.set(
    5031            "where",
    5032            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    5033        )
    5034    return update_expr

Creates an update statement.

###### Example:

>     >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz", where="id > 1").sql()
>     "UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz WHERE id > 1"

###### 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
- 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, sqlglot.expressions.Expression], where: Union[str, sqlglot.expressions.Expression, NoneType] = None, returning: Union[str, sqlglot.expressions.Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> sqlglot.expressions.Delete: View Source

    5037def delete(
    5038    table: ExpOrStr,
    5039    where: t.Optional[ExpOrStr] = None,
    5040    returning: t.Optional[ExpOrStr] = None,
    5041    dialect: DialectType = None,
    5042    **opts,
    5043) -> Delete:
    5044    """
    5045    Builds a delete statement.
    5046
    5047    Example:
    5048        >>> delete("my_table", where="id > 1").sql()
    5049        'DELETE FROM my_table WHERE id > 1'
    5050
    5051    Args:
    5052        where: sql conditional parsed into a WHERE statement
    5053        returning: sql conditional parsed into a RETURNING statement
    5054        dialect: the dialect used to parse the input expressions.
    5055        **opts: other options to use to parse the input expressions.
    5056
    5057    Returns:
    5058        Delete: the syntax tree for the DELETE statement.
    5059    """
    5060    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    5061    if where:
    5062        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    5063    if returning:
    5064        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    5065    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, sqlglot.expressions.Expression], into: Union[str, sqlglot.expressions.Expression], columns: Optional[Sequence[Union[str, sqlglot.expressions.Expression]]] = None, overwrite: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> sqlglot.expressions.Insert: View Source

    5068def insert(
    5069    expression: ExpOrStr,
    5070    into: ExpOrStr,
    5071    columns: t.Optional[t.Sequence[ExpOrStr]] = None,
    5072    overwrite: t.Optional[bool] = None,
    5073    dialect: DialectType = None,
    5074    copy: bool = True,
    5075    **opts,
    5076) -> Insert:
    5077    """
    5078    Builds an INSERT statement.
    5079
    5080    Example:
    5081        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    5082        'INSERT INTO tbl VALUES (1, 2, 3)'
    5083
    5084    Args:
    5085        expression: the sql string or expression of the INSERT statement
    5086        into: the tbl to insert data to.
    5087        columns: optionally the table's column names.
    5088        overwrite: whether to INSERT OVERWRITE or not.
    5089        dialect: the dialect used to parse the input expressions.
    5090        copy: whether or not to copy the expression.
    5091        **opts: other options to use to parse the input expressions.
    5092
    5093    Returns:
    5094        Insert: the syntax tree for the INSERT statement.
    5095    """
    5096    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    5097    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    5098
    5099    if columns:
    5100        this = _apply_list_builder(
    5101            *columns,
    5102            instance=Schema(this=this),
    5103            arg="expressions",
    5104            into=Identifier,
    5105            copy=False,
    5106            dialect=dialect,
    5107            **opts,
    5108        )
    5109
    5110    return Insert(this=this, expression=expr, overwrite=overwrite)

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.
- dialect: the dialect used to parse the input expressions.
- copy: whether or not to copy the expression.
- **opts: other options to use to parse the input expressions.

###### Returns:

> Insert: the syntax tree for the INSERT statement.

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

    5113def condition(
    5114    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    5115) -> Condition:
    5116    """
    5117    Initialize a logical condition expression.
    5118
    5119    Example:
    5120        >>> condition("x=1").sql()
    5121        'x = 1'
    5122
    5123        This is helpful for composing larger logical syntax trees:
    5124        >>> where = condition("x=1")
    5125        >>> where = where.and_("y=1")
    5126        >>> Select().from_("tbl").select("*").where(where).sql()
    5127        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    5128
    5129    Args:
    5130        *expression: the SQL code string to parse.
    5131            If an Expression instance is passed, this is used as-is.
    5132        dialect: the dialect used to parse the input expression (in the case that the
    5133            input expression is a SQL string).
    5134        copy: Whether or not to copy `expression` (only applies to expressions).
    5135        **opts: other options to use to parse the input expressions (again, in the case
    5136            that the input expression is a SQL string).
    5137
    5138    Returns:
    5139        The new Condition instance
    5140    """
    5141    return maybe_parse(
    5142        expression,
    5143        into=Condition,
    5144        dialect=dialect,
    5145        copy=copy,
    5146        **opts,
    5147    )

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

    5150def and_(
    5151    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    5152) -> Condition:
    5153    """
    5154    Combine multiple conditions with an AND logical operator.
    5155
    5156    Example:
    5157        >>> and_("x=1", and_("y=1", "z=1")).sql()
    5158        'x = 1 AND (y = 1 AND z = 1)'
    5159
    5160    Args:
    5161        *expressions: the SQL code strings to parse.
    5162            If an Expression instance is passed, this is used as-is.
    5163        dialect: the dialect used to parse the input expression.
    5164        copy: whether or not to copy `expressions` (only applies to Expressions).
    5165        **opts: other options to use to parse the input expressions.
    5166
    5167    Returns:
    5168        And: the new condition
    5169    """
    5170    return t.cast(Condition, _combine(expressions, And, dialect, copy=copy, **opts))

Combine multiple conditions with an AND logical operator.

###### Example:

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

###### Arguments:

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

###### Returns:

> And: the new condition

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

    5173def or_(
    5174    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    5175) -> Condition:
    5176    """
    5177    Combine multiple conditions with an OR logical operator.
    5178
    5179    Example:
    5180        >>> or_("x=1", or_("y=1", "z=1")).sql()
    5181        'x = 1 OR (y = 1 OR z = 1)'
    5182
    5183    Args:
    5184        *expressions: the SQL code strings to parse.
    5185            If an Expression instance is passed, this is used as-is.
    5186        dialect: the dialect used to parse the input expression.
    5187        copy: whether or not to copy `expressions` (only applies to Expressions).
    5188        **opts: other options to use to parse the input expressions.
    5189
    5190    Returns:
    5191        Or: the new condition
    5192    """
    5193    return t.cast(Condition, _combine(expressions, Or, dialect, copy=copy, **opts))

Combine multiple conditions with an OR logical operator.

###### Example:

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

###### Arguments:

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

###### Returns:

> Or: the new condition

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

    5196def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    5197    """
    5198    Wrap a condition with a NOT operator.
    5199
    5200    Example:
    5201        >>> not_("this_suit='black'").sql()
    5202        "NOT this_suit = 'black'"
    5203
    5204    Args:
    5205        expression: the SQL code string to parse.
    5206            If an Expression instance is passed, this is used as-is.
    5207        dialect: the dialect used to parse the input expression.
    5208        copy: whether to copy the expression or not.
    5209        **opts: other options to use to parse the input expressions.
    5210
    5211    Returns:
    5212        The new condition.
    5213    """
    5214    this = condition(
    5215        expression,
    5216        dialect=dialect,
    5217        copy=copy,
    5218        **opts,
    5219    )
    5220    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, sqlglot.expressions.Expression], copy: bool = True) -> sqlglot.expressions.Paren: View Source

    5223def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    5224    """
    5225    Wrap an expression in parentheses.
    5226
    5227    Example:
    5228        >>> paren("5 + 3").sql()
    5229        '(5 + 3)'
    5230
    5231    Args:
    5232        expression: the SQL code string to parse.
    5233            If an Expression instance is passed, this is used as-is.
    5234        copy: whether to copy the expression or not.
    5235
    5236    Returns:
    5237        The wrapped expression.
    5238    """
    5239    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.

def to_identifier(name, quoted=None, copy=True): View Source

    5257def to_identifier(name, quoted=None, copy=True):
    5258    """Builds an identifier.
    5259
    5260    Args:
    5261        name: The name to turn into an identifier.
    5262        quoted: Whether or not force quote the identifier.
    5263        copy: Whether or not to copy a passed in Identefier node.
    5264
    5265    Returns:
    5266        The identifier ast node.
    5267    """
    5268
    5269    if name is None:
    5270        return None
    5271
    5272    if isinstance(name, Identifier):
    5273        identifier = _maybe_copy(name, copy)
    5274    elif isinstance(name, str):
    5275        identifier = Identifier(
    5276            this=name,
    5277            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    5278        )
    5279    else:
    5280        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    5281    return identifier

Builds an identifier.

###### Arguments:

- name: The name to turn into an identifier.
- quoted: Whether or not force quote the identifier.
- copy: Whether or not to copy a passed in Identefier node.

###### Returns:

> The identifier ast node.

def to_interval( interval: str | sqlglot.expressions.Literal) -> sqlglot.expressions.Interval: View Source

    5287def to_interval(interval: str | Literal) -> Interval:
    5288    """Builds an interval expression from a string like '1 day' or '5 months'."""
    5289    if isinstance(interval, Literal):
    5290        if not interval.is_string:
    5291            raise ValueError("Invalid interval string.")
    5292
    5293        interval = interval.this
    5294
    5295    interval_parts = INTERVAL_STRING_RE.match(interval)  # type: ignore
    5296
    5297    if not interval_parts:
    5298        raise ValueError("Invalid interval string.")
    5299
    5300    return Interval(
    5301        this=Literal.string(interval_parts.group(1)),
    5302        unit=Var(this=interval_parts.group(2)),
    5303    )

Builds an interval expression from a string like '1 day' or '5 months'.

def to_table( sql_path: Union[str, sqlglot.expressions.Table, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **kwargs) -> Optional[sqlglot.expressions.Table]: View Source

    5316def to_table(
    5317    sql_path: t.Optional[str | Table], dialect: DialectType = None, **kwargs
    5318) -> t.Optional[Table]:
    5319    """
    5320    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    5321    If a table is passed in then that table is returned.
    5322
    5323    Args:
    5324        sql_path: a `[catalog].[schema].[table]` string.
    5325        dialect: the source dialect according to which the table name will be parsed.
    5326        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    5327
    5328    Returns:
    5329        A table expression.
    5330    """
    5331    if sql_path is None or isinstance(sql_path, Table):
    5332        return sql_path
    5333    if not isinstance(sql_path, str):
    5334        raise ValueError(f"Invalid type provided for a table: {type(sql_path)}")
    5335
    5336    table = maybe_parse(sql_path, into=Table, dialect=dialect)
    5337    if table:
    5338        for k, v in kwargs.items():
    5339            table.set(k, v)
    5340
    5341    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.
- kwargs: the kwargs to instantiate the resulting `Table` expression with.

###### Returns:

> A table expression.

def to_column( sql_path: str | sqlglot.expressions.Column, **kwargs) -> sqlglot.expressions.Column: View Source

    5344def to_column(sql_path: str | Column, **kwargs) -> Column:
    5345    """
    5346    Create a column from a `[table].[column]` sql path. Schema is optional.
    5347
    5348    If a column is passed in then that column is returned.
    5349
    5350    Args:
    5351        sql_path: `[table].[column]` string
    5352    Returns:
    5353        Table: A column expression
    5354    """
    5355    if sql_path is None or isinstance(sql_path, Column):
    5356        return sql_path
    5357    if not isinstance(sql_path, str):
    5358        raise ValueError(f"Invalid type provided for column: {type(sql_path)}")
    5359    return column(*reversed(sql_path.split(".")), **kwargs)  # type: ignore

Create a column from a `[table].[column]` sql path. Schema is optional.

If a column is passed in then that column is returned.

###### Arguments:

- sql_path: `[table].[column]` string

###### Returns:

> Table: A column expression

def alias_( expression: Union[str, sqlglot.expressions.Expression], alias: str | sqlglot.expressions.Identifier, table: Union[bool, Sequence[str | sqlglot.expressions.Identifier]] = False, quoted: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts): View Source

    5362def alias_(
    5363    expression: ExpOrStr,
    5364    alias: str | Identifier,
    5365    table: bool | t.Sequence[str | Identifier] = False,
    5366    quoted: t.Optional[bool] = None,
    5367    dialect: DialectType = None,
    5368    copy: bool = True,
    5369    **opts,
    5370):
    5371    """Create an Alias expression.
    5372
    5373    Example:
    5374        >>> alias_('foo', 'bar').sql()
    5375        'foo AS bar'
    5376
    5377        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    5378        '(SELECT 1, 2) AS bar(a, b)'
    5379
    5380    Args:
    5381        expression: the SQL code strings to parse.
    5382            If an Expression instance is passed, this is used as-is.
    5383        alias: the alias name to use. If the name has
    5384            special characters it is quoted.
    5385        table: Whether or not to create a table alias, can also be a list of columns.
    5386        quoted: whether or not to quote the alias
    5387        dialect: the dialect used to parse the input expression.
    5388        copy: Whether or not to copy the expression.
    5389        **opts: other options to use to parse the input expressions.
    5390
    5391    Returns:
    5392        Alias: the aliased expression
    5393    """
    5394    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    5395    alias = to_identifier(alias, quoted=quoted)
    5396
    5397    if table:
    5398        table_alias = TableAlias(this=alias)
    5399        exp.set("alias", table_alias)
    5400
    5401        if not isinstance(table, bool):
    5402            for column in table:
    5403                table_alias.append("columns", to_identifier(column, quoted=quoted))
    5404
    5405        return exp
    5406
    5407    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    5408    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    5409    # for the complete Window expression.
    5410    #
    5411    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    5412
    5413    if "alias" in exp.arg_types and not isinstance(exp, Window):
    5414        exp.set("alias", alias)
    5415        return exp
    5416    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 or not to create a table alias, can also be a list of columns.
- quoted: whether or not to quote the alias
- dialect: the dialect used to parse the input expression.
- copy: Whether or not to copy the expression.
- **opts: other options to use to parse the input expressions.

###### Returns:

> Alias: the aliased expression

def subquery( expression: Union[str, sqlglot.expressions.Expression], alias: Union[sqlglot.expressions.Identifier, str, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> sqlglot.expressions.Select: View Source

    5419def subquery(
    5420    expression: ExpOrStr,
    5421    alias: t.Optional[Identifier | str] = None,
    5422    dialect: DialectType = None,
    5423    **opts,
    5424) -> Select:
    5425    """
    5426    Build a subquery expression.
    5427
    5428    Example:
    5429        >>> subquery('select x from tbl', 'bar').select('x').sql()
    5430        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    5431
    5432    Args:
    5433        expression: the SQL code strings to parse.
    5434            If an Expression instance is passed, this is used as-is.
    5435        alias: the alias name to use.
    5436        dialect: the dialect used to parse the input expression.
    5437        **opts: other options to use to parse the input expressions.
    5438
    5439    Returns:
    5440        A new Select instance with the subquery expression included.
    5441    """
    5442
    5443    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias)
    5444    return Select().from_(expression, dialect=dialect, **opts)

Build a subquery expression.

###### 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: str | sqlglot.expressions.Identifier, table: Union[sqlglot.expressions.Identifier, str, NoneType] = None, db: Union[sqlglot.expressions.Identifier, str, NoneType] = None, catalog: Union[sqlglot.expressions.Identifier, str, NoneType] = None, quoted: Optional[bool] = None) -> sqlglot.expressions.Column: View Source

    5447def column(
    5448    col: str | Identifier,
    5449    table: t.Optional[str | Identifier] = None,
    5450    db: t.Optional[str | Identifier] = None,
    5451    catalog: t.Optional[str | Identifier] = None,
    5452    quoted: t.Optional[bool] = None,
    5453) -> Column:
    5454    """
    5455    Build a Column.
    5456
    5457    Args:
    5458        col: Column name.
    5459        table: Table name.
    5460        db: Database name.
    5461        catalog: Catalog name.
    5462        quoted: Whether to force quotes on the column's identifiers.
    5463
    5464    Returns:
    5465        The new Column instance.
    5466    """
    5467    return Column(
    5468        this=to_identifier(col, quoted=quoted),
    5469        table=to_identifier(table, quoted=quoted),
    5470        db=to_identifier(db, quoted=quoted),
    5471        catalog=to_identifier(catalog, quoted=quoted),
    5472    )

Build a Column.

###### Arguments:

- col: Column name.
- table: Table name.
- db: Database name.
- catalog: Catalog name.
- quoted: Whether to force quotes on the column's identifiers.

###### Returns:

> The new Column instance.

def cast( expression: Union[str, sqlglot.expressions.Expression], to: str | sqlglot.expressions.DataType | sqlglot.expressions.DataType.Type, **opts) -> sqlglot.expressions.Cast: View Source

    5475def cast(expression: ExpOrStr, to: str | DataType | DataType.Type, **opts) -> Cast:
    5476    """Cast an expression to a data type.
    5477
    5478    Example:
    5479        >>> cast('x + 1', 'int').sql()
    5480        'CAST(x + 1 AS INT)'
    5481
    5482    Args:
    5483        expression: The expression to cast.
    5484        to: The datatype to cast to.
    5485
    5486    Returns:
    5487        The new Cast instance.
    5488    """
    5489    expression = maybe_parse(expression, **opts)
    5490    return Cast(this=expression, to=DataType.build(to, **opts))

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.

###### Returns:

> The new Cast instance.

def table_( table: sqlglot.expressions.Identifier | str, db: Union[sqlglot.expressions.Identifier, str, NoneType] = None, catalog: Union[sqlglot.expressions.Identifier, str, NoneType] = None, quoted: Optional[bool] = None, alias: Union[sqlglot.expressions.Identifier, str, NoneType] = None) -> sqlglot.expressions.Table: View Source

    5493def table_(
    5494    table: Identifier | str,
    5495    db: t.Optional[Identifier | str] = None,
    5496    catalog: t.Optional[Identifier | str] = None,
    5497    quoted: t.Optional[bool] = None,
    5498    alias: t.Optional[Identifier | str] = None,
    5499) -> Table:
    5500    """Build a Table.
    5501
    5502    Args:
    5503        table: Table name.
    5504        db: Database name.
    5505        catalog: Catalog name.
    5506        quote: Whether to force quotes on the table's identifiers.
    5507        alias: Table's alias.
    5508
    5509    Returns:
    5510        The new Table instance.
    5511    """
    5512    return Table(
    5513        this=to_identifier(table, quoted=quoted),
    5514        db=to_identifier(db, quoted=quoted),
    5515        catalog=to_identifier(catalog, quoted=quoted),
    5516        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    5517    )

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, sqlglot.expressions.DataType], NoneType] = None) -> sqlglot.expressions.Values: View Source

    5520def values(
    5521    values: t.Iterable[t.Tuple[t.Any, ...]],
    5522    alias: t.Optional[str] = None,
    5523    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    5524) -> Values:
    5525    """Build VALUES statement.
    5526
    5527    Example:
    5528        >>> values([(1, '2')]).sql()
    5529        "VALUES (1, '2')"
    5530
    5531    Args:
    5532        values: values statements that will be converted to SQL
    5533        alias: optional alias
    5534        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    5535         If either are provided then an alias is also required.
    5536
    5537    Returns:
    5538        Values: the Values expression object
    5539    """
    5540    if columns and not alias:
    5541        raise ValueError("Alias is required when providing columns")
    5542
    5543    return Values(
    5544        expressions=[convert(tup) for tup in values],
    5545        alias=(
    5546            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    5547            if columns
    5548            else (TableAlias(this=to_identifier(alias)) if alias else None)
    5549        ),
    5550    )

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, sqlglot.expressions.Expression, NoneType]) -> sqlglot.expressions.Var: View Source

    5553def var(name: t.Optional[ExpOrStr]) -> Var:
    5554    """Build a SQL variable.
    5555
    5556    Example:
    5557        >>> repr(var('x'))
    5558        '(VAR this: x)'
    5559
    5560        >>> repr(var(column('x', table='y')))
    5561        '(VAR this: x)'
    5562
    5563    Args:
    5564        name: The name of the var or an expression who's name will become the var.
    5565
    5566    Returns:
    5567        The new variable node.
    5568    """
    5569    if not name:
    5570        raise ValueError("Cannot convert empty name into var.")
    5571
    5572    if isinstance(name, Expression):
    5573        name = name.name
    5574    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 | sqlglot.expressions.Table, new_name: str | sqlglot.expressions.Table) -> sqlglot.expressions.AlterTable: View Source

    5577def rename_table(old_name: str | Table, new_name: str | Table) -> AlterTable:
    5578    """Build ALTER TABLE... RENAME... expression
    5579
    5580    Args:
    5581        old_name: The old name of the table
    5582        new_name: The new name of the table
    5583
    5584    Returns:
    5585        Alter table expression
    5586    """
    5587    old_table = to_table(old_name)
    5588    new_table = to_table(new_name)
    5589    return AlterTable(
    5590        this=old_table,
    5591        actions=[
    5592            RenameTable(this=new_table),
    5593        ],
    5594    )

Build ALTER TABLE... RENAME... expression

###### Arguments:

- old_name: The old name of the table
- new_name: The new name of the table

###### Returns:

> Alter table expression

def convert(value: Any, copy: bool = False) -> sqlglot.expressions.Expression: View Source

    5597def convert(value: t.Any, copy: bool = False) -> Expression:
    5598    """Convert a python value into an expression object.
    5599
    5600    Raises an error if a conversion is not possible.
    5601
    5602    Args:
    5603        value: A python object.
    5604        copy: Whether or not to copy `value` (only applies to Expressions and collections).
    5605
    5606    Returns:
    5607        Expression: the equivalent expression object.
    5608    """
    5609    if isinstance(value, Expression):
    5610        return _maybe_copy(value, copy)
    5611    if isinstance(value, str):
    5612        return Literal.string(value)
    5613    if isinstance(value, bool):
    5614        return Boolean(this=value)
    5615    if value is None or (isinstance(value, float) and math.isnan(value)):
    5616        return NULL
    5617    if isinstance(value, numbers.Number):
    5618        return Literal.number(value)
    5619    if isinstance(value, datetime.datetime):
    5620        datetime_literal = Literal.string(
    5621            (value if value.tzinfo else value.replace(tzinfo=datetime.timezone.utc)).isoformat()
    5622        )
    5623        return TimeStrToTime(this=datetime_literal)
    5624    if isinstance(value, datetime.date):
    5625        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    5626        return DateStrToDate(this=date_literal)
    5627    if isinstance(value, tuple):
    5628        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    5629    if isinstance(value, list):
    5630        return Array(expressions=[convert(v, copy=copy) for v in value])
    5631    if isinstance(value, dict):
    5632        return Map(
    5633            keys=[convert(k, copy=copy) for k in value],
    5634            values=[convert(v, copy=copy) for v in value.values()],
    5635        )
    5636    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 or not to copy `value` (only applies to Expressions and collections).

###### Returns:

> Expression: the equivalent expression object.

def replace_children( expression: sqlglot.expressions.Expression, fun: Callable, *args, **kwargs) -> None: View Source

    5639def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    5640    """
    5641    Replace children of an expression with the result of a lambda fun(child) -> exp.
    5642    """
    5643    for k, v in expression.args.items():
    5644        is_list_arg = type(v) is list
    5645
    5646        child_nodes = v if is_list_arg else [v]
    5647        new_child_nodes = []
    5648
    5649        for cn in child_nodes:
    5650            if isinstance(cn, Expression):
    5651                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    5652                    new_child_nodes.append(child_node)
    5653                    child_node.parent = expression
    5654                    child_node.arg_key = k
    5655            else:
    5656                new_child_nodes.append(cn)
    5657
    5658        expression.args[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 column_table_names(expression: sqlglot.expressions.Expression) -> List[str]: View Source

    5661def column_table_names(expression: Expression) -> t.List[str]:
    5662    """
    5663    Return all table names referenced through columns in an expression.
    5664
    5665    Example:
    5666        >>> import sqlglot
    5667        >>> column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e"))
    5668        ['c', 'a']
    5669
    5670    Args:
    5671        expression: expression to find table names.
    5672
    5673    Returns:
    5674        A list of unique names.
    5675    """
    5676    return list(dict.fromkeys(column.table for column in expression.find_all(Column)))

Return all table names referenced through columns in an expression.

###### Example:

>     >>> import sqlglot
>     >>> column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e"))
>     ['c', 'a']

###### Arguments:

- expression: expression to find table names.

###### Returns:

> A list of unique names.

def table_name(table: sqlglot.expressions.Table | str) -> str: View Source

    5679def table_name(table: Table | str) -> str:
    5680    """Get the full name of a table as a string.
    5681
    5682    Args:
    5683        table: table expression node or string.
    5684
    5685    Examples:
    5686        >>> from sqlglot import exp, parse_one
    5687        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    5688        'a.b.c'
    5689
    5690    Returns:
    5691        The table name.
    5692    """
    5693
    5694    table = maybe_parse(table, into=Table)
    5695
    5696    if not table:
    5697        raise ValueError(f"Cannot parse {table}")
    5698
    5699    return ".".join(part for part in (table.text("catalog"), table.text("db"), table.name) if part)

Get the full name of a table as a string.

###### Arguments:

- table: table expression node or string.

###### 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 replace_tables(expression: ~E, mapping: Dict[str, str], copy: bool = True) -> ~E: View Source

    5702def replace_tables(expression: E, mapping: t.Dict[str, str], copy: bool = True) -> E:
    5703    """Replace all tables in expression according to the mapping.
    5704
    5705    Args:
    5706        expression: expression node to be transformed and replaced.
    5707        mapping: mapping of table names.
    5708        copy: whether or not to copy the expression.
    5709
    5710    Examples:
    5711        >>> from sqlglot import exp, parse_one
    5712        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    5713        'SELECT * FROM c'
    5714
    5715    Returns:
    5716        The mapped expression.
    5717    """
    5718
    5719    def _replace_tables(node: Expression) -> Expression:
    5720        if isinstance(node, Table):
    5721            new_name = mapping.get(table_name(node))
    5722            if new_name:
    5723                return to_table(
    5724                    new_name,
    5725                    **{k: v for k, v in node.args.items() if k not in ("this", "db", "catalog")},
    5726                )
    5727        return node
    5728
    5729    return expression.transform(_replace_tables, copy=copy)

Replace all tables in expression according to the mapping.

###### Arguments:

- expression: expression node to be transformed and replaced.
- mapping: mapping of table names.
- copy: whether or not 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'

###### Returns:

> The mapped expression.

def replace_placeholders( expression: sqlglot.expressions.Expression, *args, **kwargs) -> sqlglot.expressions.Expression: View Source

    5732def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    5733    """Replace placeholders in an expression.
    5734
    5735    Args:
    5736        expression: expression node to be transformed and replaced.
    5737        args: positional names that will substitute unnamed placeholders in the given order.
    5738        kwargs: keyword arguments that will substitute named placeholders.
    5739
    5740    Examples:
    5741        >>> from sqlglot import exp, parse_one
    5742        >>> replace_placeholders(
    5743        ...     parse_one("select * from :tbl where ? = ?"),
    5744        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    5745        ... ).sql()
    5746        "SELECT * FROM foo WHERE str_col = 'b'"
    5747
    5748    Returns:
    5749        The mapped expression.
    5750    """
    5751
    5752    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    5753        if isinstance(node, Placeholder):
    5754            if node.name:
    5755                new_name = kwargs.get(node.name)
    5756                if new_name:
    5757                    return convert(new_name)
    5758            else:
    5759                try:
    5760                    return convert(next(args))
    5761                except StopIteration:
    5762                    pass
    5763        return node
    5764
    5765    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: sqlglot.expressions.Expression, sources: Dict[str, sqlglot.expressions.Subqueryable], copy: bool = True) -> sqlglot.expressions.Expression: View Source

    5768def expand(
    5769    expression: Expression, sources: t.Dict[str, Subqueryable], copy: bool = True
    5770) -> Expression:
    5771    """Transforms an expression by expanding all referenced sources into subqueries.
    5772
    5773    Examples:
    5774        >>> from sqlglot import parse_one
    5775        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    5776        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    5777
    5778        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    5779        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    5780
    5781    Args:
    5782        expression: The expression to expand.
    5783        sources: A dictionary of name to Subqueryables.
    5784        copy: Whether or not to copy the expression during transformation. Defaults to True.
    5785
    5786    Returns:
    5787        The transformed expression.
    5788    """
    5789
    5790    def _expand(node: Expression):
    5791        if isinstance(node, Table):
    5792            name = table_name(node)
    5793            source = sources.get(name)
    5794            if source:
    5795                subquery = source.subquery(node.alias or name)
    5796                subquery.comments = [f"source: {name}"]
    5797                return subquery.transform(_expand, copy=False)
    5798        return node
    5799
    5800    return expression.transform(_expand, copy=copy)

Transforms an expression by expanding all referenced sources into subqueries.

###### Examples:

>     >>> from sqlglot import parse_one
>     >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
>     'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'

>     >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
>     'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'

###### Arguments:

- expression: The expression to expand.
- sources: A dictionary of name to Subqueryables.
- copy: Whether or not to copy the expression during transformation. Defaults to True.

###### Returns:

> The transformed expression.

def func( name: str, *args, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **kwargs) -> sqlglot.expressions.Func: View Source

    5803def func(name: str, *args, dialect: DialectType = None, **kwargs) -> Func:
    5804    """
    5805    Returns a Func expression.
    5806
    5807    Examples:
    5808        >>> func("abs", 5).sql()
    5809        'ABS(5)'
    5810
    5811        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    5812        'CAST(5 AS DOUBLE)'
    5813
    5814    Args:
    5815        name: the name of the function to build.
    5816        args: the args used to instantiate the function of interest.
    5817        dialect: the source dialect.
    5818        kwargs: the kwargs used to instantiate the function of interest.
    5819
    5820    Note:
    5821        The arguments `args` and `kwargs` are mutually exclusive.
    5822
    5823    Returns:
    5824        An instance of the function of interest, or an anonymous function, if `name` doesn't
    5825        correspond to an existing `sqlglot.expressions.Func` class.
    5826    """
    5827    if args and kwargs:
    5828        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    5829
    5830    from sqlglot.dialects.dialect import Dialect
    5831
    5832    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect) for arg in args]
    5833    kwargs = {key: maybe_parse(value, dialect=dialect) for key, value in kwargs.items()}
    5834
    5835    parser = Dialect.get_or_raise(dialect)().parser()
    5836    from_args_list = parser.FUNCTIONS.get(name.upper())
    5837
    5838    if from_args_list:
    5839        function = from_args_list(converted) if converted else from_args_list.__self__(**kwargs)  # type: ignore
    5840    else:
    5841        kwargs = kwargs or {"expressions": converted}
    5842        function = Anonymous(this=name, **kwargs)
    5843
    5844    for error_message in function.error_messages(converted):
    5845        raise ValueError(error_message)
    5846
    5847    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.
- 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 true() -> sqlglot.expressions.Boolean: View Source

    5850def true() -> Boolean:
    5851    """
    5852    Returns a true Boolean expression.
    5853    """
    5854    return Boolean(this=True)

Returns a true Boolean expression.

def false() -> sqlglot.expressions.Boolean: View Source

    5857def false() -> Boolean:
    5858    """
    5859    Returns a false Boolean expression.
    5860    """
    5861    return Boolean(this=False)

Returns a false Boolean expression.

def null() -> sqlglot.expressions.Null: View Source

    5864def null() -> Null:
    5865    """
    5866    Returns a Null expression.
    5867    """
    5868    return Null()

Returns a Null expression.