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

SQLGLOT_META = 'sqlglot.meta'
class Expression: View Source

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

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

###### Attributes:

- key: a unique key for each class in the Expression hierarchy. This is useful for hashing and representing expressions as strings.
- arg_types: determines 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 `DataType` type of an expression. This is inferred by the optimizer, in order to enable some transformations that require type information.
- meta: a dictionary that can be used to store useful metadata for a given expression.

###### Example:

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

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

###### Arguments:

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

Expression(**args: Any) View Source

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

key = 'expression'
arg_types = {'this': True}
args: Dict[str, Any]
parent: Optional[Expression]
arg_key: Optional[str]
comments: Optional[List[str]]
hashable_args: Any
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

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

alias_column_names: List[str]
name: str
alias_or_name: str
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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

type: Optional[DataType]
meta: Dict[str, Any]
def copy(self): View Source

    261    def copy(self):
    262        """
    263        Returns a deep copy of the expression.
    264        """
    265        new = deepcopy(self)
    266        new.parent = self.parent
    267        return new

Returns a deep copy of the expression.

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

    269    def add_comments(self, comments: t.Optional[t.List[str]]) -> None:
    270        if self.comments is None:
    271            self.comments = []
    272        if comments:
    273            for comment in comments:
    274                _, *meta = comment.split(SQLGLOT_META)
    275                if meta:
    276                    for kv in "".join(meta).split(","):
    277                        k, *v = kv.split("=")
    278                        value = v[0].strip() if v else True
    279                        self.meta[k.strip()] = value
    280                self.comments.append(comment)

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

    282    def append(self, arg_key: str, value: t.Any) -> None:
    283        """
    284        Appends value to arg_key if it's a list or sets it as a new list.
    285
    286        Args:
    287            arg_key (str): name of the list expression arg
    288            value (Any): value to append to the list
    289        """
    290        if not isinstance(self.args.get(arg_key), list):
    291            self.args[arg_key] = []
    292        self.args[arg_key].append(value)
    293        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

    295    def set(self, arg_key: str, value: t.Any) -> None:
    296        """
    297        Sets arg_key to value.
    298
    299        Args:
    300            arg_key: name of the expression arg.
    301            value: value to set the arg to.
    302        """
    303        if value is None:
    304            self.args.pop(arg_key, None)
    305            return
    306
    307        self.args[arg_key] = value
    308        self._set_parent(arg_key, value)

Sets arg_key to value.

###### Arguments:

- arg_key: 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, Expression]]: View Source

    329    def iter_expressions(self) -> t.Iterator[t.Tuple[str, Expression]]:
    330        """Yields the key and expression for all arguments, exploding list args."""
    331        for k, vs in self.args.items():
    332            if type(vs) is list:
    333                for v in vs:
    334                    if hasattr(v, "parent"):
    335                        yield k, v
    336            else:
    337                if hasattr(vs, "parent"):
    338                    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

    340    def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
    341        """
    342        Returns the first node in this tree which matches at least one of
    343        the specified types.
    344
    345        Args:
    346            expression_types: the expression type(s) to match.
    347            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    348
    349        Returns:
    350            The node which matches the criteria or None if no such node was found.
    351        """
    352        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

    354    def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
    355        """
    356        Returns a generator object which visits all nodes in this tree and only
    357        yields those that match at least one of the specified expression types.
    358
    359        Args:
    360            expression_types: the expression type(s) to match.
    361            bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
    362
    363        Returns:
    364            The generator object.
    365        """
    366        for expression, *_ in self.walk(bfs=bfs):
    367            if isinstance(expression, expression_types):
    368                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

    370    def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
    371        """
    372        Returns a nearest parent matching expression_types.
    373
    374        Args:
    375            expression_types: the expression type(s) to match.
    376
    377        Returns:
    378            The parent node.
    379        """
    380        ancestor = self.parent
    381        while ancestor and not isinstance(ancestor, expression_types):
    382            ancestor = ancestor.parent
    383        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[Select]

Returns the parent select statement.

same_parent: bool

Returns if the parent is the same class as itself.

def root(self) -> Expression: View Source

    397    def root(self) -> Expression:
    398        """
    399        Returns the root expression of this tree.
    400        """
    401        expression = self
    402        while expression.parent:
    403            expression = expression.parent
    404        return expression

Returns the root expression of this tree.

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

    406    def walk(self, bfs=True, prune=None):
    407        """
    408        Returns a generator object which visits all nodes in this tree.
    409
    410        Args:
    411            bfs (bool): if set to True the BFS traversal order will be applied,
    412                otherwise the DFS traversal will be used instead.
    413            prune ((node, parent, arg_key) -> bool): callable that returns True if
    414                the generator should stop traversing this branch of the tree.
    415
    416        Returns:
    417            the generator object.
    418        """
    419        if bfs:
    420            yield from self.bfs(prune=prune)
    421        else:
    422            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

    424    def dfs(self, parent=None, key=None, prune=None):
    425        """
    426        Returns a generator object which visits all nodes in this tree in
    427        the DFS (Depth-first) order.
    428
    429        Returns:
    430            The generator object.
    431        """
    432        parent = parent or self.parent
    433        yield self, parent, key
    434        if prune and prune(self, parent, key):
    435            return
    436
    437        for k, v in self.iter_expressions():
    438            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

    440    def bfs(self, prune=None):
    441        """
    442        Returns a generator object which visits all nodes in this tree in
    443        the BFS (Breadth-first) order.
    444
    445        Returns:
    446            The generator object.
    447        """
    448        queue = deque([(self, self.parent, None)])
    449
    450        while queue:
    451            item, parent, key = queue.popleft()
    452
    453            yield item, parent, key
    454            if prune and prune(item, parent, key):
    455                continue
    456
    457            for k, v in item.iter_expressions():
    458                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

    460    def unnest(self):
    461        """
    462        Returns the first non parenthesis child or self.
    463        """
    464        expression = self
    465        while type(expression) is Paren:
    466            expression = expression.this
    467        return expression

Returns the first non parenthesis child or self.

def unalias(self): View Source

    469    def unalias(self):
    470        """
    471        Returns the inner expression if this is an Alias.
    472        """
    473        if isinstance(self, Alias):
    474            return self.this
    475        return self

Returns the inner expression if this is an Alias.

def unnest_operands(self): View Source

    477    def unnest_operands(self):
    478        """
    479        Returns unnested operands as a tuple.
    480        """
    481        return tuple(arg.unnest() for _, arg in self.iter_expressions())

Returns unnested operands as a tuple.

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

    483    def flatten(self, unnest=True):
    484        """
    485        Returns a generator which yields child nodes who's parents are the same class.
    486
    487        A AND B AND C -> [A, B, C]
    488        """
    489        for node, _, _ in self.dfs(prune=lambda n, p, *_: p and not type(n) is self.__class__):
    490            if not type(node) is self.__class__:
    491                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

    499    def sql(self, dialect: DialectType = None, **opts) -> str:
    500        """
    501        Returns SQL string representation of this tree.
    502
    503        Args:
    504            dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
    505            opts: other `sqlglot.generator.Generator` options.
    506
    507        Returns:
    508            The SQL string.
    509        """
    510        from sqlglot.dialects import Dialect
    511
    512        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

    538    def transform(self, fun, *args, copy=True, **kwargs):
    539        """
    540        Recursively visits all tree nodes (excluding already transformed ones)
    541        and applies the given transformation function to each node.
    542
    543        Args:
    544            fun (function): a function which takes a node as an argument and returns a
    545                new transformed node or the same node without modifications. If the function
    546                returns None, then the corresponding node will be removed from the syntax tree.
    547            copy (bool): if set to True a new tree instance is constructed, otherwise the tree is
    548                modified in place.
    549
    550        Returns:
    551            The transformed tree.
    552        """
    553        node = self.copy() if copy else self
    554        new_node = fun(node, *args, **kwargs)
    555
    556        if new_node is None or not isinstance(new_node, Expression):
    557            return new_node
    558        if new_node is not node:
    559            new_node.parent = node.parent
    560            return new_node
    561
    562        replace_children(new_node, lambda child: child.transform(fun, *args, copy=False, **kwargs))
    563        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

    573    def replace(self, expression):
    574        """
    575        Swap out this expression with a new expression.
    576
    577        For example::
    578
    579            >>> tree = Select().select("x").from_("tbl")
    580            >>> tree.find(Column).replace(Column(this="y"))
    581            (COLUMN this: y)
    582            >>> tree.sql()
    583            'SELECT y FROM tbl'
    584
    585        Args:
    586            expression: new node
    587
    588        Returns:
    589            The new expression or expressions.
    590        """
    591        if not self.parent:
    592            return expression
    593
    594        parent = self.parent
    595        self.parent = None
    596
    597        replace_children(parent, lambda child: expression if child is self else child)
    598        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

    600    def pop(self: E) -> E:
    601        """
    602        Remove this expression from its AST.
    603
    604        Returns:
    605            The popped expression.
    606        """
    607        self.replace(None)
    608        return self

Remove this expression from its AST.

###### Returns:

> The popped expression.

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

    610    def assert_is(self, type_: t.Type[E]) -> E:
    611        """
    612        Assert that this `Expression` is an instance of `type_`.
    613
    614        If it is NOT an instance of `type_`, this raises an assertion error.
    615        Otherwise, this returns this expression.
    616
    617        Examples:
    618            This is useful for type security in chained expressions:
    619
    620            >>> import sqlglot
    621            >>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
    622            'SELECT x, z FROM y'
    623        """
    624        assert isinstance(self, type_)
    625        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

    627    def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
    628        """
    629        Checks if this expression is valid (e.g. all mandatory args are set).
    630
    631        Args:
    632            args: a sequence of values that were used to instantiate a Func expression. This is used
    633                to check that the provided arguments don't exceed the function argument limit.
    634
    635        Returns:
    636            A list of error messages for all possible errors that were found.
    637        """
    638        errors: t.List[str] = []
    639
    640        for k in self.args:
    641            if k not in self.arg_types:
    642                errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
    643        for k, mandatory in self.arg_types.items():
    644            v = self.args.get(k)
    645            if mandatory and (v is None or (isinstance(v, list) and not v)):
    646                errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
    647
    648        if (
    649            args
    650            and isinstance(self, Func)
    651            and len(args) > len(self.arg_types)
    652            and not self.is_var_len_args
    653        ):
    654            errors.append(
    655                f"The number of provided arguments ({len(args)}) is greater than "
    656                f"the maximum number of supported arguments ({len(self.arg_types)})"
    657            )
    658
    659        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

    661    def dump(self):
    662        """
    663        Dump this Expression to a JSON-serializable dict.
    664        """
    665        from sqlglot.serde import dump
    666
    667        return dump(self)

Dump this Expression to a JSON-serializable dict.

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

    669    @classmethod
    670    def load(cls, obj):
    671        """
    672        Load a dict (as returned by `Expression.dump`) into an Expression instance.
    673        """
    674        from sqlglot.serde import load
    675
    676        return load(obj)

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

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

    678    def and_(
    679        self,
    680        *expressions: t.Optional[ExpOrStr],
    681        dialect: DialectType = None,
    682        copy: bool = True,
    683        **opts,
    684    ) -> Condition:
    685        """
    686        AND this condition with one or multiple expressions.
    687
    688        Example:
    689            >>> condition("x=1").and_("y=1").sql()
    690            'x = 1 AND y = 1'
    691
    692        Args:
    693            *expressions: the SQL code strings to parse.
    694                If an `Expression` instance is passed, it will be used as-is.
    695            dialect: the dialect used to parse the input expression.
    696            copy: whether or not to copy the involved expressions (only applies to Expressions).
    697            opts: other options to use to parse the input expressions.
    698
    699        Returns:
    700            The new And condition.
    701        """
    702        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, Expression, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    704    def or_(
    705        self,
    706        *expressions: t.Optional[ExpOrStr],
    707        dialect: DialectType = None,
    708        copy: bool = True,
    709        **opts,
    710    ) -> Condition:
    711        """
    712        OR this condition with one or multiple expressions.
    713
    714        Example:
    715            >>> condition("x=1").or_("y=1").sql()
    716            'x = 1 OR y = 1'
    717
    718        Args:
    719            *expressions: the SQL code strings to parse.
    720                If an `Expression` instance is passed, it will be used as-is.
    721            dialect: the dialect used to parse the input expression.
    722            copy: whether or not to copy the involved expressions (only applies to Expressions).
    723            opts: other options to use to parse the input expressions.
    724
    725        Returns:
    726            The new Or condition.
    727        """
    728        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

    730    def not_(self, copy: bool = True):
    731        """
    732        Wrap this condition with NOT.
    733
    734        Example:
    735            >>> condition("x=1").not_().sql()
    736            'NOT x = 1'
    737
    738        Args:
    739            copy: whether or not to copy this object.
    740
    741        Returns:
    742            The new Not instance.
    743        """
    744        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 | Identifier, quoted: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Alias: View Source

    746    def as_(
    747        self,
    748        alias: str | Identifier,
    749        quoted: t.Optional[bool] = None,
    750        dialect: DialectType = None,
    751        copy: bool = True,
    752        **opts,
    753    ) -> Alias:
    754        return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)

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

    779    def isin(
    780        self,
    781        *expressions: t.Any,
    782        query: t.Optional[ExpOrStr] = None,
    783        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    784        copy: bool = True,
    785        **opts,
    786    ) -> In:
    787        return In(
    788            this=maybe_copy(self, copy),
    789            expressions=[convert(e, copy=copy) for e in expressions],
    790            query=maybe_parse(query, copy=copy, **opts) if query else None,
    791            unnest=Unnest(
    792                expressions=[
    793                    maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts) for e in ensure_list(unnest)
    794                ]
    795            )
    796            if unnest
    797            else None,
    798        )

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

    800    def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
    801        return Between(
    802            this=maybe_copy(self, copy),
    803            low=convert(low, copy=copy, **opts),
    804            high=convert(high, copy=copy, **opts),
    805        )

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

    807    def is_(self, other: ExpOrStr) -> Is:
    808        return self._binop(Is, other)

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

    810    def like(self, other: ExpOrStr) -> Like:
    811        return self._binop(Like, other)

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

    813    def ilike(self, other: ExpOrStr) -> ILike:
    814        return self._binop(ILike, other)

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

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

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

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

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

    822    def rlike(self, other: ExpOrStr) -> RegexpLike:
    823        return self._binop(RegexpLike, other)

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

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

Logical conditions like x AND y, or simply x

key = 'condition'

##### Inherited Members

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

class Predicate(Condition): View Source

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

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

key = 'predicate'

##### Inherited Members

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

class DerivedTable(Expression): View Source

    914class DerivedTable(Expression):
    915    @property
    916    def selects(self) -> t.List[Expression]:
    917        return self.this.selects if isinstance(self.this, Subqueryable) else []
    918
    919    @property
    920    def named_selects(self) -> t.List[str]:
    921        return [select.output_name for select in self.selects]

selects: List[Expression]
named_selects: List[str]
key = 'derivedtable'

##### Inherited Members

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

class Unionable(Expression): View Source

    924class Unionable(Expression):
    925    def union(
    926        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    927    ) -> Unionable:
    928        """
    929        Builds a UNION expression.
    930
    931        Example:
    932            >>> import sqlglot
    933            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    934            'SELECT * FROM foo UNION SELECT * FROM bla'
    935
    936        Args:
    937            expression: the SQL code string.
    938                If an `Expression` instance is passed, it will be used as-is.
    939            distinct: set the DISTINCT flag if and only if this is true.
    940            dialect: the dialect used to parse the input expression.
    941            opts: other options to use to parse the input expressions.
    942
    943        Returns:
    944            The new Union expression.
    945        """
    946        return union(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)
    947
    948    def intersect(
    949        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    950    ) -> Unionable:
    951        """
    952        Builds an INTERSECT expression.
    953
    954        Example:
    955            >>> import sqlglot
    956            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    957            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    958
    959        Args:
    960            expression: the SQL code string.
    961                If an `Expression` instance is passed, it will be used as-is.
    962            distinct: set the DISTINCT flag if and only if this is true.
    963            dialect: the dialect used to parse the input expression.
    964            opts: other options to use to parse the input expressions.
    965
    966        Returns:
    967            The new Intersect expression.
    968        """
    969        return intersect(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)
    970
    971    def except_(
    972        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    973    ) -> Unionable:
    974        """
    975        Builds an EXCEPT expression.
    976
    977        Example:
    978            >>> import sqlglot
    979            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    980            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    981
    982        Args:
    983            expression: the SQL code string.
    984                If an `Expression` instance is passed, it will be used as-is.
    985            distinct: set the DISTINCT flag if and only if this is true.
    986            dialect: the dialect used to parse the input expression.
    987            opts: other options to use to parse the input expressions.
    988
    989        Returns:
    990            The new Except expression.
    991        """
    992        return except_(left=self, right=expression, distinct=distinct, dialect=dialect, **opts)

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

    925    def union(
    926        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    927    ) -> Unionable:
    928        """
    929        Builds a UNION expression.
    930
    931        Example:
    932            >>> import sqlglot
    933            >>> sqlglot.parse_one("SELECT * FROM foo").union("SELECT * FROM bla").sql()
    934            'SELECT * FROM foo UNION SELECT * FROM bla'
    935
    936        Args:
    937            expression: the SQL code string.
    938                If an `Expression` instance is passed, it will be used as-is.
    939            distinct: set the DISTINCT flag if and only if this is true.
    940            dialect: the dialect used to parse the input expression.
    941            opts: other options to use to parse the input expressions.
    942
    943        Returns:
    944            The new Union expression.
    945        """
    946        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, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Unionable: View Source

    948    def intersect(
    949        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    950    ) -> Unionable:
    951        """
    952        Builds an INTERSECT expression.
    953
    954        Example:
    955            >>> import sqlglot
    956            >>> sqlglot.parse_one("SELECT * FROM foo").intersect("SELECT * FROM bla").sql()
    957            'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    958
    959        Args:
    960            expression: the SQL code string.
    961                If an `Expression` instance is passed, it will be used as-is.
    962            distinct: set the DISTINCT flag if and only if this is true.
    963            dialect: the dialect used to parse the input expression.
    964            opts: other options to use to parse the input expressions.
    965
    966        Returns:
    967            The new Intersect expression.
    968        """
    969        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, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Unionable: View Source

    971    def except_(
    972        self, expression: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    973    ) -> Unionable:
    974        """
    975        Builds an EXCEPT expression.
    976
    977        Example:
    978            >>> import sqlglot
    979            >>> sqlglot.parse_one("SELECT * FROM foo").except_("SELECT * FROM bla").sql()
    980            'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    981
    982        Args:
    983            expression: the SQL code string.
    984                If an `Expression` instance is passed, it will be used as-is.
    985            distinct: set the DISTINCT flag if and only if this is true.
    986            dialect: the dialect used to parse the input expression.
    987            opts: other options to use to parse the input expressions.
    988
    989        Returns:
    990            The new Except expression.
    991        """
    992        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.

key = 'unionable'

##### Inherited Members

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

class UDTF(DerivedTable, Unionable): View Source

    995class UDTF(DerivedTable, Unionable):
    996    @property
    997    def selects(self) -> t.List[Expression]:
    998        alias = self.args.get("alias")
    999        return alias.columns if alias else []

selects: List[Expression]
key = 'udtf'

##### Inherited Members

Expression
  Expression
  arg_types
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
DerivedTable
  named_selects
Unionable
  union
  intersect
  except_

class Cache(Expression): View Source

    1002class Cache(Expression):
    1003    arg_types = {
    1004        "with": False,
    1005        "this": True,
    1006        "lazy": False,
    1007        "options": False,
    1008        "expression": False,
    1009    }

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

##### Inherited Members

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

class Uncache(Expression): View Source

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

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

##### Inherited Members

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

class DDL(Expression): View Source

    1016class DDL(Expression):
    1017    @property
    1018    def ctes(self):
    1019        with_ = self.args.get("with")
    1020        if not with_:
    1021            return []
    1022        return with_.expressions
    1023
    1024    @property
    1025    def named_selects(self) -> t.List[str]:
    1026        if isinstance(self.expression, Subqueryable):
    1027            return self.expression.named_selects
    1028        return []
    1029
    1030    @property
    1031    def selects(self) -> t.List[Expression]:
    1032        if isinstance(self.expression, Subqueryable):
    1033            return self.expression.selects
    1034        return []

ctes
named_selects: List[str]
selects: List[Expression]
key = 'ddl'

##### Inherited Members

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

class Create(DDL): View Source

    1037class Create(DDL):
    1038    arg_types = {
    1039        "with": False,
    1040        "this": True,
    1041        "kind": True,
    1042        "expression": False,
    1043        "exists": False,
    1044        "properties": False,
    1045        "replace": False,
    1046        "unique": False,
    1047        "indexes": False,
    1048        "no_schema_binding": False,
    1049        "begin": False,
    1050        "end": False,
    1051        "clone": False,
    1052    }

arg_types = {'with': False, 'this': True, 'kind': True, 'expression': False, 'exists': False, 'properties': False, 'replace': False, 'unique': False, 'indexes': False, 'no_schema_binding': False, 'begin': False, 'end': False, 'clone': False}
key = 'create'

##### Inherited Members

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

class Clone(Expression): View Source

    1058class Clone(Expression):
    1059    arg_types = {
    1060        "this": True,
    1061        "when": False,
    1062        "kind": False,
    1063        "shallow": False,
    1064        "expression": False,
    1065        "copy": False,
    1066    }

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

##### Inherited Members

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

class Describe(Expression): View Source

    1069class Describe(Expression):
    1070    arg_types = {"this": True, "kind": False, "expressions": False}

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

##### Inherited Members

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

class Kill(Expression): View Source

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

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

##### Inherited Members

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

class Pragma(Expression): View Source

    1077class Pragma(Expression):
    1078    pass

key = 'pragma'

##### Inherited Members

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

class Set(Expression): View Source

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

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

##### Inherited Members

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

class SetItem(Expression): View Source

    1085class SetItem(Expression):
    1086    arg_types = {
    1087        "this": False,
    1088        "expressions": False,
    1089        "kind": False,
    1090        "collate": False,  # MySQL SET NAMES statement
    1091        "global": False,
    1092    }

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

##### Inherited Members

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

class Show(Expression): View Source

    1095class Show(Expression):
    1096    arg_types = {
    1097        "this": True,
    1098        "target": False,
    1099        "offset": False,
    1100        "limit": False,
    1101        "like": False,
    1102        "where": False,
    1103        "db": False,
    1104        "scope": False,
    1105        "scope_kind": False,
    1106        "full": False,
    1107        "mutex": False,
    1108        "query": False,
    1109        "channel": False,
    1110        "global": False,
    1111        "log": False,
    1112        "position": False,
    1113        "types": False,
    1114    }

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

##### Inherited Members

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

class UserDefinedFunction(Expression): View Source

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

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

##### Inherited Members

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

class CharacterSet(Expression): View Source

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

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

##### Inherited Members

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

class With(Expression): View Source

    1125class With(Expression):
    1126    arg_types = {"expressions": True, "recursive": False}
    1127
    1128    @property
    1129    def recursive(self) -> bool:
    1130        return bool(self.args.get("recursive"))

arg_types = {'expressions': True, 'recursive': False}
recursive: bool
key = 'with'

##### Inherited Members

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

class WithinGroup(Expression): View Source

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

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

##### Inherited Members

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

class CTE(DerivedTable): View Source

    1137class CTE(DerivedTable):
    1138    arg_types = {"this": True, "alias": True}

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

##### Inherited Members

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

class TableAlias(Expression): View Source

    1141class TableAlias(Expression):
    1142    arg_types = {"this": False, "columns": False}
    1143
    1144    @property
    1145    def columns(self):
    1146        return self.args.get("columns") or []

arg_types = {'this': False, 'columns': False}
columns
key = 'tablealias'

##### Inherited Members

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

class BitString(Condition): View Source

    1149class BitString(Condition):
    1150    pass

key = 'bitstring'

##### Inherited Members

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

class HexString(Condition): View Source

    1153class HexString(Condition):
    1154    pass

key = 'hexstring'

##### Inherited Members

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

class ByteString(Condition): View Source

    1157class ByteString(Condition):
    1158    pass

key = 'bytestring'

##### Inherited Members

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

class RawString(Condition): View Source

    1161class RawString(Condition):
    1162    pass

key = 'rawstring'

##### Inherited Members

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

class Column(Condition): View Source

    1165class Column(Condition):
    1166    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
    1167
    1168    @property
    1169    def table(self) -> str:
    1170        return self.text("table")
    1171
    1172    @property
    1173    def db(self) -> str:
    1174        return self.text("db")
    1175
    1176    @property
    1177    def catalog(self) -> str:
    1178        return self.text("catalog")
    1179
    1180    @property
    1181    def output_name(self) -> str:
    1182        return self.name
    1183
    1184    @property
    1185    def parts(self) -> t.List[Identifier]:
    1186        """Return the parts of a column in order catalog, db, table, name."""
    1187        return [
    1188            t.cast(Identifier, self.args[part])
    1189            for part in ("catalog", "db", "table", "this")
    1190            if self.args.get(part)
    1191        ]
    1192
    1193    def to_dot(self) -> Dot | Identifier:
    1194        """Converts the column into a dot expression."""
    1195        parts = self.parts
    1196        parent = self.parent
    1197
    1198        while parent:
    1199            if isinstance(parent, Dot):
    1200                parts.append(parent.expression)
    1201            parent = parent.parent
    1202
    1203        return Dot.build(deepcopy(parts)) if len(parts) > 1 else parts[0]

arg_types = {'this': True, 'table': False, 'db': False, 'catalog': False, 'join_mark': False}
table: str
db: str
catalog: str
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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

parts: List[Identifier]

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

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

    1193    def to_dot(self) -> Dot | Identifier:
    1194        """Converts the column into a dot expression."""
    1195        parts = self.parts
    1196        parent = self.parent
    1197
    1198        while parent:
    1199            if isinstance(parent, Dot):
    1200                parts.append(parent.expression)
    1201            parent = parent.parent
    1202
    1203        return Dot.build(deepcopy(parts)) if len(parts) > 1 else parts[0]

Converts the column into a dot expression.

key = 'column'

##### Inherited Members

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

class ColumnPosition(Expression): View Source

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

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

##### Inherited Members

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

class ColumnDef(Expression): View Source

    1210class ColumnDef(Expression):
    1211    arg_types = {
    1212        "this": True,
    1213        "kind": False,
    1214        "constraints": False,
    1215        "exists": False,
    1216        "position": False,
    1217    }
    1218
    1219    @property
    1220    def constraints(self) -> t.List[ColumnConstraint]:
    1221        return self.args.get("constraints") or []

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

##### Inherited Members

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

class AlterColumn(Expression): View Source

    1224class AlterColumn(Expression):
    1225    arg_types = {
    1226        "this": True,
    1227        "dtype": False,
    1228        "collate": False,
    1229        "using": False,
    1230        "default": False,
    1231        "drop": False,
    1232    }

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

##### Inherited Members

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

class RenameTable(Expression): View Source

    1235class RenameTable(Expression):
    1236    pass

key = 'renametable'

##### Inherited Members

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

class Comment(Expression): View Source

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

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

##### Inherited Members

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

class Comprehension(Expression): View Source

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

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

##### Inherited Members

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

class MergeTreeTTLAction(Expression): View Source

    1248class MergeTreeTTLAction(Expression):
    1249    arg_types = {
    1250        "this": True,
    1251        "delete": False,
    1252        "recompress": False,
    1253        "to_disk": False,
    1254        "to_volume": False,
    1255    }

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

##### Inherited Members

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

class MergeTreeTTL(Expression): View Source

    1259class MergeTreeTTL(Expression):
    1260    arg_types = {
    1261        "expressions": True,
    1262        "where": False,
    1263        "group": False,
    1264        "aggregates": False,
    1265    }

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

##### Inherited Members

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

class IndexConstraintOption(Expression): View Source

    1269class IndexConstraintOption(Expression):
    1270    arg_types = {
    1271        "key_block_size": False,
    1272        "using": False,
    1273        "parser": False,
    1274        "comment": False,
    1275        "visible": False,
    1276        "engine_attr": False,
    1277        "secondary_engine_attr": False,
    1278    }

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

##### Inherited Members

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

class ColumnConstraint(Expression): View Source

    1281class ColumnConstraint(Expression):
    1282    arg_types = {"this": False, "kind": True}
    1283
    1284    @property
    1285    def kind(self) -> ColumnConstraintKind:
    1286        return self.args["kind"]

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

##### Inherited Members

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

class ColumnConstraintKind(Expression): View Source

    1289class ColumnConstraintKind(Expression):
    1290    pass

key = 'columnconstraintkind'

##### Inherited Members

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

class AutoIncrementColumnConstraint(ColumnConstraintKind): View Source

    1293class AutoIncrementColumnConstraint(ColumnConstraintKind):
    1294    pass

key = 'autoincrementcolumnconstraint'

##### Inherited Members

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

class CaseSpecificColumnConstraint(ColumnConstraintKind): View Source

    1297class CaseSpecificColumnConstraint(ColumnConstraintKind):
    1298    arg_types = {"not_": True}

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

##### Inherited Members

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

class CharacterSetColumnConstraint(ColumnConstraintKind): View Source

    1301class CharacterSetColumnConstraint(ColumnConstraintKind):
    1302    arg_types = {"this": True}

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

##### Inherited Members

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

class CheckColumnConstraint(ColumnConstraintKind): View Source

    1305class CheckColumnConstraint(ColumnConstraintKind):
    1306    pass

key = 'checkcolumnconstraint'

##### Inherited Members

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

class ClusteredColumnConstraint(ColumnConstraintKind): View Source

    1309class ClusteredColumnConstraint(ColumnConstraintKind):
    1310    pass

key = 'clusteredcolumnconstraint'

##### Inherited Members

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

class CollateColumnConstraint(ColumnConstraintKind): View Source

    1313class CollateColumnConstraint(ColumnConstraintKind):
    1314    pass

key = 'collatecolumnconstraint'

##### Inherited Members

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

class CommentColumnConstraint(ColumnConstraintKind): View Source

    1317class CommentColumnConstraint(ColumnConstraintKind):
    1318    pass

key = 'commentcolumnconstraint'

##### Inherited Members

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

class CompressColumnConstraint(ColumnConstraintKind): View Source

    1321class CompressColumnConstraint(ColumnConstraintKind):
    1322    pass

key = 'compresscolumnconstraint'

##### Inherited Members

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

class DateFormatColumnConstraint(ColumnConstraintKind): View Source

    1325class DateFormatColumnConstraint(ColumnConstraintKind):
    1326    arg_types = {"this": True}

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

##### Inherited Members

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

class DefaultColumnConstraint(ColumnConstraintKind): View Source

    1329class DefaultColumnConstraint(ColumnConstraintKind):
    1330    pass

key = 'defaultcolumnconstraint'

##### Inherited Members

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

class EncodeColumnConstraint(ColumnConstraintKind): View Source

    1333class EncodeColumnConstraint(ColumnConstraintKind):
    1334    pass

key = 'encodecolumnconstraint'

##### Inherited Members

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

class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind): View Source

    1337class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
    1338    # this: True -> ALWAYS, this: False -> BY DEFAULT
    1339    arg_types = {
    1340        "this": False,
    1341        "expression": False,
    1342        "on_null": False,
    1343        "start": False,
    1344        "increment": False,
    1345        "minvalue": False,
    1346        "maxvalue": False,
    1347        "cycle": False,
    1348    }

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

##### Inherited Members

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

class IndexColumnConstraint(ColumnConstraintKind): View Source

    1352class IndexColumnConstraint(ColumnConstraintKind):
    1353    arg_types = {
    1354        "this": False,
    1355        "schema": True,
    1356        "kind": False,
    1357        "index_type": False,
    1358        "options": False,
    1359    }

arg_types = {'this': False, 'schema': True, 'kind': False, 'index_type': False, 'options': False}
key = 'indexcolumnconstraint'

##### Inherited Members

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

class InlineLengthColumnConstraint(ColumnConstraintKind): View Source

    1362class InlineLengthColumnConstraint(ColumnConstraintKind):
    1363    pass

key = 'inlinelengthcolumnconstraint'

##### Inherited Members

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

class NonClusteredColumnConstraint(ColumnConstraintKind): View Source

    1366class NonClusteredColumnConstraint(ColumnConstraintKind):
    1367    pass

key = 'nonclusteredcolumnconstraint'

##### Inherited Members

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

class NotForReplicationColumnConstraint(ColumnConstraintKind): View Source

    1370class NotForReplicationColumnConstraint(ColumnConstraintKind):
    1371    arg_types = {}

arg_types = {}
key = 'notforreplicationcolumnconstraint'

##### Inherited Members

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

class NotNullColumnConstraint(ColumnConstraintKind): View Source

    1374class NotNullColumnConstraint(ColumnConstraintKind):
    1375    arg_types = {"allow_null": False}

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

##### Inherited Members

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

class OnUpdateColumnConstraint(ColumnConstraintKind): View Source

    1379class OnUpdateColumnConstraint(ColumnConstraintKind):
    1380    pass

key = 'onupdatecolumnconstraint'

##### Inherited Members

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

class PrimaryKeyColumnConstraint(ColumnConstraintKind): View Source

    1383class PrimaryKeyColumnConstraint(ColumnConstraintKind):
    1384    arg_types = {"desc": False}

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

##### Inherited Members

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

class TitleColumnConstraint(ColumnConstraintKind): View Source

    1387class TitleColumnConstraint(ColumnConstraintKind):
    1388    pass

key = 'titlecolumnconstraint'

##### Inherited Members

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

class UniqueColumnConstraint(ColumnConstraintKind): View Source

    1391class UniqueColumnConstraint(ColumnConstraintKind):
    1392    arg_types = {"this": False, "index_type": False}

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

##### Inherited Members

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

class UppercaseColumnConstraint(ColumnConstraintKind): View Source

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

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

##### Inherited Members

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

