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.
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()
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
DataTypetype 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.
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)
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.
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 ''
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.
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)
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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]
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.Generatoroptions.
Returns:
The SQL string.
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.
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.
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.
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'
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.
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.
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.
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
Expressioninstance 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.
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
Expressioninstance 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.
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.
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 )
Logical conditions like x AND y, or simply x
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
Relationships like x = y, x > 1, x >= y.
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
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]
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
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)
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
Expressioninstance 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.
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
Expressioninstance 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.
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
Expressioninstance is passed, it will be used as-is. - distinct: set the DISTINCT flag if and only if this is true.
- dialect: the dialect used to parse the input expression.
- opts: other options to use to parse the input expressions.
Returns:
The new Except expression.
Inherited Members
- Expression
- Expression
- 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
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 []
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
1002class Cache(Expression): 1003 arg_types = { 1004 "with": False, 1005 "this": True, 1006 "lazy": False, 1007 "options": False, 1008 "expression": False, 1009 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 []
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
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1069class Describe(Expression): 1070 arg_types = {"this": True, "kind": False, "expressions": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1117class UserDefinedFunction(Expression): 1118 arg_types = {"this": True, "expressions": False, "wrapped": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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"))
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1141class TableAlias(Expression): 1142 arg_types = {"this": False, "columns": False} 1143 1144 @property 1145 def columns(self): 1146 return self.args.get("columns") 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
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
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
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
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
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]
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 ''
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.
Inherited Members
- Expression
- Expression
- args
- parent
- arg_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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 []
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
1239class Comment(Expression): 1240 arg_types = {"this": True, "kind": True, "expression": True, "exists": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1243class Comprehension(Expression): 1244 arg_types = {"this": True, "expression": True, "iterator": True, "condition": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1248class MergeTreeTTLAction(Expression): 1249 arg_types = { 1250 "this": True, 1251 "delete": False, 1252 "recompress": False, 1253 "to_disk": False, 1254 "to_volume": False, 1255 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1259class MergeTreeTTL(Expression): 1260 arg_types = { 1261 "expressions": True, 1262 "where": False, 1263 "group": False, 1264 "aggregates": False, 1265 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1281class ColumnConstraint(Expression): 1282 arg_types = {"this": False, "kind": True} 1283 1284 @property 1285 def kind(self) -> ColumnConstraintKind: 1286 return self.args["kind"]
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1352class IndexColumnConstraint(ColumnConstraintKind): 1353 arg_types = { 1354 "this": False, 1355 "schema": True, 1356 "kind": False, 1357 "index_type": False, 1358 "options": False, 1359 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
1391class UniqueColumnConstraint(ColumnConstraintKind): 1392 arg_types = {"this": False, "index_type": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
1405class ComputedColumnConstraint(ColumnConstraintKind): 1406 arg_types = {"this": True, "persisted": False, "not_null": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 )
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.
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
Expressioninstance 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.
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
Expressioninstance is passed, it will be used as-is. - dialect: the dialect used to parse the input expressions.
- copy: if
False, modify this expression instance in-place. - opts: other options to use to parse the input expressions.
Returns:
Delete: the modified expression.
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1567class ForeignKey(Expression): 1568 arg_types = { 1569 "expressions": True, 1570 "reference": False, 1571 "delete": False, 1572 "update": False, 1573 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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 ''
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 )
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
Expressioninstance is passed, this is used as-is. - as_: the SQL code string to parse as the table expression.
If an
Expressioninstance is passed, it will be used as-is. - recursive: set the RECURSIVE part of the expression. Defaults to
False. - append: if
True, add to any existing expressions. Otherwise, this resets the expressions. - dialect: the dialect used to parse the input expression.
- copy: if
False, modify this expression instance in-place. - opts: other options to use to parse the input expressions.
Returns:
The modified expression.
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1701class OnConflict(Expression): 1702 arg_types = { 1703 "duplicate": False, 1704 "expressions": False, 1705 "nothing": False, 1706 "key": False, 1707 "constraint": False, 1708 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1741class Fetch(Expression): 1742 arg_types = { 1743 "direction": False, 1744 "count": False, 1745 "percent": False, 1746 "with_ties": False, 1747 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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 ''
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
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
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
Expressioninstance 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.
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
Expressioninstance is passed, it will be used as-is. - append: if
True, concatenate the new expressions to the existing "using" list. Otherwise, this resets the expression. - dialect: the dialect used to parse the input expressions.
- copy: if
False, modify this expression instance in-place. - opts: other options to use to parse the input expressions.
Returns:
The modified Join expression.
Inherited Members
- Expression
- Expression
- 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
1909class Lateral(UDTF): 1910 arg_types = {"this": True, "view": False, "outer": False, "alias": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1970class BlockCompressionProperty(Property): 1971 arg_types = {"autotemp": False, "always": False, "default": True, "manual": True, "never": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
1990class DataBlocksizeProperty(Property): 1991 arg_types = { 1992 "size": False, 1993 "units": False, 1994 "minimum": False, 1995 "maximum": False, 1996 "default": False, 1997 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
2062class JournalProperty(Property): 2063 arg_types = { 2064 "no": False, 2065 "dual": False, 2066 "before": False, 2067 "local": False, 2068 "after": False, 2069 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
2077class ClusteredByProperty(Property): 2078 arg_types = {"expressions": True, "sorted_by": False, "buckets": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
2125class MergeBlockRatioProperty(Property): 2126 arg_types = {"this": False, "no": False, "default": False, "percent": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
2149class ReturnsProperty(Property): 2150 arg_types = {"this": True, "is_table": False, "table": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
2170class RowFormatSerdeProperty(Property): 2171 arg_types = {"this": True, "serde_properties": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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)
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)
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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.
Inherited Members
- enum.Enum
- name
- value
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
2309class InputOutputFormat(Expression): 2310 arg_types = {"input_format": False, "output_format": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
2318class Reference(Expression): 2319 arg_types = {"this": True, "expressions": False, "options": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 )
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 )
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_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
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 )
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
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
Expressioninstance is passed, this is used as-is. - as_: the SQL code string to parse as the table expression.
If an
Expressioninstance is passed, it will be used as-is. - recursive: set the RECURSIVE part of the expression. Defaults to
False. - append: if
True, add to any existing expressions. Otherwise, this resets the expressions. - dialect: the dialect used to parse the input expression.
- copy: if
False, modify this expression instance in-place. - opts: other options to use to parse the input expressions.
Returns:
The modified expression.
Inherited Members
- Expression
- Expression
- 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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
2467class IndexTableHint(Expression): 2468 arg_types = {"this": True, "expressions": False, "target": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- 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
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
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
Limitinstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aLimit. - 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.
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
Expressioninstance 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.
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
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
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
2627class Unnest(UDTF): 2628 arg_types = { 2629 "expressions": True, 2630 "alias": False, 2631 "offset": False, 2632 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
2648class Values(UDTF): 2649 arg_types = { 2650 "expressions": True, 2651 "ordinality": False, 2652 "alias": False, 2653 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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")
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Frominstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aFrom. - 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.
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
Groupinstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aGroup. 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 theGroupexpression 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.
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
Groupinstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aOrder. - append: if
True, add to any existing expressions. Otherwise, this flattens all theOrderexpression 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.
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
Groupinstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aSORT. - append: if
True, add to any existing expressions. Otherwise, this flattens all theOrderexpression 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.
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
Groupinstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aCluster. - append: if
True, add to any existing expressions. Otherwise, this flattens all theOrderexpression 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.
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
Limitinstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aLimit. - 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.
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
Offsetinstance is passed, this is used as-is. If anotherExpressioninstance is passed, it will be wrapped in aOffset. - 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.
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
Expressioninstance 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.
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
Expressioninstance 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.
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_typeto 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
Expressioninstance is passed, it will be used as-is. - on: optionally specify the join "on" criteria as a SQL string.
If an
Expressioninstance is passed, it will be used as-is. - using: optionally specify the join "using" criteria as a SQL string.
If an
Expressioninstance 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.
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
Expressioninstance 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.
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
Expressioninstance 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.
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 )
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 )
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.
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
Expressioninstance 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.
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 beFOR UPDATE, else it will beFOR SHARE. - copy: if
False, modify this expression instance in-place.
Returns:
The modified expression.
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
Expressioninstance 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.
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
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
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.
Whether this Subquery acts as a simple wrapper around another expression.
SELECT * FROM (((SELECT * FROM t))) ^ This corresponds to a "wrapper" Subquery node
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 ''
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
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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.
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
3474class WindowSpec(Expression): 3475 arg_types = { 3476 "kind": False, 3477 "start": False, 3478 "start_side": False, 3479 "end": False, 3480 "end_side": False, 3481 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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 ''
Inherited Members
- Expression
- 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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
3512class Null(Condition): 3513 arg_types: t.Dict[str, t.Any] = {} 3514 3515 @property 3516 def name(self) -> str: 3517 return "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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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,
dtypewill 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.
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
Arguments:
- dtypes: the data types to compare this DataType to.
Returns:
True, if and only if there is a type in
dtypeswhich is equal to this 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
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.
Inherited Members
- enum.Enum
- name
- value
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
3785class AlterTable(Expression): 3786 arg_types = {"this": True, "actions": True, "exists": False, "only": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
3789class AddConstraint(Expression): 3790 arg_types = {"this": False, "expression": False, "enforced": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 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 ''
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.
Inherited Members
- Expression
- 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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Kwarg in special functions like func(kwarg => y).
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
3990class Paren(Unary): 3991 arg_types = {"this": True, "with": False} 3992 3993 @property 3994 def output_name(self) -> str: 3995 return self.this.name
Name of the output column if this expression is a selection.
If the Expression has no output name, an empty string is returned.
Example:
>>> from sqlglot import parse_one >>> parse_one("SELECT a")sqlglot.expressions[0].output_name 'a' >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name 'c' >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name ''
Inherited Members
- Expression
- Expression
- args
- parent
- arg_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
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
4002class Alias(Expression): 4003 arg_types = {"this": True, "alias": False} 4004 4005 @property 4006 def output_name(self) -> str: 4007 return self.alias
Name of the output column if this expression is a selection.
If the Expression has no output name, an empty string is returned.
Example:
>>> from sqlglot import parse_one >>> parse_one("SELECT a")sqlglot.expressions[0].output_name 'a' >>> parse_one("SELECT b AS c")sqlglot.expressions[0].output_name 'c' >>> parse_one("SELECT 1 + 2")sqlglot.expressions[0].output_name ''
Inherited Members
- Expression
- Expression
- args
- parent
- arg_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
4010class Aliases(Expression): 4011 arg_types = {"this": True, "expressions": True} 4012 4013 @property 4014 def aliases(self): 4015 return self.expressions
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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 ''
Inherited Members
- Expression
- Expression
- args
- parent
- arg_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
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.
Inherited Members
- Expression
- Expression
- args
- parent
- arg_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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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.
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
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 )
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
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.
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)
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
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
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
4158class ParameterizedAgg(AggFunc): 4159 arg_types = {"this": True, "expressions": True, "params": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4171class Anonymous(Func): 4172 arg_types = {"this": True, "expressions": False} 4173 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4178class Hll(AggFunc): 4179 arg_types = {"this": True, "expressions": False} 4180 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4183class ApproxDistinct(AggFunc): 4184 arg_types = {"this": True, "accuracy": False} 4185 _sql_names = ["APPROX_DISTINCT", "APPROX_COUNT_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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4214class ArrayConcat(Func): 4215 _sql_names = ["ARRAY_CONCAT", "ARRAY_CAT"] 4216 arg_types = {"this": True, "expressions": False} 4217 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4228class ArrayFilter(Func): 4229 arg_types = {"this": True, "expression": True} 4230 _sql_names = ["FILTER", "ARRAY_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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
4257class AnyValue(AggFunc): 4258 arg_types = {"this": True, "having": False, "max": False, "ignore_nulls": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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)
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 ''
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
Arguments:
- dtypes: the data types to compare this Cast's DataType to.
Returns:
True, if and only if there is a type in
dtypeswhich is equal to this Cast's 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
- 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
Inherited Members
- Expression
- 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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4331class Ceil(Func): 4332 arg_types = {"this": True, "decimals": False} 4333 _sql_names = ["CEIL", "CEILING"]
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4336class Coalesce(Func): 4337 arg_types = {"this": True, "expressions": False} 4338 is_var_len_args = True 4339 _sql_names = ["COALESCE", "IFNULL", "NVL"]
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4342class Chr(Func): 4343 arg_types = {"this": True, "charset": False, "expressions": False} 4344 is_var_len_args = True 4345 _sql_names = ["CHR", "CHAR"]
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4361class Count(AggFunc): 4362 arg_types = {"this": False, "expressions": False} 4363 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4390class DateAdd(Func, IntervalOp): 4391 arg_types = {"this": True, "expression": True, "unit": False}
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
4394class DateSub(Func, IntervalOp): 4395 arg_types = {"this": True, "expression": True, "unit": False}
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
4398class DateDiff(Func, TimeUnit): 4399 _sql_names = ["DATEDIFF", "DATE_DIFF"] 4400 arg_types = {"this": True, "expression": True, "unit": False}
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
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"]
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4411class DatetimeAdd(Func, IntervalOp): 4412 arg_types = {"this": True, "expression": True, "unit": False}
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
4415class DatetimeSub(Func, IntervalOp): 4416 arg_types = {"this": True, "expression": True, "unit": False}
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
4419class DatetimeDiff(Func, TimeUnit): 4420 arg_types = {"this": True, "expression": True, "unit": False}
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
4423class DatetimeTrunc(Func, TimeUnit): 4424 arg_types = {"this": True, "unit": True, "zone": False}
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
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
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
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
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
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
4447class MonthsBetween(Func): 4448 arg_types = {"this": True, "expression": True, "roundoff": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4463class TimestampAdd(Func, TimeUnit): 4464 arg_types = {"this": True, "expression": True, "unit": False}
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
4467class TimestampSub(Func, TimeUnit): 4468 arg_types = {"this": True, "expression": True, "unit": False}
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
4471class TimestampDiff(Func, TimeUnit): 4472 arg_types = {"this": True, "expression": True, "unit": False}
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
4475class TimestampTrunc(Func, TimeUnit): 4476 arg_types = {"this": True, "unit": True, "zone": False}
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
4479class TimeAdd(Func, TimeUnit): 4480 arg_types = {"this": True, "expression": True, "unit": False}
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
4483class TimeSub(Func, TimeUnit): 4484 arg_types = {"this": True, "expression": True, "unit": False}
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
4487class TimeDiff(Func, TimeUnit): 4488 arg_types = {"this": True, "expression": True, "unit": False}
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
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
4495class DateFromParts(Func): 4496 _sql_names = ["DATEFROMPARTS"] 4497 arg_types = {"year": True, "month": True, "day": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
4513class Date(Func): 4514 arg_types = {"this": False, "zone": False, "expressions": False} 4515 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
4554class Greatest(Func): 4555 arg_types = {"this": True, "expressions": False} 4556 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
4567class Xor(Connector, Func): 4568 arg_types = {"this": False, "expression": False, "expressions": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4602class JSONArray(Func): 4603 arg_types = { 4604 "expressions": True, 4605 "null_handling": False, 4606 "return_type": False, 4607 "strict": False, 4608 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4612class JSONArrayAgg(Func): 4613 arg_types = { 4614 "this": True, 4615 "order": False, 4616 "null_handling": False, 4617 "return_type": False, 4618 "strict": False, 4619 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4629class JSONTable(Func): 4630 arg_types = { 4631 "this": True, 4632 "expressions": True, 4633 "path": False, 4634 "error_handling": False, 4635 "empty_handling": False, 4636 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4639class OpenJSONColumnDef(Expression): 4640 arg_types = {"this": True, "kind": True, "path": False, "as_json": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4667class JSONFormat(Func): 4668 arg_types = {"this": False, "options": False} 4669 _sql_names = ["JSON_FORMAT"]
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4677class ParseJSON(Func): 4678 # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE 4679 _sql_names = ["PARSE_JSON", "JSON_PARSE"]
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
4682class Least(Func): 4683 arg_types = {"this": True, "expressions": False} 4684 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4763class MatchAgainst(Func): 4764 arg_types = {"this": True, "expressions": True, "modifier": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4767class Max(AggFunc): 4768 arg_types = {"this": True, "expressions": False} 4769 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
4781class Min(AggFunc): 4782 arg_types = {"this": True, "expressions": False} 4783 is_var_len_args = True
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
4799class Predict(Func): 4800 arg_types = {"this": True, "expression": True, "params_struct": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4819class ApproxQuantile(Quantile): 4820 arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4827class ReadCSV(Func): 4828 _sql_names = ["READ_CSV"] 4829 is_var_len_args = True 4830 arg_types = {"this": True, "expressions": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4833class Reduce(Func): 4834 arg_types = {"this": True, "initial": True, "merge": True, "finish": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4859class RegexpLike(Binary, Func): 4860 arg_types = {"this": True, "expression": True, "flag": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4920class StartsWith(Func): 4921 _sql_names = ["STARTS_WITH", "STARTSWITH"] 4922 arg_types = {"this": True, "expression": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4925class StrPosition(Func): 4926 arg_types = { 4927 "this": True, 4928 "substr": True, 4929 "position": False, 4930 "instance": False, 4931 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4950class StrToMap(Func): 4951 arg_types = { 4952 "this": True, 4953 "pair_delim": False, 4954 "key_value_delim": False, 4955 "duplicate_resolution_callback": False, 4956 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
4978class Stuff(Func): 4979 _sql_names = ["STUFF", "INSERT"] 4980 arg_types = {"this": True, "start": True, "length": True, "expression": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
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
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
5027class Trim(Func): 5028 arg_types = { 5029 "this": True, 5030 "expression": False, 5031 "position": False, 5032 "collation": False, 5033 }
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
5036class TsOrDsAdd(Func, TimeUnit): 5037 arg_types = {"this": True, "expression": True, "unit": False}
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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")
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
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
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
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
5090class XMLTable(Func): 5091 arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
5102class Merge(Expression): 5103 arg_types = {"this": True, "using": True, "on": True, "expressions": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
5106class When(Func): 5107 arg_types = {"matched": True, "source": False, "condition": False, "then": True}
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
Inherited Members
- Expression
- Expression
- args
- parent
- arg_key
- comments
- hashable_args
- this
- expression
- expressions
- text
- is_string
- is_number
- is_int
- is_star
- alias
- alias_column_names
- name
- alias_or_name
- output_name
- type
- meta
- copy
- add_comments
- append
- set
- depth
- iter_expressions
- find
- find_all
- find_ancestor
- parent_select
- same_parent
- root
- walk
- dfs
- bfs
- unnest
- unalias
- unnest_operands
- flatten
- sql
- transform
- replace
- pop
- assert_is
- error_messages
- dump
- load
- and_
- or_
- not_
- as_
- isin
- between
- is_
- like
- ilike
- eq
- neq
- rlike
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.
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
Expressioninstance is passed, it will be used as-is. - right: the SQL code string corresponding to the right-hand side.
If an
Expressioninstance 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.
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
Expressioninstance is passed, it will be used as-is. - right: the SQL code string corresponding to the right-hand side.
If an
Expressioninstance 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.
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
Expressioninstance is passed, it will be used as-is. - right: the SQL code string corresponding to the right-hand side.
If an
Expressioninstance 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.
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.
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.
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.
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.
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.
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
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
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
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.
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.
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.
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'.
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
Tableexpression with.
Returns:
A table expression.
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
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
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.
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.
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.
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.
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
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.
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
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.
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.
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.
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.
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.
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.
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.
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
argsandkwargsare mutually exclusive.
Returns:
An instance of the function of interest, or an anonymous function, if
namedoesn't correspond to an existingFuncclass.
6394def true() -> Boolean: 6395 """ 6396 Returns a true Boolean expression. 6397 """ 6398 return Boolean(this=True)
Returns a true Boolean expression.
6401def false() -> Boolean: 6402 """ 6403 Returns a false Boolean expression. 6404 """ 6405 return Boolean(this=False)
Returns a false Boolean expression.
Returns a Null expression.