class PathColumnConstraint(ColumnConstraintKind): View Source

    1399class PathColumnConstraint(ColumnConstraintKind):
    1400    pass

key = 'pathcolumnconstraint'

##### Inherited Members

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

class ComputedColumnConstraint(ColumnConstraintKind): View Source

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

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

##### Inherited Members

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

class Constraint(Expression): View Source

    1409class Constraint(Expression):
    1410    arg_types = {"this": True, "expressions": True}

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

##### Inherited Members

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

class Delete(Expression): View Source

    1413class Delete(Expression):
    1414    arg_types = {
    1415        "with": False,
    1416        "this": False,
    1417        "using": False,
    1418        "where": False,
    1419        "returning": False,
    1420        "limit": False,
    1421        "tables": False,  # Multiple-Table Syntax (MySQL)
    1422    }
    1423
    1424    def delete(
    1425        self,
    1426        table: ExpOrStr,
    1427        dialect: DialectType = None,
    1428        copy: bool = True,
    1429        **opts,
    1430    ) -> Delete:
    1431        """
    1432        Create a DELETE expression or replace the table on an existing DELETE expression.
    1433
    1434        Example:
    1435            >>> delete("tbl").sql()
    1436            'DELETE FROM tbl'
    1437
    1438        Args:
    1439            table: the table from which to delete.
    1440            dialect: the dialect used to parse the input expression.
    1441            copy: if `False`, modify this expression instance in-place.
    1442            opts: other options to use to parse the input expressions.
    1443
    1444        Returns:
    1445            Delete: the modified expression.
    1446        """
    1447        return _apply_builder(
    1448            expression=table,
    1449            instance=self,
    1450            arg="this",
    1451            dialect=dialect,
    1452            into=Table,
    1453            copy=copy,
    1454            **opts,
    1455        )
    1456
    1457    def where(
    1458        self,
    1459        *expressions: t.Optional[ExpOrStr],
    1460        append: bool = True,
    1461        dialect: DialectType = None,
    1462        copy: bool = True,
    1463        **opts,
    1464    ) -> Delete:
    1465        """
    1466        Append to or set the WHERE expressions.
    1467
    1468        Example:
    1469            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1470            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1471
    1472        Args:
    1473            *expressions: the SQL code strings to parse.
    1474                If an `Expression` instance is passed, it will be used as-is.
    1475                Multiple expressions are combined with an AND operator.
    1476            append: if `True`, AND the new expressions to any existing expression.
    1477                Otherwise, this resets the expression.
    1478            dialect: the dialect used to parse the input expressions.
    1479            copy: if `False`, modify this expression instance in-place.
    1480            opts: other options to use to parse the input expressions.
    1481
    1482        Returns:
    1483            Delete: the modified expression.
    1484        """
    1485        return _apply_conjunction_builder(
    1486            *expressions,
    1487            instance=self,
    1488            arg="where",
    1489            append=append,
    1490            into=Where,
    1491            dialect=dialect,
    1492            copy=copy,
    1493            **opts,
    1494        )
    1495
    1496    def returning(
    1497        self,
    1498        expression: ExpOrStr,
    1499        dialect: DialectType = None,
    1500        copy: bool = True,
    1501        **opts,
    1502    ) -> Delete:
    1503        """
    1504        Set the RETURNING expression. Not supported by all dialects.
    1505
    1506        Example:
    1507            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1508            'DELETE FROM tbl RETURNING *'
    1509
    1510        Args:
    1511            expression: the SQL code strings to parse.
    1512                If an `Expression` instance is passed, it will be used as-is.
    1513            dialect: the dialect used to parse the input expressions.
    1514            copy: if `False`, modify this expression instance in-place.
    1515            opts: other options to use to parse the input expressions.
    1516
    1517        Returns:
    1518            Delete: the modified expression.
    1519        """
    1520        return _apply_builder(
    1521            expression=expression,
    1522            instance=self,
    1523            arg="returning",
    1524            prefix="RETURNING",
    1525            dialect=dialect,
    1526            copy=copy,
    1527            into=Returning,
    1528            **opts,
    1529        )

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

    1424    def delete(
    1425        self,
    1426        table: ExpOrStr,
    1427        dialect: DialectType = None,
    1428        copy: bool = True,
    1429        **opts,
    1430    ) -> Delete:
    1431        """
    1432        Create a DELETE expression or replace the table on an existing DELETE expression.
    1433
    1434        Example:
    1435            >>> delete("tbl").sql()
    1436            'DELETE FROM tbl'
    1437
    1438        Args:
    1439            table: the table from which to delete.
    1440            dialect: the dialect used to parse the input expression.
    1441            copy: if `False`, modify this expression instance in-place.
    1442            opts: other options to use to parse the input expressions.
    1443
    1444        Returns:
    1445            Delete: the modified expression.
    1446        """
    1447        return _apply_builder(
    1448            expression=table,
    1449            instance=self,
    1450            arg="this",
    1451            dialect=dialect,
    1452            into=Table,
    1453            copy=copy,
    1454            **opts,
    1455        )

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

###### Example:

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

###### Arguments:

- table: the table from which to delete.
- dialect: the dialect used to parse the input expression.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input expressions.

###### Returns:

> Delete: the modified expression.

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

    1457    def where(
    1458        self,
    1459        *expressions: t.Optional[ExpOrStr],
    1460        append: bool = True,
    1461        dialect: DialectType = None,
    1462        copy: bool = True,
    1463        **opts,
    1464    ) -> Delete:
    1465        """
    1466        Append to or set the WHERE expressions.
    1467
    1468        Example:
    1469            >>> delete("tbl").where("x = 'a' OR x < 'b'").sql()
    1470            "DELETE FROM tbl WHERE x = 'a' OR x < 'b'"
    1471
    1472        Args:
    1473            *expressions: the SQL code strings to parse.
    1474                If an `Expression` instance is passed, it will be used as-is.
    1475                Multiple expressions are combined with an AND operator.
    1476            append: if `True`, AND the new expressions to any existing expression.
    1477                Otherwise, this resets the expression.
    1478            dialect: the dialect used to parse the input expressions.
    1479            copy: if `False`, modify this expression instance in-place.
    1480            opts: other options to use to parse the input expressions.
    1481
    1482        Returns:
    1483            Delete: the modified expression.
    1484        """
    1485        return _apply_conjunction_builder(
    1486            *expressions,
    1487            instance=self,
    1488            arg="where",
    1489            append=append,
    1490            into=Where,
    1491            dialect=dialect,
    1492            copy=copy,
    1493            **opts,
    1494        )

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

    1496    def returning(
    1497        self,
    1498        expression: ExpOrStr,
    1499        dialect: DialectType = None,
    1500        copy: bool = True,
    1501        **opts,
    1502    ) -> Delete:
    1503        """
    1504        Set the RETURNING expression. Not supported by all dialects.
    1505
    1506        Example:
    1507            >>> delete("tbl").returning("*", dialect="postgres").sql()
    1508            'DELETE FROM tbl RETURNING *'
    1509
    1510        Args:
    1511            expression: the SQL code strings to parse.
    1512                If an `Expression` instance is passed, it will be used as-is.
    1513            dialect: the dialect used to parse the input expressions.
    1514            copy: if `False`, modify this expression instance in-place.
    1515            opts: other options to use to parse the input expressions.
    1516
    1517        Returns:
    1518            Delete: the modified expression.
    1519        """
    1520        return _apply_builder(
    1521            expression=expression,
    1522            instance=self,
    1523            arg="returning",
    1524            prefix="RETURNING",
    1525            dialect=dialect,
    1526            copy=copy,
    1527            into=Returning,
    1528            **opts,
    1529        )

Set the RETURNING expression. Not supported by all dialects.

###### Example:

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

###### Arguments:

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

###### Returns:

> Delete: the modified expression.

key = 'delete'

##### Inherited Members

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

class Drop(Expression): View Source

    1532class Drop(Expression):
    1533    arg_types = {
    1534        "this": False,
    1535        "kind": False,
    1536        "exists": False,
    1537        "temporary": False,
    1538        "materialized": False,
    1539        "cascade": False,
    1540        "constraints": False,
    1541        "purge": False,
    1542    }

arg_types = {'this': False, 'kind': False, 'exists': False, 'temporary': False, 'materialized': False, 'cascade': False, 'constraints': False, 'purge': False}
key = 'drop'

##### Inherited Members

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

class Filter(Expression): View Source

    1545class Filter(Expression):
    1546    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Check(Expression): View Source

    1549class Check(Expression):
    1550    pass

key = 'check'

##### Inherited Members

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

class Connect(Expression): View Source

    1554class Connect(Expression):
    1555    arg_types = {"start": False, "connect": True}

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

##### Inherited Members

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

class Prior(Expression): View Source

    1558class Prior(Expression):
    1559    pass

key = 'prior'

##### Inherited Members

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

class Directory(Expression): View Source

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

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

##### Inherited Members

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

class ForeignKey(Expression): View Source

    1567class ForeignKey(Expression):
    1568    arg_types = {
    1569        "expressions": True,
    1570        "reference": False,
    1571        "delete": False,
    1572        "update": False,
    1573    }

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

##### Inherited Members

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

class ColumnPrefix(Expression): View Source

    1576class ColumnPrefix(Expression):
    1577    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class PrimaryKey(Expression): View Source

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

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

##### Inherited Members

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

class Into(Expression): View Source

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

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

##### Inherited Members

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

class From(Expression): View Source

    1590class From(Expression):
    1591    @property
    1592    def name(self) -> str:
    1593        return self.this.name
    1594
    1595    @property
    1596    def alias_or_name(self) -> str:
    1597        return self.this.alias_or_name

name: str
alias_or_name: str
key = 'from'

##### Inherited Members

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

class Having(Expression): View Source

    1600class Having(Expression):
    1601    pass

key = 'having'

##### Inherited Members

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

class Hint(Expression): View Source

    1604class Hint(Expression):
    1605    arg_types = {"expressions": True}

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

##### Inherited Members

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

class JoinHint(Expression): View Source

    1608class JoinHint(Expression):
    1609    arg_types = {"this": True, "expressions": True}

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

##### Inherited Members

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

class Identifier(Expression): View Source

    1612class Identifier(Expression):
    1613    arg_types = {"this": True, "quoted": False, "global": False, "temporary": False}
    1614
    1615    @property
    1616    def quoted(self) -> bool:
    1617        return bool(self.args.get("quoted"))
    1618
    1619    @property
    1620    def hashable_args(self) -> t.Any:
    1621        return (self.this, self.quoted)
    1622
    1623    @property
    1624    def output_name(self) -> str:
    1625        return self.name

arg_types = {'this': True, 'quoted': False, 'global': False, 'temporary': False}
quoted: bool
hashable_args: Any
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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'identifier'

##### Inherited Members

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

class Opclass(Expression): View Source

    1629class Opclass(Expression):
    1630    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Index(Expression): View Source

    1633class Index(Expression):
    1634    arg_types = {
    1635        "this": False,
    1636        "table": False,
    1637        "using": False,
    1638        "where": False,
    1639        "columns": False,
    1640        "unique": False,
    1641        "primary": False,
    1642        "amp": False,  # teradata
    1643        "partition_by": False,  # teradata
    1644        "where": False,  # postgres partial indexes
    1645    }

arg_types = {'this': False, 'table': False, 'using': False, 'where': False, 'columns': False, 'unique': False, 'primary': False, 'amp': False, 'partition_by': False}
key = 'index'

##### Inherited Members

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

class Insert(DDL): View Source

    1648class Insert(DDL):
    1649    arg_types = {
    1650        "with": False,
    1651        "this": True,
    1652        "expression": False,
    1653        "conflict": False,
    1654        "returning": False,
    1655        "overwrite": False,
    1656        "exists": False,
    1657        "partition": False,
    1658        "alternative": False,
    1659        "where": False,
    1660        "ignore": False,
    1661        "by_name": False,
    1662    }
    1663
    1664    def with_(
    1665        self,
    1666        alias: ExpOrStr,
    1667        as_: ExpOrStr,
    1668        recursive: t.Optional[bool] = None,
    1669        append: bool = True,
    1670        dialect: DialectType = None,
    1671        copy: bool = True,
    1672        **opts,
    1673    ) -> Insert:
    1674        """
    1675        Append to or set the common table expressions.
    1676
    1677        Example:
    1678            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    1679            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    1680
    1681        Args:
    1682            alias: the SQL code string to parse as the table name.
    1683                If an `Expression` instance is passed, this is used as-is.
    1684            as_: the SQL code string to parse as the table expression.
    1685                If an `Expression` instance is passed, it will be used as-is.
    1686            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1687            append: if `True`, add to any existing expressions.
    1688                Otherwise, this resets the expressions.
    1689            dialect: the dialect used to parse the input expression.
    1690            copy: if `False`, modify this expression instance in-place.
    1691            opts: other options to use to parse the input expressions.
    1692
    1693        Returns:
    1694            The modified expression.
    1695        """
    1696        return _apply_cte_builder(
    1697            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    1698        )

arg_types = {'with': False, 'this': True, 'expression': False, 'conflict': False, 'returning': False, 'overwrite': False, 'exists': False, 'partition': False, 'alternative': False, 'where': False, 'ignore': False, 'by_name': False}
def with_( self, alias: Union[str, Expression], as_: Union[str, 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) -> Insert: View Source

    1664    def with_(
    1665        self,
    1666        alias: ExpOrStr,
    1667        as_: ExpOrStr,
    1668        recursive: t.Optional[bool] = None,
    1669        append: bool = True,
    1670        dialect: DialectType = None,
    1671        copy: bool = True,
    1672        **opts,
    1673    ) -> Insert:
    1674        """
    1675        Append to or set the common table expressions.
    1676
    1677        Example:
    1678            >>> insert("SELECT x FROM cte", "t").with_("cte", as_="SELECT * FROM tbl").sql()
    1679            'WITH cte AS (SELECT * FROM tbl) INSERT INTO t SELECT x FROM cte'
    1680
    1681        Args:
    1682            alias: the SQL code string to parse as the table name.
    1683                If an `Expression` instance is passed, this is used as-is.
    1684            as_: the SQL code string to parse as the table expression.
    1685                If an `Expression` instance is passed, it will be used as-is.
    1686            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    1687            append: if `True`, add to any existing expressions.
    1688                Otherwise, this resets the expressions.
    1689            dialect: the dialect used to parse the input expression.
    1690            copy: if `False`, modify this expression instance in-place.
    1691            opts: other options to use to parse the input expressions.
    1692
    1693        Returns:
    1694            The modified expression.
    1695        """
    1696        return _apply_cte_builder(
    1697            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    1698        )

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.

key = 'insert'

##### Inherited Members

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

class OnConflict(Expression): View Source

    1701class OnConflict(Expression):
    1702    arg_types = {
    1703        "duplicate": False,
    1704        "expressions": False,
    1705        "nothing": False,
    1706        "key": False,
    1707        "constraint": False,
    1708    }

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

##### Inherited Members

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

class Returning(Expression): View Source

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

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

##### Inherited Members

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

class Introducer(Expression): View Source

    1716class Introducer(Expression):
    1717    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class National(Expression): View Source

    1721class National(Expression):
    1722    pass

key = 'national'

##### Inherited Members

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

class LoadData(Expression): View Source

    1725class LoadData(Expression):
    1726    arg_types = {
    1727        "this": True,
    1728        "local": False,
    1729        "overwrite": False,
    1730        "inpath": True,
    1731        "partition": False,
    1732        "input_format": False,
    1733        "serde": False,
    1734    }

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

##### Inherited Members

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

class Partition(Expression): View Source

    1737class Partition(Expression):
    1738    arg_types = {"expressions": True}

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

##### Inherited Members

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

class Fetch(Expression): View Source

    1741class Fetch(Expression):
    1742    arg_types = {
    1743        "direction": False,
    1744        "count": False,
    1745        "percent": False,
    1746        "with_ties": False,
    1747    }

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

##### Inherited Members

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

class Group(Expression): View Source

    1750class Group(Expression):
    1751    arg_types = {
    1752        "expressions": False,
    1753        "grouping_sets": False,
    1754        "cube": False,
    1755        "rollup": False,
    1756        "totals": False,
    1757        "all": False,
    1758    }

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

##### Inherited Members

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

class Lambda(Expression): View Source

    1761class Lambda(Expression):
    1762    arg_types = {"this": True, "expressions": True}

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

##### Inherited Members

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

class Limit(Expression): View Source

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

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

##### Inherited Members

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

class Literal(Condition): View Source

    1769class Literal(Condition):
    1770    arg_types = {"this": True, "is_string": True}
    1771
    1772    @property
    1773    def hashable_args(self) -> t.Any:
    1774        return (self.this, self.args.get("is_string"))
    1775
    1776    @classmethod
    1777    def number(cls, number) -> Literal:
    1778        return cls(this=str(number), is_string=False)
    1779
    1780    @classmethod
    1781    def string(cls, string) -> Literal:
    1782        return cls(this=str(string), is_string=True)
    1783
    1784    @property
    1785    def output_name(self) -> str:
    1786        return self.name

arg_types = {'this': True, 'is_string': True}
hashable_args: Any
@classmethod
def number(cls, number) -> Literal: View Source

    1776    @classmethod
    1777    def number(cls, number) -> Literal:
    1778        return cls(this=str(number), is_string=False)

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

    1780    @classmethod
    1781    def string(cls, string) -> Literal:
    1782        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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'literal'

##### Inherited Members

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

class Join(Expression): View Source

    1789class Join(Expression):
    1790    arg_types = {
    1791        "this": True,
    1792        "on": False,
    1793        "side": False,
    1794        "kind": False,
    1795        "using": False,
    1796        "method": False,
    1797        "global": False,
    1798        "hint": False,
    1799    }
    1800
    1801    @property
    1802    def method(self) -> str:
    1803        return self.text("method").upper()
    1804
    1805    @property
    1806    def kind(self) -> str:
    1807        return self.text("kind").upper()
    1808
    1809    @property
    1810    def side(self) -> str:
    1811        return self.text("side").upper()
    1812
    1813    @property
    1814    def hint(self) -> str:
    1815        return self.text("hint").upper()
    1816
    1817    @property
    1818    def alias_or_name(self) -> str:
    1819        return self.this.alias_or_name
    1820
    1821    def on(
    1822        self,
    1823        *expressions: t.Optional[ExpOrStr],
    1824        append: bool = True,
    1825        dialect: DialectType = None,
    1826        copy: bool = True,
    1827        **opts,
    1828    ) -> Join:
    1829        """
    1830        Append to or set the ON expressions.
    1831
    1832        Example:
    1833            >>> import sqlglot
    1834            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    1835            'JOIN x ON y = 1'
    1836
    1837        Args:
    1838            *expressions: the SQL code strings to parse.
    1839                If an `Expression` instance is passed, it will be used as-is.
    1840                Multiple expressions are combined with an AND operator.
    1841            append: if `True`, AND the new expressions to any existing expression.
    1842                Otherwise, this resets the expression.
    1843            dialect: the dialect used to parse the input expressions.
    1844            copy: if `False`, modify this expression instance in-place.
    1845            opts: other options to use to parse the input expressions.
    1846
    1847        Returns:
    1848            The modified Join expression.
    1849        """
    1850        join = _apply_conjunction_builder(
    1851            *expressions,
    1852            instance=self,
    1853            arg="on",
    1854            append=append,
    1855            dialect=dialect,
    1856            copy=copy,
    1857            **opts,
    1858        )
    1859
    1860        if join.kind == "CROSS":
    1861            join.set("kind", None)
    1862
    1863        return join
    1864
    1865    def using(
    1866        self,
    1867        *expressions: t.Optional[ExpOrStr],
    1868        append: bool = True,
    1869        dialect: DialectType = None,
    1870        copy: bool = True,
    1871        **opts,
    1872    ) -> Join:
    1873        """
    1874        Append to or set the USING expressions.
    1875
    1876        Example:
    1877            >>> import sqlglot
    1878            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    1879            'JOIN x USING (foo, bla)'
    1880
    1881        Args:
    1882            *expressions: the SQL code strings to parse.
    1883                If an `Expression` instance is passed, it will be used as-is.
    1884            append: if `True`, concatenate the new expressions to the existing "using" list.
    1885                Otherwise, this resets the expression.
    1886            dialect: the dialect used to parse the input expressions.
    1887            copy: if `False`, modify this expression instance in-place.
    1888            opts: other options to use to parse the input expressions.
    1889
    1890        Returns:
    1891            The modified Join expression.
    1892        """
    1893        join = _apply_list_builder(
    1894            *expressions,
    1895            instance=self,
    1896            arg="using",
    1897            append=append,
    1898            dialect=dialect,
    1899            copy=copy,
    1900            **opts,
    1901        )
    1902
    1903        if join.kind == "CROSS":
    1904            join.set("kind", None)
    1905
    1906        return join

arg_types = {'this': True, 'on': False, 'side': False, 'kind': False, 'using': False, 'method': False, 'global': False, 'hint': False}
method: str
kind: str
side: str
hint: str
alias_or_name: str
def on( self, *expressions: Union[str, Expression, NoneType], append: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Join: View Source

    1821    def on(
    1822        self,
    1823        *expressions: t.Optional[ExpOrStr],
    1824        append: bool = True,
    1825        dialect: DialectType = None,
    1826        copy: bool = True,
    1827        **opts,
    1828    ) -> Join:
    1829        """
    1830        Append to or set the ON expressions.
    1831
    1832        Example:
    1833            >>> import sqlglot
    1834            >>> sqlglot.parse_one("JOIN x", into=Join).on("y = 1").sql()
    1835            'JOIN x ON y = 1'
    1836
    1837        Args:
    1838            *expressions: the SQL code strings to parse.
    1839                If an `Expression` instance is passed, it will be used as-is.
    1840                Multiple expressions are combined with an AND operator.
    1841            append: if `True`, AND the new expressions to any existing expression.
    1842                Otherwise, this resets the expression.
    1843            dialect: the dialect used to parse the input expressions.
    1844            copy: if `False`, modify this expression instance in-place.
    1845            opts: other options to use to parse the input expressions.
    1846
    1847        Returns:
    1848            The modified Join expression.
    1849        """
    1850        join = _apply_conjunction_builder(
    1851            *expressions,
    1852            instance=self,
    1853            arg="on",
    1854            append=append,
    1855            dialect=dialect,
    1856            copy=copy,
    1857            **opts,
    1858        )
    1859
    1860        if join.kind == "CROSS":
    1861            join.set("kind", None)
    1862
    1863        return join

Append to or set the ON expressions.

###### Example:

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

###### Arguments:

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

###### Returns:

> The modified Join expression.

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

    1865    def using(
    1866        self,
    1867        *expressions: t.Optional[ExpOrStr],
    1868        append: bool = True,
    1869        dialect: DialectType = None,
    1870        copy: bool = True,
    1871        **opts,
    1872    ) -> Join:
    1873        """
    1874        Append to or set the USING expressions.
    1875
    1876        Example:
    1877            >>> import sqlglot
    1878            >>> sqlglot.parse_one("JOIN x", into=Join).using("foo", "bla").sql()
    1879            'JOIN x USING (foo, bla)'
    1880
    1881        Args:
    1882            *expressions: the SQL code strings to parse.
    1883                If an `Expression` instance is passed, it will be used as-is.
    1884            append: if `True`, concatenate the new expressions to the existing "using" list.
    1885                Otherwise, this resets the expression.
    1886            dialect: the dialect used to parse the input expressions.
    1887            copy: if `False`, modify this expression instance in-place.
    1888            opts: other options to use to parse the input expressions.
    1889
    1890        Returns:
    1891            The modified Join expression.
    1892        """
    1893        join = _apply_list_builder(
    1894            *expressions,
    1895            instance=self,
    1896            arg="using",
    1897            append=append,
    1898            dialect=dialect,
    1899            copy=copy,
    1900            **opts,
    1901        )
    1902
    1903        if join.kind == "CROSS":
    1904            join.set("kind", None)
    1905
    1906        return join

Append to or set the USING expressions.

###### Example:

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

###### Arguments:

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

###### Returns:

> The modified Join expression.

key = 'join'

##### Inherited Members

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

class Lateral(UDTF): View Source

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

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

##### Inherited Members

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

class MatchRecognize(Expression): View Source

    1913class MatchRecognize(Expression):
    1914    arg_types = {
    1915        "partition_by": False,
    1916        "order": False,
    1917        "measures": False,
    1918        "rows": False,
    1919        "after": False,
    1920        "pattern": False,
    1921        "define": False,
    1922        "alias": False,
    1923    }

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

##### Inherited Members

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

class Final(Expression): View Source

    1928class Final(Expression):
    1929    pass

key = 'final'

##### Inherited Members

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

class Offset(Expression): View Source

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

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

##### Inherited Members

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

class Order(Expression): View Source

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

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

##### Inherited Members

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

class Cluster(Order): View Source

    1942class Cluster(Order):
    1943    pass

key = 'cluster'

##### Inherited Members

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

class Distribute(Order): View Source

    1946class Distribute(Order):
    1947    pass

key = 'distribute'

##### Inherited Members

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

class Sort(Order): View Source

    1950class Sort(Order):
    1951    pass

key = 'sort'

##### Inherited Members

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

class Ordered(Expression): View Source

    1954class Ordered(Expression):
    1955    arg_types = {"this": True, "desc": False, "nulls_first": True}

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

##### Inherited Members

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

class Property(Expression): View Source

    1958class Property(Expression):
    1959    arg_types = {"this": True, "value": True}

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

##### Inherited Members

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

class AlgorithmProperty(Property): View Source

    1962class AlgorithmProperty(Property):
    1963    arg_types = {"this": True}

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

##### Inherited Members

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

class AutoIncrementProperty(Property): View Source

    1966class AutoIncrementProperty(Property):
    1967    arg_types = {"this": True}

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

##### Inherited Members

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

class BlockCompressionProperty(Property): View Source

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

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

##### Inherited Members

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

class CharacterSetProperty(Property): View Source

    1974class CharacterSetProperty(Property):
    1975    arg_types = {"this": True, "default": True}

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

##### Inherited Members

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

class ChecksumProperty(Property): View Source

    1978class ChecksumProperty(Property):
    1979    arg_types = {"on": False, "default": False}

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

##### Inherited Members

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

class CollateProperty(Property): View Source

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

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

##### Inherited Members

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

class CopyGrantsProperty(Property): View Source

    1986class CopyGrantsProperty(Property):
    1987    arg_types = {}

arg_types = {}
key = 'copygrantsproperty'

##### Inherited Members

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

class DataBlocksizeProperty(Property): View Source

    1990class DataBlocksizeProperty(Property):
    1991    arg_types = {
    1992        "size": False,
    1993        "units": False,
    1994        "minimum": False,
    1995        "maximum": False,
    1996        "default": False,
    1997    }

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

##### Inherited Members

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

class DefinerProperty(Property): View Source

    2000class DefinerProperty(Property):
    2001    arg_types = {"this": True}

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

##### Inherited Members

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

class DistKeyProperty(Property): View Source

    2004class DistKeyProperty(Property):
    2005    arg_types = {"this": True}

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

##### Inherited Members

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

class DistStyleProperty(Property): View Source

    2008class DistStyleProperty(Property):
    2009    arg_types = {"this": True}

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

##### Inherited Members

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

class EngineProperty(Property): View Source

    2012class EngineProperty(Property):
    2013    arg_types = {"this": True}

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

##### Inherited Members

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

class HeapProperty(Property): View Source

    2016class HeapProperty(Property):
    2017    arg_types = {}

arg_types = {}
key = 'heapproperty'

##### Inherited Members

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

class ToTableProperty(Property): View Source

    2020class ToTableProperty(Property):
    2021    arg_types = {"this": True}

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

##### Inherited Members

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

class ExecuteAsProperty(Property): View Source

    2024class ExecuteAsProperty(Property):
    2025    arg_types = {"this": True}

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

##### Inherited Members

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

class ExternalProperty(Property): View Source

    2028class ExternalProperty(Property):
    2029    arg_types = {"this": False}

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

##### Inherited Members

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

class FallbackProperty(Property): View Source

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

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

##### Inherited Members

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

class FileFormatProperty(Property): View Source

    2036class FileFormatProperty(Property):
    2037    arg_types = {"this": True}

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

##### Inherited Members

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

class FreespaceProperty(Property): View Source

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

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

##### Inherited Members

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

class InputModelProperty(Property): View Source

    2044class InputModelProperty(Property):
    2045    arg_types = {"this": True}

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

##### Inherited Members

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

class OutputModelProperty(Property): View Source

    2048class OutputModelProperty(Property):
    2049    arg_types = {"this": True}

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

##### Inherited Members

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

class IsolatedLoadingProperty(Property): View Source

    2052class IsolatedLoadingProperty(Property):
    2053    arg_types = {
    2054        "no": True,
    2055        "concurrent": True,
    2056        "for_all": True,
    2057        "for_insert": True,
    2058        "for_none": True,
    2059    }

arg_types = {'no': True, 'concurrent': True, 'for_all': True, 'for_insert': True, 'for_none': True}
key = 'isolatedloadingproperty'

##### Inherited Members

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

class JournalProperty(Property): View Source

    2062class JournalProperty(Property):
    2063    arg_types = {
    2064        "no": False,
    2065        "dual": False,
    2066        "before": False,
    2067        "local": False,
    2068        "after": False,
    2069    }

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

##### Inherited Members

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

class LanguageProperty(Property): View Source

    2072class LanguageProperty(Property):
    2073    arg_types = {"this": True}

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

##### Inherited Members

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

class ClusteredByProperty(Property): View Source

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

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

##### Inherited Members

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

class DictProperty(Property): View Source

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

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

##### Inherited Members

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

class DictSubProperty(Property): View Source

    2085class DictSubProperty(Property):
    2086    pass

key = 'dictsubproperty'

##### Inherited Members

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

class DictRange(Property): View Source

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

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

##### Inherited Members

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

class OnCluster(Property): View Source

    2095class OnCluster(Property):
    2096    arg_types = {"this": True}

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

##### Inherited Members

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

class LikeProperty(Property): View Source

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

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

##### Inherited Members

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

class LocationProperty(Property): View Source

    2103class LocationProperty(Property):
    2104    arg_types = {"this": True}

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

##### Inherited Members

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

class LockingProperty(Property): View Source

    2107class LockingProperty(Property):
    2108    arg_types = {
    2109        "this": False,
    2110        "kind": True,
    2111        "for_or_in": True,
    2112        "lock_type": True,
    2113        "override": False,
    2114    }

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

##### Inherited Members

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

class LogProperty(Property): View Source

    2117class LogProperty(Property):
    2118    arg_types = {"no": True}

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

##### Inherited Members

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

class MaterializedProperty(Property): View Source

    2121class MaterializedProperty(Property):
    2122    arg_types = {"this": False}

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

##### Inherited Members

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

class MergeBlockRatioProperty(Property): View Source

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

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

##### Inherited Members

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

class NoPrimaryIndexProperty(Property): View Source

    2129class NoPrimaryIndexProperty(Property):
    2130    arg_types = {}

arg_types = {}
key = 'noprimaryindexproperty'

##### Inherited Members

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

class OnProperty(Property): View Source

    2133class OnProperty(Property):
    2134    arg_types = {"this": True}

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

##### Inherited Members

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

class OnCommitProperty(Property): View Source

    2137class OnCommitProperty(Property):
    2138    arg_types = {"delete": False}

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

##### Inherited Members

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

class PartitionedByProperty(Property): View Source

    2141class PartitionedByProperty(Property):
    2142    arg_types = {"this": True}

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

##### Inherited Members

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

class RemoteWithConnectionModelProperty(Property): View Source

    2145class RemoteWithConnectionModelProperty(Property):
    2146    arg_types = {"this": True}

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

##### Inherited Members

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

class ReturnsProperty(Property): View Source

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

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

##### Inherited Members

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

class RowFormatProperty(Property): View Source

    2153class RowFormatProperty(Property):
    2154    arg_types = {"this": True}

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

##### Inherited Members

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

class RowFormatDelimitedProperty(Property): View Source

    2157class RowFormatDelimitedProperty(Property):
    2158    # https://cwiki.apache.org/confluence/display/hive/languagemanual+dml
    2159    arg_types = {
    2160        "fields": False,
    2161        "escaped": False,
    2162        "collection_items": False,
    2163        "map_keys": False,
    2164        "lines": False,
    2165        "null": False,
    2166        "serde": False,
    2167    }

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

##### Inherited Members

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

class RowFormatSerdeProperty(Property): View Source

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

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

##### Inherited Members

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

class QueryTransform(Expression): View Source

    2175class QueryTransform(Expression):
    2176    arg_types = {
    2177        "expressions": True,
    2178        "command_script": True,
    2179        "schema": False,
    2180        "row_format_before": False,
    2181        "record_writer": False,
    2182        "row_format_after": False,
    2183        "record_reader": False,
    2184    }

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

##### Inherited Members

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

class SampleProperty(Property): View Source

    2187class SampleProperty(Property):
    2188    arg_types = {"this": True}

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

##### Inherited Members

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

class SchemaCommentProperty(Property): View Source

    2191class SchemaCommentProperty(Property):
    2192    arg_types = {"this": True}

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

##### Inherited Members

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

class SerdeProperties(Property): View Source

    2195class SerdeProperties(Property):
    2196    arg_types = {"expressions": True}

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

##### Inherited Members

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

class SetProperty(Property): View Source

    2199class SetProperty(Property):
    2200    arg_types = {"multi": True}

arg_types = {'multi': True}
key = 'setproperty'

##### Inherited Members

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

class SettingsProperty(Property): View Source

    2203class SettingsProperty(Property):
    2204    arg_types = {"expressions": True}

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

##### Inherited Members

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

class SortKeyProperty(Property): View Source

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

arg_types = {'this': True, 'compound': False}
key = 'sortkeyproperty'

##### Inherited Members

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

class SqlSecurityProperty(Property): View Source

    2211class SqlSecurityProperty(Property):
    2212    arg_types = {"definer": True}

arg_types = {'definer': True}
key = 'sqlsecurityproperty'

##### Inherited Members

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

class StabilityProperty(Property): View Source

    2215class StabilityProperty(Property):
    2216    arg_types = {"this": True}

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

##### Inherited Members

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

class TemporaryProperty(Property): View Source

    2219class TemporaryProperty(Property):
    2220    arg_types = {}

arg_types = {}
key = 'temporaryproperty'

##### Inherited Members

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

class TransformModelProperty(Property): View Source

    2223class TransformModelProperty(Property):
    2224    arg_types = {"expressions": True}

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

##### Inherited Members

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

class TransientProperty(Property): View Source

    2227class TransientProperty(Property):
    2228    arg_types = {"this": False}

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

##### Inherited Members

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

class VolatileProperty(Property): View Source

    2231class VolatileProperty(Property):
    2232    arg_types = {"this": False}

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

##### Inherited Members

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

class WithDataProperty(Property): View Source

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

arg_types = {'no': True, 'statistics': False}
key = 'withdataproperty'

##### Inherited Members

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

class WithJournalTableProperty(Property): View Source

    2239class WithJournalTableProperty(Property):
    2240    arg_types = {"this": True}

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

##### Inherited Members

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

class Properties(Expression): View Source

    2243class Properties(Expression):
    2244    arg_types = {"expressions": True}
    2245
    2246    NAME_TO_PROPERTY = {
    2247        "ALGORITHM": AlgorithmProperty,
    2248        "AUTO_INCREMENT": AutoIncrementProperty,
    2249        "CHARACTER SET": CharacterSetProperty,
    2250        "CLUSTERED_BY": ClusteredByProperty,
    2251        "COLLATE": CollateProperty,
    2252        "COMMENT": SchemaCommentProperty,
    2253        "DEFINER": DefinerProperty,
    2254        "DISTKEY": DistKeyProperty,
    2255        "DISTSTYLE": DistStyleProperty,
    2256        "ENGINE": EngineProperty,
    2257        "EXECUTE AS": ExecuteAsProperty,
    2258        "FORMAT": FileFormatProperty,
    2259        "LANGUAGE": LanguageProperty,
    2260        "LOCATION": LocationProperty,
    2261        "PARTITIONED_BY": PartitionedByProperty,
    2262        "RETURNS": ReturnsProperty,
    2263        "ROW_FORMAT": RowFormatProperty,
    2264        "SORTKEY": SortKeyProperty,
    2265    }
    2266
    2267    PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
    2268
    2269    # CREATE property locations
    2270    # Form: schema specified
    2271    #   create [POST_CREATE]
    2272    #     table a [POST_NAME]
    2273    #     (b int) [POST_SCHEMA]
    2274    #     with ([POST_WITH])
    2275    #     index (b) [POST_INDEX]
    2276    #
    2277    # Form: alias selection
    2278    #   create [POST_CREATE]
    2279    #     table a [POST_NAME]
    2280    #     as [POST_ALIAS] (select * from b) [POST_EXPRESSION]
    2281    #     index (c) [POST_INDEX]
    2282    class Location(AutoName):
    2283        POST_CREATE = auto()
    2284        POST_NAME = auto()
    2285        POST_SCHEMA = auto()
    2286        POST_WITH = auto()
    2287        POST_ALIAS = auto()
    2288        POST_EXPRESSION = auto()
    2289        POST_INDEX = auto()
    2290        UNSUPPORTED = auto()
    2291
    2292    @classmethod
    2293    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    2294        expressions = []
    2295        for key, value in properties_dict.items():
    2296            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    2297            if property_cls:
    2298                expressions.append(property_cls(this=convert(value)))
    2299            else:
    2300                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    2301
    2302        return cls(expressions=expressions)

arg_types = {'expressions': True}
NAME_TO_PROPERTY = {'ALGORITHM': <class 'AlgorithmProperty'>, 'AUTO_INCREMENT': <class 'AutoIncrementProperty'>, 'CHARACTER SET': <class 'CharacterSetProperty'>, 'CLUSTERED_BY': <class 'ClusteredByProperty'>, 'COLLATE': <class 'CollateProperty'>, 'COMMENT': <class 'SchemaCommentProperty'>, 'DEFINER': <class 'DefinerProperty'>, 'DISTKEY': <class 'DistKeyProperty'>, 'DISTSTYLE': <class 'DistStyleProperty'>, 'ENGINE': <class 'EngineProperty'>, 'EXECUTE AS': <class 'ExecuteAsProperty'>, 'FORMAT': <class 'FileFormatProperty'>, 'LANGUAGE': <class 'LanguageProperty'>, 'LOCATION': <class 'LocationProperty'>, 'PARTITIONED_BY': <class 'PartitionedByProperty'>, 'RETURNS': <class 'ReturnsProperty'>, 'ROW_FORMAT': <class 'RowFormatProperty'>, 'SORTKEY': <class 'SortKeyProperty'>}
PROPERTY_TO_NAME = {<class 'AlgorithmProperty'>: 'ALGORITHM', <class 'AutoIncrementProperty'>: 'AUTO_INCREMENT', <class 'CharacterSetProperty'>: 'CHARACTER SET', <class 'ClusteredByProperty'>: 'CLUSTERED_BY', <class 'CollateProperty'>: 'COLLATE', <class 'SchemaCommentProperty'>: 'COMMENT', <class 'DefinerProperty'>: 'DEFINER', <class 'DistKeyProperty'>: 'DISTKEY', <class 'DistStyleProperty'>: 'DISTSTYLE', <class 'EngineProperty'>: 'ENGINE', <class 'ExecuteAsProperty'>: 'EXECUTE AS', <class 'FileFormatProperty'>: 'FORMAT', <class 'LanguageProperty'>: 'LANGUAGE', <class 'LocationProperty'>: 'LOCATION', <class 'PartitionedByProperty'>: 'PARTITIONED_BY', <class 'ReturnsProperty'>: 'RETURNS', <class 'RowFormatProperty'>: 'ROW_FORMAT', <class 'SortKeyProperty'>: 'SORTKEY'}
@classmethod
def from_dict(cls, properties_dict: Dict) -> Properties: View Source

    2292    @classmethod
    2293    def from_dict(cls, properties_dict: t.Dict) -> Properties:
    2294        expressions = []
    2295        for key, value in properties_dict.items():
    2296            property_cls = cls.NAME_TO_PROPERTY.get(key.upper())
    2297            if property_cls:
    2298                expressions.append(property_cls(this=convert(value)))
    2299            else:
    2300                expressions.append(Property(this=Literal.string(key), value=convert(value)))
    2301
    2302        return cls(expressions=expressions)

key = 'properties'

##### Inherited Members

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

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

    2282    class Location(AutoName):
    2283        POST_CREATE = auto()
    2284        POST_NAME = auto()
    2285        POST_SCHEMA = auto()
    2286        POST_WITH = auto()
    2287        POST_ALIAS = auto()
    2288        POST_EXPRESSION = auto()
    2289        POST_INDEX = auto()
    2290        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

    2305class Qualify(Expression):
    2306    pass

key = 'qualify'

##### Inherited Members

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

class InputOutputFormat(Expression): View Source

    2309class InputOutputFormat(Expression):
    2310    arg_types = {"input_format": False, "output_format": False}

arg_types = {'input_format': False, 'output_format': False}
key = 'inputoutputformat'

##### Inherited Members

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

class Return(Expression): View Source

    2314class Return(Expression):
    2315    pass

key = 'return'

##### Inherited Members

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

class Reference(Expression): View Source

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

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

##### Inherited Members

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

class Tuple(Expression): View Source

    2322class Tuple(Expression):
    2323    arg_types = {"expressions": False}
    2324
    2325    def isin(
    2326        self,
    2327        *expressions: t.Any,
    2328        query: t.Optional[ExpOrStr] = None,
    2329        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    2330        copy: bool = True,
    2331        **opts,
    2332    ) -> In:
    2333        return In(
    2334            this=maybe_copy(self, copy),
    2335            expressions=[convert(e, copy=copy) for e in expressions],
    2336            query=maybe_parse(query, copy=copy, **opts) if query else None,
    2337            unnest=Unnest(
    2338                expressions=[
    2339                    maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts) for e in ensure_list(unnest)
    2340                ]
    2341            )
    2342            if unnest
    2343            else None,
    2344        )

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

    2325    def isin(
    2326        self,
    2327        *expressions: t.Any,
    2328        query: t.Optional[ExpOrStr] = None,
    2329        unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
    2330        copy: bool = True,
    2331        **opts,
    2332    ) -> In:
    2333        return In(
    2334            this=maybe_copy(self, copy),
    2335            expressions=[convert(e, copy=copy) for e in expressions],
    2336            query=maybe_parse(query, copy=copy, **opts) if query else None,
    2337            unnest=Unnest(
    2338                expressions=[
    2339                    maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts) for e in ensure_list(unnest)
    2340                ]
    2341            )
    2342            if unnest
    2343            else None,
    2344        )

key = 'tuple'

##### Inherited Members

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

class Subqueryable(Unionable): View Source

    2347class Subqueryable(Unionable):
    2348    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    2349        """
    2350        Convert this expression to an aliased expression that can be used as a Subquery.
    2351
    2352        Example:
    2353            >>> subquery = Select().select("x").from_("tbl").subquery()
    2354            >>> Select().select("x").from_(subquery).sql()
    2355            'SELECT x FROM (SELECT x FROM tbl)'
    2356
    2357        Args:
    2358            alias (str | Identifier): an optional alias for the subquery
    2359            copy (bool): if `False`, modify this expression instance in-place.
    2360
    2361        Returns:
    2362            Alias: the subquery
    2363        """
    2364        instance = maybe_copy(self, copy)
    2365        if not isinstance(alias, Expression):
    2366            alias = TableAlias(this=to_identifier(alias)) if alias else None
    2367
    2368        return Subquery(this=instance, alias=alias)
    2369
    2370    def limit(
    2371        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2372    ) -> Select:
    2373        raise NotImplementedError
    2374
    2375    @property
    2376    def ctes(self):
    2377        with_ = self.args.get("with")
    2378        if not with_:
    2379            return []
    2380        return with_.expressions
    2381
    2382    @property
    2383    def selects(self) -> t.List[Expression]:
    2384        raise NotImplementedError("Subqueryable objects must implement `selects`")
    2385
    2386    @property
    2387    def named_selects(self) -> t.List[str]:
    2388        raise NotImplementedError("Subqueryable objects must implement `named_selects`")
    2389
    2390    def select(
    2391        self,
    2392        *expressions: t.Optional[ExpOrStr],
    2393        append: bool = True,
    2394        dialect: DialectType = None,
    2395        copy: bool = True,
    2396        **opts,
    2397    ) -> Subqueryable:
    2398        raise NotImplementedError("Subqueryable objects must implement `select`")
    2399
    2400    def with_(
    2401        self,
    2402        alias: ExpOrStr,
    2403        as_: ExpOrStr,
    2404        recursive: t.Optional[bool] = None,
    2405        append: bool = True,
    2406        dialect: DialectType = None,
    2407        copy: bool = True,
    2408        **opts,
    2409    ) -> Subqueryable:
    2410        """
    2411        Append to or set the common table expressions.
    2412
    2413        Example:
    2414            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    2415            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    2416
    2417        Args:
    2418            alias: the SQL code string to parse as the table name.
    2419                If an `Expression` instance is passed, this is used as-is.
    2420            as_: the SQL code string to parse as the table expression.
    2421                If an `Expression` instance is passed, it will be used as-is.
    2422            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2423            append: if `True`, add to any existing expressions.
    2424                Otherwise, this resets the expressions.
    2425            dialect: the dialect used to parse the input expression.
    2426            copy: if `False`, modify this expression instance in-place.
    2427            opts: other options to use to parse the input expressions.
    2428
    2429        Returns:
    2430            The modified expression.
    2431        """
    2432        return _apply_cte_builder(
    2433            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    2434        )

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

    2348    def subquery(self, alias: t.Optional[ExpOrStr] = None, copy: bool = True) -> Subquery:
    2349        """
    2350        Convert this expression to an aliased expression that can be used as a Subquery.
    2351
    2352        Example:
    2353            >>> subquery = Select().select("x").from_("tbl").subquery()
    2354            >>> Select().select("x").from_(subquery).sql()
    2355            'SELECT x FROM (SELECT x FROM tbl)'
    2356
    2357        Args:
    2358            alias (str | Identifier): an optional alias for the subquery
    2359            copy (bool): if `False`, modify this expression instance in-place.
    2360
    2361        Returns:
    2362            Alias: the subquery
    2363        """
    2364        instance = maybe_copy(self, copy)
    2365        if not isinstance(alias, Expression):
    2366            alias = TableAlias(this=to_identifier(alias)) if alias else None
    2367
    2368        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, Expression, int], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    2370    def limit(
    2371        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2372    ) -> Select:
    2373        raise NotImplementedError

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

    2390    def select(
    2391        self,
    2392        *expressions: t.Optional[ExpOrStr],
    2393        append: bool = True,
    2394        dialect: DialectType = None,
    2395        copy: bool = True,
    2396        **opts,
    2397    ) -> Subqueryable:
    2398        raise NotImplementedError("Subqueryable objects must implement `select`")

def with_( self, alias: Union[str, Expression], as_: Union[str, 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) -> Subqueryable: View Source

    2400    def with_(
    2401        self,
    2402        alias: ExpOrStr,
    2403        as_: ExpOrStr,
    2404        recursive: t.Optional[bool] = None,
    2405        append: bool = True,
    2406        dialect: DialectType = None,
    2407        copy: bool = True,
    2408        **opts,
    2409    ) -> Subqueryable:
    2410        """
    2411        Append to or set the common table expressions.
    2412
    2413        Example:
    2414            >>> Select().with_("tbl2", as_="SELECT * FROM tbl").select("x").from_("tbl2").sql()
    2415            'WITH tbl2 AS (SELECT * FROM tbl) SELECT x FROM tbl2'
    2416
    2417        Args:
    2418            alias: the SQL code string to parse as the table name.
    2419                If an `Expression` instance is passed, this is used as-is.
    2420            as_: the SQL code string to parse as the table expression.
    2421                If an `Expression` instance is passed, it will be used as-is.
    2422            recursive: set the RECURSIVE part of the expression. Defaults to `False`.
    2423            append: if `True`, add to any existing expressions.
    2424                Otherwise, this resets the expressions.
    2425            dialect: the dialect used to parse the input expression.
    2426            copy: if `False`, modify this expression instance in-place.
    2427            opts: other options to use to parse the input expressions.
    2428
    2429        Returns:
    2430            The modified expression.
    2431        """
    2432        return _apply_cte_builder(
    2433            self, alias, as_, recursive=recursive, append=append, dialect=dialect, copy=copy, **opts
    2434        )

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.

key = 'subqueryable'

##### Inherited Members

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

QUERY_MODIFIERS = {'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False}
class WithTableHint(Expression): View Source

    2462class WithTableHint(Expression):
    2463    arg_types = {"expressions": True}

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

##### Inherited Members

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

class IndexTableHint(Expression): View Source

    2467class IndexTableHint(Expression):
    2468    arg_types = {"this": True, "expressions": False, "target": False}

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

##### Inherited Members

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

class Table(Expression): View Source

    2471class Table(Expression):
    2472    arg_types = {
    2473        "this": True,
    2474        "alias": False,
    2475        "db": False,
    2476        "catalog": False,
    2477        "laterals": False,
    2478        "joins": False,
    2479        "pivots": False,
    2480        "hints": False,
    2481        "system_time": False,
    2482        "version": False,
    2483        "format": False,
    2484        "pattern": False,
    2485        "index": False,
    2486    }
    2487
    2488    @property
    2489    def name(self) -> str:
    2490        if isinstance(self.this, Func):
    2491            return ""
    2492        return self.this.name
    2493
    2494    @property
    2495    def db(self) -> str:
    2496        return self.text("db")
    2497
    2498    @property
    2499    def catalog(self) -> str:
    2500        return self.text("catalog")
    2501
    2502    @property
    2503    def selects(self) -> t.List[Expression]:
    2504        return []
    2505
    2506    @property
    2507    def named_selects(self) -> t.List[str]:
    2508        return []
    2509
    2510    @property
    2511    def parts(self) -> t.List[Expression]:
    2512        """Return the parts of a table in order catalog, db, table."""
    2513        parts: t.List[Expression] = []
    2514
    2515        for arg in ("catalog", "db", "this"):
    2516            part = self.args.get(arg)
    2517
    2518            if isinstance(part, Dot):
    2519                parts.extend(part.flatten())
    2520            elif isinstance(part, Expression):
    2521                parts.append(part)
    2522
    2523        return parts

arg_types = {'this': True, 'alias': False, 'db': False, 'catalog': False, 'laterals': False, 'joins': False, 'pivots': False, 'hints': False, 'system_time': False, 'version': False, 'format': False, 'pattern': False, 'index': False}
name: str
db: str
catalog: str
selects: List[Expression]
named_selects: List[str]
parts: List[Expression]

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

key = 'table'

##### Inherited Members

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

class Union(Subqueryable): View Source

    2526class Union(Subqueryable):
    2527    arg_types = {
    2528        "with": False,
    2529        "this": True,
    2530        "expression": True,
    2531        "distinct": False,
    2532        "by_name": False,
    2533        **QUERY_MODIFIERS,
    2534    }
    2535
    2536    def limit(
    2537        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2538    ) -> Select:
    2539        """
    2540        Set the LIMIT expression.
    2541
    2542        Example:
    2543            >>> select("1").union(select("1")).limit(1).sql()
    2544            'SELECT * FROM (SELECT 1 UNION SELECT 1) AS _l_0 LIMIT 1'
    2545
    2546        Args:
    2547            expression: the SQL code string to parse.
    2548                This can also be an integer.
    2549                If a `Limit` instance is passed, this is used as-is.
    2550                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2551            dialect: the dialect used to parse the input expression.
    2552            copy: if `False`, modify this expression instance in-place.
    2553            opts: other options to use to parse the input expressions.
    2554
    2555        Returns:
    2556            The limited subqueryable.
    2557        """
    2558        return (
    2559            select("*")
    2560            .from_(self.subquery(alias="_l_0", copy=copy))
    2561            .limit(expression, dialect=dialect, copy=False, **opts)
    2562        )
    2563
    2564    def select(
    2565        self,
    2566        *expressions: t.Optional[ExpOrStr],
    2567        append: bool = True,
    2568        dialect: DialectType = None,
    2569        copy: bool = True,
    2570        **opts,
    2571    ) -> Union:
    2572        """Append to or set the SELECT of the union recursively.
    2573
    2574        Example:
    2575            >>> from sqlglot import parse_one
    2576            >>> parse_one("select a from x union select a from y union select a from z").select("b").sql()
    2577            'SELECT a, b FROM x UNION SELECT a, b FROM y UNION SELECT a, b FROM z'
    2578
    2579        Args:
    2580            *expressions: the SQL code strings to parse.
    2581                If an `Expression` instance is passed, it will be used as-is.
    2582            append: if `True`, add to any existing expressions.
    2583                Otherwise, this resets the expressions.
    2584            dialect: the dialect used to parse the input expressions.
    2585            copy: if `False`, modify this expression instance in-place.
    2586            opts: other options to use to parse the input expressions.
    2587
    2588        Returns:
    2589            Union: the modified expression.
    2590        """
    2591        this = self.copy() if copy else self
    2592        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    2593        this.expression.unnest().select(
    2594            *expressions, append=append, dialect=dialect, copy=False, **opts
    2595        )
    2596        return this
    2597
    2598    @property
    2599    def named_selects(self) -> t.List[str]:
    2600        return self.this.unnest().named_selects
    2601
    2602    @property
    2603    def is_star(self) -> bool:
    2604        return self.this.is_star or self.expression.is_star
    2605
    2606    @property
    2607    def selects(self) -> t.List[Expression]:
    2608        return self.this.unnest().selects
    2609
    2610    @property
    2611    def left(self):
    2612        return self.this
    2613
    2614    @property
    2615    def right(self):
    2616        return self.expression

arg_types = {'with': False, 'this': True, 'expression': True, 'distinct': False, 'by_name': False, 'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False}
def limit( self, expression: Union[str, Expression, int], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    2536    def limit(
    2537        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2538    ) -> Select:
    2539        """
    2540        Set the LIMIT expression.
    2541
    2542        Example:
    2543            >>> select("1").union(select("1")).limit(1).sql()
    2544            'SELECT * FROM (SELECT 1 UNION SELECT 1) AS _l_0 LIMIT 1'
    2545
    2546        Args:
    2547            expression: the SQL code string to parse.
    2548                This can also be an integer.
    2549                If a `Limit` instance is passed, this is used as-is.
    2550                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2551            dialect: the dialect used to parse the input expression.
    2552            copy: if `False`, modify this expression instance in-place.
    2553            opts: other options to use to parse the input expressions.
    2554
    2555        Returns:
    2556            The limited subqueryable.
    2557        """
    2558        return (
    2559            select("*")
    2560            .from_(self.subquery(alias="_l_0", copy=copy))
    2561            .limit(expression, dialect=dialect, copy=False, **opts)
    2562        )

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

    2564    def select(
    2565        self,
    2566        *expressions: t.Optional[ExpOrStr],
    2567        append: bool = True,
    2568        dialect: DialectType = None,
    2569        copy: bool = True,
    2570        **opts,
    2571    ) -> Union:
    2572        """Append to or set the SELECT of the union recursively.
    2573
    2574        Example:
    2575            >>> from sqlglot import parse_one
    2576            >>> parse_one("select a from x union select a from y union select a from z").select("b").sql()
    2577            'SELECT a, b FROM x UNION SELECT a, b FROM y UNION SELECT a, b FROM z'
    2578
    2579        Args:
    2580            *expressions: the SQL code strings to parse.
    2581                If an `Expression` instance is passed, it will be used as-is.
    2582            append: if `True`, add to any existing expressions.
    2583                Otherwise, this resets the expressions.
    2584            dialect: the dialect used to parse the input expressions.
    2585            copy: if `False`, modify this expression instance in-place.
    2586            opts: other options to use to parse the input expressions.
    2587
    2588        Returns:
    2589            Union: the modified expression.
    2590        """
    2591        this = self.copy() if copy else self
    2592        this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
    2593        this.expression.unnest().select(
    2594            *expressions, append=append, dialect=dialect, copy=False, **opts
    2595        )
    2596        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.

named_selects: List[str]
is_star: bool

Checks whether an expression is a star.

selects: List[Expression]
left
right
key = 'union'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Subqueryable
  subquery
  ctes
  with_
Unionable
  union
  intersect
  except_

class Except(Union): View Source

    2619class Except(Union):
    2620    pass

key = 'except'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Union
  arg_types
  limit
  select
  named_selects
  is_star
  selects
  left
  right
Subqueryable
  subquery
  ctes
  with_
Unionable
  union
  intersect
  except_

class Intersect(Union): View Source

    2623class Intersect(Union):
    2624    pass

key = 'intersect'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Union
  arg_types
  limit
  select
  named_selects
  is_star
  selects
  left
  right
Subqueryable
  subquery
  ctes
  with_
Unionable
  union
  intersect
  except_

class Unnest(UDTF): View Source

    2627class Unnest(UDTF):
    2628    arg_types = {
    2629        "expressions": True,
    2630        "alias": False,
    2631        "offset": False,
    2632    }

arg_types = {'expressions': True, 'alias': False, 'offset': False}
key = 'unnest'

##### Inherited Members

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

class Update(Expression): View Source

    2635class Update(Expression):
    2636    arg_types = {
    2637        "with": False,
    2638        "this": False,
    2639        "expressions": True,
    2640        "from": False,
    2641        "where": False,
    2642        "returning": False,
    2643        "order": False,
    2644        "limit": False,
    2645    }

arg_types = {'with': False, 'this': False, 'expressions': True, 'from': False, 'where': False, 'returning': False, 'order': False, 'limit': False}
key = 'update'

##### Inherited Members

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

class Values(UDTF): View Source

    2648class Values(UDTF):
    2649    arg_types = {
    2650        "expressions": True,
    2651        "ordinality": False,
    2652        "alias": False,
    2653    }

arg_types = {'expressions': True, 'ordinality': False, 'alias': False}
key = 'values'

##### Inherited Members

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

class Var(Expression): View Source

    2656class Var(Expression):
    2657    pass

key = 'var'

##### Inherited Members

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

class Version(Expression): View Source

    2660class Version(Expression):
    2661    """
    2662    Time travel, iceberg, bigquery etc
    2663    https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots
    2664    https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html
    2665    https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of
    2666    https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16
    2667    this is either TIMESTAMP or VERSION
    2668    kind is ("AS OF", "BETWEEN")
    2669    """
    2670
    2671    arg_types = {"this": True, "kind": True, "expression": False}

Time travel, iceberg, bigquery etc https://trino.io/docs/current/connector/iceberg.html?highlight=snapshot#using-snapshots https://www.databricks.com/blog/2019/02/04/introducing-delta-time-travel-for-large-scale-data-lakes.html https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#for_system_time_as_of https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table?view=sql-server-ver16 this is either TIMESTAMP or VERSION kind is ("AS OF", "BETWEEN")

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

##### Inherited Members

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

class Schema(Expression): View Source

    2674class Schema(Expression):
    2675    arg_types = {"this": False, "expressions": False}

arg_types = {'this': False, 'expressions': False}
key = 'schema'

##### Inherited Members

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

class Lock(Expression): View Source

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

arg_types = {'update': True, 'expressions': False, 'wait': False}
key = 'lock'

##### Inherited Members

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

class Select(Subqueryable): View Source

    2684class Select(Subqueryable):
    2685    arg_types = {
    2686        "with": False,
    2687        "kind": False,
    2688        "expressions": False,
    2689        "hint": False,
    2690        "distinct": False,
    2691        "into": False,
    2692        "from": False,
    2693        **QUERY_MODIFIERS,
    2694    }
    2695
    2696    def from_(
    2697        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    2698    ) -> Select:
    2699        """
    2700        Set the FROM expression.
    2701
    2702        Example:
    2703            >>> Select().from_("tbl").select("x").sql()
    2704            'SELECT x FROM tbl'
    2705
    2706        Args:
    2707            expression : the SQL code strings to parse.
    2708                If a `From` instance is passed, this is used as-is.
    2709                If another `Expression` instance is passed, it will be wrapped in a `From`.
    2710            dialect: the dialect used to parse the input expression.
    2711            copy: if `False`, modify this expression instance in-place.
    2712            opts: other options to use to parse the input expressions.
    2713
    2714        Returns:
    2715            The modified Select expression.
    2716        """
    2717        return _apply_builder(
    2718            expression=expression,
    2719            instance=self,
    2720            arg="from",
    2721            into=From,
    2722            prefix="FROM",
    2723            dialect=dialect,
    2724            copy=copy,
    2725            **opts,
    2726        )
    2727
    2728    def group_by(
    2729        self,
    2730        *expressions: t.Optional[ExpOrStr],
    2731        append: bool = True,
    2732        dialect: DialectType = None,
    2733        copy: bool = True,
    2734        **opts,
    2735    ) -> Select:
    2736        """
    2737        Set the GROUP BY expression.
    2738
    2739        Example:
    2740            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    2741            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    2742
    2743        Args:
    2744            *expressions: the SQL code strings to parse.
    2745                If a `Group` instance is passed, this is used as-is.
    2746                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    2747                If nothing is passed in then a group by is not applied to the expression
    2748            append: if `True`, add to any existing expressions.
    2749                Otherwise, this flattens all the `Group` expression into a single expression.
    2750            dialect: the dialect used to parse the input expression.
    2751            copy: if `False`, modify this expression instance in-place.
    2752            opts: other options to use to parse the input expressions.
    2753
    2754        Returns:
    2755            The modified Select expression.
    2756        """
    2757        if not expressions:
    2758            return self if not copy else self.copy()
    2759
    2760        return _apply_child_list_builder(
    2761            *expressions,
    2762            instance=self,
    2763            arg="group",
    2764            append=append,
    2765            copy=copy,
    2766            prefix="GROUP BY",
    2767            into=Group,
    2768            dialect=dialect,
    2769            **opts,
    2770        )
    2771
    2772    def order_by(
    2773        self,
    2774        *expressions: t.Optional[ExpOrStr],
    2775        append: bool = True,
    2776        dialect: DialectType = None,
    2777        copy: bool = True,
    2778        **opts,
    2779    ) -> Select:
    2780        """
    2781        Set the ORDER BY expression.
    2782
    2783        Example:
    2784            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    2785            'SELECT x FROM tbl ORDER BY x DESC'
    2786
    2787        Args:
    2788            *expressions: the SQL code strings to parse.
    2789                If a `Group` instance is passed, this is used as-is.
    2790                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    2791            append: if `True`, add to any existing expressions.
    2792                Otherwise, this flattens all the `Order` expression into a single expression.
    2793            dialect: the dialect used to parse the input expression.
    2794            copy: if `False`, modify this expression instance in-place.
    2795            opts: other options to use to parse the input expressions.
    2796
    2797        Returns:
    2798            The modified Select expression.
    2799        """
    2800        return _apply_child_list_builder(
    2801            *expressions,
    2802            instance=self,
    2803            arg="order",
    2804            append=append,
    2805            copy=copy,
    2806            prefix="ORDER BY",
    2807            into=Order,
    2808            dialect=dialect,
    2809            **opts,
    2810        )
    2811
    2812    def sort_by(
    2813        self,
    2814        *expressions: t.Optional[ExpOrStr],
    2815        append: bool = True,
    2816        dialect: DialectType = None,
    2817        copy: bool = True,
    2818        **opts,
    2819    ) -> Select:
    2820        """
    2821        Set the SORT BY expression.
    2822
    2823        Example:
    2824            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    2825            'SELECT x FROM tbl SORT BY x DESC'
    2826
    2827        Args:
    2828            *expressions: the SQL code strings to parse.
    2829                If a `Group` instance is passed, this is used as-is.
    2830                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    2831            append: if `True`, add to any existing expressions.
    2832                Otherwise, this flattens all the `Order` expression into a single expression.
    2833            dialect: the dialect used to parse the input expression.
    2834            copy: if `False`, modify this expression instance in-place.
    2835            opts: other options to use to parse the input expressions.
    2836
    2837        Returns:
    2838            The modified Select expression.
    2839        """
    2840        return _apply_child_list_builder(
    2841            *expressions,
    2842            instance=self,
    2843            arg="sort",
    2844            append=append,
    2845            copy=copy,
    2846            prefix="SORT BY",
    2847            into=Sort,
    2848            dialect=dialect,
    2849            **opts,
    2850        )
    2851
    2852    def cluster_by(
    2853        self,
    2854        *expressions: t.Optional[ExpOrStr],
    2855        append: bool = True,
    2856        dialect: DialectType = None,
    2857        copy: bool = True,
    2858        **opts,
    2859    ) -> Select:
    2860        """
    2861        Set the CLUSTER BY expression.
    2862
    2863        Example:
    2864            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    2865            'SELECT x FROM tbl CLUSTER BY x DESC'
    2866
    2867        Args:
    2868            *expressions: the SQL code strings to parse.
    2869                If a `Group` instance is passed, this is used as-is.
    2870                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    2871            append: if `True`, add to any existing expressions.
    2872                Otherwise, this flattens all the `Order` expression into a single expression.
    2873            dialect: the dialect used to parse the input expression.
    2874            copy: if `False`, modify this expression instance in-place.
    2875            opts: other options to use to parse the input expressions.
    2876
    2877        Returns:
    2878            The modified Select expression.
    2879        """
    2880        return _apply_child_list_builder(
    2881            *expressions,
    2882            instance=self,
    2883            arg="cluster",
    2884            append=append,
    2885            copy=copy,
    2886            prefix="CLUSTER BY",
    2887            into=Cluster,
    2888            dialect=dialect,
    2889            **opts,
    2890        )
    2891
    2892    def limit(
    2893        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2894    ) -> Select:
    2895        """
    2896        Set the LIMIT expression.
    2897
    2898        Example:
    2899            >>> Select().from_("tbl").select("x").limit(10).sql()
    2900            'SELECT x FROM tbl LIMIT 10'
    2901
    2902        Args:
    2903            expression: the SQL code string to parse.
    2904                This can also be an integer.
    2905                If a `Limit` instance is passed, this is used as-is.
    2906                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2907            dialect: the dialect used to parse the input expression.
    2908            copy: if `False`, modify this expression instance in-place.
    2909            opts: other options to use to parse the input expressions.
    2910
    2911        Returns:
    2912            Select: the modified expression.
    2913        """
    2914        return _apply_builder(
    2915            expression=expression,
    2916            instance=self,
    2917            arg="limit",
    2918            into=Limit,
    2919            prefix="LIMIT",
    2920            dialect=dialect,
    2921            copy=copy,
    2922            into_arg="expression",
    2923            **opts,
    2924        )
    2925
    2926    def offset(
    2927        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2928    ) -> Select:
    2929        """
    2930        Set the OFFSET expression.
    2931
    2932        Example:
    2933            >>> Select().from_("tbl").select("x").offset(10).sql()
    2934            'SELECT x FROM tbl OFFSET 10'
    2935
    2936        Args:
    2937            expression: the SQL code string to parse.
    2938                This can also be an integer.
    2939                If a `Offset` instance is passed, this is used as-is.
    2940                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    2941            dialect: the dialect used to parse the input expression.
    2942            copy: if `False`, modify this expression instance in-place.
    2943            opts: other options to use to parse the input expressions.
    2944
    2945        Returns:
    2946            The modified Select expression.
    2947        """
    2948        return _apply_builder(
    2949            expression=expression,
    2950            instance=self,
    2951            arg="offset",
    2952            into=Offset,
    2953            prefix="OFFSET",
    2954            dialect=dialect,
    2955            copy=copy,
    2956            into_arg="expression",
    2957            **opts,
    2958        )
    2959
    2960    def select(
    2961        self,
    2962        *expressions: t.Optional[ExpOrStr],
    2963        append: bool = True,
    2964        dialect: DialectType = None,
    2965        copy: bool = True,
    2966        **opts,
    2967    ) -> Select:
    2968        """
    2969        Append to or set the SELECT expressions.
    2970
    2971        Example:
    2972            >>> Select().select("x", "y").sql()
    2973            'SELECT x, y'
    2974
    2975        Args:
    2976            *expressions: the SQL code strings to parse.
    2977                If an `Expression` instance is passed, it will be used as-is.
    2978            append: if `True`, add to any existing expressions.
    2979                Otherwise, this resets the expressions.
    2980            dialect: the dialect used to parse the input expressions.
    2981            copy: if `False`, modify this expression instance in-place.
    2982            opts: other options to use to parse the input expressions.
    2983
    2984        Returns:
    2985            The modified Select expression.
    2986        """
    2987        return _apply_list_builder(
    2988            *expressions,
    2989            instance=self,
    2990            arg="expressions",
    2991            append=append,
    2992            dialect=dialect,
    2993            copy=copy,
    2994            **opts,
    2995        )
    2996
    2997    def lateral(
    2998        self,
    2999        *expressions: t.Optional[ExpOrStr],
    3000        append: bool = True,
    3001        dialect: DialectType = None,
    3002        copy: bool = True,
    3003        **opts,
    3004    ) -> Select:
    3005        """
    3006        Append to or set the LATERAL expressions.
    3007
    3008        Example:
    3009            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3010            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3011
    3012        Args:
    3013            *expressions: the SQL code strings to parse.
    3014                If an `Expression` instance is passed, it will be used as-is.
    3015            append: if `True`, add to any existing expressions.
    3016                Otherwise, this resets the expressions.
    3017            dialect: the dialect used to parse the input expressions.
    3018            copy: if `False`, modify this expression instance in-place.
    3019            opts: other options to use to parse the input expressions.
    3020
    3021        Returns:
    3022            The modified Select expression.
    3023        """
    3024        return _apply_list_builder(
    3025            *expressions,
    3026            instance=self,
    3027            arg="laterals",
    3028            append=append,
    3029            into=Lateral,
    3030            prefix="LATERAL VIEW",
    3031            dialect=dialect,
    3032            copy=copy,
    3033            **opts,
    3034        )
    3035
    3036    def join(
    3037        self,
    3038        expression: ExpOrStr,
    3039        on: t.Optional[ExpOrStr] = None,
    3040        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3041        append: bool = True,
    3042        join_type: t.Optional[str] = None,
    3043        join_alias: t.Optional[Identifier | str] = None,
    3044        dialect: DialectType = None,
    3045        copy: bool = True,
    3046        **opts,
    3047    ) -> Select:
    3048        """
    3049        Append to or set the JOIN expressions.
    3050
    3051        Example:
    3052            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3053            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3054
    3055            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3056            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3057
    3058            Use `join_type` to change the type of join:
    3059
    3060            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3061            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3062
    3063        Args:
    3064            expression: the SQL code string to parse.
    3065                If an `Expression` instance is passed, it will be used as-is.
    3066            on: optionally specify the join "on" criteria as a SQL string.
    3067                If an `Expression` instance is passed, it will be used as-is.
    3068            using: optionally specify the join "using" criteria as a SQL string.
    3069                If an `Expression` instance is passed, it will be used as-is.
    3070            append: if `True`, add to any existing expressions.
    3071                Otherwise, this resets the expressions.
    3072            join_type: if set, alter the parsed join type.
    3073            join_alias: an optional alias for the joined source.
    3074            dialect: the dialect used to parse the input expressions.
    3075            copy: if `False`, modify this expression instance in-place.
    3076            opts: other options to use to parse the input expressions.
    3077
    3078        Returns:
    3079            Select: the modified expression.
    3080        """
    3081        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3082
    3083        try:
    3084            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3085        except ParseError:
    3086            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3087
    3088        join = expression if isinstance(expression, Join) else Join(this=expression)
    3089
    3090        if isinstance(join.this, Select):
    3091            join.this.replace(join.this.subquery())
    3092
    3093        if join_type:
    3094            method: t.Optional[Token]
    3095            side: t.Optional[Token]
    3096            kind: t.Optional[Token]
    3097
    3098            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3099
    3100            if method:
    3101                join.set("method", method.text)
    3102            if side:
    3103                join.set("side", side.text)
    3104            if kind:
    3105                join.set("kind", kind.text)
    3106
    3107        if on:
    3108            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3109            join.set("on", on)
    3110
    3111        if using:
    3112            join = _apply_list_builder(
    3113                *ensure_list(using),
    3114                instance=join,
    3115                arg="using",
    3116                append=append,
    3117                copy=copy,
    3118                into=Identifier,
    3119                **opts,
    3120            )
    3121
    3122        if join_alias:
    3123            join.set("this", alias_(join.this, join_alias, table=True))
    3124
    3125        return _apply_list_builder(
    3126            join,
    3127            instance=self,
    3128            arg="joins",
    3129            append=append,
    3130            copy=copy,
    3131            **opts,
    3132        )
    3133
    3134    def where(
    3135        self,
    3136        *expressions: t.Optional[ExpOrStr],
    3137        append: bool = True,
    3138        dialect: DialectType = None,
    3139        copy: bool = True,
    3140        **opts,
    3141    ) -> Select:
    3142        """
    3143        Append to or set the WHERE expressions.
    3144
    3145        Example:
    3146            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3147            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3148
    3149        Args:
    3150            *expressions: the SQL code strings to parse.
    3151                If an `Expression` instance is passed, it will be used as-is.
    3152                Multiple expressions are combined with an AND operator.
    3153            append: if `True`, AND the new expressions to any existing expression.
    3154                Otherwise, this resets the expression.
    3155            dialect: the dialect used to parse the input expressions.
    3156            copy: if `False`, modify this expression instance in-place.
    3157            opts: other options to use to parse the input expressions.
    3158
    3159        Returns:
    3160            Select: the modified expression.
    3161        """
    3162        return _apply_conjunction_builder(
    3163            *expressions,
    3164            instance=self,
    3165            arg="where",
    3166            append=append,
    3167            into=Where,
    3168            dialect=dialect,
    3169            copy=copy,
    3170            **opts,
    3171        )
    3172
    3173    def having(
    3174        self,
    3175        *expressions: t.Optional[ExpOrStr],
    3176        append: bool = True,
    3177        dialect: DialectType = None,
    3178        copy: bool = True,
    3179        **opts,
    3180    ) -> Select:
    3181        """
    3182        Append to or set the HAVING expressions.
    3183
    3184        Example:
    3185            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3186            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3187
    3188        Args:
    3189            *expressions: the SQL code strings to parse.
    3190                If an `Expression` instance is passed, it will be used as-is.
    3191                Multiple expressions are combined with an AND operator.
    3192            append: if `True`, AND the new expressions to any existing expression.
    3193                Otherwise, this resets the expression.
    3194            dialect: the dialect used to parse the input expressions.
    3195            copy: if `False`, modify this expression instance in-place.
    3196            opts: other options to use to parse the input expressions.
    3197
    3198        Returns:
    3199            The modified Select expression.
    3200        """
    3201        return _apply_conjunction_builder(
    3202            *expressions,
    3203            instance=self,
    3204            arg="having",
    3205            append=append,
    3206            into=Having,
    3207            dialect=dialect,
    3208            copy=copy,
    3209            **opts,
    3210        )
    3211
    3212    def window(
    3213        self,
    3214        *expressions: t.Optional[ExpOrStr],
    3215        append: bool = True,
    3216        dialect: DialectType = None,
    3217        copy: bool = True,
    3218        **opts,
    3219    ) -> Select:
    3220        return _apply_list_builder(
    3221            *expressions,
    3222            instance=self,
    3223            arg="windows",
    3224            append=append,
    3225            into=Window,
    3226            dialect=dialect,
    3227            copy=copy,
    3228            **opts,
    3229        )
    3230
    3231    def qualify(
    3232        self,
    3233        *expressions: t.Optional[ExpOrStr],
    3234        append: bool = True,
    3235        dialect: DialectType = None,
    3236        copy: bool = True,
    3237        **opts,
    3238    ) -> Select:
    3239        return _apply_conjunction_builder(
    3240            *expressions,
    3241            instance=self,
    3242            arg="qualify",
    3243            append=append,
    3244            into=Qualify,
    3245            dialect=dialect,
    3246            copy=copy,
    3247            **opts,
    3248        )
    3249
    3250    def distinct(
    3251        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3252    ) -> Select:
    3253        """
    3254        Set the OFFSET expression.
    3255
    3256        Example:
    3257            >>> Select().from_("tbl").select("x").distinct().sql()
    3258            'SELECT DISTINCT x FROM tbl'
    3259
    3260        Args:
    3261            ons: the expressions to distinct on
    3262            distinct: whether the Select should be distinct
    3263            copy: if `False`, modify this expression instance in-place.
    3264
    3265        Returns:
    3266            Select: the modified expression.
    3267        """
    3268        instance = maybe_copy(self, copy)
    3269        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3270        instance.set("distinct", Distinct(on=on) if distinct else None)
    3271        return instance
    3272
    3273    def ctas(
    3274        self,
    3275        table: ExpOrStr,
    3276        properties: t.Optional[t.Dict] = None,
    3277        dialect: DialectType = None,
    3278        copy: bool = True,
    3279        **opts,
    3280    ) -> Create:
    3281        """
    3282        Convert this expression to a CREATE TABLE AS statement.
    3283
    3284        Example:
    3285            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3286            'CREATE TABLE x AS SELECT * FROM tbl'
    3287
    3288        Args:
    3289            table: the SQL code string to parse as the table name.
    3290                If another `Expression` instance is passed, it will be used as-is.
    3291            properties: an optional mapping of table properties
    3292            dialect: the dialect used to parse the input table.
    3293            copy: if `False`, modify this expression instance in-place.
    3294            opts: other options to use to parse the input table.
    3295
    3296        Returns:
    3297            The new Create expression.
    3298        """
    3299        instance = maybe_copy(self, copy)
    3300        table_expression = maybe_parse(
    3301            table,
    3302            into=Table,
    3303            dialect=dialect,
    3304            **opts,
    3305        )
    3306        properties_expression = None
    3307        if properties:
    3308            properties_expression = Properties.from_dict(properties)
    3309
    3310        return Create(
    3311            this=table_expression,
    3312            kind="table",
    3313            expression=instance,
    3314            properties=properties_expression,
    3315        )
    3316
    3317    def lock(self, update: bool = True, copy: bool = True) -> Select:
    3318        """
    3319        Set the locking read mode for this expression.
    3320
    3321        Examples:
    3322            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    3323            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    3324
    3325            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    3326            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    3327
    3328        Args:
    3329            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    3330            copy: if `False`, modify this expression instance in-place.
    3331
    3332        Returns:
    3333            The modified expression.
    3334        """
    3335        inst = maybe_copy(self, copy)
    3336        inst.set("locks", [Lock(update=update)])
    3337
    3338        return inst
    3339
    3340    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    3341        """
    3342        Set hints for this expression.
    3343
    3344        Examples:
    3345            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    3346            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    3347
    3348        Args:
    3349            hints: The SQL code strings to parse as the hints.
    3350                If an `Expression` instance is passed, it will be used as-is.
    3351            dialect: The dialect used to parse the hints.
    3352            copy: If `False`, modify this expression instance in-place.
    3353
    3354        Returns:
    3355            The modified expression.
    3356        """
    3357        inst = maybe_copy(self, copy)
    3358        inst.set(
    3359            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    3360        )
    3361
    3362        return inst
    3363
    3364    @property
    3365    def named_selects(self) -> t.List[str]:
    3366        return [e.output_name for e in self.expressions if e.alias_or_name]
    3367
    3368    @property
    3369    def is_star(self) -> bool:
    3370        return any(expression.is_star for expression in self.expressions)
    3371
    3372    @property
    3373    def selects(self) -> t.List[Expression]:
    3374        return self.expressions

arg_types = {'with': False, 'kind': False, 'expressions': False, 'hint': False, 'distinct': False, 'into': False, 'from': False, 'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False}
def from_( self, expression: Union[str, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    2696    def from_(
    2697        self, expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    2698    ) -> Select:
    2699        """
    2700        Set the FROM expression.
    2701
    2702        Example:
    2703            >>> Select().from_("tbl").select("x").sql()
    2704            'SELECT x FROM tbl'
    2705
    2706        Args:
    2707            expression : the SQL code strings to parse.
    2708                If a `From` instance is passed, this is used as-is.
    2709                If another `Expression` instance is passed, it will be wrapped in a `From`.
    2710            dialect: the dialect used to parse the input expression.
    2711            copy: if `False`, modify this expression instance in-place.
    2712            opts: other options to use to parse the input expressions.
    2713
    2714        Returns:
    2715            The modified Select expression.
    2716        """
    2717        return _apply_builder(
    2718            expression=expression,
    2719            instance=self,
    2720            arg="from",
    2721            into=From,
    2722            prefix="FROM",
    2723            dialect=dialect,
    2724            copy=copy,
    2725            **opts,
    2726        )

Set the FROM expression.

###### Example:

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

###### Arguments:

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

###### Returns:

> The modified Select expression.

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

    2728    def group_by(
    2729        self,
    2730        *expressions: t.Optional[ExpOrStr],
    2731        append: bool = True,
    2732        dialect: DialectType = None,
    2733        copy: bool = True,
    2734        **opts,
    2735    ) -> Select:
    2736        """
    2737        Set the GROUP BY expression.
    2738
    2739        Example:
    2740            >>> Select().from_("tbl").select("x", "COUNT(1)").group_by("x").sql()
    2741            'SELECT x, COUNT(1) FROM tbl GROUP BY x'
    2742
    2743        Args:
    2744            *expressions: the SQL code strings to parse.
    2745                If a `Group` instance is passed, this is used as-is.
    2746                If another `Expression` instance is passed, it will be wrapped in a `Group`.
    2747                If nothing is passed in then a group by is not applied to the expression
    2748            append: if `True`, add to any existing expressions.
    2749                Otherwise, this flattens all the `Group` expression into a single expression.
    2750            dialect: the dialect used to parse the input expression.
    2751            copy: if `False`, modify this expression instance in-place.
    2752            opts: other options to use to parse the input expressions.
    2753
    2754        Returns:
    2755            The modified Select expression.
    2756        """
    2757        if not expressions:
    2758            return self if not copy else self.copy()
    2759
    2760        return _apply_child_list_builder(
    2761            *expressions,
    2762            instance=self,
    2763            arg="group",
    2764            append=append,
    2765            copy=copy,
    2766            prefix="GROUP BY",
    2767            into=Group,
    2768            dialect=dialect,
    2769            **opts,
    2770        )

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

    2772    def order_by(
    2773        self,
    2774        *expressions: t.Optional[ExpOrStr],
    2775        append: bool = True,
    2776        dialect: DialectType = None,
    2777        copy: bool = True,
    2778        **opts,
    2779    ) -> Select:
    2780        """
    2781        Set the ORDER BY expression.
    2782
    2783        Example:
    2784            >>> Select().from_("tbl").select("x").order_by("x DESC").sql()
    2785            'SELECT x FROM tbl ORDER BY x DESC'
    2786
    2787        Args:
    2788            *expressions: the SQL code strings to parse.
    2789                If a `Group` instance is passed, this is used as-is.
    2790                If another `Expression` instance is passed, it will be wrapped in a `Order`.
    2791            append: if `True`, add to any existing expressions.
    2792                Otherwise, this flattens all the `Order` expression into a single expression.
    2793            dialect: the dialect used to parse the input expression.
    2794            copy: if `False`, modify this expression instance in-place.
    2795            opts: other options to use to parse the input expressions.
    2796
    2797        Returns:
    2798            The modified Select expression.
    2799        """
    2800        return _apply_child_list_builder(
    2801            *expressions,
    2802            instance=self,
    2803            arg="order",
    2804            append=append,
    2805            copy=copy,
    2806            prefix="ORDER BY",
    2807            into=Order,
    2808            dialect=dialect,
    2809            **opts,
    2810        )

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

    2812    def sort_by(
    2813        self,
    2814        *expressions: t.Optional[ExpOrStr],
    2815        append: bool = True,
    2816        dialect: DialectType = None,
    2817        copy: bool = True,
    2818        **opts,
    2819    ) -> Select:
    2820        """
    2821        Set the SORT BY expression.
    2822
    2823        Example:
    2824            >>> Select().from_("tbl").select("x").sort_by("x DESC").sql(dialect="hive")
    2825            'SELECT x FROM tbl SORT BY x DESC'
    2826
    2827        Args:
    2828            *expressions: the SQL code strings to parse.
    2829                If a `Group` instance is passed, this is used as-is.
    2830                If another `Expression` instance is passed, it will be wrapped in a `SORT`.
    2831            append: if `True`, add to any existing expressions.
    2832                Otherwise, this flattens all the `Order` expression into a single expression.
    2833            dialect: the dialect used to parse the input expression.
    2834            copy: if `False`, modify this expression instance in-place.
    2835            opts: other options to use to parse the input expressions.
    2836
    2837        Returns:
    2838            The modified Select expression.
    2839        """
    2840        return _apply_child_list_builder(
    2841            *expressions,
    2842            instance=self,
    2843            arg="sort",
    2844            append=append,
    2845            copy=copy,
    2846            prefix="SORT BY",
    2847            into=Sort,
    2848            dialect=dialect,
    2849            **opts,
    2850        )

Set the SORT BY expression.

###### Example:

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

###### Arguments:

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

###### Returns:

> The modified Select expression.

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

    2852    def cluster_by(
    2853        self,
    2854        *expressions: t.Optional[ExpOrStr],
    2855        append: bool = True,
    2856        dialect: DialectType = None,
    2857        copy: bool = True,
    2858        **opts,
    2859    ) -> Select:
    2860        """
    2861        Set the CLUSTER BY expression.
    2862
    2863        Example:
    2864            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
    2865            'SELECT x FROM tbl CLUSTER BY x DESC'
    2866
    2867        Args:
    2868            *expressions: the SQL code strings to parse.
    2869                If a `Group` instance is passed, this is used as-is.
    2870                If another `Expression` instance is passed, it will be wrapped in a `Cluster`.
    2871            append: if `True`, add to any existing expressions.
    2872                Otherwise, this flattens all the `Order` expression into a single expression.
    2873            dialect: the dialect used to parse the input expression.
    2874            copy: if `False`, modify this expression instance in-place.
    2875            opts: other options to use to parse the input expressions.
    2876
    2877        Returns:
    2878            The modified Select expression.
    2879        """
    2880        return _apply_child_list_builder(
    2881            *expressions,
    2882            instance=self,
    2883            arg="cluster",
    2884            append=append,
    2885            copy=copy,
    2886            prefix="CLUSTER BY",
    2887            into=Cluster,
    2888            dialect=dialect,
    2889            **opts,
    2890        )

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

    2892    def limit(
    2893        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2894    ) -> Select:
    2895        """
    2896        Set the LIMIT expression.
    2897
    2898        Example:
    2899            >>> Select().from_("tbl").select("x").limit(10).sql()
    2900            'SELECT x FROM tbl LIMIT 10'
    2901
    2902        Args:
    2903            expression: the SQL code string to parse.
    2904                This can also be an integer.
    2905                If a `Limit` instance is passed, this is used as-is.
    2906                If another `Expression` instance is passed, it will be wrapped in a `Limit`.
    2907            dialect: the dialect used to parse the input expression.
    2908            copy: if `False`, modify this expression instance in-place.
    2909            opts: other options to use to parse the input expressions.
    2910
    2911        Returns:
    2912            Select: the modified expression.
    2913        """
    2914        return _apply_builder(
    2915            expression=expression,
    2916            instance=self,
    2917            arg="limit",
    2918            into=Limit,
    2919            prefix="LIMIT",
    2920            dialect=dialect,
    2921            copy=copy,
    2922            into_arg="expression",
    2923            **opts,
    2924        )

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

    2926    def offset(
    2927        self, expression: ExpOrStr | int, dialect: DialectType = None, copy: bool = True, **opts
    2928    ) -> Select:
    2929        """
    2930        Set the OFFSET expression.
    2931
    2932        Example:
    2933            >>> Select().from_("tbl").select("x").offset(10).sql()
    2934            'SELECT x FROM tbl OFFSET 10'
    2935
    2936        Args:
    2937            expression: the SQL code string to parse.
    2938                This can also be an integer.
    2939                If a `Offset` instance is passed, this is used as-is.
    2940                If another `Expression` instance is passed, it will be wrapped in a `Offset`.
    2941            dialect: the dialect used to parse the input expression.
    2942            copy: if `False`, modify this expression instance in-place.
    2943            opts: other options to use to parse the input expressions.
    2944
    2945        Returns:
    2946            The modified Select expression.
    2947        """
    2948        return _apply_builder(
    2949            expression=expression,
    2950            instance=self,
    2951            arg="offset",
    2952            into=Offset,
    2953            prefix="OFFSET",
    2954            dialect=dialect,
    2955            copy=copy,
    2956            into_arg="expression",
    2957            **opts,
    2958        )

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

    2960    def select(
    2961        self,
    2962        *expressions: t.Optional[ExpOrStr],
    2963        append: bool = True,
    2964        dialect: DialectType = None,
    2965        copy: bool = True,
    2966        **opts,
    2967    ) -> Select:
    2968        """
    2969        Append to or set the SELECT expressions.
    2970
    2971        Example:
    2972            >>> Select().select("x", "y").sql()
    2973            'SELECT x, y'
    2974
    2975        Args:
    2976            *expressions: the SQL code strings to parse.
    2977                If an `Expression` instance is passed, it will be used as-is.
    2978            append: if `True`, add to any existing expressions.
    2979                Otherwise, this resets the expressions.
    2980            dialect: the dialect used to parse the input expressions.
    2981            copy: if `False`, modify this expression instance in-place.
    2982            opts: other options to use to parse the input expressions.
    2983
    2984        Returns:
    2985            The modified Select expression.
    2986        """
    2987        return _apply_list_builder(
    2988            *expressions,
    2989            instance=self,
    2990            arg="expressions",
    2991            append=append,
    2992            dialect=dialect,
    2993            copy=copy,
    2994            **opts,
    2995        )

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

    2997    def lateral(
    2998        self,
    2999        *expressions: t.Optional[ExpOrStr],
    3000        append: bool = True,
    3001        dialect: DialectType = None,
    3002        copy: bool = True,
    3003        **opts,
    3004    ) -> Select:
    3005        """
    3006        Append to or set the LATERAL expressions.
    3007
    3008        Example:
    3009            >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
    3010            'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'
    3011
    3012        Args:
    3013            *expressions: the SQL code strings to parse.
    3014                If an `Expression` instance is passed, it will be used as-is.
    3015            append: if `True`, add to any existing expressions.
    3016                Otherwise, this resets the expressions.
    3017            dialect: the dialect used to parse the input expressions.
    3018            copy: if `False`, modify this expression instance in-place.
    3019            opts: other options to use to parse the input expressions.
    3020
    3021        Returns:
    3022            The modified Select expression.
    3023        """
    3024        return _apply_list_builder(
    3025            *expressions,
    3026            instance=self,
    3027            arg="laterals",
    3028            append=append,
    3029            into=Lateral,
    3030            prefix="LATERAL VIEW",
    3031            dialect=dialect,
    3032            copy=copy,
    3033            **opts,
    3034        )

Append to or set the LATERAL expressions.

###### Example:

>     >>> Select().select("x").lateral("OUTER explode(y) tbl2 AS z").from_("tbl").sql()
>     'SELECT x FROM tbl LATERAL VIEW OUTER EXPLODE(y) tbl2 AS z'

###### Arguments:

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

###### Returns:

> The modified Select expression.

def join( self, expression: Union[str, Expression], on: Union[str, Expression, NoneType] = None, using: Union[str, Expression, Collection[Union[str, Expression]], NoneType] = None, append: bool = True, join_type: Optional[str] = None, join_alias: Union[Identifier, str, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Select: View Source

    3036    def join(
    3037        self,
    3038        expression: ExpOrStr,
    3039        on: t.Optional[ExpOrStr] = None,
    3040        using: t.Optional[ExpOrStr | t.Collection[ExpOrStr]] = None,
    3041        append: bool = True,
    3042        join_type: t.Optional[str] = None,
    3043        join_alias: t.Optional[Identifier | str] = None,
    3044        dialect: DialectType = None,
    3045        copy: bool = True,
    3046        **opts,
    3047    ) -> Select:
    3048        """
    3049        Append to or set the JOIN expressions.
    3050
    3051        Example:
    3052            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql()
    3053            'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y'
    3054
    3055            >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql()
    3056            'SELECT 1 FROM a JOIN b USING (x, y, z)'
    3057
    3058            Use `join_type` to change the type of join:
    3059
    3060            >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql()
    3061            'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y'
    3062
    3063        Args:
    3064            expression: the SQL code string to parse.
    3065                If an `Expression` instance is passed, it will be used as-is.
    3066            on: optionally specify the join "on" criteria as a SQL string.
    3067                If an `Expression` instance is passed, it will be used as-is.
    3068            using: optionally specify the join "using" criteria as a SQL string.
    3069                If an `Expression` instance is passed, it will be used as-is.
    3070            append: if `True`, add to any existing expressions.
    3071                Otherwise, this resets the expressions.
    3072            join_type: if set, alter the parsed join type.
    3073            join_alias: an optional alias for the joined source.
    3074            dialect: the dialect used to parse the input expressions.
    3075            copy: if `False`, modify this expression instance in-place.
    3076            opts: other options to use to parse the input expressions.
    3077
    3078        Returns:
    3079            Select: the modified expression.
    3080        """
    3081        parse_args: t.Dict[str, t.Any] = {"dialect": dialect, **opts}
    3082
    3083        try:
    3084            expression = maybe_parse(expression, into=Join, prefix="JOIN", **parse_args)
    3085        except ParseError:
    3086            expression = maybe_parse(expression, into=(Join, Expression), **parse_args)
    3087
    3088        join = expression if isinstance(expression, Join) else Join(this=expression)
    3089
    3090        if isinstance(join.this, Select):
    3091            join.this.replace(join.this.subquery())
    3092
    3093        if join_type:
    3094            method: t.Optional[Token]
    3095            side: t.Optional[Token]
    3096            kind: t.Optional[Token]
    3097
    3098            method, side, kind = maybe_parse(join_type, into="JOIN_TYPE", **parse_args)  # type: ignore
    3099
    3100            if method:
    3101                join.set("method", method.text)
    3102            if side:
    3103                join.set("side", side.text)
    3104            if kind:
    3105                join.set("kind", kind.text)
    3106
    3107        if on:
    3108            on = and_(*ensure_list(on), dialect=dialect, copy=copy, **opts)
    3109            join.set("on", on)
    3110
    3111        if using:
    3112            join = _apply_list_builder(
    3113                *ensure_list(using),
    3114                instance=join,
    3115                arg="using",
    3116                append=append,
    3117                copy=copy,
    3118                into=Identifier,
    3119                **opts,
    3120            )
    3121
    3122        if join_alias:
    3123            join.set("this", alias_(join.this, join_alias, table=True))
    3124
    3125        return _apply_list_builder(
    3126            join,
    3127            instance=self,
    3128            arg="joins",
    3129            append=append,
    3130            copy=copy,
    3131            **opts,
    3132        )

Append to or set the JOIN expressions.

###### Example:

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

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

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

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

###### Arguments:

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

###### Returns:

> Select: the modified expression.

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

    3134    def where(
    3135        self,
    3136        *expressions: t.Optional[ExpOrStr],
    3137        append: bool = True,
    3138        dialect: DialectType = None,
    3139        copy: bool = True,
    3140        **opts,
    3141    ) -> Select:
    3142        """
    3143        Append to or set the WHERE expressions.
    3144
    3145        Example:
    3146            >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql()
    3147            "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'"
    3148
    3149        Args:
    3150            *expressions: the SQL code strings to parse.
    3151                If an `Expression` instance is passed, it will be used as-is.
    3152                Multiple expressions are combined with an AND operator.
    3153            append: if `True`, AND the new expressions to any existing expression.
    3154                Otherwise, this resets the expression.
    3155            dialect: the dialect used to parse the input expressions.
    3156            copy: if `False`, modify this expression instance in-place.
    3157            opts: other options to use to parse the input expressions.
    3158
    3159        Returns:
    3160            Select: the modified expression.
    3161        """
    3162        return _apply_conjunction_builder(
    3163            *expressions,
    3164            instance=self,
    3165            arg="where",
    3166            append=append,
    3167            into=Where,
    3168            dialect=dialect,
    3169            copy=copy,
    3170            **opts,
    3171        )

Append to or set the WHERE expressions.

###### Example:

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

###### Arguments:

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

###### Returns:

> Select: the modified expression.

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

    3173    def having(
    3174        self,
    3175        *expressions: t.Optional[ExpOrStr],
    3176        append: bool = True,
    3177        dialect: DialectType = None,
    3178        copy: bool = True,
    3179        **opts,
    3180    ) -> Select:
    3181        """
    3182        Append to or set the HAVING expressions.
    3183
    3184        Example:
    3185            >>> Select().select("x", "COUNT(y)").from_("tbl").group_by("x").having("COUNT(y) > 3").sql()
    3186            'SELECT x, COUNT(y) FROM tbl GROUP BY x HAVING COUNT(y) > 3'
    3187
    3188        Args:
    3189            *expressions: the SQL code strings to parse.
    3190                If an `Expression` instance is passed, it will be used as-is.
    3191                Multiple expressions are combined with an AND operator.
    3192            append: if `True`, AND the new expressions to any existing expression.
    3193                Otherwise, this resets the expression.
    3194            dialect: the dialect used to parse the input expressions.
    3195            copy: if `False`, modify this expression instance in-place.
    3196            opts: other options to use to parse the input expressions.
    3197
    3198        Returns:
    3199            The modified Select expression.
    3200        """
    3201        return _apply_conjunction_builder(
    3202            *expressions,
    3203            instance=self,
    3204            arg="having",
    3205            append=append,
    3206            into=Having,
    3207            dialect=dialect,
    3208            copy=copy,
    3209            **opts,
    3210        )

Append to or set the HAVING expressions.

###### Example:

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

###### Arguments:

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

###### Returns:

> The modified Select expression.

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

    3212    def window(
    3213        self,
    3214        *expressions: t.Optional[ExpOrStr],
    3215        append: bool = True,
    3216        dialect: DialectType = None,
    3217        copy: bool = True,
    3218        **opts,
    3219    ) -> Select:
    3220        return _apply_list_builder(
    3221            *expressions,
    3222            instance=self,
    3223            arg="windows",
    3224            append=append,
    3225            into=Window,
    3226            dialect=dialect,
    3227            copy=copy,
    3228            **opts,
    3229        )

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

    3231    def qualify(
    3232        self,
    3233        *expressions: t.Optional[ExpOrStr],
    3234        append: bool = True,
    3235        dialect: DialectType = None,
    3236        copy: bool = True,
    3237        **opts,
    3238    ) -> Select:
    3239        return _apply_conjunction_builder(
    3240            *expressions,
    3241            instance=self,
    3242            arg="qualify",
    3243            append=append,
    3244            into=Qualify,
    3245            dialect=dialect,
    3246            copy=copy,
    3247            **opts,
    3248        )

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

    3250    def distinct(
    3251        self, *ons: t.Optional[ExpOrStr], distinct: bool = True, copy: bool = True
    3252    ) -> Select:
    3253        """
    3254        Set the OFFSET expression.
    3255
    3256        Example:
    3257            >>> Select().from_("tbl").select("x").distinct().sql()
    3258            'SELECT DISTINCT x FROM tbl'
    3259
    3260        Args:
    3261            ons: the expressions to distinct on
    3262            distinct: whether the Select should be distinct
    3263            copy: if `False`, modify this expression instance in-place.
    3264
    3265        Returns:
    3266            Select: the modified expression.
    3267        """
    3268        instance = maybe_copy(self, copy)
    3269        on = Tuple(expressions=[maybe_parse(on, copy=copy) for on in ons if on]) if ons else None
    3270        instance.set("distinct", Distinct(on=on) if distinct else None)
    3271        return instance

Set the OFFSET expression.

###### Example:

>     >>> Select().from_("tbl").select("x").distinct().sql()
>     'SELECT DISTINCT x FROM tbl'

###### Arguments:

- ons: the expressions to distinct on
- distinct: whether the Select should be distinct
- copy: if `False`, modify this expression instance in-place.

###### Returns:

> Select: the modified expression.

def ctas( self, table: Union[str, Expression], properties: Optional[Dict] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Create: View Source

    3273    def ctas(
    3274        self,
    3275        table: ExpOrStr,
    3276        properties: t.Optional[t.Dict] = None,
    3277        dialect: DialectType = None,
    3278        copy: bool = True,
    3279        **opts,
    3280    ) -> Create:
    3281        """
    3282        Convert this expression to a CREATE TABLE AS statement.
    3283
    3284        Example:
    3285            >>> Select().select("*").from_("tbl").ctas("x").sql()
    3286            'CREATE TABLE x AS SELECT * FROM tbl'
    3287
    3288        Args:
    3289            table: the SQL code string to parse as the table name.
    3290                If another `Expression` instance is passed, it will be used as-is.
    3291            properties: an optional mapping of table properties
    3292            dialect: the dialect used to parse the input table.
    3293            copy: if `False`, modify this expression instance in-place.
    3294            opts: other options to use to parse the input table.
    3295
    3296        Returns:
    3297            The new Create expression.
    3298        """
    3299        instance = maybe_copy(self, copy)
    3300        table_expression = maybe_parse(
    3301            table,
    3302            into=Table,
    3303            dialect=dialect,
    3304            **opts,
    3305        )
    3306        properties_expression = None
    3307        if properties:
    3308            properties_expression = Properties.from_dict(properties)
    3309
    3310        return Create(
    3311            this=table_expression,
    3312            kind="table",
    3313            expression=instance,
    3314            properties=properties_expression,
    3315        )

Convert this expression to a CREATE TABLE AS statement.

###### Example:

>     >>> Select().select("*").from_("tbl").ctas("x").sql()
>     'CREATE TABLE x AS SELECT * FROM tbl'

###### Arguments:

- table: the SQL code string to parse as the table name. If another `Expression` instance is passed, it will be used as-is.
- properties: an optional mapping of table properties
- dialect: the dialect used to parse the input table.
- copy: if `False`, modify this expression instance in-place.
- opts: other options to use to parse the input table.

###### Returns:

> The new Create expression.

def lock( self, update: bool = True, copy: bool = True) -> Select: View Source

    3317    def lock(self, update: bool = True, copy: bool = True) -> Select:
    3318        """
    3319        Set the locking read mode for this expression.
    3320
    3321        Examples:
    3322            >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
    3323            "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"
    3324
    3325            >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
    3326            "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"
    3327
    3328        Args:
    3329            update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
    3330            copy: if `False`, modify this expression instance in-place.
    3331
    3332        Returns:
    3333            The modified expression.
    3334        """
    3335        inst = maybe_copy(self, copy)
    3336        inst.set("locks", [Lock(update=update)])
    3337
    3338        return inst

Set the locking read mode for this expression.

###### Examples:

>     >>> Select().select("x").from_("tbl").where("x = 'a'").lock().sql("mysql")
>     "SELECT x FROM tbl WHERE x = 'a' FOR UPDATE"

>     >>> Select().select("x").from_("tbl").where("x = 'a'").lock(update=False).sql("mysql")
>     "SELECT x FROM tbl WHERE x = 'a' FOR SHARE"

###### Arguments:

- update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`.
- copy: if `False`, modify this expression instance in-place.

###### Returns:

> The modified expression.

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

    3340    def hint(self, *hints: ExpOrStr, dialect: DialectType = None, copy: bool = True) -> Select:
    3341        """
    3342        Set hints for this expression.
    3343
    3344        Examples:
    3345            >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
    3346            'SELECT /*+ BROADCAST(y) */ x FROM tbl'
    3347
    3348        Args:
    3349            hints: The SQL code strings to parse as the hints.
    3350                If an `Expression` instance is passed, it will be used as-is.
    3351            dialect: The dialect used to parse the hints.
    3352            copy: If `False`, modify this expression instance in-place.
    3353
    3354        Returns:
    3355            The modified expression.
    3356        """
    3357        inst = maybe_copy(self, copy)
    3358        inst.set(
    3359            "hint", Hint(expressions=[maybe_parse(h, copy=copy, dialect=dialect) for h in hints])
    3360        )
    3361
    3362        return inst

Set hints for this expression.

###### Examples:

>     >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark")
>     'SELECT /*+ BROADCAST(y) */ x FROM tbl'

###### Arguments:

- hints: The SQL code strings to parse as the hints. If an `Expression` instance is passed, it will be used as-is.
- dialect: The dialect used to parse the hints.
- copy: If `False`, modify this expression instance in-place.

###### Returns:

> The modified expression.

named_selects: List[str]
is_star: bool

Checks whether an expression is a star.

selects: List[Expression]
key = 'select'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Subqueryable
  subquery
  ctes
  with_
Unionable
  union
  intersect
  except_

class Subquery(DerivedTable, Unionable): View Source

    3377class Subquery(DerivedTable, Unionable):
    3378    arg_types = {
    3379        "this": True,
    3380        "alias": False,
    3381        "with": False,
    3382        **QUERY_MODIFIERS,
    3383    }
    3384
    3385    def unnest(self):
    3386        """
    3387        Returns the first non subquery.
    3388        """
    3389        expression = self
    3390        while isinstance(expression, Subquery):
    3391            expression = expression.this
    3392        return expression
    3393
    3394    def unwrap(self) -> Subquery:
    3395        expression = self
    3396        while expression.same_parent and expression.is_wrapper:
    3397            expression = t.cast(Subquery, expression.parent)
    3398        return expression
    3399
    3400    @property
    3401    def is_wrapper(self) -> bool:
    3402        """
    3403        Whether this Subquery acts as a simple wrapper around another expression.
    3404
    3405        SELECT * FROM (((SELECT * FROM t)))
    3406                      ^
    3407                      This corresponds to a "wrapper" Subquery node
    3408        """
    3409        return all(v is None for k, v in self.args.items() if k != "this")
    3410
    3411    @property
    3412    def is_star(self) -> bool:
    3413        return self.this.is_star
    3414
    3415    @property
    3416    def output_name(self) -> str:
    3417        return self.alias

arg_types = {'this': True, 'alias': False, 'with': False, 'match': False, 'laterals': False, 'joins': False, 'connect': False, 'pivots': False, 'where': False, 'group': False, 'having': False, 'qualify': False, 'windows': False, 'distribute': False, 'sort': False, 'cluster': False, 'order': False, 'limit': False, 'offset': False, 'locks': False, 'sample': False, 'settings': False, 'format': False}
def unnest(self): View Source

    3385    def unnest(self):
    3386        """
    3387        Returns the first non subquery.
    3388        """
    3389        expression = self
    3390        while isinstance(expression, Subquery):
    3391            expression = expression.this
    3392        return expression

Returns the first non subquery.

def unwrap(self) -> Subquery: View Source

    3394    def unwrap(self) -> Subquery:
    3395        expression = self
    3396        while expression.same_parent and expression.is_wrapper:
    3397            expression = t.cast(Subquery, expression.parent)
    3398        return expression

is_wrapper: bool

Whether this Subquery acts as a simple wrapper around another expression.

SELECT * FROM (((SELECT * FROM t))) ^ This corresponds to a "wrapper" Subquery node

is_star: bool

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

key = 'subquery'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  alias
  alias_column_names
  name
  alias_or_name
  type
  meta
  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
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
DerivedTable
  selects
  named_selects
Unionable
  union
  intersect
  except_

class TableSample(Expression): View Source

    3420class TableSample(Expression):
    3421    arg_types = {
    3422        "this": False,
    3423        "expressions": False,
    3424        "method": False,
    3425        "bucket_numerator": False,
    3426        "bucket_denominator": False,
    3427        "bucket_field": False,
    3428        "percent": False,
    3429        "rows": False,
    3430        "size": False,
    3431        "seed": False,
    3432        "kind": False,
    3433    }

arg_types = {'this': False, 'expressions': False, 'method': False, 'bucket_numerator': False, 'bucket_denominator': False, 'bucket_field': False, 'percent': False, 'rows': False, 'size': False, 'seed': False, 'kind': False}
key = 'tablesample'

##### Inherited Members

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

class Tag(Expression): View Source

    3436class Tag(Expression):
    3437    """Tags are used for generating arbitrary sql like SELECT <span>x</span>."""
    3438
    3439    arg_types = {
    3440        "this": False,
    3441        "prefix": False,
    3442        "postfix": False,
    3443    }

Tags are used for generating arbitrary sql like SELECT x.

arg_types = {'this': False, 'prefix': False, 'postfix': False}
key = 'tag'

##### Inherited Members

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

class Pivot(Expression): View Source

    3448class Pivot(Expression):
    3449    arg_types = {
    3450        "this": False,
    3451        "alias": False,
    3452        "expressions": False,
    3453        "field": False,
    3454        "unpivot": False,
    3455        "using": False,
    3456        "group": False,
    3457        "columns": False,
    3458        "include_nulls": False,
    3459    }

arg_types = {'this': False, 'alias': False, 'expressions': False, 'field': False, 'unpivot': False, 'using': False, 'group': False, 'columns': False, 'include_nulls': False}
key = 'pivot'

##### Inherited Members

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

class Window(Condition): View Source

    3462class Window(Condition):
    3463    arg_types = {
    3464        "this": True,
    3465        "partition_by": False,
    3466        "order": False,
    3467        "spec": False,
    3468        "alias": False,
    3469        "over": False,
    3470        "first": False,
    3471    }

arg_types = {'this': True, 'partition_by': False, 'order': False, 'spec': False, 'alias': False, 'over': False, 'first': False}
key = 'window'

##### Inherited Members

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

class WindowSpec(Expression): View Source

    3474class WindowSpec(Expression):
    3475    arg_types = {
    3476        "kind": False,
    3477        "start": False,
    3478        "start_side": False,
    3479        "end": False,
    3480        "end_side": False,
    3481    }

arg_types = {'kind': False, 'start': False, 'start_side': False, 'end': False, 'end_side': False}
key = 'windowspec'

##### Inherited Members

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

class Where(Expression): View Source

    3484class Where(Expression):
    3485    pass

key = 'where'

##### Inherited Members

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

class Star(Expression): View Source

    3488class Star(Expression):
    3489    arg_types = {"except": False, "replace": False}
    3490
    3491    @property
    3492    def name(self) -> str:
    3493        return "*"
    3494
    3495    @property
    3496    def output_name(self) -> str:
    3497        return self.name

arg_types = {'except': False, 'replace': False}
name: str
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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'star'

##### Inherited Members

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

class Parameter(Condition): View Source

    3500class Parameter(Condition):
    3501    arg_types = {"this": True, "wrapped": False}

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

##### Inherited Members

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

class SessionParameter(Condition): View Source

    3504class SessionParameter(Condition):
    3505    arg_types = {"this": True, "kind": False}

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

##### Inherited Members

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

class Placeholder(Condition): View Source

    3508class Placeholder(Condition):
    3509    arg_types = {"this": False, "kind": False}

arg_types = {'this': False, 'kind': False}
key = 'placeholder'

##### Inherited Members

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

class Null(Condition): View Source

    3512class Null(Condition):
    3513    arg_types: t.Dict[str, t.Any] = {}
    3514
    3515    @property
    3516    def name(self) -> str:
    3517        return "NULL"

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

##### Inherited Members

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

class Boolean(Condition): View Source

    3520class Boolean(Condition):
    3521    pass

key = 'boolean'

##### Inherited Members

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

class DataTypeParam(Expression): View Source

    3524class DataTypeParam(Expression):
    3525    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

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

class DataType(Expression): View Source

    3528class DataType(Expression):
    3529    arg_types = {
    3530        "this": True,
    3531        "expressions": False,
    3532        "nested": False,
    3533        "values": False,
    3534        "prefix": False,
    3535        "kind": False,
    3536    }
    3537
    3538    class Type(AutoName):
    3539        ARRAY = auto()
    3540        BIGDECIMAL = auto()
    3541        BIGINT = auto()
    3542        BIGSERIAL = auto()
    3543        BINARY = auto()
    3544        BIT = auto()
    3545        BOOLEAN = auto()
    3546        CHAR = auto()
    3547        DATE = auto()
    3548        DATEMULTIRANGE = auto()
    3549        DATERANGE = auto()
    3550        DATETIME = auto()
    3551        DATETIME64 = auto()
    3552        DECIMAL = auto()
    3553        DOUBLE = auto()
    3554        ENUM = auto()
    3555        ENUM8 = auto()
    3556        ENUM16 = auto()
    3557        FIXEDSTRING = auto()
    3558        FLOAT = auto()
    3559        GEOGRAPHY = auto()
    3560        GEOMETRY = auto()
    3561        HLLSKETCH = auto()
    3562        HSTORE = auto()
    3563        IMAGE = auto()
    3564        INET = auto()
    3565        INT = auto()
    3566        INT128 = auto()
    3567        INT256 = auto()
    3568        INT4MULTIRANGE = auto()
    3569        INT4RANGE = auto()
    3570        INT8MULTIRANGE = auto()
    3571        INT8RANGE = auto()
    3572        INTERVAL = auto()
    3573        IPADDRESS = auto()
    3574        IPPREFIX = auto()
    3575        JSON = auto()
    3576        JSONB = auto()
    3577        LONGBLOB = auto()
    3578        LONGTEXT = auto()
    3579        LOWCARDINALITY = auto()
    3580        MAP = auto()
    3581        MEDIUMBLOB = auto()
    3582        MEDIUMINT = auto()
    3583        MEDIUMTEXT = auto()
    3584        MONEY = auto()
    3585        NCHAR = auto()
    3586        NESTED = auto()
    3587        NULL = auto()
    3588        NULLABLE = auto()
    3589        NUMMULTIRANGE = auto()
    3590        NUMRANGE = auto()
    3591        NVARCHAR = auto()
    3592        OBJECT = auto()
    3593        ROWVERSION = auto()
    3594        SERIAL = auto()
    3595        SET = auto()
    3596        SMALLINT = auto()
    3597        SMALLMONEY = auto()
    3598        SMALLSERIAL = auto()
    3599        STRUCT = auto()
    3600        SUPER = auto()
    3601        TEXT = auto()
    3602        TINYBLOB = auto()
    3603        TINYTEXT = auto()
    3604        TIME = auto()
    3605        TIMETZ = auto()
    3606        TIMESTAMP = auto()
    3607        TIMESTAMPLTZ = auto()
    3608        TIMESTAMPTZ = auto()
    3609        TINYINT = auto()
    3610        TSMULTIRANGE = auto()
    3611        TSRANGE = auto()
    3612        TSTZMULTIRANGE = auto()
    3613        TSTZRANGE = auto()
    3614        UBIGINT = auto()
    3615        UINT = auto()
    3616        UINT128 = auto()
    3617        UINT256 = auto()
    3618        UMEDIUMINT = auto()
    3619        UDECIMAL = auto()
    3620        UNIQUEIDENTIFIER = auto()
    3621        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    3622        USERDEFINED = "USER-DEFINED"
    3623        USMALLINT = auto()
    3624        UTINYINT = auto()
    3625        UUID = auto()
    3626        VARBINARY = auto()
    3627        VARCHAR = auto()
    3628        VARIANT = auto()
    3629        XML = auto()
    3630        YEAR = auto()
    3631
    3632    TEXT_TYPES = {
    3633        Type.CHAR,
    3634        Type.NCHAR,
    3635        Type.VARCHAR,
    3636        Type.NVARCHAR,
    3637        Type.TEXT,
    3638    }
    3639
    3640    INTEGER_TYPES = {
    3641        Type.INT,
    3642        Type.TINYINT,
    3643        Type.SMALLINT,
    3644        Type.BIGINT,
    3645        Type.INT128,
    3646        Type.INT256,
    3647    }
    3648
    3649    FLOAT_TYPES = {
    3650        Type.FLOAT,
    3651        Type.DOUBLE,
    3652    }
    3653
    3654    NUMERIC_TYPES = {
    3655        *INTEGER_TYPES,
    3656        *FLOAT_TYPES,
    3657    }
    3658
    3659    TEMPORAL_TYPES = {
    3660        Type.TIME,
    3661        Type.TIMETZ,
    3662        Type.TIMESTAMP,
    3663        Type.TIMESTAMPTZ,
    3664        Type.TIMESTAMPLTZ,
    3665        Type.DATE,
    3666        Type.DATETIME,
    3667        Type.DATETIME64,
    3668    }
    3669
    3670    @classmethod
    3671    def build(
    3672        cls,
    3673        dtype: str | DataType | DataType.Type,
    3674        dialect: DialectType = None,
    3675        udt: bool = False,
    3676        **kwargs,
    3677    ) -> DataType:
    3678        """
    3679        Constructs a DataType object.
    3680
    3681        Args:
    3682            dtype: the data type of interest.
    3683            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    3684            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    3685                DataType, thus creating a user-defined type.
    3686            kawrgs: additional arguments to pass in the constructor of DataType.
    3687
    3688        Returns:
    3689            The constructed DataType object.
    3690        """
    3691        from sqlglot import parse_one
    3692
    3693        if isinstance(dtype, str):
    3694            if dtype.upper() == "UNKNOWN":
    3695                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    3696
    3697            try:
    3698                data_type_exp = parse_one(dtype, read=dialect, into=DataType)
    3699            except ParseError:
    3700                if udt:
    3701                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    3702                raise
    3703        elif isinstance(dtype, DataType.Type):
    3704            data_type_exp = DataType(this=dtype)
    3705        elif isinstance(dtype, DataType):
    3706            return dtype
    3707        else:
    3708            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    3709
    3710        return DataType(**{**data_type_exp.args, **kwargs})
    3711
    3712    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3713        """
    3714        Checks whether this DataType matches one of the provided data types. Nested types or precision
    3715        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    3716
    3717        Args:
    3718            dtypes: the data types to compare this DataType to.
    3719
    3720        Returns:
    3721            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    3722        """
    3723        for dtype in dtypes:
    3724            other = DataType.build(dtype, udt=True)
    3725
    3726            if (
    3727                other.expressions
    3728                or self.this == DataType.Type.USERDEFINED
    3729                or other.this == DataType.Type.USERDEFINED
    3730            ):
    3731                matches = self == other
    3732            else:
    3733                matches = self.this == other.this
    3734
    3735            if matches:
    3736                return True
    3737        return False

arg_types = {'this': True, 'expressions': False, 'nested': False, 'values': False, 'prefix': False, 'kind': False}
TEXT_TYPES = {<Type.CHAR: 'CHAR'>, <Type.NVARCHAR: 'NVARCHAR'>, <Type.VARCHAR: 'VARCHAR'>, <Type.TEXT: 'TEXT'>, <Type.NCHAR: 'NCHAR'>}
INTEGER_TYPES = {<Type.INT: 'INT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.TINYINT: 'TINYINT'>, <Type.INT256: 'INT256'>, <Type.BIGINT: 'BIGINT'>, <Type.INT128: 'INT128'>}
FLOAT_TYPES = {<Type.FLOAT: 'FLOAT'>, <Type.DOUBLE: 'DOUBLE'>}
NUMERIC_TYPES = {<Type.SMALLINT: 'SMALLINT'>, <Type.TINYINT: 'TINYINT'>, <Type.INT256: 'INT256'>, <Type.BIGINT: 'BIGINT'>, <Type.INT128: 'INT128'>, <Type.FLOAT: 'FLOAT'>, <Type.DOUBLE: 'DOUBLE'>, <Type.INT: 'INT'>}
TEMPORAL_TYPES = {<Type.TIMESTAMP: 'TIMESTAMP'>, <Type.DATE: 'DATE'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <Type.TIMETZ: 'TIMETZ'>, <Type.DATETIME64: 'DATETIME64'>, <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIME: 'TIME'>, <Type.DATETIME: 'DATETIME'>}
@classmethod
def build( cls, dtype: str | DataType | DataType.Type, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, udt: bool = False, **kwargs) -> DataType: View Source

    3670    @classmethod
    3671    def build(
    3672        cls,
    3673        dtype: str | DataType | DataType.Type,
    3674        dialect: DialectType = None,
    3675        udt: bool = False,
    3676        **kwargs,
    3677    ) -> DataType:
    3678        """
    3679        Constructs a DataType object.
    3680
    3681        Args:
    3682            dtype: the data type of interest.
    3683            dialect: the dialect to use for parsing `dtype`, in case it's a string.
    3684            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
    3685                DataType, thus creating a user-defined type.
    3686            kawrgs: additional arguments to pass in the constructor of DataType.
    3687
    3688        Returns:
    3689            The constructed DataType object.
    3690        """
    3691        from sqlglot import parse_one
    3692
    3693        if isinstance(dtype, str):
    3694            if dtype.upper() == "UNKNOWN":
    3695                return DataType(this=DataType.Type.UNKNOWN, **kwargs)
    3696
    3697            try:
    3698                data_type_exp = parse_one(dtype, read=dialect, into=DataType)
    3699            except ParseError:
    3700                if udt:
    3701                    return DataType(this=DataType.Type.USERDEFINED, kind=dtype, **kwargs)
    3702                raise
    3703        elif isinstance(dtype, DataType.Type):
    3704            data_type_exp = DataType(this=dtype)
    3705        elif isinstance(dtype, DataType):
    3706            return dtype
    3707        else:
    3708            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DataType.Type")
    3709
    3710        return DataType(**{**data_type_exp.args, **kwargs})

Constructs a DataType object.

###### Arguments:

- dtype: the data type of interest.
- dialect: the dialect to use for parsing `dtype`, in case it's a string.
- udt: when set to True, `dtype` will be used as-is if it can't be parsed into a DataType, thus creating a user-defined type.
- kawrgs: additional arguments to pass in the constructor of DataType.

###### Returns:

> The constructed DataType object.

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

    3712    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    3713        """
    3714        Checks whether this DataType matches one of the provided data types. Nested types or precision
    3715        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
    3716
    3717        Args:
    3718            dtypes: the data types to compare this DataType to.
    3719
    3720        Returns:
    3721            True, if and only if there is a type in `dtypes` which is equal to this DataType.
    3722        """
    3723        for dtype in dtypes:
    3724            other = DataType.build(dtype, udt=True)
    3725
    3726            if (
    3727                other.expressions
    3728                or self.this == DataType.Type.USERDEFINED
    3729                or other.this == DataType.Type.USERDEFINED
    3730            ):
    3731                matches = self == other
    3732            else:
    3733                matches = self.this == other.this
    3734
    3735            if matches:
    3736                return True
    3737        return False

Checks whether this DataType matches one of the provided data types. Nested types or precision will be compared using "structural equivalence" semantics, so e.g. array != array.

###### Arguments:

- dtypes: the data types to compare this DataType to.

###### Returns:

> True, if and only if there is a type in `dtypes` which is equal to this DataType.

key = 'datatype'

##### Inherited Members

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

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

    3538    class Type(AutoName):
    3539        ARRAY = auto()
    3540        BIGDECIMAL = auto()
    3541        BIGINT = auto()
    3542        BIGSERIAL = auto()
    3543        BINARY = auto()
    3544        BIT = auto()
    3545        BOOLEAN = auto()
    3546        CHAR = auto()
    3547        DATE = auto()
    3548        DATEMULTIRANGE = auto()
    3549        DATERANGE = auto()
    3550        DATETIME = auto()
    3551        DATETIME64 = auto()
    3552        DECIMAL = auto()
    3553        DOUBLE = auto()
    3554        ENUM = auto()
    3555        ENUM8 = auto()
    3556        ENUM16 = auto()
    3557        FIXEDSTRING = auto()
    3558        FLOAT = auto()
    3559        GEOGRAPHY = auto()
    3560        GEOMETRY = auto()
    3561        HLLSKETCH = auto()
    3562        HSTORE = auto()
    3563        IMAGE = auto()
    3564        INET = auto()
    3565        INT = auto()
    3566        INT128 = auto()
    3567        INT256 = auto()
    3568        INT4MULTIRANGE = auto()
    3569        INT4RANGE = auto()
    3570        INT8MULTIRANGE = auto()
    3571        INT8RANGE = auto()
    3572        INTERVAL = auto()
    3573        IPADDRESS = auto()
    3574        IPPREFIX = auto()
    3575        JSON = auto()
    3576        JSONB = auto()
    3577        LONGBLOB = auto()
    3578        LONGTEXT = auto()
    3579        LOWCARDINALITY = auto()
    3580        MAP = auto()
    3581        MEDIUMBLOB = auto()
    3582        MEDIUMINT = auto()
    3583        MEDIUMTEXT = auto()
    3584        MONEY = auto()
    3585        NCHAR = auto()
    3586        NESTED = auto()
    3587        NULL = auto()
    3588        NULLABLE = auto()
    3589        NUMMULTIRANGE = auto()
    3590        NUMRANGE = auto()
    3591        NVARCHAR = auto()
    3592        OBJECT = auto()
    3593        ROWVERSION = auto()
    3594        SERIAL = auto()
    3595        SET = auto()
    3596        SMALLINT = auto()
    3597        SMALLMONEY = auto()
    3598        SMALLSERIAL = auto()
    3599        STRUCT = auto()
    3600        SUPER = auto()
    3601        TEXT = auto()
    3602        TINYBLOB = auto()
    3603        TINYTEXT = auto()
    3604        TIME = auto()
    3605        TIMETZ = auto()
    3606        TIMESTAMP = auto()
    3607        TIMESTAMPLTZ = auto()
    3608        TIMESTAMPTZ = auto()
    3609        TINYINT = auto()
    3610        TSMULTIRANGE = auto()
    3611        TSRANGE = auto()
    3612        TSTZMULTIRANGE = auto()
    3613        TSTZRANGE = auto()
    3614        UBIGINT = auto()
    3615        UINT = auto()
    3616        UINT128 = auto()
    3617        UINT256 = auto()
    3618        UMEDIUMINT = auto()
    3619        UDECIMAL = auto()
    3620        UNIQUEIDENTIFIER = auto()
    3621        UNKNOWN = auto()  # Sentinel value, useful for type annotation
    3622        USERDEFINED = "USER-DEFINED"
    3623        USMALLINT = auto()
    3624        UTINYINT = auto()
    3625        UUID = auto()
    3626        VARBINARY = auto()
    3627        VARCHAR = auto()
    3628        VARIANT = auto()
    3629        XML = auto()
    3630        YEAR = 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'>
DATEMULTIRANGE = <Type.DATEMULTIRANGE: 'DATEMULTIRANGE'>
DATERANGE = <Type.DATERANGE: 'DATERANGE'>
DATETIME = <Type.DATETIME: 'DATETIME'>
DATETIME64 = <Type.DATETIME64: 'DATETIME64'>
DECIMAL = <Type.DECIMAL: 'DECIMAL'>
DOUBLE = <Type.DOUBLE: 'DOUBLE'>
ENUM = <Type.ENUM: 'ENUM'>
ENUM8 = <Type.ENUM8: 'ENUM8'>
ENUM16 = <Type.ENUM16: 'ENUM16'>
FIXEDSTRING = <Type.FIXEDSTRING: 'FIXEDSTRING'>
FLOAT = <Type.FLOAT: 'FLOAT'>
GEOGRAPHY = <Type.GEOGRAPHY: 'GEOGRAPHY'>
GEOMETRY = <Type.GEOMETRY: 'GEOMETRY'>
HLLSKETCH = <Type.HLLSKETCH: 'HLLSKETCH'>
HSTORE = <Type.HSTORE: 'HSTORE'>
IMAGE = <Type.IMAGE: 'IMAGE'>
INET = <Type.INET: 'INET'>
INT = <Type.INT: 'INT'>
INT128 = <Type.INT128: 'INT128'>
INT256 = <Type.INT256: 'INT256'>
INT4MULTIRANGE = <Type.INT4MULTIRANGE: 'INT4MULTIRANGE'>
INT4RANGE = <Type.INT4RANGE: 'INT4RANGE'>
INT8MULTIRANGE = <Type.INT8MULTIRANGE: 'INT8MULTIRANGE'>
INT8RANGE = <Type.INT8RANGE: 'INT8RANGE'>
INTERVAL = <Type.INTERVAL: 'INTERVAL'>
IPADDRESS = <Type.IPADDRESS: 'IPADDRESS'>
IPPREFIX = <Type.IPPREFIX: 'IPPREFIX'>
JSON = <Type.JSON: 'JSON'>
JSONB = <Type.JSONB: 'JSONB'>
LONGBLOB = <Type.LONGBLOB: 'LONGBLOB'>
LONGTEXT = <Type.LONGTEXT: 'LONGTEXT'>
LOWCARDINALITY = <Type.LOWCARDINALITY: 'LOWCARDINALITY'>
MAP = <Type.MAP: 'MAP'>
MEDIUMBLOB = <Type.MEDIUMBLOB: 'MEDIUMBLOB'>
MEDIUMINT = <Type.MEDIUMINT: 'MEDIUMINT'>
MEDIUMTEXT = <Type.MEDIUMTEXT: 'MEDIUMTEXT'>
MONEY = <Type.MONEY: 'MONEY'>
NCHAR = <Type.NCHAR: 'NCHAR'>
NESTED = <Type.NESTED: 'NESTED'>
NULL = <Type.NULL: 'NULL'>
NULLABLE = <Type.NULLABLE: 'NULLABLE'>
NUMMULTIRANGE = <Type.NUMMULTIRANGE: 'NUMMULTIRANGE'>
NUMRANGE = <Type.NUMRANGE: 'NUMRANGE'>
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'>
TINYBLOB = <Type.TINYBLOB: 'TINYBLOB'>
TINYTEXT = <Type.TINYTEXT: 'TINYTEXT'>
TIME = <Type.TIME: 'TIME'>
TIMETZ = <Type.TIMETZ: 'TIMETZ'>
TIMESTAMP = <Type.TIMESTAMP: 'TIMESTAMP'>
TIMESTAMPLTZ = <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>
TIMESTAMPTZ = <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>
TINYINT = <Type.TINYINT: 'TINYINT'>
TSMULTIRANGE = <Type.TSMULTIRANGE: 'TSMULTIRANGE'>
TSRANGE = <Type.TSRANGE: 'TSRANGE'>
TSTZMULTIRANGE = <Type.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>
TSTZRANGE = <Type.TSTZRANGE: 'TSTZRANGE'>
UBIGINT = <Type.UBIGINT: 'UBIGINT'>
UINT = <Type.UINT: 'UINT'>
UINT128 = <Type.UINT128: 'UINT128'>
UINT256 = <Type.UINT256: 'UINT256'>
UMEDIUMINT = <Type.UMEDIUMINT: 'UMEDIUMINT'>
UDECIMAL = <Type.UDECIMAL: 'UDECIMAL'>
UNIQUEIDENTIFIER = <Type.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>
UNKNOWN = <Type.UNKNOWN: 'UNKNOWN'>
USERDEFINED = <Type.USERDEFINED: 'USER-DEFINED'>
USMALLINT = <Type.USMALLINT: 'USMALLINT'>
UTINYINT = <Type.UTINYINT: 'UTINYINT'>
UUID = <Type.UUID: 'UUID'>
VARBINARY = <Type.VARBINARY: 'VARBINARY'>
VARCHAR = <Type.VARCHAR: 'VARCHAR'>
VARIANT = <Type.VARIANT: 'VARIANT'>
XML = <Type.XML: 'XML'>
YEAR = <Type.YEAR: 'YEAR'>

##### Inherited Members

enum.Enum
  name
  value

class PseudoType(DataType): View Source

    3741class PseudoType(DataType):
    3742    arg_types = {"this": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
DataType
  Type
  TEXT_TYPES
  INTEGER_TYPES
  FLOAT_TYPES
  NUMERIC_TYPES
  TEMPORAL_TYPES
  build
  is_type

class ObjectIdentifier(DataType): View Source

    3746class ObjectIdentifier(DataType):
    3747    arg_types = {"this": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
DataType
  Type
  TEXT_TYPES
  INTEGER_TYPES
  FLOAT_TYPES
  NUMERIC_TYPES
  TEMPORAL_TYPES
  build
  is_type

class SubqueryPredicate(Predicate): View Source

    3751class SubqueryPredicate(Predicate):
    3752    pass

key = 'subquerypredicate'

##### Inherited Members

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

class All(SubqueryPredicate): View Source

    3755class All(SubqueryPredicate):
    3756    pass

key = 'all'

##### Inherited Members

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

class Any(SubqueryPredicate): View Source

    3759class Any(SubqueryPredicate):
    3760    pass

key = 'any'

##### Inherited Members

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

class Exists(SubqueryPredicate): View Source

    3763class Exists(SubqueryPredicate):
    3764    pass

key = 'exists'

##### Inherited Members

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

class Command(Expression): View Source

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

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

##### Inherited Members

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

class Transaction(Expression): View Source

    3773class Transaction(Expression):
    3774    arg_types = {"this": False, "modes": False, "mark": False}

arg_types = {'this': False, 'modes': False, 'mark': False}
key = 'transaction'

##### Inherited Members

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

class Commit(Expression): View Source

    3777class Commit(Expression):
    3778    arg_types = {"chain": False, "this": False, "durability": False}

arg_types = {'chain': False, 'this': False, 'durability': False}
key = 'commit'

##### Inherited Members

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

class Rollback(Expression): View Source

    3781class Rollback(Expression):
    3782    arg_types = {"savepoint": False, "this": False}

arg_types = {'savepoint': False, 'this': False}
key = 'rollback'

##### Inherited Members

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

class AlterTable(Expression): View Source

    3785class AlterTable(Expression):
    3786    arg_types = {"this": True, "actions": True, "exists": False, "only": False}

arg_types = {'this': True, 'actions': True, 'exists': False, 'only': False}
key = 'altertable'

##### Inherited Members

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

class AddConstraint(Expression): View Source

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

arg_types = {'this': False, 'expression': False, 'enforced': False}
key = 'addconstraint'

##### Inherited Members

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

class DropPartition(Expression): View Source

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

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

##### Inherited Members

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

class Binary(Condition): View Source

    3798class Binary(Condition):
    3799    arg_types = {"this": True, "expression": True}
    3800
    3801    @property
    3802    def left(self):
    3803        return self.this
    3804
    3805    @property
    3806    def right(self):
    3807        return self.expression

arg_types = {'this': True, 'expression': True}
left
right
key = 'binary'

##### Inherited Members

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

class Add(Binary): View Source

    3810class Add(Binary):
    3811    pass

key = 'add'

##### Inherited Members

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

class Connector(Binary): View Source

    3814class Connector(Binary):
    3815    pass

key = 'connector'

##### Inherited Members

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

class And(Connector): View Source

    3818class And(Connector):
    3819    pass

key = 'and'

##### Inherited Members

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

class Or(Connector): View Source

    3822class Or(Connector):
    3823    pass

key = 'or'

##### Inherited Members

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

class BitwiseAnd(Binary): View Source

    3826class BitwiseAnd(Binary):
    3827    pass

key = 'bitwiseand'

##### Inherited Members

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

class BitwiseLeftShift(Binary): View Source

    3830class BitwiseLeftShift(Binary):
    3831    pass

key = 'bitwiseleftshift'

##### Inherited Members

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

class BitwiseOr(Binary): View Source

    3834class BitwiseOr(Binary):
    3835    pass

key = 'bitwiseor'

##### Inherited Members

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

class BitwiseRightShift(Binary): View Source

    3838class BitwiseRightShift(Binary):
    3839    pass

key = 'bitwiserightshift'

##### Inherited Members

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

class BitwiseXor(Binary): View Source

    3842class BitwiseXor(Binary):
    3843    pass

key = 'bitwisexor'

##### Inherited Members

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

class Div(Binary): View Source

    3846class Div(Binary):
    3847    pass

key = 'div'

##### Inherited Members

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

class Overlaps(Binary): View Source

    3850class Overlaps(Binary):
    3851    pass

key = 'overlaps'

##### Inherited Members

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

class Dot(Binary): View Source

    3854class Dot(Binary):
    3855    @property
    3856    def name(self) -> str:
    3857        return self.expression.name
    3858
    3859    @property
    3860    def output_name(self) -> str:
    3861        return self.name
    3862
    3863    @classmethod
    3864    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    3865        """Build a Dot object with a sequence of expressions."""
    3866        if len(expressions) < 2:
    3867            raise ValueError(f"Dot requires >= 2 expressions.")
    3868
    3869        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))

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

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

    3863    @classmethod
    3864    def build(self, expressions: t.Sequence[Expression]) -> Dot:
    3865        """Build a Dot object with a sequence of expressions."""
    3866        if len(expressions) < 2:
    3867            raise ValueError(f"Dot requires >= 2 expressions.")
    3868
    3869        return t.cast(Dot, reduce(lambda x, y: Dot(this=x, expression=y), expressions))

Build a Dot object with a sequence of expressions.

key = 'dot'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  alias_or_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right

class DPipe(Binary): View Source

    3872class DPipe(Binary):
    3873    pass

key = 'dpipe'

##### Inherited Members

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

class SafeDPipe(DPipe): View Source

    3876class SafeDPipe(DPipe):
    3877    pass

key = 'safedpipe'

##### Inherited Members

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

class EQ(Binary, Predicate): View Source

    3880class EQ(Binary, Predicate):
    3881    pass

key = 'eq'

##### Inherited Members

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

class NullSafeEQ(Binary, Predicate): View Source

    3884class NullSafeEQ(Binary, Predicate):
    3885    pass

key = 'nullsafeeq'

##### Inherited Members

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

class NullSafeNEQ(Binary, Predicate): View Source

    3888class NullSafeNEQ(Binary, Predicate):
    3889    pass

key = 'nullsafeneq'

##### Inherited Members

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

class Distance(Binary): View Source

    3892class Distance(Binary):
    3893    pass

key = 'distance'

##### Inherited Members

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

class Escape(Binary): View Source

    3896class Escape(Binary):
    3897    pass

key = 'escape'

##### Inherited Members

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

class Glob(Binary, Predicate): View Source

    3900class Glob(Binary, Predicate):
    3901    pass

key = 'glob'

##### Inherited Members

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

class GT(Binary, Predicate): View Source

    3904class GT(Binary, Predicate):
    3905    pass

key = 'gt'

##### Inherited Members

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

class GTE(Binary, Predicate): View Source

    3908class GTE(Binary, Predicate):
    3909    pass

key = 'gte'

##### Inherited Members

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

class ILike(Binary, Predicate): View Source

    3912class ILike(Binary, Predicate):
    3913    pass

key = 'ilike'

##### Inherited Members

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

class ILikeAny(Binary, Predicate): View Source

    3916class ILikeAny(Binary, Predicate):
    3917    pass

key = 'ilikeany'

##### Inherited Members

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

class IntDiv(Binary): View Source

    3920class IntDiv(Binary):
    3921    pass

key = 'intdiv'

##### Inherited Members

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

class Is(Binary, Predicate): View Source

    3924class Is(Binary, Predicate):
    3925    pass

key = 'is'

##### Inherited Members

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

class Kwarg(Binary): View Source

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

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

key = 'kwarg'

##### Inherited Members

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

class Like(Binary, Predicate): View Source

    3932class Like(Binary, Predicate):
    3933    pass

key = 'like'

##### Inherited Members

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

class LikeAny(Binary, Predicate): View Source

    3936class LikeAny(Binary, Predicate):
    3937    pass

key = 'likeany'

##### Inherited Members

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

class LT(Binary, Predicate): View Source

    3940class LT(Binary, Predicate):
    3941    pass

key = 'lt'

##### Inherited Members

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

class LTE(Binary, Predicate): View Source

    3944class LTE(Binary, Predicate):
    3945    pass

key = 'lte'

##### Inherited Members

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

class Mod(Binary): View Source

    3948class Mod(Binary):
    3949    pass

key = 'mod'

##### Inherited Members

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

class Mul(Binary): View Source

    3952class Mul(Binary):
    3953    pass

key = 'mul'

##### Inherited Members

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

class NEQ(Binary, Predicate): View Source

    3956class NEQ(Binary, Predicate):
    3957    pass

key = 'neq'

##### Inherited Members

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

class SimilarTo(Binary, Predicate): View Source

    3960class SimilarTo(Binary, Predicate):
    3961    pass

key = 'similarto'

##### Inherited Members

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

class Slice(Binary): View Source

    3964class Slice(Binary):
    3965    arg_types = {"this": False, "expression": False}

arg_types = {'this': False, 'expression': False}
key = 'slice'

##### Inherited Members

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

class Sub(Binary): View Source

    3968class Sub(Binary):
    3969    pass

key = 'sub'

##### Inherited Members

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

class ArrayOverlaps(Binary): View Source

    3972class ArrayOverlaps(Binary):
    3973    pass

key = 'arrayoverlaps'

##### Inherited Members

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

class Unary(Condition): View Source

    3978class Unary(Condition):
    3979    pass

key = 'unary'

##### Inherited Members

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

class BitwiseNot(Unary): View Source

    3982class BitwiseNot(Unary):
    3983    pass

key = 'bitwisenot'

##### Inherited Members

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

class Not(Unary): View Source

    3986class Not(Unary):
    3987    pass

key = 'not'

##### Inherited Members

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

class Paren(Unary): View Source

    3990class Paren(Unary):
    3991    arg_types = {"this": True, "with": False}
    3992
    3993    @property
    3994    def output_name(self) -> str:
    3995        return self.this.name

arg_types = {'this': True, 'with': False}
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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'paren'

##### Inherited Members

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

class Neg(Unary): View Source

    3998class Neg(Unary):
    3999    pass

key = 'neg'

##### Inherited Members

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

class Alias(Expression): View Source

    4002class Alias(Expression):
    4003    arg_types = {"this": True, "alias": False}
    4004
    4005    @property
    4006    def output_name(self) -> str:
    4007        return self.alias

arg_types = {'this': True, 'alias': False}
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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'alias'

##### Inherited Members

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

class Aliases(Expression): View Source

    4010class Aliases(Expression):
    4011    arg_types = {"this": True, "expressions": True}
    4012
    4013    @property
    4014    def aliases(self):
    4015        return self.expressions

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

##### Inherited Members

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

class AtTimeZone(Expression): View Source

    4018class AtTimeZone(Expression):
    4019    arg_types = {"this": True, "zone": True}

arg_types = {'this': True, 'zone': True}
key = 'attimezone'

##### Inherited Members

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

class Between(Predicate): View Source

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

arg_types = {'this': True, 'low': True, 'high': True}
key = 'between'

##### Inherited Members

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

class Bracket(Condition): View Source

    4026class Bracket(Condition):
    4027    arg_types = {"this": True, "expressions": True}
    4028
    4029    @property
    4030    def output_name(self) -> str:
    4031        if len(self.expressions) == 1:
    4032            return self.expressions[0].output_name
    4033
    4034        return super().output_name

arg_types = {'this': True, 'expressions': 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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

key = 'bracket'

##### Inherited Members

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

class SafeBracket(Bracket): View Source

    4037class SafeBracket(Bracket):
    4038    """Represents array lookup where OOB index yields NULL instead of causing a failure."""

Represents array lookup where OOB index yields NULL instead of causing a failure.

key = 'safebracket'

##### Inherited Members

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

class Distinct(Expression): View Source

    4041class Distinct(Expression):
    4042    arg_types = {"expressions": False, "on": False}

arg_types = {'expressions': False, 'on': False}
key = 'distinct'

##### Inherited Members

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

class In(Predicate): View Source

    4045class In(Predicate):
    4046    arg_types = {
    4047        "this": True,
    4048        "expressions": False,
    4049        "query": False,
    4050        "unnest": False,
    4051        "field": False,
    4052        "is_global": False,
    4053    }

arg_types = {'this': True, 'expressions': False, 'query': False, 'unnest': False, 'field': False, 'is_global': False}
key = 'in'

##### Inherited Members

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

class TimeUnit(Expression): View Source

    4056class TimeUnit(Expression):
    4057    """Automatically converts unit arg into a var."""
    4058
    4059    arg_types = {"unit": False}
    4060
    4061    def __init__(self, **args):
    4062        unit = args.get("unit")
    4063        if isinstance(unit, (Column, Literal)):
    4064            args["unit"] = Var(this=unit.name)
    4065        elif isinstance(unit, Week):
    4066            unit.set("this", Var(this=unit.this.name))
    4067
    4068        super().__init__(**args)
    4069
    4070    @property
    4071    def unit(self) -> t.Optional[Var]:
    4072        return self.args.get("unit")

Automatically converts unit arg into a var.

TimeUnit(**args) View Source

    4061    def __init__(self, **args):
    4062        unit = args.get("unit")
    4063        if isinstance(unit, (Column, Literal)):
    4064            args["unit"] = Var(this=unit.name)
    4065        elif isinstance(unit, Week):
    4066            unit.set("this", Var(this=unit.this.name))
    4067
    4068        super().__init__(**args)

arg_types = {'unit': False}
unit: Optional[Var]
key = 'timeunit'

##### Inherited Members

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

class IntervalOp(TimeUnit): View Source

    4075class IntervalOp(TimeUnit):
    4076    arg_types = {"unit": True, "expression": True}
    4077
    4078    def interval(self):
    4079        return Interval(
    4080            this=self.expression.copy(),
    4081            unit=self.unit.copy(),
    4082        )

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

    4078    def interval(self):
    4079        return Interval(
    4080            this=self.expression.copy(),
    4081            unit=self.unit.copy(),
    4082        )

key = 'intervalop'

##### Inherited Members

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

class IntervalSpan(DataType): View Source

    4088class IntervalSpan(DataType):
    4089    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
DataType
  Type
  TEXT_TYPES
  INTEGER_TYPES
  FLOAT_TYPES
  NUMERIC_TYPES
  TEMPORAL_TYPES
  build
  is_type

class Interval(TimeUnit): View Source

    4092class Interval(TimeUnit):
    4093    arg_types = {"this": False, "unit": False}

arg_types = {'this': False, 'unit': False}
key = 'interval'

##### Inherited Members

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

class IgnoreNulls(Expression): View Source

    4096class IgnoreNulls(Expression):
    4097    pass

key = 'ignorenulls'

##### Inherited Members

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

class RespectNulls(Expression): View Source

    4100class RespectNulls(Expression):
    4101    pass

key = 'respectnulls'

##### Inherited Members

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

class Func(Condition): View Source

    4105class Func(Condition):
    4106    """
    4107    The base class for all function expressions.
    4108
    4109    Attributes:
    4110        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
    4111            treated as a variable length argument and the argument's value will be stored as a list.
    4112        _sql_names (list): determines the SQL name (1st item in the list) and aliases (subsequent items)
    4113            for this function expression. These values are used to map this node to a name during parsing
    4114            as well as to provide the function's name during SQL string generation. By default the SQL
    4115            name is set to the expression's class name transformed to snake case.
    4116    """
    4117
    4118    is_var_len_args = False
    4119
    4120    @classmethod
    4121    def from_arg_list(cls, args):
    4122        if cls.is_var_len_args:
    4123            all_arg_keys = list(cls.arg_types)
    4124            # If this function supports variable length argument treat the last argument as such.
    4125            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    4126            num_non_var = len(non_var_len_arg_keys)
    4127
    4128            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    4129            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    4130        else:
    4131            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    4132
    4133        return cls(**args_dict)
    4134
    4135    @classmethod
    4136    def sql_names(cls):
    4137        if cls is Func:
    4138            raise NotImplementedError(
    4139                "SQL name is only supported by concrete function implementations"
    4140            )
    4141        if "_sql_names" not in cls.__dict__:
    4142            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    4143        return cls._sql_names
    4144
    4145    @classmethod
    4146    def sql_name(cls):
    4147        return cls.sql_names()[0]
    4148
    4149    @classmethod
    4150    def default_parser_mappings(cls):
    4151        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.

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

    4120    @classmethod
    4121    def from_arg_list(cls, args):
    4122        if cls.is_var_len_args:
    4123            all_arg_keys = list(cls.arg_types)
    4124            # If this function supports variable length argument treat the last argument as such.
    4125            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
    4126            num_non_var = len(non_var_len_arg_keys)
    4127
    4128            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
    4129            args_dict[all_arg_keys[-1]] = args[num_non_var:]
    4130        else:
    4131            args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
    4132
    4133        return cls(**args_dict)

@classmethod
def sql_names(cls): View Source

    4135    @classmethod
    4136    def sql_names(cls):
    4137        if cls is Func:
    4138            raise NotImplementedError(
    4139                "SQL name is only supported by concrete function implementations"
    4140            )
    4141        if "_sql_names" not in cls.__dict__:
    4142            cls._sql_names = [camel_to_snake_case(cls.__name__)]
    4143        return cls._sql_names

@classmethod
def sql_name(cls): View Source

    4145    @classmethod
    4146    def sql_name(cls):
    4147        return cls.sql_names()[0]

@classmethod
def default_parser_mappings(cls): View Source

    4149    @classmethod
    4150    def default_parser_mappings(cls):
    4151        return {name: cls.from_arg_list for name in cls.sql_names()}

key = 'func'

##### Inherited Members

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

class AggFunc(Func): View Source

    4154class AggFunc(Func):
    4155    pass

key = 'aggfunc'

##### Inherited Members

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

class ParameterizedAgg(AggFunc): View Source

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

arg_types = {'this': True, 'expressions': True, 'params': True}
key = 'parameterizedagg'

##### Inherited Members

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

class Abs(Func): View Source

    4162class Abs(Func):
    4163    pass

key = 'abs'

##### Inherited Members

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

class Transform(Func): View Source

    4167class Transform(Func):
    4168    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Anonymous(Func): View Source

    4171class Anonymous(Func):
    4172    arg_types = {"this": True, "expressions": False}
    4173    is_var_len_args = True

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

##### Inherited Members

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

class Hll(AggFunc): View Source

    4178class Hll(AggFunc):
    4179    arg_types = {"this": True, "expressions": False}
    4180    is_var_len_args = True

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

##### Inherited Members

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

class ApproxDistinct(AggFunc): View Source

    4183class ApproxDistinct(AggFunc):
    4184    arg_types = {"this": True, "accuracy": False}
    4185    _sql_names = ["APPROX_DISTINCT", "APPROX_COUNT_DISTINCT"]

arg_types = {'this': True, 'accuracy': False}
key = 'approxdistinct'

##### Inherited Members

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

class Array(Func): View Source

    4188class Array(Func):
    4189    arg_types = {"expressions": False}
    4190    is_var_len_args = True

arg_types = {'expressions': False}
is_var_len_args = True
key = 'array'

##### Inherited Members

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

class ToChar(Func): View Source

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

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

##### Inherited Members

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

class GenerateSeries(Func): View Source

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

arg_types = {'start': True, 'end': True, 'step': False}
key = 'generateseries'

##### Inherited Members

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

class ArrayAgg(AggFunc): View Source

    4202class ArrayAgg(AggFunc):
    4203    pass

key = 'arrayagg'

##### Inherited Members

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

class ArrayAll(Func): View Source

    4206class ArrayAll(Func):
    4207    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class ArrayAny(Func): View Source

    4210class ArrayAny(Func):
    4211    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class ArrayConcat(Func): View Source

    4214class ArrayConcat(Func):
    4215    _sql_names = ["ARRAY_CONCAT", "ARRAY_CAT"]
    4216    arg_types = {"this": True, "expressions": False}
    4217    is_var_len_args = True

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

##### Inherited Members

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

class ArrayContains(Binary, Func): View Source

    4220class ArrayContains(Binary, Func):
    4221    pass

key = 'arraycontains'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ArrayContained(Binary): View Source

    4224class ArrayContained(Binary):
    4225    pass

key = 'arraycontained'

##### Inherited Members

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

class ArrayFilter(Func): View Source

    4228class ArrayFilter(Func):
    4229    arg_types = {"this": True, "expression": True}
    4230    _sql_names = ["FILTER", "ARRAY_FILTER"]

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

##### Inherited Members

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

class ArrayJoin(Func): View Source

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

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

##### Inherited Members

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

class ArraySize(Func): View Source

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

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

##### Inherited Members

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

class ArraySort(Func): View Source

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

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

##### Inherited Members

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

class ArraySum(Func): View Source

    4245class ArraySum(Func):
    4246    pass

key = 'arraysum'

##### Inherited Members

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

class ArrayUnionAgg(AggFunc): View Source

    4249class ArrayUnionAgg(AggFunc):
    4250    pass

key = 'arrayunionagg'

##### Inherited Members

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

class Avg(AggFunc): View Source

    4253class Avg(AggFunc):
    4254    pass

key = 'avg'

##### Inherited Members

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

class AnyValue(AggFunc): View Source

    4257class AnyValue(AggFunc):
    4258    arg_types = {"this": True, "having": False, "max": False, "ignore_nulls": False}

arg_types = {'this': True, 'having': False, 'max': False, 'ignore_nulls': False}
key = 'anyvalue'

##### Inherited Members

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

class First(Func): View Source

    4261class First(Func):
    4262    arg_types = {"this": True, "ignore_nulls": False}

arg_types = {'this': True, 'ignore_nulls': False}
key = 'first'

##### Inherited Members

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

class Last(Func): View Source

    4265class Last(Func):
    4266    arg_types = {"this": True, "ignore_nulls": False}

arg_types = {'this': True, 'ignore_nulls': False}
key = 'last'

##### Inherited Members

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

class Case(Func): View Source

    4269class Case(Func):
    4270    arg_types = {"this": False, "ifs": True, "default": False}
    4271
    4272    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    4273        instance = maybe_copy(self, copy)
    4274        instance.append(
    4275            "ifs",
    4276            If(
    4277                this=maybe_parse(condition, copy=copy, **opts),
    4278                true=maybe_parse(then, copy=copy, **opts),
    4279            ),
    4280        )
    4281        return instance
    4282
    4283    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    4284        instance = maybe_copy(self, copy)
    4285        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    4286        return instance

arg_types = {'this': False, 'ifs': True, 'default': False}
def when( self, condition: Union[str, Expression], then: Union[str, Expression], copy: bool = True, **opts) -> Case: View Source

    4272    def when(self, condition: ExpOrStr, then: ExpOrStr, copy: bool = True, **opts) -> Case:
    4273        instance = maybe_copy(self, copy)
    4274        instance.append(
    4275            "ifs",
    4276            If(
    4277                this=maybe_parse(condition, copy=copy, **opts),
    4278                true=maybe_parse(then, copy=copy, **opts),
    4279            ),
    4280        )
    4281        return instance

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

    4283    def else_(self, condition: ExpOrStr, copy: bool = True, **opts) -> Case:
    4284        instance = maybe_copy(self, copy)
    4285        instance.set("default", maybe_parse(condition, copy=copy, **opts))
    4286        return instance

key = 'case'

##### Inherited Members

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

class Cast(Func): View Source

    4289class Cast(Func):
    4290    arg_types = {"this": True, "to": True, "format": False}
    4291
    4292    @property
    4293    def name(self) -> str:
    4294        return self.this.name
    4295
    4296    @property
    4297    def to(self) -> DataType:
    4298        return self.args["to"]
    4299
    4300    @property
    4301    def output_name(self) -> str:
    4302        return self.name
    4303
    4304    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    4305        """
    4306        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    4307        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    4308        array<int> != array<float>.
    4309
    4310        Args:
    4311            dtypes: the data types to compare this Cast's DataType to.
    4312
    4313        Returns:
    4314            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    4315        """
    4316        return self.to.is_type(*dtypes)

arg_types = {'this': True, 'to': True, 'format': False}
name: str
to: DataType
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")sqlglot.expressions[0].output_name
>     'a'
>     >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name
>     'c'
>     >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name
>     ''

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

    4304    def is_type(self, *dtypes: str | DataType | DataType.Type) -> bool:
    4305        """
    4306        Checks whether this Cast's DataType matches one of the provided data types. Nested types
    4307        like arrays or structs will be compared using "structural equivalence" semantics, so e.g.
    4308        array<int> != array<float>.
    4309
    4310        Args:
    4311            dtypes: the data types to compare this Cast's DataType to.
    4312
    4313        Returns:
    4314            True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.
    4315        """
    4316        return self.to.is_type(*dtypes)

Checks whether this Cast's DataType matches one of the provided data types. Nested types like arrays or structs will be compared using "structural equivalence" semantics, so e.g. array != array.

###### Arguments:

- dtypes: the data types to compare this Cast's DataType to.

###### Returns:

> True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType.

key = 'cast'

##### Inherited Members

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

class TryCast(Cast): View Source

    4319class TryCast(Cast):
    4320    pass

key = 'trycast'

##### Inherited Members

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

class CastToStrType(Func): View Source

    4323class CastToStrType(Func):
    4324    arg_types = {"this": True, "to": True}

arg_types = {'this': True, 'to': True}
key = 'casttostrtype'

##### Inherited Members

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

class Collate(Binary, Func): View Source

    4327class Collate(Binary, Func):
    4328    pass

key = 'collate'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Ceil(Func): View Source

    4331class Ceil(Func):
    4332    arg_types = {"this": True, "decimals": False}
    4333    _sql_names = ["CEIL", "CEILING"]

arg_types = {'this': True, 'decimals': False}
key = 'ceil'

##### Inherited Members

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

class Coalesce(Func): View Source

    4336class Coalesce(Func):
    4337    arg_types = {"this": True, "expressions": False}
    4338    is_var_len_args = True
    4339    _sql_names = ["COALESCE", "IFNULL", "NVL"]

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

##### Inherited Members

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

class Chr(Func): View Source

    4342class Chr(Func):
    4343    arg_types = {"this": True, "charset": False, "expressions": False}
    4344    is_var_len_args = True
    4345    _sql_names = ["CHR", "CHAR"]

arg_types = {'this': True, 'charset': False, 'expressions': False}
is_var_len_args = True
key = 'chr'

##### Inherited Members

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

class Concat(Func): View Source

    4348class Concat(Func):
    4349    arg_types = {"expressions": True}
    4350    is_var_len_args = True

arg_types = {'expressions': True}
is_var_len_args = True
key = 'concat'

##### Inherited Members

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

class SafeConcat(Concat): View Source

    4353class SafeConcat(Concat):
    4354    pass

key = 'safeconcat'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Concat
  arg_types
  is_var_len_args
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ConcatWs(Concat): View Source

    4357class ConcatWs(Concat):
    4358    _sql_names = ["CONCAT_WS"]

key = 'concatws'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Concat
  arg_types
  is_var_len_args
Func
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class Count(AggFunc): View Source

    4361class Count(AggFunc):
    4362    arg_types = {"this": False, "expressions": False}
    4363    is_var_len_args = True

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

##### Inherited Members

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

class CountIf(AggFunc): View Source

    4366class CountIf(AggFunc):
    4367    pass

key = 'countif'

##### Inherited Members

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

class CurrentDate(Func): View Source

    4370class CurrentDate(Func):
    4371    arg_types = {"this": False}

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

##### Inherited Members

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

class CurrentDatetime(Func): View Source

    4374class CurrentDatetime(Func):
    4375    arg_types = {"this": False}

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

##### Inherited Members

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

class CurrentTime(Func): View Source

    4378class CurrentTime(Func):
    4379    arg_types = {"this": False}

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

##### Inherited Members

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

class CurrentTimestamp(Func): View Source

    4382class CurrentTimestamp(Func):
    4383    arg_types = {"this": False}

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

##### Inherited Members

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

class CurrentUser(Func): View Source

    4386class CurrentUser(Func):
    4387    arg_types = {"this": False}

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

##### Inherited Members

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

class DateAdd(Func, IntervalOp): View Source

    4390class DateAdd(Func, IntervalOp):
    4391    arg_types = {"this": True, "expression": True, "unit": False}

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

##### Inherited Members

TimeUnit
  TimeUnit
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DateSub(Func, IntervalOp): View Source

    4394class DateSub(Func, IntervalOp):
    4395    arg_types = {"this": True, "expression": True, "unit": False}

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

##### Inherited Members

TimeUnit
  TimeUnit
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DateDiff(Func, TimeUnit): View Source

    4398class DateDiff(Func, TimeUnit):
    4399    _sql_names = ["DATEDIFF", "DATE_DIFF"]
    4400    arg_types = {"this": True, "expression": True, "unit": False}

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

##### Inherited Members

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

class DateTrunc(Func): View Source

    4403class DateTrunc(Func):
    4404    arg_types = {"unit": True, "this": True, "zone": False}
    4405
    4406    @property
    4407    def unit(self) -> Expression:
    4408        return self.args["unit"]

arg_types = {'unit': True, 'this': True, 'zone': False}
unit: Expression
key = 'datetrunc'

##### Inherited Members

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

class DatetimeAdd(Func, IntervalOp): View Source

    4411class DatetimeAdd(Func, IntervalOp):
    4412    arg_types = {"this": True, "expression": True, "unit": False}

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

##### Inherited Members

TimeUnit
  TimeUnit
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DatetimeSub(Func, IntervalOp): View Source

    4415class DatetimeSub(Func, IntervalOp):
    4416    arg_types = {"this": True, "expression": True, "unit": False}

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

##### Inherited Members

TimeUnit
  TimeUnit
  unit
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings
IntervalOp
  interval
Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike

class DatetimeDiff(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class DatetimeTrunc(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class DayOfWeek(Func): View Source

    4427class DayOfWeek(Func):
    4428    _sql_names = ["DAY_OF_WEEK", "DAYOFWEEK"]

key = 'dayofweek'

##### Inherited Members

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

class DayOfMonth(Func): View Source

    4431class DayOfMonth(Func):
    4432    _sql_names = ["DAY_OF_MONTH", "DAYOFMONTH"]

key = 'dayofmonth'

##### Inherited Members

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

class DayOfYear(Func): View Source

    4435class DayOfYear(Func):
    4436    _sql_names = ["DAY_OF_YEAR", "DAYOFYEAR"]

key = 'dayofyear'

##### Inherited Members

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

class ToDays(Func): View Source

    4439class ToDays(Func):
    4440    pass

key = 'todays'

##### Inherited Members

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

class WeekOfYear(Func): View Source

    4443class WeekOfYear(Func):
    4444    _sql_names = ["WEEK_OF_YEAR", "WEEKOFYEAR"]

key = 'weekofyear'

##### Inherited Members

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

class MonthsBetween(Func): View Source

    4447class MonthsBetween(Func):
    4448    arg_types = {"this": True, "expression": True, "roundoff": False}

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

##### Inherited Members

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

class LastDateOfMonth(Func): View Source

    4451class LastDateOfMonth(Func):
    4452    pass

key = 'lastdateofmonth'

##### Inherited Members

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

class Extract(Func): View Source

    4455class Extract(Func):
    4456    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Timestamp(Func): View Source

    4459class Timestamp(Func):
    4460    arg_types = {"this": False, "expression": False}

arg_types = {'this': False, 'expression': False}
key = 'timestamp'

##### Inherited Members

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

class TimestampAdd(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class TimestampSub(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class TimestampDiff(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class TimestampTrunc(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class TimeAdd(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class TimeSub(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class TimeDiff(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class TimeTrunc(Func, TimeUnit): View Source

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

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

##### Inherited Members

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

class DateFromParts(Func): View Source

    4495class DateFromParts(Func):
    4496    _sql_names = ["DATEFROMPARTS"]
    4497    arg_types = {"year": True, "month": True, "day": True}

arg_types = {'year': True, 'month': True, 'day': True}
key = 'datefromparts'

##### Inherited Members

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

class DateStrToDate(Func): View Source

    4500class DateStrToDate(Func):
    4501    pass

key = 'datestrtodate'

##### Inherited Members

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

class DateToDateStr(Func): View Source

    4504class DateToDateStr(Func):
    4505    pass

key = 'datetodatestr'

##### Inherited Members

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

class DateToDi(Func): View Source

    4508class DateToDi(Func):
    4509    pass

key = 'datetodi'

##### Inherited Members

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

class Date(Func): View Source

    4513class Date(Func):
    4514    arg_types = {"this": False, "zone": False, "expressions": False}
    4515    is_var_len_args = True

arg_types = {'this': False, 'zone': False, 'expressions': False}
is_var_len_args = True
key = 'date'

##### Inherited Members

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

class Day(Func): View Source

    4518class Day(Func):
    4519    pass

key = 'day'

##### Inherited Members

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

class Decode(Func): View Source

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

arg_types = {'this': True, 'charset': True, 'replace': False}
key = 'decode'

##### Inherited Members

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

class DiToDate(Func): View Source

    4526class DiToDate(Func):
    4527    pass

key = 'ditodate'

##### Inherited Members

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

class Encode(Func): View Source

    4530class Encode(Func):
    4531    arg_types = {"this": True, "charset": True}

arg_types = {'this': True, 'charset': True}
key = 'encode'

##### Inherited Members

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

class Exp(Func): View Source

    4534class Exp(Func):
    4535    pass

key = 'exp'

##### Inherited Members

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

class Explode(Func): View Source

    4538class Explode(Func):
    4539    pass

key = 'explode'

##### Inherited Members

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

class Floor(Func): View Source

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

arg_types = {'this': True, 'decimals': False}
key = 'floor'

##### Inherited Members

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

class FromBase64(Func): View Source

    4546class FromBase64(Func):
    4547    pass

key = 'frombase64'

##### Inherited Members

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

class ToBase64(Func): View Source

    4550class ToBase64(Func):
    4551    pass

key = 'tobase64'

##### Inherited Members

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

class Greatest(Func): View Source

    4554class Greatest(Func):
    4555    arg_types = {"this": True, "expressions": False}
    4556    is_var_len_args = True

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

##### Inherited Members

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

class GroupConcat(AggFunc): View Source

    4559class GroupConcat(AggFunc):
    4560    arg_types = {"this": True, "separator": False}

arg_types = {'this': True, 'separator': False}
key = 'groupconcat'

##### Inherited Members

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

class Hex(Func): View Source

    4563class Hex(Func):
    4564    pass

key = 'hex'

##### Inherited Members

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

class Xor(Connector, Func): View Source

    4567class Xor(Connector, Func):
    4568    arg_types = {"this": False, "expression": False, "expressions": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class If(Func): View Source

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

arg_types = {'this': True, 'true': True, 'false': False}
key = 'if'

##### Inherited Members

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

class Initcap(Func): View Source

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

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

##### Inherited Members

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

class IsNan(Func): View Source

    4579class IsNan(Func):
    4580    _sql_names = ["IS_NAN", "ISNAN"]

key = 'isnan'

##### Inherited Members

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

class FormatJson(Expression): View Source

    4583class FormatJson(Expression):
    4584    pass

key = 'formatjson'

##### Inherited Members

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

class JSONKeyValue(Expression): View Source

    4587class JSONKeyValue(Expression):
    4588    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class JSONObject(Func): View Source

    4591class JSONObject(Func):
    4592    arg_types = {
    4593        "expressions": False,
    4594        "null_handling": False,
    4595        "unique_keys": False,
    4596        "return_type": False,
    4597        "encoding": False,
    4598    }

arg_types = {'expressions': False, 'null_handling': False, 'unique_keys': False, 'return_type': False, 'encoding': False}
key = 'jsonobject'

##### Inherited Members

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

class JSONArray(Func): View Source

    4602class JSONArray(Func):
    4603    arg_types = {
    4604        "expressions": True,
    4605        "null_handling": False,
    4606        "return_type": False,
    4607        "strict": False,
    4608    }

arg_types = {'expressions': True, 'null_handling': False, 'return_type': False, 'strict': False}
key = 'jsonarray'

##### Inherited Members

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

class JSONArrayAgg(Func): View Source

    4612class JSONArrayAgg(Func):
    4613    arg_types = {
    4614        "this": True,
    4615        "order": False,
    4616        "null_handling": False,
    4617        "return_type": False,
    4618        "strict": False,
    4619    }

arg_types = {'this': True, 'order': False, 'null_handling': False, 'return_type': False, 'strict': False}
key = 'jsonarrayagg'

##### Inherited Members

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

class JSONColumnDef(Expression): View Source

    4624class JSONColumnDef(Expression):
    4625    arg_types = {"this": True, "kind": False, "path": False}

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

##### Inherited Members

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

class JSONTable(Func): View Source

    4629class JSONTable(Func):
    4630    arg_types = {
    4631        "this": True,
    4632        "expressions": True,
    4633        "path": False,
    4634        "error_handling": False,
    4635        "empty_handling": False,
    4636    }

arg_types = {'this': True, 'expressions': True, 'path': False, 'error_handling': False, 'empty_handling': False}
key = 'jsontable'

##### Inherited Members

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

class OpenJSONColumnDef(Expression): View Source

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

arg_types = {'this': True, 'kind': True, 'path': False, 'as_json': False}
key = 'openjsoncolumndef'

##### Inherited Members

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

class OpenJSON(Func): View Source

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

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

##### Inherited Members

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

class JSONBContains(Binary): View Source

    4647class JSONBContains(Binary):
    4648    _sql_names = ["JSONB_CONTAINS"]

key = 'jsonbcontains'

##### Inherited Members

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

class JSONExtract(Binary, Func): View Source

    4651class JSONExtract(Binary, Func):
    4652    _sql_names = ["JSON_EXTRACT"]

key = 'jsonextract'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONExtractScalar(JSONExtract): View Source

    4655class JSONExtractScalar(JSONExtract):
    4656    _sql_names = ["JSON_EXTRACT_SCALAR"]

key = 'jsonextractscalar'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONBExtract(JSONExtract): View Source

    4659class JSONBExtract(JSONExtract):
    4660    _sql_names = ["JSONB_EXTRACT"]

key = 'jsonbextract'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONBExtractScalar(JSONExtract): View Source

    4663class JSONBExtractScalar(JSONExtract):
    4664    _sql_names = ["JSONB_EXTRACT_SCALAR"]

key = 'jsonbextractscalar'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class JSONFormat(Func): View Source

    4667class JSONFormat(Func):
    4668    arg_types = {"this": False, "options": False}
    4669    _sql_names = ["JSON_FORMAT"]

arg_types = {'this': False, 'options': False}
key = 'jsonformat'

##### Inherited Members

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

class JSONArrayContains(Binary, Predicate, Func): View Source

    4673class JSONArrayContains(Binary, Predicate, Func):
    4674    _sql_names = ["JSON_ARRAY_CONTAINS"]

key = 'jsonarraycontains'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class ParseJSON(Func): View Source

    4677class ParseJSON(Func):
    4678    # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
    4679    _sql_names = ["PARSE_JSON", "JSON_PARSE"]

key = 'parsejson'

##### Inherited Members

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

class Least(Func): View Source

    4682class Least(Func):
    4683    arg_types = {"this": True, "expressions": False}
    4684    is_var_len_args = True

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

##### Inherited Members

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

class Left(Func): View Source

    4687class Left(Func):
    4688    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Right(Func): View Source

    4691class Right(Func):
    4692    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Length(Func): View Source

    4695class Length(Func):
    4696    _sql_names = ["LENGTH", "LEN"]

key = 'length'

##### Inherited Members

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

class Levenshtein(Func): View Source

    4699class Levenshtein(Func):
    4700    arg_types = {
    4701        "this": True,
    4702        "expression": False,
    4703        "ins_cost": False,
    4704        "del_cost": False,
    4705        "sub_cost": False,
    4706    }

arg_types = {'this': True, 'expression': False, 'ins_cost': False, 'del_cost': False, 'sub_cost': False}
key = 'levenshtein'

##### Inherited Members

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

class Ln(Func): View Source

    4709class Ln(Func):
    4710    pass

key = 'ln'

##### Inherited Members

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

class Log(Func): View Source

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

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

##### Inherited Members

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

class Log2(Func): View Source

    4717class Log2(Func):
    4718    pass

key = 'log2'

##### Inherited Members

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

class Log10(Func): View Source

    4721class Log10(Func):
    4722    pass

key = 'log10'

##### Inherited Members

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

class LogicalOr(AggFunc): View Source

    4725class LogicalOr(AggFunc):
    4726    _sql_names = ["LOGICAL_OR", "BOOL_OR", "BOOLOR_AGG"]

key = 'logicalor'

##### Inherited Members

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

class LogicalAnd(AggFunc): View Source

    4729class LogicalAnd(AggFunc):
    4730    _sql_names = ["LOGICAL_AND", "BOOL_AND", "BOOLAND_AGG"]

key = 'logicaland'

##### Inherited Members

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

class Lower(Func): View Source

    4733class Lower(Func):
    4734    _sql_names = ["LOWER", "LCASE"]

key = 'lower'

##### Inherited Members

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

class Map(Func): View Source

    4737class Map(Func):
    4738    arg_types = {"keys": False, "values": False}

arg_types = {'keys': False, 'values': False}
key = 'map'

##### Inherited Members

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

class MapFromEntries(Func): View Source

    4741class MapFromEntries(Func):
    4742    pass

key = 'mapfromentries'

##### Inherited Members

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

class StarMap(Func): View Source

    4745class StarMap(Func):
    4746    pass

key = 'starmap'

##### Inherited Members

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

class VarMap(Func): View Source

    4749class VarMap(Func):
    4750    arg_types = {"keys": True, "values": True}
    4751    is_var_len_args = True
    4752
    4753    @property
    4754    def keys(self) -> t.List[Expression]:
    4755        return self.args["keys"].expressions
    4756
    4757    @property
    4758    def values(self) -> t.List[Expression]:
    4759        return self.args["values"].expressions

arg_types = {'keys': True, 'values': True}
is_var_len_args = True
keys: List[Expression]
values: List[Expression]
key = 'varmap'

##### Inherited Members

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

class MatchAgainst(Func): View Source

    4763class MatchAgainst(Func):
    4764    arg_types = {"this": True, "expressions": True, "modifier": False}

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

##### Inherited Members

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

class Max(AggFunc): View Source

    4767class Max(AggFunc):
    4768    arg_types = {"this": True, "expressions": False}
    4769    is_var_len_args = True

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

##### Inherited Members

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

class MD5(Func): View Source

    4772class MD5(Func):
    4773    _sql_names = ["MD5"]

key = 'md5'

##### Inherited Members

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

class MD5Digest(Func): View Source

    4777class MD5Digest(Func):
    4778    _sql_names = ["MD5_DIGEST"]

key = 'md5digest'

##### Inherited Members

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

class Min(AggFunc): View Source

    4781class Min(AggFunc):
    4782    arg_types = {"this": True, "expressions": False}
    4783    is_var_len_args = True

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

##### Inherited Members

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

class Month(Func): View Source

    4786class Month(Func):
    4787    pass

key = 'month'

##### Inherited Members

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

class Nvl2(Func): View Source

    4790class Nvl2(Func):
    4791    arg_types = {"this": True, "true": True, "false": False}

arg_types = {'this': True, 'true': True, 'false': False}
key = 'nvl2'

##### Inherited Members

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

class Posexplode(Func): View Source

    4794class Posexplode(Func):
    4795    pass

key = 'posexplode'

##### Inherited Members

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

class Predict(Func): View Source

    4799class Predict(Func):
    4800    arg_types = {"this": True, "expression": True, "params_struct": False}

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

##### Inherited Members

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

class Pow(Binary, Func): View Source

    4803class Pow(Binary, Func):
    4804    _sql_names = ["POWER", "POW"]

key = 'pow'

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  arg_types
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class PercentileCont(AggFunc): View Source

    4807class PercentileCont(AggFunc):
    4808    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

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

class PercentileDisc(AggFunc): View Source

    4811class PercentileDisc(AggFunc):
    4812    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

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

class Quantile(AggFunc): View Source

    4815class Quantile(AggFunc):
    4816    arg_types = {"this": True, "quantile": True}

arg_types = {'this': True, 'quantile': True}
key = 'quantile'

##### Inherited Members

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

class ApproxQuantile(Quantile): View Source

    4819class ApproxQuantile(Quantile):
    4820    arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}

arg_types = {'this': True, 'quantile': True, 'accuracy': False, 'weight': False}
key = 'approxquantile'

##### Inherited Members

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

class RangeN(Func): View Source

    4823class RangeN(Func):
    4824    arg_types = {"this": True, "expressions": True, "each": False}

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

##### Inherited Members

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

class ReadCSV(Func): View Source

    4827class ReadCSV(Func):
    4828    _sql_names = ["READ_CSV"]
    4829    is_var_len_args = True
    4830    arg_types = {"this": True, "expressions": False}

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

##### Inherited Members

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

class Reduce(Func): View Source

    4833class Reduce(Func):
    4834    arg_types = {"this": True, "initial": True, "merge": True, "finish": False}

arg_types = {'this': True, 'initial': True, 'merge': True, 'finish': False}
key = 'reduce'

##### Inherited Members

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

class RegexpExtract(Func): View Source

    4837class RegexpExtract(Func):
    4838    arg_types = {
    4839        "this": True,
    4840        "expression": True,
    4841        "position": False,
    4842        "occurrence": False,
    4843        "parameters": False,
    4844        "group": False,
    4845    }

arg_types = {'this': True, 'expression': True, 'position': False, 'occurrence': False, 'parameters': False, 'group': False}
key = 'regexpextract'

##### Inherited Members

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

class RegexpReplace(Func): View Source

    4848class RegexpReplace(Func):
    4849    arg_types = {
    4850        "this": True,
    4851        "expression": True,
    4852        "replacement": True,
    4853        "position": False,
    4854        "occurrence": False,
    4855        "parameters": False,
    4856    }

arg_types = {'this': True, 'expression': True, 'replacement': True, 'position': False, 'occurrence': False, 'parameters': False}
key = 'regexpreplace'

##### Inherited Members

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

class RegexpLike(Binary, Func): View Source

    4859class RegexpLike(Binary, Func):
    4860    arg_types = {"this": True, "expression": True, "flag": False}

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

##### Inherited Members

Expression
  Expression
  args
  parent
  arg_key
  comments
  hashable_args
  this
  expression
  expressions
  text
  is_string
  is_number
  is_int
  is_star
  alias
  alias_column_names
  name
  alias_or_name
  output_name
  type
  meta
  copy
  add_comments
  append
  set
  depth
  iter_expressions
  find
  find_all
  find_ancestor
  parent_select
  same_parent
  root
  walk
  dfs
  bfs
  unnest
  unalias
  unnest_operands
  flatten
  sql
  transform
  replace
  pop
  assert_is
  error_messages
  dump
  load
  and_
  or_
  not_
  as_
  isin
  between
  is_
  like
  ilike
  eq
  neq
  rlike
Binary
  left
  right
Func
  is_var_len_args
  from_arg_list
  sql_names
  sql_name
  default_parser_mappings

class RegexpILike(Func): View Source

    4863class RegexpILike(Func):
    4864    arg_types = {"this": True, "expression": True, "flag": False}

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

##### Inherited Members

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

class RegexpSplit(Func): View Source

    4869class RegexpSplit(Func):
    4870    arg_types = {"this": True, "expression": True, "limit": False}

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

##### Inherited Members

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

class Repeat(Func): View Source

    4873class Repeat(Func):
    4874    arg_types = {"this": True, "times": True}

arg_types = {'this': True, 'times': True}
key = 'repeat'

##### Inherited Members

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

class Round(Func): View Source

    4877class Round(Func):
    4878    arg_types = {"this": True, "decimals": False}

arg_types = {'this': True, 'decimals': False}
key = 'round'

##### Inherited Members

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

class RowNumber(Func): View Source

    4881class RowNumber(Func):
    4882    arg_types: t.Dict[str, t.Any] = {}

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

##### Inherited Members

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

class SafeDivide(Func): View Source

    4885class SafeDivide(Func):
    4886    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class SetAgg(AggFunc): View Source

    4889class SetAgg(AggFunc):
    4890    pass

key = 'setagg'

##### Inherited Members

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

class SHA(Func): View Source

    4893class SHA(Func):
    4894    _sql_names = ["SHA", "SHA1"]

key = 'sha'

##### Inherited Members

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

class SHA2(Func): View Source

    4897class SHA2(Func):
    4898    _sql_names = ["SHA2"]
    4899    arg_types = {"this": True, "length": False}

arg_types = {'this': True, 'length': False}
key = 'sha2'

##### Inherited Members

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

class SortArray(Func): View Source

    4902class SortArray(Func):
    4903    arg_types = {"this": True, "asc": False}

arg_types = {'this': True, 'asc': False}
key = 'sortarray'

##### Inherited Members

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

class Split(Func): View Source

    4906class Split(Func):
    4907    arg_types = {"this": True, "expression": True, "limit": False}

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

##### Inherited Members

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

class Substring(Func): View Source

    4912class Substring(Func):
    4913    arg_types = {"this": True, "start": False, "length": False}

arg_types = {'this': True, 'start': False, 'length': False}
key = 'substring'

##### Inherited Members

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

class StandardHash(Func): View Source

    4916class StandardHash(Func):
    4917    arg_types = {"this": True, "expression": False}

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

##### Inherited Members

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

class StartsWith(Func): View Source

    4920class StartsWith(Func):
    4921    _sql_names = ["STARTS_WITH", "STARTSWITH"]
    4922    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class StrPosition(Func): View Source

    4925class StrPosition(Func):
    4926    arg_types = {
    4927        "this": True,
    4928        "substr": True,
    4929        "position": False,
    4930        "instance": False,
    4931    }

arg_types = {'this': True, 'substr': True, 'position': False, 'instance': False}
key = 'strposition'

##### Inherited Members

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

class StrToDate(Func): View Source

    4934class StrToDate(Func):
    4935    arg_types = {"this": True, "format": True}

arg_types = {'this': True, 'format': True}
key = 'strtodate'

##### Inherited Members

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

class StrToTime(Func): View Source

    4938class StrToTime(Func):
    4939    arg_types = {"this": True, "format": True, "zone": False}

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

##### Inherited Members

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

class StrToUnix(Func): View Source

    4944class StrToUnix(Func):
    4945    arg_types = {"this": False, "format": False}

arg_types = {'this': False, 'format': False}
key = 'strtounix'

##### Inherited Members

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

class StrToMap(Func): View Source

    4950class StrToMap(Func):
    4951    arg_types = {
    4952        "this": True,
    4953        "pair_delim": False,
    4954        "key_value_delim": False,
    4955        "duplicate_resolution_callback": False,
    4956    }

arg_types = {'this': True, 'pair_delim': False, 'key_value_delim': False, 'duplicate_resolution_callback': False}
key = 'strtomap'

##### Inherited Members

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

class NumberToStr(Func): View Source

    4959class NumberToStr(Func):
    4960    arg_types = {"this": True, "format": True, "culture": False}

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

##### Inherited Members

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

class FromBase(Func): View Source

    4963class FromBase(Func):
    4964    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Struct(Func): View Source

    4967class Struct(Func):
    4968    arg_types = {"expressions": True}
    4969    is_var_len_args = True

arg_types = {'expressions': True}
is_var_len_args = True
key = 'struct'

##### Inherited Members

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

class StructExtract(Func): View Source

    4972class StructExtract(Func):
    4973    arg_types = {"this": True, "expression": True}

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

##### Inherited Members

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

class Stuff(Func): View Source

    4978class Stuff(Func):
    4979    _sql_names = ["STUFF", "INSERT"]
    4980    arg_types = {"this": True, "start": True, "length": True, "expression": True}

arg_types = {'this': True, 'start': True, 'length': True, 'expression': True}
key = 'stuff'

##### Inherited Members

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

class Sum(AggFunc): View Source

    4983class Sum(AggFunc):
    4984    pass

key = 'sum'

##### Inherited Members

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

class Sqrt(Func): View Source

    4987class Sqrt(Func):
    4988    pass

key = 'sqrt'

##### Inherited Members

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

class Stddev(AggFunc): View Source

    4991class Stddev(AggFunc):
    4992    pass

key = 'stddev'

##### Inherited Members

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

class StddevPop(AggFunc): View Source

    4995class StddevPop(AggFunc):
    4996    pass

key = 'stddevpop'

##### Inherited Members

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

class StddevSamp(AggFunc): View Source

    4999class StddevSamp(AggFunc):
    5000    pass

key = 'stddevsamp'

##### Inherited Members

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

class TimeToStr(Func): View Source

    5003class TimeToStr(Func):
    5004    arg_types = {"this": True, "format": True, "culture": False}

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

##### Inherited Members

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

class TimeToTimeStr(Func): View Source

    5007class TimeToTimeStr(Func):
    5008    pass

key = 'timetotimestr'

##### Inherited Members

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

class TimeToUnix(Func): View Source

    5011class TimeToUnix(Func):
    5012    pass

key = 'timetounix'

##### Inherited Members

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

class TimeStrToDate(Func): View Source

    5015class TimeStrToDate(Func):
    5016    pass

key = 'timestrtodate'

##### Inherited Members

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

class TimeStrToTime(Func): View Source

    5019class TimeStrToTime(Func):
    5020    pass

key = 'timestrtotime'

##### Inherited Members

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

class TimeStrToUnix(Func): View Source

    5023class TimeStrToUnix(Func):
    5024    pass

key = 'timestrtounix'

##### Inherited Members

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

class Trim(Func): View Source

    5027class Trim(Func):
    5028    arg_types = {
    5029        "this": True,
    5030        "expression": False,
    5031        "position": False,
    5032        "collation": False,
    5033    }

arg_types = {'this': True, 'expression': False, 'position': False, 'collation': False}
key = 'trim'

##### Inherited Members

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

class TsOrDsAdd(Func, TimeUnit): View Source

    5036class TsOrDsAdd(Func, TimeUnit):
    5037    arg_types = {"this": True, "expression": True, "unit": False}

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

##### Inherited Members

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

class TsOrDsToDateStr(Func): View Source

    5040class TsOrDsToDateStr(Func):
    5041    pass

key = 'tsordstodatestr'

##### Inherited Members

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

class TsOrDsToDate(Func): View Source

    5044class TsOrDsToDate(Func):
    5045    arg_types = {"this": True, "format": False}

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

##### Inherited Members

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

class TsOrDiToDi(Func): View Source

    5048class TsOrDiToDi(Func):
    5049    pass

key = 'tsorditodi'

##### Inherited Members

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

class Unhex(Func): View Source

    5052class Unhex(Func):
    5053    pass

key = 'unhex'

##### Inherited Members

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

class UnixToStr(Func): View Source

    5056class UnixToStr(Func):
    5057    arg_types = {"this": True, "format": False}

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

##### Inherited Members

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

class UnixToTime(Func): View Source

    5062class UnixToTime(Func):
    5063    arg_types = {"this": True, "scale": False, "zone": False, "hours": False, "minutes": False}
    5064
    5065    SECONDS = Literal.string("seconds")
    5066    MILLIS = Literal.string("millis")
    5067    MICROS = Literal.string("micros")

arg_types = {'this': True, 'scale': False, 'zone': False, 'hours': False, 'minutes': False}
SECONDS = (LITERAL this: seconds, is_string: True)
MILLIS = (LITERAL this: millis, is_string: True)
MICROS = (LITERAL this: micros, is_string: True)
key = 'unixtotime'

##### Inherited Members

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

class UnixToTimeStr(Func): View Source

    5070class UnixToTimeStr(Func):
    5071    pass

key = 'unixtotimestr'

##### Inherited Members

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

class Upper(Func): View Source

    5074class Upper(Func):
    5075    _sql_names = ["UPPER", "UCASE"]

key = 'upper'

##### Inherited Members

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

class Variance(AggFunc): View Source

    5078class Variance(AggFunc):
    5079    _sql_names = ["VARIANCE", "VARIANCE_SAMP", "VAR_SAMP"]

key = 'variance'

##### Inherited Members

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

class VariancePop(AggFunc): View Source

    5082class VariancePop(AggFunc):
    5083    _sql_names = ["VARIANCE_POP", "VAR_POP"]

key = 'variancepop'

##### Inherited Members

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

class Week(Func): View Source

    5086class Week(Func):
    5087    arg_types = {"this": True, "mode": False}

arg_types = {'this': True, 'mode': False}
key = 'week'

##### Inherited Members

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

class XMLTable(Func): View Source

    5090class XMLTable(Func):
    5091    arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}

arg_types = {'this': True, 'passing': False, 'columns': False, 'by_ref': False}
key = 'xmltable'

##### Inherited Members

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

class Year(Func): View Source

    5094class Year(Func):
    5095    pass

key = 'year'

##### Inherited Members

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

class Use(Expression): View Source

    5098class Use(Expression):
    5099    arg_types = {"this": True, "kind": False}

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

##### Inherited Members

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

class Merge(Expression): View Source

    5102class Merge(Expression):
    5103    arg_types = {"this": True, "using": True, "on": True, "expressions": True}

arg_types = {'this': True, 'using': True, 'on': True, 'expressions': True}
key = 'merge'

##### Inherited Members

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

class When(Func): View Source

    5106class When(Func):
    5107    arg_types = {"matched": True, "source": False, "condition": False, "then": True}

arg_types = {'matched': True, 'source': False, 'condition': False, 'then': True}
key = 'when'

##### Inherited Members

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

class NextValueFor(Func): View Source

    5112class NextValueFor(Func):
    5113    arg_types = {"this": True, "order": False}

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

##### Inherited Members

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

ALL_FUNCTIONS = [<class 'Abs'>, <class 'AnyValue'>, <class 'ApproxDistinct'>, <class 'ApproxQuantile'>, <class 'Array'>, <class 'ArrayAgg'>, <class 'ArrayAll'>, <class 'ArrayAny'>, <class 'ArrayConcat'>, <class 'ArrayContains'>, <class 'ArrayFilter'>, <class 'ArrayJoin'>, <class 'ArraySize'>, <class 'ArraySort'>, <class 'ArraySum'>, <class 'ArrayUnionAgg'>, <class 'Avg'>, <class 'Case'>, <class 'Cast'>, <class 'CastToStrType'>, <class 'Ceil'>, <class 'Chr'>, <class 'Coalesce'>, <class 'Collate'>, <class 'Concat'>, <class 'ConcatWs'>, <class 'Count'>, <class 'CountIf'>, <class 'CurrentDate'>, <class 'CurrentDatetime'>, <class 'CurrentTime'>, <class 'CurrentTimestamp'>, <class 'CurrentUser'>, <class 'Date'>, <class 'DateAdd'>, <class 'DateDiff'>, <class 'DateFromParts'>, <class 'DateStrToDate'>, <class 'DateSub'>, <class 'DateToDateStr'>, <class 'DateToDi'>, <class 'DateTrunc'>, <class 'DatetimeAdd'>, <class 'DatetimeDiff'>, <class 'DatetimeSub'>, <class 'DatetimeTrunc'>, <class 'Day'>, <class 'DayOfMonth'>, <class 'DayOfWeek'>, <class 'DayOfYear'>, <class 'Decode'>, <class 'DiToDate'>, <class 'Encode'>, <class 'Exp'>, <class 'Explode'>, <class 'Extract'>, <class 'First'>, <class 'Floor'>, <class 'FromBase'>, <class 'FromBase64'>, <class 'GenerateSeries'>, <class 'Greatest'>, <class 'GroupConcat'>, <class 'Hex'>, <class 'Hll'>, <class 'If'>, <class 'Initcap'>, <class 'IsNan'>, <class 'JSONArray'>, <class 'JSONArrayAgg'>, <class 'JSONArrayContains'>, <class 'JSONBExtract'>, <class 'JSONBExtractScalar'>, <class 'JSONExtract'>, <class 'JSONExtractScalar'>, <class 'JSONFormat'>, <class 'JSONObject'>, <class 'JSONTable'>, <class 'Last'>, <class 'LastDateOfMonth'>, <class 'Least'>, <class 'Left'>, <class 'Length'>, <class 'Levenshtein'>, <class 'Ln'>, <class 'Log'>, <class 'Log10'>, <class 'Log2'>, <class 'LogicalAnd'>, <class 'LogicalOr'>, <class 'Lower'>, <class 'MD5'>, <class 'MD5Digest'>, <class 'Map'>, <class 'MapFromEntries'>, <class 'MatchAgainst'>, <class 'Max'>, <class 'Min'>, <class 'Month'>, <class 'MonthsBetween'>, <class 'NextValueFor'>, <class 'NumberToStr'>, <class 'Nvl2'>, <class 'OpenJSON'>, <class 'ParameterizedAgg'>, <class 'ParseJSON'>, <class 'PercentileCont'>, <class 'PercentileDisc'>, <class 'Posexplode'>, <class 'Pow'>, <class 'Predict'>, <class 'Quantile'>, <class 'RangeN'>, <class 'ReadCSV'>, <class 'Reduce'>, <class 'RegexpExtract'>, <class 'RegexpILike'>, <class 'RegexpLike'>, <class 'RegexpReplace'>, <class 'RegexpSplit'>, <class 'Repeat'>, <class 'Right'>, <class 'Round'>, <class 'RowNumber'>, <class 'SHA'>, <class 'SHA2'>, <class 'SafeConcat'>, <class 'SafeDivide'>, <class 'SetAgg'>, <class 'SortArray'>, <class 'Split'>, <class 'Sqrt'>, <class 'StandardHash'>, <class 'StarMap'>, <class 'StartsWith'>, <class 'Stddev'>, <class 'StddevPop'>, <class 'StddevSamp'>, <class 'StrPosition'>, <class 'StrToDate'>, <class 'StrToMap'>, <class 'StrToTime'>, <class 'StrToUnix'>, <class 'Struct'>, <class 'StructExtract'>, <class 'Stuff'>, <class 'Substring'>, <class 'Sum'>, <class 'TimeAdd'>, <class 'TimeDiff'>, <class 'TimeStrToDate'>, <class 'TimeStrToTime'>, <class 'TimeStrToUnix'>, <class 'TimeSub'>, <class 'TimeToStr'>, <class 'TimeToTimeStr'>, <class 'TimeToUnix'>, <class 'TimeTrunc'>, <class 'Timestamp'>, <class 'TimestampAdd'>, <class 'TimestampDiff'>, <class 'TimestampSub'>, <class 'TimestampTrunc'>, <class 'ToBase64'>, <class 'ToChar'>, <class 'ToDays'>, <class 'Transform'>, <class 'Trim'>, <class 'TryCast'>, <class 'TsOrDiToDi'>, <class 'TsOrDsAdd'>, <class 'TsOrDsToDate'>, <class 'TsOrDsToDateStr'>, <class 'Unhex'>, <class 'UnixToStr'>, <class 'UnixToTime'>, <class 'UnixToTimeStr'>, <class 'Upper'>, <class 'VarMap'>, <class 'Variance'>, <class 'VariancePop'>, <class 'Week'>, <class 'WeekOfYear'>, <class 'When'>, <class 'XMLTable'>, <class 'Xor'>, <class 'Year'>]
def maybe_parse( sql_or_expression: Union[str, Expression], *, into: Union[str, Type[Expression], Collection[Union[str, Type[Expression]]], NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, prefix: Optional[str] = None, copy: bool = False, **opts) -> Expression: View Source

    5150def maybe_parse(
    5151    sql_or_expression: ExpOrStr,
    5152    *,
    5153    into: t.Optional[IntoType] = None,
    5154    dialect: DialectType = None,
    5155    prefix: t.Optional[str] = None,
    5156    copy: bool = False,
    5157    **opts,
    5158) -> Expression:
    5159    """Gracefully handle a possible string or expression.
    5160
    5161    Example:
    5162        >>> maybe_parse("1")
    5163        (LITERAL this: 1, is_string: False)
    5164        >>> maybe_parse(to_identifier("x"))
    5165        (IDENTIFIER this: x, quoted: False)
    5166
    5167    Args:
    5168        sql_or_expression: the SQL code string or an expression
    5169        into: the SQLGlot Expression to parse into
    5170        dialect: the dialect used to parse the input expressions (in the case that an
    5171            input expression is a SQL string).
    5172        prefix: a string to prefix the sql with before it gets parsed
    5173            (automatically includes a space)
    5174        copy: whether or not to copy the expression.
    5175        **opts: other options to use to parse the input expressions (again, in the case
    5176            that an input expression is a SQL string).
    5177
    5178    Returns:
    5179        Expression: the parsed or given expression.
    5180    """
    5181    if isinstance(sql_or_expression, Expression):
    5182        if copy:
    5183            return sql_or_expression.copy()
    5184        return sql_or_expression
    5185
    5186    if sql_or_expression is None:
    5187        raise ParseError(f"SQL cannot be None")
    5188
    5189    import sqlglot
    5190
    5191    sql = str(sql_or_expression)
    5192    if prefix:
    5193        sql = f"{prefix} {sql}"
    5194
    5195    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 maybe_copy(instance, copy=True): View Source

    5208def maybe_copy(instance, copy=True):
    5209    return instance.copy() if copy and instance else instance

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

    5390def union(
    5391    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    5392) -> Union:
    5393    """
    5394    Initializes a syntax tree from one UNION expression.
    5395
    5396    Example:
    5397        >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql()
    5398        'SELECT * FROM foo UNION SELECT * FROM bla'
    5399
    5400    Args:
    5401        left: the SQL code string corresponding to the left-hand side.
    5402            If an `Expression` instance is passed, it will be used as-is.
    5403        right: the SQL code string corresponding to the right-hand side.
    5404            If an `Expression` instance is passed, it will be used as-is.
    5405        distinct: set the DISTINCT flag if and only if this is true.
    5406        dialect: the dialect used to parse the input expression.
    5407        opts: other options to use to parse the input expressions.
    5408
    5409    Returns:
    5410        The new Union instance.
    5411    """
    5412    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    5413    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    5414
    5415    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, Expression], right: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Intersect: View Source

    5418def intersect(
    5419    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    5420) -> Intersect:
    5421    """
    5422    Initializes a syntax tree from one INTERSECT expression.
    5423
    5424    Example:
    5425        >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql()
    5426        'SELECT * FROM foo INTERSECT SELECT * FROM bla'
    5427
    5428    Args:
    5429        left: the SQL code string corresponding to the left-hand side.
    5430            If an `Expression` instance is passed, it will be used as-is.
    5431        right: the SQL code string corresponding to the right-hand side.
    5432            If an `Expression` instance is passed, it will be used as-is.
    5433        distinct: set the DISTINCT flag if and only if this is true.
    5434        dialect: the dialect used to parse the input expression.
    5435        opts: other options to use to parse the input expressions.
    5436
    5437    Returns:
    5438        The new Intersect instance.
    5439    """
    5440    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    5441    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    5442
    5443    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, Expression], right: Union[str, Expression], distinct: bool = True, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Except: View Source

    5446def except_(
    5447    left: ExpOrStr, right: ExpOrStr, distinct: bool = True, dialect: DialectType = None, **opts
    5448) -> Except:
    5449    """
    5450    Initializes a syntax tree from one EXCEPT expression.
    5451
    5452    Example:
    5453        >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql()
    5454        'SELECT * FROM foo EXCEPT SELECT * FROM bla'
    5455
    5456    Args:
    5457        left: the SQL code string corresponding to the left-hand side.
    5458            If an `Expression` instance is passed, it will be used as-is.
    5459        right: the SQL code string corresponding to the right-hand side.
    5460            If an `Expression` instance is passed, it will be used as-is.
    5461        distinct: set the DISTINCT flag if and only if this is true.
    5462        dialect: the dialect used to parse the input expression.
    5463        opts: other options to use to parse the input expressions.
    5464
    5465    Returns:
    5466        The new Except instance.
    5467    """
    5468    left = maybe_parse(sql_or_expression=left, dialect=dialect, **opts)
    5469    right = maybe_parse(sql_or_expression=right, dialect=dialect, **opts)
    5470
    5471    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, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Select: View Source

    5474def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    5475    """
    5476    Initializes a syntax tree from one or multiple SELECT expressions.
    5477
    5478    Example:
    5479        >>> select("col1", "col2").from_("tbl").sql()
    5480        'SELECT col1, col2 FROM tbl'
    5481
    5482    Args:
    5483        *expressions: the SQL code string to parse as the expressions of a
    5484            SELECT statement. If an Expression instance is passed, this is used as-is.
    5485        dialect: the dialect used to parse the input expressions (in the case that an
    5486            input expression is a SQL string).
    5487        **opts: other options to use to parse the input expressions (again, in the case
    5488            that an input expression is a SQL string).
    5489
    5490    Returns:
    5491        Select: the syntax tree for the SELECT statement.
    5492    """
    5493    return Select().select(*expressions, dialect=dialect, **opts)

Initializes a syntax tree from one or multiple SELECT expressions.

###### Example:

>     >>> select("col1", "col2").from_("tbl").sql()
>     'SELECT col1, col2 FROM tbl'

###### Arguments:

- *expressions: the SQL code string to parse as the expressions of a SELECT statement. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expressions (in the case that an input expression is a SQL string).
- **opts: other options to use to parse the input expressions (again, in the case that an input expression is a SQL string).

###### Returns:

> Select: the syntax tree for the SELECT statement.

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

    5496def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
    5497    """
    5498    Initializes a syntax tree from a FROM expression.
    5499
    5500    Example:
    5501        >>> from_("tbl").select("col1", "col2").sql()
    5502        'SELECT col1, col2 FROM tbl'
    5503
    5504    Args:
    5505        *expression: the SQL code string to parse as the FROM expressions of a
    5506            SELECT statement. If an Expression instance is passed, this is used as-is.
    5507        dialect: the dialect used to parse the input expression (in the case that the
    5508            input expression is a SQL string).
    5509        **opts: other options to use to parse the input expressions (again, in the case
    5510            that the input expression is a SQL string).
    5511
    5512    Returns:
    5513        Select: the syntax tree for the SELECT statement.
    5514    """
    5515    return Select().from_(expression, dialect=dialect, **opts)

Initializes a syntax tree from a FROM expression.

###### Example:

>     >>> from_("tbl").select("col1", "col2").sql()
>     'SELECT col1, col2 FROM tbl'

###### Arguments:

- *expression: the SQL code string to parse as the FROM expressions of a SELECT statement. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression (in the case that the input expression is a SQL string).
- **opts: other options to use to parse the input expressions (again, in the case that the input expression is a SQL string).

###### Returns:

> Select: the syntax tree for the SELECT statement.

def update( table: str | Table, properties: dict, where: Union[str, Expression, NoneType] = None, from_: Union[str, Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Update: View Source

    5518def update(
    5519    table: str | Table,
    5520    properties: dict,
    5521    where: t.Optional[ExpOrStr] = None,
    5522    from_: t.Optional[ExpOrStr] = None,
    5523    dialect: DialectType = None,
    5524    **opts,
    5525) -> Update:
    5526    """
    5527    Creates an update statement.
    5528
    5529    Example:
    5530        >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz", where="id > 1").sql()
    5531        "UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz WHERE id > 1"
    5532
    5533    Args:
    5534        *properties: dictionary of properties to set which are
    5535            auto converted to sql objects eg None -> NULL
    5536        where: sql conditional parsed into a WHERE statement
    5537        from_: sql statement parsed into a FROM statement
    5538        dialect: the dialect used to parse the input expressions.
    5539        **opts: other options to use to parse the input expressions.
    5540
    5541    Returns:
    5542        Update: the syntax tree for the UPDATE statement.
    5543    """
    5544    update_expr = Update(this=maybe_parse(table, into=Table, dialect=dialect))
    5545    update_expr.set(
    5546        "expressions",
    5547        [
    5548            EQ(this=maybe_parse(k, dialect=dialect, **opts), expression=convert(v))
    5549            for k, v in properties.items()
    5550        ],
    5551    )
    5552    if from_:
    5553        update_expr.set(
    5554            "from",
    5555            maybe_parse(from_, into=From, dialect=dialect, prefix="FROM", **opts),
    5556        )
    5557    if isinstance(where, Condition):
    5558        where = Where(this=where)
    5559    if where:
    5560        update_expr.set(
    5561            "where",
    5562            maybe_parse(where, into=Where, dialect=dialect, prefix="WHERE", **opts),
    5563        )
    5564    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, Expression], where: Union[str, Expression, NoneType] = None, returning: Union[str, Expression, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Delete: View Source

    5567def delete(
    5568    table: ExpOrStr,
    5569    where: t.Optional[ExpOrStr] = None,
    5570    returning: t.Optional[ExpOrStr] = None,
    5571    dialect: DialectType = None,
    5572    **opts,
    5573) -> Delete:
    5574    """
    5575    Builds a delete statement.
    5576
    5577    Example:
    5578        >>> delete("my_table", where="id > 1").sql()
    5579        'DELETE FROM my_table WHERE id > 1'
    5580
    5581    Args:
    5582        where: sql conditional parsed into a WHERE statement
    5583        returning: sql conditional parsed into a RETURNING statement
    5584        dialect: the dialect used to parse the input expressions.
    5585        **opts: other options to use to parse the input expressions.
    5586
    5587    Returns:
    5588        Delete: the syntax tree for the DELETE statement.
    5589    """
    5590    delete_expr = Delete().delete(table, dialect=dialect, copy=False, **opts)
    5591    if where:
    5592        delete_expr = delete_expr.where(where, dialect=dialect, copy=False, **opts)
    5593    if returning:
    5594        delete_expr = delete_expr.returning(returning, dialect=dialect, copy=False, **opts)
    5595    return delete_expr

Builds a delete statement.

###### Example:

>     >>> delete("my_table", where="id > 1").sql()
>     'DELETE FROM my_table WHERE id > 1'

###### Arguments:

- where: sql conditional parsed into a WHERE statement
- returning: sql conditional parsed into a RETURNING statement
- dialect: the dialect used to parse the input expressions.
- **opts: other options to use to parse the input expressions.

###### Returns:

> Delete: the syntax tree for the DELETE statement.

def insert( expression: Union[str, Expression], into: Union[str, Expression], columns: Optional[Sequence[Union[str, Expression]]] = None, overwrite: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Insert: View Source

    5598def insert(
    5599    expression: ExpOrStr,
    5600    into: ExpOrStr,
    5601    columns: t.Optional[t.Sequence[ExpOrStr]] = None,
    5602    overwrite: t.Optional[bool] = None,
    5603    dialect: DialectType = None,
    5604    copy: bool = True,
    5605    **opts,
    5606) -> Insert:
    5607    """
    5608    Builds an INSERT statement.
    5609
    5610    Example:
    5611        >>> insert("VALUES (1, 2, 3)", "tbl").sql()
    5612        'INSERT INTO tbl VALUES (1, 2, 3)'
    5613
    5614    Args:
    5615        expression: the sql string or expression of the INSERT statement
    5616        into: the tbl to insert data to.
    5617        columns: optionally the table's column names.
    5618        overwrite: whether to INSERT OVERWRITE or not.
    5619        dialect: the dialect used to parse the input expressions.
    5620        copy: whether or not to copy the expression.
    5621        **opts: other options to use to parse the input expressions.
    5622
    5623    Returns:
    5624        Insert: the syntax tree for the INSERT statement.
    5625    """
    5626    expr = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    5627    this: Table | Schema = maybe_parse(into, into=Table, dialect=dialect, copy=copy, **opts)
    5628
    5629    if columns:
    5630        this = _apply_list_builder(
    5631            *columns,
    5632            instance=Schema(this=this),
    5633            arg="expressions",
    5634            into=Identifier,
    5635            copy=False,
    5636            dialect=dialect,
    5637            **opts,
    5638        )
    5639
    5640    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, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    5643def condition(
    5644    expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts
    5645) -> Condition:
    5646    """
    5647    Initialize a logical condition expression.
    5648
    5649    Example:
    5650        >>> condition("x=1").sql()
    5651        'x = 1'
    5652
    5653        This is helpful for composing larger logical syntax trees:
    5654        >>> where = condition("x=1")
    5655        >>> where = where.and_("y=1")
    5656        >>> Select().from_("tbl").select("*").where(where).sql()
    5657        'SELECT * FROM tbl WHERE x = 1 AND y = 1'
    5658
    5659    Args:
    5660        *expression: the SQL code string to parse.
    5661            If an Expression instance is passed, this is used as-is.
    5662        dialect: the dialect used to parse the input expression (in the case that the
    5663            input expression is a SQL string).
    5664        copy: Whether or not to copy `expression` (only applies to expressions).
    5665        **opts: other options to use to parse the input expressions (again, in the case
    5666            that the input expression is a SQL string).
    5667
    5668    Returns:
    5669        The new Condition instance
    5670    """
    5671    return maybe_parse(
    5672        expression,
    5673        into=Condition,
    5674        dialect=dialect,
    5675        copy=copy,
    5676        **opts,
    5677    )

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

    5680def and_(
    5681    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    5682) -> Condition:
    5683    """
    5684    Combine multiple conditions with an AND logical operator.
    5685
    5686    Example:
    5687        >>> and_("x=1", and_("y=1", "z=1")).sql()
    5688        'x = 1 AND (y = 1 AND z = 1)'
    5689
    5690    Args:
    5691        *expressions: the SQL code strings to parse.
    5692            If an Expression instance is passed, this is used as-is.
    5693        dialect: the dialect used to parse the input expression.
    5694        copy: whether or not to copy `expressions` (only applies to Expressions).
    5695        **opts: other options to use to parse the input expressions.
    5696
    5697    Returns:
    5698        And: the new condition
    5699    """
    5700    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, Expression, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Condition: View Source

    5703def or_(
    5704    *expressions: t.Optional[ExpOrStr], dialect: DialectType = None, copy: bool = True, **opts
    5705) -> Condition:
    5706    """
    5707    Combine multiple conditions with an OR logical operator.
    5708
    5709    Example:
    5710        >>> or_("x=1", or_("y=1", "z=1")).sql()
    5711        'x = 1 OR (y = 1 OR z = 1)'
    5712
    5713    Args:
    5714        *expressions: the SQL code strings to parse.
    5715            If an Expression instance is passed, this is used as-is.
    5716        dialect: the dialect used to parse the input expression.
    5717        copy: whether or not to copy `expressions` (only applies to Expressions).
    5718        **opts: other options to use to parse the input expressions.
    5719
    5720    Returns:
    5721        Or: the new condition
    5722    """
    5723    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, Expression], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts) -> Not: View Source

    5726def not_(expression: ExpOrStr, dialect: DialectType = None, copy: bool = True, **opts) -> Not:
    5727    """
    5728    Wrap a condition with a NOT operator.
    5729
    5730    Example:
    5731        >>> not_("this_suit='black'").sql()
    5732        "NOT this_suit = 'black'"
    5733
    5734    Args:
    5735        expression: the SQL code string to parse.
    5736            If an Expression instance is passed, this is used as-is.
    5737        dialect: the dialect used to parse the input expression.
    5738        copy: whether to copy the expression or not.
    5739        **opts: other options to use to parse the input expressions.
    5740
    5741    Returns:
    5742        The new condition.
    5743    """
    5744    this = condition(
    5745        expression,
    5746        dialect=dialect,
    5747        copy=copy,
    5748        **opts,
    5749    )
    5750    return Not(this=_wrap(this, Connector))

Wrap a condition with a NOT operator.

###### Example:

>     >>> not_("this_suit='black'").sql()
>     "NOT this_suit = 'black'"

###### Arguments:

- expression: the SQL code string to parse. If an Expression instance is passed, this is used as-is.
- dialect: the dialect used to parse the input expression.
- copy: whether to copy the expression or not.
- **opts: other options to use to parse the input expressions.

###### Returns:

> The new condition.

def paren( expression: Union[str, Expression], copy: bool = True) -> Paren: View Source

    5753def paren(expression: ExpOrStr, copy: bool = True) -> Paren:
    5754    """
    5755    Wrap an expression in parentheses.
    5756
    5757    Example:
    5758        >>> paren("5 + 3").sql()
    5759        '(5 + 3)'
    5760
    5761    Args:
    5762        expression: the SQL code string to parse.
    5763            If an Expression instance is passed, this is used as-is.
    5764        copy: whether to copy the expression or not.
    5765
    5766    Returns:
    5767        The wrapped expression.
    5768    """
    5769    return Paren(this=maybe_parse(expression, copy=copy))

Wrap an expression in parentheses.

###### Example:

>     >>> paren("5 + 3").sql()
>     '(5 + 3)'

###### Arguments:

- expression: the SQL code string to parse. If an Expression instance is passed, this is used as-is.
- copy: whether to copy the expression or not.

###### Returns:

> The wrapped expression.

SAFE_IDENTIFIER_RE = re.compile('^[_a-zA-Z][\\w]*$')
def to_identifier(name, quoted=None, copy=True): View Source

    5787def to_identifier(name, quoted=None, copy=True):
    5788    """Builds an identifier.
    5789
    5790    Args:
    5791        name: The name to turn into an identifier.
    5792        quoted: Whether or not force quote the identifier.
    5793        copy: Whether or not to copy a passed in Identefier node.
    5794
    5795    Returns:
    5796        The identifier ast node.
    5797    """
    5798
    5799    if name is None:
    5800        return None
    5801
    5802    if isinstance(name, Identifier):
    5803        identifier = maybe_copy(name, copy)
    5804    elif isinstance(name, str):
    5805        identifier = Identifier(
    5806            this=name,
    5807            quoted=not SAFE_IDENTIFIER_RE.match(name) if quoted is None else quoted,
    5808        )
    5809    else:
    5810        raise ValueError(f"Name needs to be a string or an Identifier, got: {name.__class__}")
    5811    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.

INTERVAL_STRING_RE = re.compile('\\s*([0-9]+)\\s*([a-zA-Z]+)\\s*')
def to_interval( interval: str | Literal) -> Interval: View Source

    5817def to_interval(interval: str | Literal) -> Interval:
    5818    """Builds an interval expression from a string like '1 day' or '5 months'."""
    5819    if isinstance(interval, Literal):
    5820        if not interval.is_string:
    5821            raise ValueError("Invalid interval string.")
    5822
    5823        interval = interval.this
    5824
    5825    interval_parts = INTERVAL_STRING_RE.match(interval)  # type: ignore
    5826
    5827    if not interval_parts:
    5828        raise ValueError("Invalid interval string.")
    5829
    5830    return Interval(
    5831        this=Literal.string(interval_parts.group(1)),
    5832        unit=Var(this=interval_parts.group(2)),
    5833    )

Builds an interval expression from a string like '1 day' or '5 months'.

def to_table( sql_path: Union[str, Table, NoneType], dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **kwargs) -> Optional[Table]: View Source

    5846def to_table(
    5847    sql_path: t.Optional[str | Table], dialect: DialectType = None, **kwargs
    5848) -> t.Optional[Table]:
    5849    """
    5850    Create a table expression from a `[catalog].[schema].[table]` sql path. Catalog and schema are optional.
    5851    If a table is passed in then that table is returned.
    5852
    5853    Args:
    5854        sql_path: a `[catalog].[schema].[table]` string.
    5855        dialect: the source dialect according to which the table name will be parsed.
    5856        kwargs: the kwargs to instantiate the resulting `Table` expression with.
    5857
    5858    Returns:
    5859        A table expression.
    5860    """
    5861    if sql_path is None or isinstance(sql_path, Table):
    5862        return sql_path
    5863    if not isinstance(sql_path, str):
    5864        raise ValueError(f"Invalid type provided for a table: {type(sql_path)}")
    5865
    5866    table = maybe_parse(sql_path, into=Table, dialect=dialect)
    5867    if table:
    5868        for k, v in kwargs.items():
    5869            table.set(k, v)
    5870
    5871    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 | Column, **kwargs) -> Column: View Source

    5874def to_column(sql_path: str | Column, **kwargs) -> Column:
    5875    """
    5876    Create a column from a `[table].[column]` sql path. Schema is optional.
    5877
    5878    If a column is passed in then that column is returned.
    5879
    5880    Args:
    5881        sql_path: `[table].[column]` string
    5882    Returns:
    5883        Table: A column expression
    5884    """
    5885    if sql_path is None or isinstance(sql_path, Column):
    5886        return sql_path
    5887    if not isinstance(sql_path, str):
    5888        raise ValueError(f"Invalid type provided for column: {type(sql_path)}")
    5889    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, Expression], alias: str | Identifier, table: Union[bool, Sequence[str | Identifier]] = False, quoted: Optional[bool] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, copy: bool = True, **opts): View Source

    5892def alias_(
    5893    expression: ExpOrStr,
    5894    alias: str | Identifier,
    5895    table: bool | t.Sequence[str | Identifier] = False,
    5896    quoted: t.Optional[bool] = None,
    5897    dialect: DialectType = None,
    5898    copy: bool = True,
    5899    **opts,
    5900):
    5901    """Create an Alias expression.
    5902
    5903    Example:
    5904        >>> alias_('foo', 'bar').sql()
    5905        'foo AS bar'
    5906
    5907        >>> alias_('(select 1, 2)', 'bar', table=['a', 'b']).sql()
    5908        '(SELECT 1, 2) AS bar(a, b)'
    5909
    5910    Args:
    5911        expression: the SQL code strings to parse.
    5912            If an Expression instance is passed, this is used as-is.
    5913        alias: the alias name to use. If the name has
    5914            special characters it is quoted.
    5915        table: Whether or not to create a table alias, can also be a list of columns.
    5916        quoted: whether or not to quote the alias
    5917        dialect: the dialect used to parse the input expression.
    5918        copy: Whether or not to copy the expression.
    5919        **opts: other options to use to parse the input expressions.
    5920
    5921    Returns:
    5922        Alias: the aliased expression
    5923    """
    5924    exp = maybe_parse(expression, dialect=dialect, copy=copy, **opts)
    5925    alias = to_identifier(alias, quoted=quoted)
    5926
    5927    if table:
    5928        table_alias = TableAlias(this=alias)
    5929        exp.set("alias", table_alias)
    5930
    5931        if not isinstance(table, bool):
    5932            for column in table:
    5933                table_alias.append("columns", to_identifier(column, quoted=quoted))
    5934
    5935        return exp
    5936
    5937    # We don't set the "alias" arg for Window expressions, because that would add an IDENTIFIER node in
    5938    # the AST, representing a "named_window" [1] construct (eg. bigquery). What we want is an ALIAS node
    5939    # for the complete Window expression.
    5940    #
    5941    # [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls
    5942
    5943    if "alias" in exp.arg_types and not isinstance(exp, Window):
    5944        exp.set("alias", alias)
    5945        return exp
    5946    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, Expression], alias: Union[Identifier, str, NoneType] = None, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None, **opts) -> Select: View Source

    5949def subquery(
    5950    expression: ExpOrStr,
    5951    alias: t.Optional[Identifier | str] = None,
    5952    dialect: DialectType = None,
    5953    **opts,
    5954) -> Select:
    5955    """
    5956    Build a subquery expression.
    5957
    5958    Example:
    5959        >>> subquery('select x from tbl', 'bar').select('x').sql()
    5960        'SELECT x FROM (SELECT x FROM tbl) AS bar'
    5961
    5962    Args:
    5963        expression: the SQL code strings to parse.
    5964            If an Expression instance is passed, this is used as-is.
    5965        alias: the alias name to use.
    5966        dialect: the dialect used to parse the input expression.
    5967        **opts: other options to use to parse the input expressions.
    5968
    5969    Returns:
    5970        A new Select instance with the subquery expression included.
    5971    """
    5972
    5973    expression = maybe_parse(expression, dialect=dialect, **opts).subquery(alias)
    5974    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 | Identifier, table: Union[Identifier, str, NoneType] = None, db: Union[Identifier, str, NoneType] = None, catalog: Union[Identifier, str, NoneType] = None, quoted: Optional[bool] = None) -> Column: View Source

    5977def column(
    5978    col: str | Identifier,
    5979    table: t.Optional[str | Identifier] = None,
    5980    db: t.Optional[str | Identifier] = None,
    5981    catalog: t.Optional[str | Identifier] = None,
    5982    quoted: t.Optional[bool] = None,
    5983) -> Column:
    5984    """
    5985    Build a Column.
    5986
    5987    Args:
    5988        col: Column name.
    5989        table: Table name.
    5990        db: Database name.
    5991        catalog: Catalog name.
    5992        quoted: Whether to force quotes on the column's identifiers.
    5993
    5994    Returns:
    5995        The new Column instance.
    5996    """
    5997    return Column(
    5998        this=to_identifier(col, quoted=quoted),
    5999        table=to_identifier(table, quoted=quoted),
    6000        db=to_identifier(db, quoted=quoted),
    6001        catalog=to_identifier(catalog, quoted=quoted),
    6002    )

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, Expression], to: str | DataType | DataType.Type, **opts) -> Cast: View Source

    6005def cast(expression: ExpOrStr, to: str | DataType | DataType.Type, **opts) -> Cast:
    6006    """Cast an expression to a data type.
    6007
    6008    Example:
    6009        >>> cast('x + 1', 'int').sql()
    6010        'CAST(x + 1 AS INT)'
    6011
    6012    Args:
    6013        expression: The expression to cast.
    6014        to: The datatype to cast to.
    6015
    6016    Returns:
    6017        The new Cast instance.
    6018    """
    6019    expression = maybe_parse(expression, **opts)
    6020    data_type = DataType.build(to, **opts)
    6021    expression = Cast(this=expression, to=data_type)
    6022    expression.type = data_type
    6023    return expression

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: Identifier | str, db: Union[Identifier, str, NoneType] = None, catalog: Union[Identifier, str, NoneType] = None, quoted: Optional[bool] = None, alias: Union[Identifier, str, NoneType] = None) -> Table: View Source

    6026def table_(
    6027    table: Identifier | str,
    6028    db: t.Optional[Identifier | str] = None,
    6029    catalog: t.Optional[Identifier | str] = None,
    6030    quoted: t.Optional[bool] = None,
    6031    alias: t.Optional[Identifier | str] = None,
    6032) -> Table:
    6033    """Build a Table.
    6034
    6035    Args:
    6036        table: Table name.
    6037        db: Database name.
    6038        catalog: Catalog name.
    6039        quote: Whether to force quotes on the table's identifiers.
    6040        alias: Table's alias.
    6041
    6042    Returns:
    6043        The new Table instance.
    6044    """
    6045    return Table(
    6046        this=to_identifier(table, quoted=quoted) if table else None,
    6047        db=to_identifier(db, quoted=quoted) if db else None,
    6048        catalog=to_identifier(catalog, quoted=quoted) if catalog else None,
    6049        alias=TableAlias(this=to_identifier(alias)) if alias else None,
    6050    )

Build a Table.

###### Arguments:

- table: Table name.
- db: Database name.
- catalog: Catalog name.
- quote: Whether to force quotes on the table's identifiers.
- alias: Table's alias.

###### Returns:

> The new Table instance.

def values( values: Iterable[Tuple[Any, ...]], alias: Optional[str] = None, columns: Union[Iterable[str], Dict[str, DataType], NoneType] = None) -> Values: View Source

    6053def values(
    6054    values: t.Iterable[t.Tuple[t.Any, ...]],
    6055    alias: t.Optional[str] = None,
    6056    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
    6057) -> Values:
    6058    """Build VALUES statement.
    6059
    6060    Example:
    6061        >>> values([(1, '2')]).sql()
    6062        "VALUES (1, '2')"
    6063
    6064    Args:
    6065        values: values statements that will be converted to SQL
    6066        alias: optional alias
    6067        columns: Optional list of ordered column names or ordered dictionary of column names to types.
    6068         If either are provided then an alias is also required.
    6069
    6070    Returns:
    6071        Values: the Values expression object
    6072    """
    6073    if columns and not alias:
    6074        raise ValueError("Alias is required when providing columns")
    6075
    6076    return Values(
    6077        expressions=[convert(tup) for tup in values],
    6078        alias=(
    6079            TableAlias(this=to_identifier(alias), columns=[to_identifier(x) for x in columns])
    6080            if columns
    6081            else (TableAlias(this=to_identifier(alias)) if alias else None)
    6082        ),
    6083    )

Build VALUES statement.

###### Example:

>     >>> values([(1, '2')]).sql()
>     "VALUES (1, '2')"

###### Arguments:

- values: values statements that will be converted to SQL
- alias: optional alias
- columns: Optional list of ordered column names or ordered dictionary of column names to types. If either are provided then an alias is also required.

###### Returns:

> Values: the Values expression object

def var( name: Union[str, Expression, NoneType]) -> Var: View Source

    6086def var(name: t.Optional[ExpOrStr]) -> Var:
    6087    """Build a SQL variable.
    6088
    6089    Example:
    6090        >>> repr(var('x'))
    6091        '(VAR this: x)'
    6092
    6093        >>> repr(var(column('x', table='y')))
    6094        '(VAR this: x)'
    6095
    6096    Args:
    6097        name: The name of the var or an expression who's name will become the var.
    6098
    6099    Returns:
    6100        The new variable node.
    6101    """
    6102    if not name:
    6103        raise ValueError("Cannot convert empty name into var.")
    6104
    6105    if isinstance(name, Expression):
    6106        name = name.name
    6107    return Var(this=name)

Build a SQL variable.

###### Example:

>     >>> repr(var('x'))
>     '(VAR this: x)'

>     >>> repr(var(column('x', table='y')))
>     '(VAR this: x)'

###### Arguments:

- name: The name of the var or an expression who's name will become the var.

###### Returns:

> The new variable node.

def rename_table( old_name: str | Table, new_name: str | Table) -> AlterTable: View Source

    6110def rename_table(old_name: str | Table, new_name: str | Table) -> AlterTable:
    6111    """Build ALTER TABLE... RENAME... expression
    6112
    6113    Args:
    6114        old_name: The old name of the table
    6115        new_name: The new name of the table
    6116
    6117    Returns:
    6118        Alter table expression
    6119    """
    6120    old_table = to_table(old_name)
    6121    new_table = to_table(new_name)
    6122    return AlterTable(
    6123        this=old_table,
    6124        actions=[
    6125            RenameTable(this=new_table),
    6126        ],
    6127    )

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

    6130def convert(value: t.Any, copy: bool = False) -> Expression:
    6131    """Convert a python value into an expression object.
    6132
    6133    Raises an error if a conversion is not possible.
    6134
    6135    Args:
    6136        value: A python object.
    6137        copy: Whether or not to copy `value` (only applies to Expressions and collections).
    6138
    6139    Returns:
    6140        Expression: the equivalent expression object.
    6141    """
    6142    if isinstance(value, Expression):
    6143        return maybe_copy(value, copy)
    6144    if isinstance(value, str):
    6145        return Literal.string(value)
    6146    if isinstance(value, bool):
    6147        return Boolean(this=value)
    6148    if value is None or (isinstance(value, float) and math.isnan(value)):
    6149        return NULL
    6150    if isinstance(value, numbers.Number):
    6151        return Literal.number(value)
    6152    if isinstance(value, datetime.datetime):
    6153        datetime_literal = Literal.string(
    6154            (value if value.tzinfo else value.replace(tzinfo=datetime.timezone.utc)).isoformat()
    6155        )
    6156        return TimeStrToTime(this=datetime_literal)
    6157    if isinstance(value, datetime.date):
    6158        date_literal = Literal.string(value.strftime("%Y-%m-%d"))
    6159        return DateStrToDate(this=date_literal)
    6160    if isinstance(value, tuple):
    6161        return Tuple(expressions=[convert(v, copy=copy) for v in value])
    6162    if isinstance(value, list):
    6163        return Array(expressions=[convert(v, copy=copy) for v in value])
    6164    if isinstance(value, dict):
    6165        return Map(
    6166            keys=Array(expressions=[convert(k, copy=copy) for k in value]),
    6167            values=Array(expressions=[convert(v, copy=copy) for v in value.values()]),
    6168        )
    6169    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: Expression, fun: Callable, *args, **kwargs) -> None: View Source

    6172def replace_children(expression: Expression, fun: t.Callable, *args, **kwargs) -> None:
    6173    """
    6174    Replace children of an expression with the result of a lambda fun(child) -> exp.
    6175    """
    6176    for k, v in expression.args.items():
    6177        is_list_arg = type(v) is list
    6178
    6179        child_nodes = v if is_list_arg else [v]
    6180        new_child_nodes = []
    6181
    6182        for cn in child_nodes:
    6183            if isinstance(cn, Expression):
    6184                for child_node in ensure_collection(fun(cn, *args, **kwargs)):
    6185                    new_child_nodes.append(child_node)
    6186                    child_node.parent = expression
    6187                    child_node.arg_key = k
    6188            else:
    6189                new_child_nodes.append(cn)
    6190
    6191        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: Expression, exclude: str = '') -> Set[str]: View Source

    6194def column_table_names(expression: Expression, exclude: str = "") -> t.Set[str]:
    6195    """
    6196    Return all table names referenced through columns in an expression.
    6197
    6198    Example:
    6199        >>> import sqlglot
    6200        >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
    6201        ['a', 'c']
    6202
    6203    Args:
    6204        expression: expression to find table names.
    6205        exclude: a table name to exclude
    6206
    6207    Returns:
    6208        A list of unique names.
    6209    """
    6210    return {
    6211        table
    6212        for table in (column.table for column in expression.find_all(Column))
    6213        if table and table != exclude
    6214    }

Return all table names referenced through columns in an expression.

###### Example:

>     >>> import sqlglot
>     >>> sorted(column_table_names(sqlglot.parse_one("a.b AND c.d AND c.e")))
>     ['a', 'c']

###### Arguments:

- expression: expression to find table names.
- exclude: a table name to exclude

###### Returns:

> A list of unique names.

def table_name( table: Table | str, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None) -> str: View Source

    6217def table_name(table: Table | str, dialect: DialectType = None) -> str:
    6218    """Get the full name of a table as a string.
    6219
    6220    Args:
    6221        table: Table expression node or string.
    6222        dialect: The dialect to generate the table name for.
    6223
    6224    Examples:
    6225        >>> from sqlglot import exp, parse_one
    6226        >>> table_name(parse_one("select * from a.b.c").find(exp.Table))
    6227        'a.b.c'
    6228
    6229    Returns:
    6230        The table name.
    6231    """
    6232
    6233    table = maybe_parse(table, into=Table, dialect=dialect)
    6234
    6235    if not table:
    6236        raise ValueError(f"Cannot parse {table}")
    6237
    6238    return ".".join(
    6239        part.sql(dialect=dialect, identify=True)
    6240        if not SAFE_IDENTIFIER_RE.match(part.name)
    6241        else part.name
    6242        for part in table.parts
    6243    )

Get the full name of a table as a string.

###### Arguments:

- table: Table expression node or string.
- dialect: The dialect to generate the table name for.

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

    6246def replace_tables(expression: E, mapping: t.Dict[str, str], copy: bool = True) -> E:
    6247    """Replace all tables in expression according to the mapping.
    6248
    6249    Args:
    6250        expression: expression node to be transformed and replaced.
    6251        mapping: mapping of table names.
    6252        copy: whether or not to copy the expression.
    6253
    6254    Examples:
    6255        >>> from sqlglot import exp, parse_one
    6256        >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql()
    6257        'SELECT * FROM c'
    6258
    6259    Returns:
    6260        The mapped expression.
    6261    """
    6262
    6263    def _replace_tables(node: Expression) -> Expression:
    6264        if isinstance(node, Table):
    6265            new_name = mapping.get(table_name(node))
    6266            if new_name:
    6267                return to_table(
    6268                    new_name,
    6269                    **{k: v for k, v in node.args.items() if k not in ("this", "db", "catalog")},
    6270                )
    6271        return node
    6272
    6273    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: Expression, *args, **kwargs) -> Expression: View Source

    6276def replace_placeholders(expression: Expression, *args, **kwargs) -> Expression:
    6277    """Replace placeholders in an expression.
    6278
    6279    Args:
    6280        expression: expression node to be transformed and replaced.
    6281        args: positional names that will substitute unnamed placeholders in the given order.
    6282        kwargs: keyword arguments that will substitute named placeholders.
    6283
    6284    Examples:
    6285        >>> from sqlglot import exp, parse_one
    6286        >>> replace_placeholders(
    6287        ...     parse_one("select * from :tbl where ? = ?"),
    6288        ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
    6289        ... ).sql()
    6290        "SELECT * FROM foo WHERE str_col = 'b'"
    6291
    6292    Returns:
    6293        The mapped expression.
    6294    """
    6295
    6296    def _replace_placeholders(node: Expression, args, **kwargs) -> Expression:
    6297        if isinstance(node, Placeholder):
    6298            if node.name:
    6299                new_name = kwargs.get(node.name)
    6300                if new_name:
    6301                    return convert(new_name)
    6302            else:
    6303                try:
    6304                    return convert(next(args))
    6305                except StopIteration:
    6306                    pass
    6307        return node
    6308
    6309    return expression.transform(_replace_placeholders, iter(args), **kwargs)

Replace placeholders in an expression.

###### Arguments:

- expression: expression node to be transformed and replaced.
- args: positional names that will substitute unnamed placeholders in the given order.
- kwargs: keyword arguments that will substitute named placeholders.

###### Examples:

>     >>> from sqlglot import exp, parse_one
>     >>> replace_placeholders(
>     ...     parse_one("select * from :tbl where ? = ?"),
>     ...     exp.to_identifier("str_col"), "b", tbl=exp.to_identifier("foo")
>     ... ).sql()
>     "SELECT * FROM foo WHERE str_col = 'b'"

###### Returns:

> The mapped expression.

def expand( expression: Expression, sources: Dict[str, Subqueryable], copy: bool = True) -> Expression: View Source

    6312def expand(
    6313    expression: Expression, sources: t.Dict[str, Subqueryable], copy: bool = True
    6314) -> Expression:
    6315    """Transforms an expression by expanding all referenced sources into subqueries.
    6316
    6317    Examples:
    6318        >>> from sqlglot import parse_one
    6319        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y")}).sql()
    6320        'SELECT * FROM (SELECT * FROM y) AS z /* source: x */'
    6321
    6322        >>> expand(parse_one("select * from x AS z"), {"x": parse_one("select * from y"), "y": parse_one("select * from z")}).sql()
    6323        'SELECT * FROM (SELECT * FROM (SELECT * FROM z) AS y /* source: y */) AS z /* source: x */'
    6324
    6325    Args:
    6326        expression: The expression to expand.
    6327        sources: A dictionary of name to Subqueryables.
    6328        copy: Whether or not to copy the expression during transformation. Defaults to True.
    6329
    6330    Returns:
    6331        The transformed expression.
    6332    """
    6333
    6334    def _expand(node: Expression):
    6335        if isinstance(node, Table):
    6336            name = table_name(node)
    6337            source = sources.get(name)
    6338            if source:
    6339                subquery = source.subquery(node.alias or name)
    6340                subquery.comments = [f"source: {name}"]
    6341                return subquery.transform(_expand, copy=False)
    6342        return node
    6343
    6344    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) -> Func: View Source

    6347def func(name: str, *args, dialect: DialectType = None, **kwargs) -> Func:
    6348    """
    6349    Returns a Func expression.
    6350
    6351    Examples:
    6352        >>> func("abs", 5).sql()
    6353        'ABS(5)'
    6354
    6355        >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql()
    6356        'CAST(5 AS DOUBLE)'
    6357
    6358    Args:
    6359        name: the name of the function to build.
    6360        args: the args used to instantiate the function of interest.
    6361        dialect: the source dialect.
    6362        kwargs: the kwargs used to instantiate the function of interest.
    6363
    6364    Note:
    6365        The arguments `args` and `kwargs` are mutually exclusive.
    6366
    6367    Returns:
    6368        An instance of the function of interest, or an anonymous function, if `name` doesn't
    6369        correspond to an existing `sqlglot.expressions.Func` class.
    6370    """
    6371    if args and kwargs:
    6372        raise ValueError("Can't use both args and kwargs to instantiate a function.")
    6373
    6374    from sqlglot.dialects.dialect import Dialect
    6375
    6376    converted: t.List[Expression] = [maybe_parse(arg, dialect=dialect) for arg in args]
    6377    kwargs = {key: maybe_parse(value, dialect=dialect) for key, value in kwargs.items()}
    6378
    6379    parser = Dialect.get_or_raise(dialect)().parser()
    6380    from_args_list = parser.FUNCTIONS.get(name.upper())
    6381
    6382    if from_args_list:
    6383        function = from_args_list(converted) if converted else from_args_list.__self__(**kwargs)  # type: ignore
    6384    else:
    6385        kwargs = kwargs or {"expressions": converted}
    6386        function = Anonymous(this=name, **kwargs)
    6387
    6388    for error_message in function.error_messages(converted):
    6389        raise ValueError(error_message)
    6390
    6391    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 `Func` class.

def true() -> Boolean: View Source

    6394def true() -> Boolean:
    6395    """
    6396    Returns a true Boolean expression.
    6397    """
    6398    return Boolean(this=True)

Returns a true Boolean expression.

def false() -> Boolean: View Source

    6401def false() -> Boolean:
    6402    """
    6403    Returns a false Boolean expression.
    6404    """
    6405    return Boolean(this=False)

Returns a false Boolean expression.

def null() -> Null: View Source

    6408def null() -> Null:
    6409    """
    6410    Returns a Null expression.
    6411    """
    6412    return Null()

Returns a Null expression.

TRUE = (BOOLEAN this: True)
FALSE = (BOOLEAN this: False)
NULL = (NULL )