o 8Di@sKUdZddlmZddlZddlZddlZddlZddlZddlZ ddl m Z ddl m Z ddlmZddlmZddlmZdd lmZmZdd lmZmZmZmZmZmZmZmZdd l m!Z!m"Z"e j#rdd l$m%Z%dd l&m'Z'm(Z(ddl)m*Z*e j+dddZ,e j+dddZ-Gddde.Z/dZ0dZ1dZ2dZ3dZ4Gddde/dZ5e j6e7e j8e5e j9e j6e7e j8e5ffZ:e j6e7e5fZ;Gddde5ZGd$dde5Z?Gd%d&d&e>Z@Gd'd(d(e5ZAGd)d*d*e5ZBGd+d,d,e5ZCGd-d.d.e5ZDGd/d0d0e5ZEGd1d2d2eDZFGd3d4d4e5ZGGd5d6d6e5ZHGd7d8d8e5ZIGd9d:d:e5ZJGd;d<dd>e5ZLGd?d@d@e5ZMGdAdBdBe5ZNGdCdDdDe5ZOGdEdFdFe5ZPGdGdHdHe5ZQGdIdJdJe5ZRGdKdLdLe5ZSGdMdNdNe5ZTGdOdPdPe5ZUGdQdRdRe5ZVGdSdTdTe5ZWGdUdVdVe5ZXGdWdXdXe5ZYGdYdZdZe5ZZGd[d\d\e>Z[Gd]d^d^e5Z\Gd_d`d`e5Z]Gdadbdbe<Z^Gdcdddde<Z_Gdedfdfe<Z`Gdgdhdhe<ZaGdidjdje<ZbGdkdldle<ZcGdmdndne5ZdGdodpdpe5ZeGdqdrdre5ZfGdsdtdte5ZgGdudvdve5ZhGdwdxdxe5ZiGdydzdze5ZjGd{d|d|e5ZkGd}d~d~e5ZlGddde5ZmGddde5ZnGddde5ZoGddde5ZpGddde5ZqGddde5ZrGddde5ZsGddde5ZtGdddetZuGdddetZvGdddetZwGdddetZxGdddetZyGdddetZzGdddetZ{GdddetZ|GdddetZ}GdddetZ~GdddetZGdddetZGdddetZGdddetZGddde5ZGdddetZGdddetZGdddetZGdddetZGdddetZGdddetZGdddetZGdddetZGdddetZGdddetZGdd„detZGddĄdetZGddƄdetZGddȄde5ZGddʄdetZGdd̄detZGdd΄detZGddЄde5ZGdd҄deEZGddԄde5ZGddքde5ZGdd؄de5ZGddڄde5ZGdd܄de5ZGddބde5ZGddde5ZGdddeEZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGdddeDeEZGddde5ZGddde5ZGddde5ZGd d d e5ZGd d d e5ZGd dde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGdd d e5ZGd!d"d"e5ZGd#d$d$e5ZGd%d&d&e5ZGd'd(d(e5ZGd)d*d*e5ZGd+d,d,e<ZGd-d.d.e5ZGd/d0d0e@ZGd1d2d2e@ZGd3d4d4e5ZGd5d6d6e5ZGd7d8d8e5ZGd9d:d:e5ZGd;d<dd>e5ZGd?d@d@e˃ZGdAdBdBe˃ZGdCdDdDe˃ZGdEdFdFe5ZGdGdHdHe5ZGdIdJdJe5ZGdKdLdLe5ZGdMdNdNe5ZGdOdPdPeуZGdQdRdReуZGdSdTdTeуZGdUdVdVeуZGdWdXdXeуZGdYdZdZeуZGd[d\d\eуZGd]d^d^eуZGd_d`d`eуZGdadbdbeуZGdcddddeуZGdedfdfeуZGdgdhdheуZGdidjdjeуZGdkdldleуZGdmdndneуZGdodpdpeуZGdqdrdreуZGdsdtdteуZGdudvdveуZGdwdxdxeуZGdydzdzeуZGd{d|d|eуZGd}d~d~eуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZGdddeуZ GdddeуZ GdddeуZ Gddde5Z GdddeуZ Gdd„de5ZGdÐdĄdeуZGdŐdƄdeуZGdǐdȄdeуZGdɐdʄdeуZGdːd̄deуZGd͐d΄deуZGdϐdЄdeуZGdѐd҄deуZGdӐdԄde5ZGdՐdքdeуZGdאd؄deуZGdِdڄdeуZGdېd܄deуZGdݐdބdeуZGdߐddeуZGdddeуZGdddeуZGdddeуZ GdddeуZ!GdddeуZ"GdddeуZ#GdddeуZ$GdddeуZ%GdddeуZ&GdddeteуZ'GdddeуZ(GdddeуZ)GdddeуZ*GdddeуZ+GdddeуZ,GdddeуZ-GdddeуZ.GdddeуZ/GdddeуZ0GdddeуZ1Gd d d eуZ2Gd d d eуZ3Gd ddeуZ4GdddeуZ5Gddde5Z6Gddde5Z7Gddde5Z8Gddde5Z9Gddde5Z:Gddde5Z;iddddd dd!dd"dd#dd$dd%dd&dd'dd(dd)dd*dd+dd,dd-dd.ddddddd/ZGd4d5d5e5Z?Gd6d7d7e5Z@Gd8d9d9e5ZAGd:d;d;e5ZBGd<d=d=e5ZCGd>dde?ZDGd?d@d@eDZ6GdAdBdBeDZEGdCdDdDeDZFGdEdFdFeEZGGdGdHdHe@ZHGdIdJdJe5ZIGdKdLdLe5ZJGdMdNdNe5ZKGdOdPdPe5ZLGdQdRdRe?ZMeMeDfZNGdSdTdTe>e?ZOGdUdVdVe5ZPGdWdXdXe5ZQGdYdZdZe5ZRGd[d\d\e5ZSGd]d^d^e<ZTGd_d`d`e5ZUGdadbdbe5ZVGdcdddde5ZWGdedfdfe5ZXGdgdhdhe<ZYGdidjdje<ZZGdkdldle<Z[Gdmdndne<Z\Gdodpdpe<Z]Gdqdrdre5Z^Gdsdtdte5Z_Gdudvdve_Z`Gdwdxdxe_ZaGdydzdze=ZbGd{d|d|ebZcGd}d~d~ebZdGddde5ZeGddde5ZfGddde5ZgGddde5ZhGddde5ZiGddde5ZjGddde5ZkGddde5ZlGddde5ZmGddde5ZnGddde5ZoGddde5ZpGddde5ZqGddde5ZrGddde5ZsGddde5ZtGddde5ZuGddde5ZvGddde5ZwGddde5ZxGddde<ZyGdddeyZzGdddeyZ{GdddeyZ|GdddeyZ}GdddeyZ~GdddeyZGdddeyZGdddeyZGdddeyZGdddeyZe j6e7eee_e_j8fZGdddeyZGdddeye=ZGdd„deye=ZGdÐdĄdĐeye=ZGdŐdƄdƐeyZGdǐdȄdȐeyZGdɐdʄdʐeyZGdːd̄d̐eye=ZGd͐d΄dΐeye=ZGdϐdЄdАeye=ZGdѐd҄dҐeye=ZGdӐdԄdԐeye=ZGdՐdքd֐eyZGdאd؄dؐeye=ZGdِdڄdڐeyZGdېd܄dܐeye=ZGdݐdބdސeye=ZGdߐddeye=ZGdddeye=ZGdddeyZGdddeyZGdddeye=ZGdddeyZGdddeye=ZGdddeyZGdddeyZGddde<ZGdddeZGdddeZGdddeZGdddeZGddde5ZGdddeZGddde5ZGddde5ZGddde5ZGddde5ZGddde5ZGd d d e5ZGd d d e=ZGd dde<ZGddde5ZGddde=ZGddde5ZGddde5ZGdddeZGddde_ZGdddeZGddde5ZGdd d e5ZGd!d"d"e5ZGd#d$d$e<ZGd%d&d&eZGd'd(d(eZGd)d*d*eZGd+d,d,eZGd-d.d.eZGd/d0d0eZGd1d2d2eZGd3d4d4eZGd5d6d6eZGd7d8d8eZGd9d:d:eZGd;d<d<eZGd=d>d>eăZGd?d@d@eZGdAdBdBeZGdCdDdDeZGdEdFdFeZGdGdHdHeZGdIdJdJeZGdKdLdLeZGdMdNdNeZGdOdPdPeZGdQdRdReZGdSdTdTeZGdUdVdVeZGdWdXdXeZGdYdZdZeZGd[d\d\eZGd]d^d^eZGd_d`d`eՃZGdadbdbeZGdcddddeZGdedfdfeZGdgdhdheZGdidjdjeZGdkdldleZGdmdndneZGdodpdpeyeZGdqdrdreyeZGdsdtdteZGdudvdveZGdwdxdxeZGdydzdzeZGd{d|d|eZGd}d~d~eZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeyeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGddde5ZGdddeyeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdd„deZGdÐdĄdĐeZGdŐdƄdƐeZ GdǐdȄdȐeZ GdɐdʄdʐeZ Gdːd̄d̐eZ Gd͐d΄dΐeZ GdϐdЄdАeZGdѐd҄dҐeZGdӐdԄdԐeZGdՐdքd֐eZGdאd؄dؐeeZGdِdڄdڐeeZGdېd܄dܐeeZGdݐdބdސeeZGdߐddeZGdddeZGdddeeZGdddeeZGdddeeZGdddeeZGdddeZGdddeZGdddeZGdddeZGdddeZ GdddeZ!GdddeZ"GdddeZ#GdddeeZ$GdddeZ%GdddeebZ&GdddeZ'GdddeeZ(GdddeeZ)GdddeeZ*Gd d d eeZ+Gd d d eeZ,Gd ddeeZ-GdddeeZ.GdddeeZ/GdddeZ0GdddeZ1GdddeZ2GdddeZ3GdddeZ4GdddeZ5Gdd d eZ6Gd!d"d"eZ7Gd#d$d$eZ8Gd%d&d&eZ9Gd'd(d(eZ:Gd)d*d*eZ;Gd+d,d,ee@ZGd1d2d2e<Z?Gd3d4d4e?e>Z@Gd5d6d6ee@ZAGd7d8d8eZBGd9d:d:eZCGd;d<d<eZDGd=d>d>eZEGd?d@d@eZFGdAdBdBeZGGdCdDdDeZHGdEdFdFeZIGdGdHdHeZJGdIdJdJe5ZKGdKdLdLeZLGdMdNdNeZMGdOdPdPeMZNGdQdRdRe{eZOGdSdTdTe{eZPGdUdVdVe{eZQGdWdXdXeZRGdYdZdZeZSGd[d\d\eZTGd]d^d^eZUGd_d`d`eZVGdadbdbeZWGdcddddeZXGdedfdfe5ZYGdgdhdhe5ZZGdidjdje5Z[Gdkdldle[Z\Gdmdndne[Z]Gdodpdpe[Z^Gdqdrdre[Z_Gdsdtdte[Z`Gdudvdve[ZaGdwdxdxe[ZbGdydzdze[ZcGd{d|d|e[ZdGd}d~d~e[ZeGddde5ZfGddde5ZgGdddeZhGdddeZiGdddeZjGdddeZkGdddeZlGdddeZmGddde5ZnGddde5ZoGddde5ZpGdddeZqGdddeZrGdddeZsGddde5ZtGdddeZuGdddeyeZvGdddeZwGdddeyeZxGddde5ZyGdddeZzGdddeyeZ{GdddeyeZ|GdddeyeZ}GdddeZ~Gdddeye=eZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdd„deZGdÐdĄdĐeZGdŐdƄdƐeZGdǐdȄdȐeZGdɐdʄdʐeZGdːd̄d̐eZGd͐d΄dΐeZGdϐdЄde5ZGdѐd҄de5ZGdӐdԄdԐeZGdՐdքd֐eZGdאd؄dؐeZGdِdڄdڐeZGdېd܄dܐeZGdݐdބdސeZGdߐddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeyeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGd d d eZGd d d eyeZGd ddeyeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdd d eZGd!d"d"eZGd#d$d$eZGd%d&d&eZGd'd(d(eZGd)d*d*eZGd+d,d,eZGd-d.d.eZGd/d0d0eZGd1d2d2eZGd3d4d4eZGd5d6d6eZGd7d8d8eZGd9d:d:eZGd;d<d<eZGd=d>d>eZGd?d@d@eZGdAdBdBeZGdCdDdDeZGdEdFdFeZGdGdHdHeZGdIdJdJeZGdKdLdLeZGdMdNdNeZGdOdPdPeZGdQdRdReZGdSdTdTeZGdUdVdVeZGdWdXdXeZGdYdZdZeZGd[d\d\eZGd]d^d^eZGd_d`d`eZGdadbdbeeZGdcddddeeZGdedfdfeZGdgdhdheZGdidjdjeZGdkdldleZGdmdndneZGdodpdpeZGdqdrdreZGdsdtdteZGdudvdveZGdwdxdxeZGdydzdzeZGd{d|d|eZGd}d~d~eZGdddeZGdddeZGdddeZGdddeyeZGdddeZGdddeZGdddeyeZGdddeyeZGdddeZGdddeZGdddeZGddde5ZGddde5ZGdddeZGddde5ZGdddeEZGddde5ZGddde5ZGdddeZGddde5ZGddde5ZddZeeeeeÐefZddeDZeee[e[fZeefZe jdddddddZe jddddddddZddddddddZe jdddĐdńZe jdddƐdńZddǐdńZdddϐdЄZdѐd҄Z    ӐddԐdՄZddddddd֜dאd؄ZddddddٜdڐdۄZdddddܜdݐdބZ     ddddZ   ddddZ e jdddZ e jdddZ dddZ dddddddZ dddddddZdddddddZdddddddZdddddZdddd Z     ddddZ   ddddZ     ddddZddddddd Z ddd!d"Zdddd#dd$d%Zdddd#dd&d'Zdddd#dd(d)Zddd*d+Zddd,d-Zed.Zd/ed0<e jddd3d4Z e j ddd6d4Z dd7d4Z ddÐd8d9Z!ed:Z"dĐd=d>Z# ddŐd@dAZ$   dƐdǐdCdDZ%    dȐdɐdGdHZ&  dʐdːdJdKZ'e j   ddddLd̐dRdSZ(e j   dddddTd͐dWdSZ(   dddddTdXdSZ( dΐdϐd[d\Z)    dАdѐd^d_Z*  dʐdҐdcd`Z+dӐdddeZ, ddԐdhdiZ-  dʐdՐdndoZ.d֐dאdqdrZ/dؐdudvZ0 ddِdydzZ1dڐdېd~dZ2dܐdݐddjZ3ddސddZ4 ddߐddZ5dddZ6  ddddZ7ddddddZ8 ddddZ9ddddddZ:ddddddZ;dddZ<dddZ=dddZ>eÐe]fZ?eÐe]e\fZ@dS(aK ## Expressions Every AST node in SQLGlot is represented by a subclass of `Expression`. This module contains the implementation of all supported `Expression` types. Additionally, it exposes a number of helper functions, which are mainly used to programmatically build SQL expressions, such as `sqlglot.expressions.select`. ---- ) annotationsN)dequedeepcopy)Decimal)autoreduce) ErrorLevel ParseError)AutoNamecamel_to_snake_caseensure_collection ensure_listseq_getsplit_num_words subclassesto_bool)Token TokenError)Self)ELit) DialectTypeQQuery)boundS SetOperationcseZdZfddZZS) _Expressioncs,t||||}||_|jpd|_|SN)super__new__lowerkey__doc__)clsclsnamebasesattrsklass __class__L/var/www/Datamplify/venv/lib/python3.10/site-packages/sqlglot/expressions.pyr#3s  z_Expression.__new__)__name__ __module__ __qualname__r# __classcell__r.r.r,r/r2srz sqlglot.metazsqlglot.anonymous)thisdbcatalogr4tabler5r6linecolstartendc@seZdZdZdZddiZdZd-dd Zd.d d Ze d/ddZ d0ddZ e d/ddZ e d/ddZ e d1ddZd2ddZe d.ddZe d.dd Zd/d!d"Ze d.d#d$Ze d.d%d&Ze d2d'd(Ze d3d*d+Ze d2d,d-Ze d2d.d/Ze d2d0d1Ze d4d3d4Zejd5d8d4Zd.d9d:Zd.d;d<Ze d6d>d?Zd@dAZd7dCdDZ d8d9dJdKZ!d3dLdMZ"d:dPdQZ# E d;ddWdXZ%e d0dYdZZ&d?d@d]d^Z'dd_dAdddeZ(dd_dBdgdhZ)dCdidjZ*e dDdldmZ+e d.dndoZ,dEdpdqZ- EdFdGdtduZ. Ed=dHdvdwZ/ Ed=dHdxdyZ0dzd{Z1d|d}Z2d~dZ3dIddZ4d2ddZ5d2ddZ6d2ddZ7d=dJddZ8dddKddZ9e:j;dLddZd=dPddZ?ddZ@eAddZBdEddddQddZCdEddddQddZDdIdRddZE Ed=dSddZF E E dTdUddZGd?dVddZHdWddZIdXddĄZJdEdEddŜdYdd˄ZKdIdZddЄZLd[ddԄZMd\ddׄZNd]ddڄZOd^dd݄ZPd_ddZQd`ddZRdadbddZSdIdcddZTd?dcddZUddddZVdeddZWdfddZXdgddZYdhddZZdhddZ[diddZ\diddZ]djddZ^djdd Z_dkd d Z`dkd d ZadlddZbdlddZcdmddZddmddZednddZfdnddZgdoddZhdod d!Zidpd#d$Zjdpd%d&Zkdqd(d)Zldrd+d,ZmdES(s Expressiona The base class for all expressions in a syntax tree. Each Expression encapsulates any necessary context, such as its child expressions, their names (arg keys), and whether a given child expression is optional or not. Attributes: key: a unique key for each class in the Expression hierarchy. This is useful for hashing and representing expressions as strings. arg_types: determines the arguments (child nodes) supported by an expression. It maps arg keys to booleans that indicate whether the corresponding args are optional. parent: a reference to the parent expression (or None, in case of root expressions). arg_key: the arg key an expression is associated with, i.e. the name its parent expression uses to refer to it. index: the index of an expression if it is inside of a list argument in its parent. comments: a list of comments that are associated with a given expression. This is used in order to preserve comments when transpiling SQL code. type: the `sqlglot.expressions.DataType` type of an expression. This is inferred by the optimizer, in order to enable some transformations that require type information. meta: a dictionary that can be used to store useful metadata for a given expression. Example: >>> class Foo(Expression): ... arg_types = {"this": True, "expression": False} The above definition informs us that Foo is an Expression that requires an argument called "this" and may also optionally receive an argument called "expression". Args: args: a mapping used for retrieving the arguments of an expression, given their arg keys. expressionr4T)argsparentarg_keyindexcomments_type_meta_hashr@t.AnycKsT||_d|_d|_d|_d|_d|_d|_d|_|jD] \}}| ||qdSN) r@rArBrCrDrErFrGitems _set_parent)selfr@rBvaluer.r.r/__init__kszExpression.__init__returnboolcCs t|t|uot|t|kSrI)typehashrLotherr.r.r/__eq__xs zExpression.__eq__cCtdd|jDS)Ncss^|]*\}}|dus|dust|tur|r|t|tur&tdd|Dnt|fVqdS)NFcss|]}t|VqdSrI) _norm_arg).0ar.r.r/ ~z5Expression.hashable_args...)rQlisttuplerWrXkvr.r.r/rZ}s (z+Expression.hashable_args..) frozensetr@rJrLr.r.r/ hashable_args{szExpression.hashable_argsintcCs |jdur|jSt|j|jfSrI)rGrRr-rcrbr.r.r/__hash__s zExpression.__hash__cC |jdS)z9 Retrieves the argument with key "this". r4r@getrbr.r.r/r4 zExpression.thiscCrf)z? Retrieves the argument with key "expression". r?rgrbr.r.r/r?rizExpression.expression t.List[t.Any]cC|jdpgS)z@ Retrieves the argument with key "expressions". expressionsrgrbr.r.r/rlszExpression.expressionsstrcCsH|j|}t|tr |St|tttfr|jSt|tt fr"|j SdS)z 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. r!) r@rh isinstancerm IdentifierLiteralVarr4StarNullname)rLr%fieldr.r.r/texts  zExpression.textcCst|to |jdS)zB Checks whether a Literal expression is a string. is_string)rnrpr@rbr.r.r/rwzExpression.is_stringcCs(t|tr |jd pt|to|jjS)zB Checks whether a Literal expression is a number. rw)rnrpr@Negr4 is_numberrbr.r.r/rzszExpression.is_numbercCst|d)zE Returns a Python object equivalent of the SQL node. z( cannot be converted to a Python object.) ValueErrorrbr.r.r/to_pyszExpression.to_pycCs|jo t|tS)z= Checks whether an expression is an integer. )rzrnr|rdrbr.r.r/is_intrxzExpression.is_intcCs t|tpt|tot|jtS)z'Checks whether an expression is a star.)rnrrColumnr4rbr.r.r/is_stars zExpression.is_starcCs(t|jdtr|jdjS|dS)z^ Returns the alias of the expression, or an empty string if it's not aliased. alias)rnr@rh TableAliasrtrvrbr.r.r/rs  zExpression.alias t.List[str]cCs.|jd}|s gSdd|jdpgDS)NrcSg|]}|jqSr.rtrXcr.r.r/ z1Expression.alias_column_names..columnsrg)rL table_aliasr.r.r/alias_column_namess zExpression.alias_column_namescC |dS)Nr4rvrbr.r.r/rt zExpression.namecCs |jp|jSrI)rrtrbr.r.r/ alias_or_name zExpression.alias_or_namecCdS)a Name of the output column if this expression is a selection. If the Expression has no output name, an empty string is returned. Example: >>> from sqlglot import parse_one >>> parse_one("SELECT a").expressions[0].output_name 'a' >>> parse_one("SELECT b AS c").expressions[0].output_name 'c' >>> parse_one("SELECT 1 + 2").expressions[0].output_name '' r!r.rbr.r.r/ output_nameszExpression.output_namet.Optional[DataType]cC|jSrI)rErbr.r.r/rQzExpression.typedtype*t.Optional[DataType | DataType.Type | str]NonecCs"|r t|ts t|}||_dSrI)rnDataTypebuildrE)rLrr.r.r/rQs  cGs|jduo |jj|SrI)rQis_typerLdtypesr.r.r/rzExpression.is_typecCstdd|jD S)Ncss|] }t|ttfVqdSrI)rnr>r\rXr`r.r.r/rZz%Expression.is_leaf..)anyr@valuesrbr.r.r/is_leafszExpression.is_leaft.Dict[str, t.Any]cCs|jduri|_|jSrI)rFrbr.r.r/metas zExpression.metac Cs.|}||fg}|r|\}}|jdurt|j|_|jdur't|j|_|jdur2t|j|_|jdur;|j|_|jD]R\}}t |dr]| ||f| ||ddq@t |t urg|j|<|D]!}t |dr| ||f| ||ddqj| ||qjq@||j|<q@|s |S)NrA)r-poprDrrErFrGr@rJhasattrappendsetrQr\) rLmemorootstacknodecopyr_vsr`r.r.r/ __deepcopy__s6              zExpression.__deepcopy__rcCt|S)z8 Returns a deep copy of the expression. rrbr.r.r/r0szExpression.copyNFrDt.Optional[t.List[str]]prependc Cs|jdurg|_|rO|D]8}|t^}}|r.)r]rrbr.r.r/unnest_operands?szExpression.unnest_operandsc#sJjfdddD]}t|jur"|rt|ts|n|Vq dS)z Returns a generator which yields child nodes whose parents are the same class. A AND B AND C -> [A, B, C] cs|jo t|juSrI)rArQr-nrbr.r/Kz$Expression.flatten..rN)rrQr-rnSubqueryr)rLrrr.rbr/flattenEs zExpression.flattencCs|SrI)sqlrbr.r.r/__str__OzExpression.__str__cCrrI_to_srbr.r.r/__repr__RrzExpression.__repr__cCs t|ddS)z Same as __repr__, but includes additional information which can be useful for debugging, like empty or missing args and the AST nodes' object IDs. Tverboserrbr.r.r/to_sUrizExpression.to_sdialectrcKs$ddlm}||j|fi|S)a! Returns SQL string representation of this tree. Args: dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql"). opts: other `sqlglot.generator.Generator` options. Returns: The SQL string. rDialect)sqlglot.dialectsr get_or_raisegenerate)rLroptsrr.r.r/r\s zExpression.sqlrfun t.Callablerc sd}d|r |n|jfdddD],}|j|j|j}}} ||g|Ri||s1}q|r@|r@|ur@||| q|sEJ|tS)aZ Visits all tree nodes (excluding already transformed ones) and applies the given transformation function to each node. Args: fun: a function which takes a node as an argument and returns a new transformed node or the same node without modifications. If the function returns None, then the corresponding node will be removed from the syntax tree. copy: if set to True a new tree instance is constructed, otherwise the tree is modified in place. Returns: The transformed tree. Ncs|uSrIr.rnew_noder.r/r}sz&Expression.transform..r)rrrArBrCr assert_isr>) rLrrr@kwargsrrrArBrCr.rr/ transformks$ zExpression.transformrcCdSrIr.rr.r.r/replacezExpression.replacecCrrIr.rr.r.r/r r cCsz|j}|r ||ur |S|j}|j|}t|tur&t|tr&|j|n| |||j ||ur;d|_d|_d|_ |S)a Swap out this expression with a new expression. For example:: >>> tree = Select().select("x").from_("tbl") >>> tree.find(Column).replace(column("y")) Column( this=Identifier(this=y, quoted=False)) >>> tree.sql() 'SELECT y FROM tbl' Args: expression: new node Returns: The new expression or expressions. N) rArBr@rhrQr\rnr>r rrC)rLr?rAr%rMr.r.r/r s  rLcCs|d|S)zk Remove this expression from its AST. Returns: The popped expression. N)r rbr.r.r/rs zExpression.poptype_cCs"t||st|d|d|S)a 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' z is not .)rnAssertionError)rLr r.r.r/rs zExpression.assert_ist.Optional[t.Sequence]cCsg}|jD]}||jvr|d|d|jq|jD]#\}}|j|}|rA|dus5t|trA|sA|d|d|jq|rft|trft |t |jkrf|j sf|dt |dt |jd|S) a Checks if this expression is valid (e.g. all mandatory args are set). Args: 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. zUnexpected keyword: 'z' for NzRequired keyword: 'z' missing for z"The number of provided arguments (z=) is greater than the maximum number of supported arguments ()) r@ arg_typesrr-rJrhrnr\Funcris_var_len_args)rLr@errorsr_ mandatoryr`r.r.r/error_messagess.    zExpression.error_messagescCsddlm}||S)zC Dump this Expression to a JSON-serializable dict. r)dump) sqlglot.serder)rLrr.r.r/rs zExpression.dumpcCsddlm}||S)z] Load a dict (as returned by `Expression.dump`) into an Expression instance. r)load)rr)r'objrr.r.r/rs zExpression.loadrrwraprlt.Optional[ExpOrStr]r ConditioncOt|g|R|||d|S)aG AND this condition with one or multiple expressions. Example: >>> condition("x=1").and_("y=1").sql() 'x = 1 AND y = 1' Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. dialect: the dialect used to parse the input expression. copy: whether to copy the involved expressions (only applies to Expressions). wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues. opts: other options to use to parse the input expressions. Returns: The new And condition. r)and_rLrrrrlrr.r.r/rzExpression.and_cOr)aC OR this condition with one or multiple expressions. Example: >>> condition("x=1").or_("y=1").sql() 'x = 1 OR y = 1' Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. dialect: the dialect used to parse the input expression. copy: whether to copy the involved expressions (only applies to Expressions). wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues. opts: other options to use to parse the input expressions. Returns: The new Or condition. r)or_r r.r.r/r"%r!zExpression.or_cC t||dS)z Wrap this condition with NOT. Example: >>> condition("x=1").not_().sql() 'NOT x = 1' Args: copy: whether to copy this object. Returns: The new Not instance. r)not_)rLrr.r.r/r$Cs zExpression.not_rTt.Optional[Token | Expression]rcKslt|tr|jdd|jDn|dur'|j|j|j|j|jd|jdd|D|S)z Update this expression with positions from a token or other expression. Args: other: a token or expression to update this expression with. Returns: The updated expression. cSi|] \}}|tvr||qSr.POSITION_META_KEYSr^r.r.r/ `z/Expression.update_positions..Nr9cSr&r.r'r^r.r.r/r)jr*) rnr>rupdaterJr:r;r<r=)rLrTrr.r.r/update_positionsSs zExpression.update_positionsrstr | Identifierquotedt.Optional[bool]rcKst||f|||d|S)N)r.rr)alias_)rLrr.rrrr.r.r/as_mszExpression.as_r+cCsX|}t|dd}t||st||st|t}t|t}|r&|||dS|||dS)NTrr4r?)rconvertrn_wrapBinary)rLr+rTrr4r.r.r/_binopws     zExpression._binopExpOrStr | t.Tuple[ExpOrStr]BracketcCst|ddt|DdS)NcSsg|]}t|ddqS)Trr3rXer.r.r/rz*Expression.__getitem__..r4rl)r8rrrSr.r.r/ __getitem__szExpression.__getitem__ t.IteratorcCs2d|jvrt|jdp gStd|jjd)Nrl'z' object is not iterable)riterr@rh TypeErrorr-r0rbr.r.r/__iter__s zExpression.__iter__queryrrrEr-t.Optional[ExpOrStr] | t.Collection[ExpOrStr]Incs|r t|fdind}|rt|ts|jdd}tt|fdd|D||r.c(g|]}ttt|fdiqSr maybe_parsetcastExpOrStrr:rrr.r/rrlr4rlrEr)rLrnrsubqueryrG maybe_copyUnnestr)rLrErrrlrrTr.rPr/isins    zExpression.isinlowhighBetweencKs4tt||t|fd|i|t|fd|i|dS)Nrr4rXrY)rZrUr3)rLrXrYrrr.r.r/betweens zExpression.betweenrOIscC |t|SrI)r6r]rSr.r.r/is_ zExpression.is_LikecCr^rI)r6rarSr.r.r/liker`zExpression.likeILikecCr^rI)r6rcrSr.r.r/iliker`zExpression.ilikeEQcCr^rI)r6rerSr.r.r/eqr`z Expression.eqNEQcCr^rI)r6rgrSr.r.r/neqr`zExpression.neq RegexpLikecCr^rI)r6rirSr.r.r/rliker`zExpression.rliketypedsafeDivcCs$|t|}||jd<||jd<|S)Nrkrl)r6rmr@)rLrTrkrldivr.r.r/rns   zExpression.div nulls_firstOrderedcCst||dS)N)r4rorprrLror.r.r/asczExpression.asccCst|d|dS)NT)r4descrorqrrr.r.r/ruszExpression.descLTcCr^rI)r6rvrSr.r.r/__lt__r`zExpression.__lt__LTEcCr^rI)r6rxrSr.r.r/__le__r`zExpression.__le__GTcCr^rI)r6rzrSr.r.r/__gt__r`zExpression.__gt__GTEcCr^rI)r6r|rSr.r.r/__ge__r`zExpression.__ge__AddcCr^rIr6r~rSr.r.r/__add__r`zExpression.__add__cC|jt|ddSNTrrrSr.r.r/__radd__rtzExpression.__radd__SubcCr^rIr6rrSr.r.r/__sub__r`zExpression.__sub__cCrrrrSr.r.r/__rsub__rtzExpression.__rsub__MulcCr^rIr6rrSr.r.r/__mul__r`zExpression.__mul__cCrrrrSr.r.r/__rmul__rtzExpression.__rmul__cCr^rIr6rmrSr.r.r/ __truediv__r`zExpression.__truediv__cCrrrrSr.r.r/ __rtruediv__rtzExpression.__rtruediv__IntDivcCr^rIr6rrSr.r.r/ __floordiv__r`zExpression.__floordiv__cCrrrrSr.r.r/ __rfloordiv__rtzExpression.__rfloordiv__ModcCr^rIr6rrSr.r.r/__mod__r`zExpression.__mod__cCrrrrSr.r.r/__rmod__rtzExpression.__rmod__PowcCr^rIr6rrSr.r.r/__pow__r`zExpression.__pow__cCrrrrSr.r.r/__rpow__rtzExpression.__rpow__AndcCr^rIr6rrSr.r.r/__and__r`zExpression.__and__cCrrrrSr.r.r/__rand__rtzExpression.__rand__OrcCr^rIr6rrSr.r.r/__or__ r`zExpression.__or__cCrrrrSr.r.r/__ror__rtzExpression.__ror__rycCstt|tdSNr4)ryr4rr5rbr.r.r/__neg__zExpression.__neg__NotcCs t|SrI)r$rrbr.r.r/ __invert__r`zExpression.__invert__)r@rHrOrPrOrH)rOrd)rOrjrOrmrOrrOr)rrrOr)rOr)rOrNF)rDrrrPrOr)rBrmrMrHrOrNT) rBrmrMrHrCrrrPrOrrI)rBrmrMrHrCrrOrF)rrPrOr)rrrrPrOr)rrrrPrOr)rrrOr)rOrrOr>TN)rrPrrrOr)rrrOrT)rrrOrm)rrr@rHrrPrOr>)r?rrOr)r?rrOr)rLrrOr)r rrOr)r@rrOr rlrrrrrPrrPrOr)rrP)rLrrTr%rrHrOrNNT) rr-r.r/rrrrPrOr)r+rrTrHrrPrOr)rTr7rOr8)rOr? rlrHrErrrFrrPrOrG)rXrHrYrHrrPrOrZ)rTrOrOr])rTrOrOra)rTrOrOrc)rTrHrOre)rTrHrOrg)rTrOrOri)FF)rTrOrkrPrlrPrOrm)rorPrOrp)rTrHrOrv)rTrHrOrx)rTrHrOrz)rTrHrOr|)rTrHrOr~)rTrHrOr)rTrHrOr)rTrHrOrm)rTrHrOr)rTrHrOr)rTrHrOr)rTrHrOr)rTrHrOr)rOry)rOr)nr0r1r2r&r%r __slots__rNrUpropertyrcrer4r?rlrvrwrzr|r}rrrrtrrrQsetterrrrrrrrrrrKrrrrrrrrrrrrrrrrrrrrrMoverloadr rrrr classmethodrrr"r$r,r1r6r>rCrWr\r_rbrdrfrhrjrnrsrurwryr{r}rrrrrrrrrrrrrrrrrrrrr.r.r.r/r>Gs$        "  ,          ) "  !              r>) metaclassc@eZdZdZdS)rz,Logical conditions like x AND y, or simply xNr0r1r2r&r.r.r.r/r rc@r) Predicatez(Relationships like x = y, x > 1, x >= y.Nrr.r.r.r/r$rrc@s(eZdZed ddZed ddZdS) DerivedTablerOt.List[Expression]cCt|jtr |jjSgSrI)rnr4rselectsrbr.r.r/r)szDerivedTable.selectsrcCdd|jDS)NcSrr.)r)rXselectr.r.r/r/rz.DerivedTable.named_selects..)rrbr.r.r/ named_selects-zDerivedTable.named_selectsNrOrr)r0r1r2rrrr.r.r.r/r(  rc@seZdZd;dddZed?ddZed@ddZ edAd!d"Z ddddd>d#d$Z ddddd>d%d&Z      'dBdCd.d/Z ddd0dDd3d4Zddd0dEd6d7Zddd0dFd9d:ZdS)GrNTrrrrPrOrcCs6t||}t|ts|rtt|dnd}t||dS)a Returns a `Subquery` that wraps around this query. Example: >>> subquery = Select().select("x").from_("tbl").subquery() >>> Select().select("x").from_(subquery).sql() 'SELECT x FROM (SELECT x FROM tbl)' Args: alias: an optional alias for the subquery. copy: if `False`, modify this expression instance in-place. rNr4r)rUrnr>r to_identifierr)rLrrinstancer.r.r/rT3s  zQuery.subqueryrLrr?ExpOrStr | intrrc K td||dtd||dd|S)a Adds a LIMIT clause to this query. Example: >>> select("1").union(select("1")).limit(1).sql() 'SELECT 1 UNION SELECT 1 LIMIT 1' Args: expression: the SQL code string to parse. This can also be an integer. If a `Limit` instance is passed, it will be used as-is. If another `Expression` instance is passed, it will be wrapped in a `Limit`. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: A limited Select expression. limitLIMITr?r?rrintoprefixrrinto_argNr.)_apply_builderLimitrLr?rrrr.r.r/rF z Query.limitc Kr)a Set the OFFSET expression. Example: >>> Select().from_("tbl").select("x").offset(10).sql() 'SELECT x FROM tbl OFFSET 10' Args: expression: the SQL code string to parse. This can also be an integer. If a `Offset` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Offset`. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. offsetOFFSETr?rNr.)rOffsetrr.r.r/rhrz Query.offsetrrrrlrc Ot||d||dt|d|S)aU Set the ORDER BY expression. Example: >>> Select().from_("tbl").select("x").order_by("x DESC").sql() 'SELECT x FROM tbl ORDER BY x DESC' Args: *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Order`. append: if `True`, add to any existing expressions. Otherwise, this flattens all the `Order` expression into a single expression. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. orderzORDER BYrrrrrrr)_apply_child_list_builderOrderrLrrrrlrr.r.r/order_by zQuery.order_by t.List[CTE]cC|jd}|r |jSgS)z6Returns a list of all the CTEs attached to this query.withr@rhrlrLwith_r.r.r/ctes z Query.ctesrcCtd)z Returns the query's projections.z&Query objects must implement `selects`NotImplementedErrorrbr.r.r/rz Query.selectsrcCr)z4Returns the output names of the query's projections.z,Query objects must implement `named_selects`rrbr.r.r/rrzQuery.named_selectscOr)a Append to or set the SELECT expressions. Example: >>> Select().select("x", "y").sql() 'SELECT x, y' Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. append: if `True`, add to any existing expressions. Otherwise, this resets the expressions. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Query expression. z%Query objects must implement `select`rrr.r.r/rsz Query.selectc Os&tdd|D|d|t||d|S)aM Append to or set the WHERE expressions. Examples: >>> Select().select("x").from_("tbl").where("x = 'a' OR x < 'b'").sql() "SELECT x FROM tbl WHERE x = 'a' OR x < 'b'" Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator. append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified expression. cSs g|] }t|tr |jn|qSr.)rnWherer4)rXexprr.r.r/r zQuery.where..whererrrrrr_apply_conjunction_builderrrr.r.r/rs z Query.whereFrOr1 recursiver/ materializedscalarc Ks"t|||f||||||d| S)a 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' Args: alias: the SQL code string to parse as the table name. If an `Expression` instance is passed, this is used as-is. as_: the SQL code string to parse as the table expression. If an `Expression` instance is passed, it will be used as-is. recursive: set the RECURSIVE part of the expression. Defaults to `False`. materialized: set the MATERIALIZED part of the expression. append: if `True`, add to any existing expressions. Otherwise, this resets the expressions. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. scalar: if `True`, this is a scalar common table expression. opts: other options to use to parse the input expressions. Returns: The modified expression. )rrrrrr_apply_cte_builder) rLrr1rrrrrrrr.r.r/rs$ z Query.with_distinctrrUnioncOt|g|R||d|S)a 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' Args: expressions: the SQL code strings. If `Expression` instances are passed, they will be used as-is. distinct: set the DISTINCT flag if and only if this is true. dialect: the dialect used to parse the input expression. opts: other options to use to parse the input expressions. Returns: The new Union expression. r)unionrLrrrlrr.r.r/r7z Query.union IntersectcOr)a 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' Args: expressions: the SQL code strings. If `Expression` instances are passed, they will be used as-is. distinct: set the DISTINCT flag if and only if this is true. dialect: the dialect used to parse the input expression. opts: other options to use to parse the input expressions. Returns: The new Intersect expression. r) intersectrr.r.r/rNrzQuery.intersectExceptcOr)a 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' Args: expressions: the SQL code strings. If `Expression` instance are passed, they will be used as-is. distinct: set the DISTINCT flag if and only if this is true. dialect: the dialect used to parse the input expression. opts: other options to use to parse the input expressions. Returns: The new Except expression. r)except_rr.r.r/rerz Query.except_r)rrrrPrOr) rLrr?rrrrrPrOr) rLrrlrrrPrrrrPrOrrOrrrNNTNTF)rLrrrOr1rOrr/rr/rrPrrrrPrrPrOr)rlrOrrPrrrOr)rlrOrrPrrrOr)rlrOrrPrrrOr)r0r1r2rTrrrrrrrrrrrrrr.r.r.r/r2sJ  # %(    + 2c@eZdZedddZdS)UDTFrOrcCr)Nr)r@rhr)rLrr.r.r/r~ z UDTF.selectsNr)r0r1r2rrr.r.r.r/r }r c@eZdZdddddZdS)CacheTF)r4lazyoptionsr?Nr0r1r2rr.r.r.r/r  rc@eZdZdddZdS)UncacheTFr4existsNrr.r.r.r/rrc@ eZdZdS)RefreshNr0r1r2r.r.r.r/rrc@s6eZdZed ddZed ddZedd d Zd S)DDLrOrcCr)z:Returns a list of all the CTEs attached to this statement.rrrr.r.r/rrzDDL.ctesrcCr)zWIf this statement contains a query (e.g. a CTAS), this returns the query's projections.)rnr?rrrbr.r.r/rsz DDL.selectsrcCr)z If this statement contains a query (e.g. a CTAS), this returns the output names of the query's projections. )rnr?rrrbr.r.r/rszDDL.named_selectsNr rr)r0r1r2rrrrr.r.r.r/rs  rc@seZdZ  d dd d ZdS)DMLNTr?rOrrrrPrO'Self'c Kstd||dd||td|S)ay Set the RETURNING expression. Not supported by all dialects. Example: >>> delete("tbl").returning("*", dialect="postgres").sql() 'DELETE FROM tbl RETURNING *' Args: expression: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: Delete: the modified expression. returning RETURNING)r?rrrrrrNr.)r Returningrr.r.r/r!sz DML.returningr)r?rOrrrrPrOr )r0r1r2r!r.r.r.r/rsrc@s~eZdZiddddddddddddd dd dd dd dd dddddddddddZedddZdS)CreaterFr4Tkindr?r propertiesr refreshuniqueindexesno_schema_bindingbeginr=clone concurrently clusteredrOt.Optional[str]cC|jd}|o |SNr%r@rhupperrLr%r.r.r/r%  z Create.kindNrOr/r0r1r2rrr%r.r.r.r/r$sH     r$c@ eZdZddddddddZdS)SequencePropertiesF) incrementminvaluemaxvaluecacher<ownedrNrr.r.r.r/r9 r9c @s"eZdZdddddddddZdS) TruncateTableTF)rl is_databaseronlyclusteridentityoption partitionNrr.r.r.r/r@ r@c@eZdZddddZdS)CloneTF)r4shallowrNrr.r.r.r/rIrIc@eZdZdddddddZdS)DescribeTF)r4styler%rlrFformatNrr.r.r.r/rM  rMc@rH)AttachTF)r4rrlNrr.r.r.r/rQrKrQc@r)DetachTFrNrr.r.r.r/rRrrRc@r) SummarizeTF)r4r8Nrr.r.r.r/rSrrSc@r)KillTFr4r%Nrr.r.r.r/rT#rrTc@r)PragmaNrr.r.r.r/rV'rrVc@eZdZddiZdS)DeclarerlTNrr.r.r.r/rX+ rXc@eZdZddddZdS) DeclareItemTF)r4r%defaultNrr.r.r.r/r[/rKr[c@eZdZddddZdS)SetF)rlunsettagNrr.r.r.r/r^3rKr^c@r)HeredocTF)r4r`Nrr.r.r.r/ra7rrac@eZdZddddddZdS)SetItemF)r4rlr%collateglobalNrr.r.r.r/rc; rcc@seZdZiddddddddddddd dd dd dd dd dddddddddddddddddddZdS)Showr4ThistoryFtersetargetr starts_withrfromrbrr5scope scope_kindfullmutexrEchannel)relogpositiontypes privilegesNrr.r.r.r/rgEsT      rgc@rH)UserDefinedFunctionTF)r4rlwrappedNrr.r.r.r/rv`rKrvc@r) CharacterSetTFr4r\Nrr.r.r.r/rxdrrxc@eZdZdddddZdS)RecursiveWithSearchTF)r%r4r?usingNrr.r.r.r/r{hr{c@s&eZdZddddZed ddZdS) WithTF)rlrsearchrOrPcCt|jdS)NrrPr@rhrbr.r.r/rorzWith.recursiveNr)r0r1r2rrrr.r.r.r/r~l r~c@r) WithinGroupTFr2Nrr.r.r.r/rtrrc@eZdZdddddZdS)CTETF)r4rrrNrr.r.r.r/rzrrc@eZdZdddZdS) ProjectionDefTr2Nrr.r.r.r/rrrc@"eZdZdddZeddZdS)rFr4rcCrk)Nrrgrbr.r.r/rrzTableAlias.columnsN)r0r1r2rrrr.r.r.r/r rc@r) BitStringNrr.r.r.r/rrrc@r) HexStringTF)r4 is_integerNrr.r.r.r/rrrc@r) ByteStringNrr.r.r.r/rrrc@r) RawStringNrr.r.r.r/rrrc@r) UnicodeStringTF)r4escapeNrr.r.r.r/rrrc@sneZdZddddddZedddZeddd Zedd d Zedd d ZedddZ ddddZ dS)r~TF)r4r8r5r6 join_markrOrmcCr)Nr8rrbr.r.r/r8rz Column.tablecCrNr5rrbr.r.r/r5rz Column.dbcCrNr6rrbr.r.r/r6rzColumn.catalogcCrrIrrbr.r.r/rrzColumn.output_namet.List[Identifier]csfdddDS)z?Return the parts of a column in order catalog, db, table, name.cs*g|]}j|rttj|qSr.)r@rhrMrNrorXpartrbr.r/rs  z Column.parts..)r6r5r8r4r.rbr.rbr/partss z Column.parts include_dotsrPDot | IdentifiercCsX|j}|j}|rt|tr||j|j}t|ts t|dkr(tt|S|dS)z*Converts the column into a dot expression.rr) rrArnDotrr?rrr)rLrrrAr.r.r/to_dots   "z Column.to_dotNr)rOrr)rrPrOr) r0r1r2rrr8r5r6rrrr.r.r.r/r~s     r~c@r)ColumnPositionFT)r4rsNrr.r.r.r/rrrc@s<eZdZddddddddZed ddZed d d Zd S) ColumnDefTF)r4r% constraintsrrsr\outputrOt.List[ColumnConstraint]cCrk)Nrrgrbr.r.r/rrzColumnDef.constraintsrcCrfr1rgrbr.r.r/r%rzColumnDef.kindN)rOrr)r0r1r2rrrr%r.r.r.r/rs rc @s$eZdZdddddddddd ZdS) AlterColumnTF) r4rrdr|r\dropr allow_nullvisibleNrr.r.r.r/r rc@r) AlterIndexT)r4rNrr.r.r.r/rrrc@r)AlterDistStyleNrr.r.r.r/rrrc@r]) AlterSortKeyF)r4rlcompoundNrr.r.r.r/rrKrc @$eZdZdddddddddd ZdS)AlterSetF) rlrE tablespace access_method file_format copy_optionsr`locationserdeNrr.r.r.r/rrrc@rZ) RenameColumnTFr4torNrr.r.r.r/rrKrc@r) AlterRenameNrr.r.r.r/rrrc@r) SwapTableNrr.r.r.r/rrrc@seZdZddddddZdS)CommentTF)r4r%r?rrNrr.r.r.r/rrfrc@rz) ComprehensionTF)r4r?iterator conditionNrr.r.r.r/r$r}rc@eZdZddddddZdS)MergeTreeTTLActionTF)r4delete recompressto_disk to_volumeNrr.r.r.r/r)rfrc@r) MergeTreeTTLTF)rlrgroup aggregatesNrr.r.r.r/r4rrc@r8)IndexConstraintOptionF)key_block_sizer|parserrr engine_attrsecondary_engine_attrNrr.r.r.r/r>r?rc@$eZdZdddZed ddZdS) ColumnConstraintFTrUrOColumnConstraintKindcC |jdSr1r@rbr.r.r/r%MrzColumnConstraint.kindN)rOrr7r.r.r.r/rJ rc@r)rNrr.r.r.r/rRrrc@r)AutoIncrementColumnConstraintNrr.r.r.r/rVrrc@r)PeriodForSystemTimeConstraintTr2Nrr.r.r.r/rZrrc@rW)CaseSpecificColumnConstraintr$TNrr.r.r.r/r^rYrc@rW)CharacterSetColumnConstraintr4TNrr.r.r.r/rbrYrc@r)CheckColumnConstraintTF)r4enforcedNrr.r.r.r/rfrrc@r)ClusteredColumnConstraintNrr.r.r.r/rjrrc@r)CollateColumnConstraintNrr.r.r.r/rnrrc@r)CommentColumnConstraintNrr.r.r.r/rrrrc@rW)CompressColumnConstraintr4FNrr.r.r.r/rvrYrc@rW)DateFormatColumnConstraintr4TNrr.r.r.r/rzrYrc@r)DefaultColumnConstraintNrr.r.r.r/r~rrc@r)EncodeColumnConstraintNrr.r.r.r/rrrc@r)ExcludeColumnConstraintNrr.r.r.r/rrrc@rW)EphemeralColumnConstraintr4FNrr.r.r.r/rrYrc@r) WithOperatorT)r4opNrr.r.r.r/rrrc @r)#GeneratedAsIdentityColumnConstraintF) r4r?on_nullr<r:r;r<cyclerNrr.r.r.r/rs rc@r)GeneratedAsRowColumnConstraintF)r<hiddenNrr.r.r.r/rrrc@r8)IndexColumnConstraintF)r4rlr% index_typerr? granularityNrr.r.r.r/rr?rc@r)InlineLengthColumnConstraintNrr.r.r.r/rrrc@r)NonClusteredColumnConstraintNrr.r.r.r/rrrc@eZdZiZdS)!NotForReplicationColumnConstraintNrr.r.r.r/rrrc@r)MaskingPolicyColumnConstraintTFr=Nrr.r.r.r/rrrc@rW)NotNullColumnConstraintrFNrr.r.r.r/rrYrc@r)OnUpdateColumnConstraintNrr.r.r.r/rrrc@r)PrimaryKeyColumnConstraintF)rurNrr.r.r.r/rrrc@r)TitleColumnConstraintNrr.r.r.r/rrrc@rb)UniqueColumnConstraintF)r4r on_conflictnullsrNrr.r.r.r/rrfrc@seZdZUiZded<dS)UppercaseColumnConstraintrrN)r0r1r2r__annotations__r.r.r.r/rs rc@r)WatermarkColumnConstraintTr2Nrr.r.r.r/rrrc@r)PathColumnConstraintNrr.r.r.r/rrrc@r) ProjectionPolicyColumnConstraintNrr.r.r.r/rrrc@rH)ComputedColumnConstraintTF)r4 persistednot_nullNrr.r.r.r/rrKrc@r) ConstraintTr=Nrr.r.r.r/rrrc @sFeZdZdddddddddZ  ddd d ZdddddddZdS)DeleteF)rr4r|rr!rtablesrCNTr8rOrrrrPrOc Kstd||d|t|d|S)a  Create a DELETE expression or replace the table on an existing DELETE expression. Example: >>> delete("tbl").sql() 'DELETE FROM tbl' Args: 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. r4)r?rrrrrNr.rTable)rLr8rrrr.r.r/rsz Delete.deleterrlrrc Ot||d|t||d|S)a> 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'" Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator. append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: Delete: the modified expression. rrrrr.r.r/r)z Delete.wherer)r8rOrrrrPrOr) rlrrrPrrrrPrOr)r0r1r2rrrr.r.r.r/rs" $rc @s6eZdZdddddddddddd ZedddZdS) DropF) r4r%rlr temporaryrcascaderpurgerCr-rOr/cCr0r1r2r4r.r.r/r%`r5z Drop.kindNr6r7r.r.r.r/rQsrc@eZdZddddZdS)ExportTF)r4 connectionrNrr.r.r.r/r grKr c@r)FilterTr2Nrr.r.r.r/r krr c@r)CheckNrr.r.r.r/r orr c@rH)ChangesTF) information at_beforer=Nrr.r.r.r/r srKr c@r)ConnectFT)r<connectnocycleNrr.r.r.r/rxrKrc@rH) CopyParameterTFr4r?rlNrr.r.r.r/r|rKrc@seZdZdddddddZdS)CopyTF)r4r%files credentialsrOparamsNrr.r.r.r/rrPrc@rb) CredentialsF)r encryptionstorageiam_roleregionNrr.r.r.r/rrfrc@r)PriorNrr.r.r.r/rrrc@rH) DirectoryTF)r4local row_formatNrr.r.r.r/rsrc@rb) ForeignKeyF)rl referencerr+rNrr.r.r.r/r"rfr"c@r) ColumnPrefixTr2Nrr.r.r.r/r$rr$c@r) PrimaryKeyTF)rlrNrr.r.r.r/r%rr%c@rb)IntoF)r4runlogged bulk_collectrlNrr.r.r.r/r&rfr&c@s(eZdZedddZedddZdS) FromrOrmcC|jjSrIr4rtrbr.r.r/rtz From.namecCr*rIr4rrbr.r.r/rr,zFrom.alias_or_nameNr)r0r1r2rrtrr.r.r.r/r)rr)c@r)HavingNrr.r.r.r/r.rr.c@rW)HintrlTNrr.r.r.r/r/rYr/c@r)JoinHintTr=Nrr.r.r.r/r0rr0c@sDeZdZdddddZedddZedd d Zedd d ZdS)roTF)r4r.rerrOrPcCr)Nr.rrbr.r.r/r.rzIdentifier.quotedrHcCs |j|jfSrIr4r.rbr.r.r/rcrzIdentifier.hashable_argsrmcCrrIrrbr.r.r/rrzIdentifier.output_nameNrrr)r0r1r2rrr.rcrr.r.r.r/ros  roc@r)OpclassTr2Nrr.r.r.r/r2rr2c@eZdZdddddddZdS)IndexF)r4r8r(primaryamprNrr.r.r.r/r4rPr4c @"eZdZdddddddddZdS)IndexParametersF)r|includer with_storage partition_byrronNrr.r.r.r/r8rGr8c@seZdZiddddddddddddddd dd dd dd dd dddddddddddZ     d#d$d!d"ZdS)%InserthintFr is_functionr4r?conflictr!rr alternativerignoreby_namestoredrFsettingssourceNTrrOr1rr/rrrPrrrrOc K t|||f|||||d|S)aO 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' Args: alias: the SQL code string to parse as the table name. If an `Expression` instance is passed, this is used as-is. as_: the SQL code string to parse as the table expression. If an `Expression` instance is passed, it will be used as-is. recursive: set the RECURSIVE part of the expression. Defaults to `False`. materialized: set the MATERIALIZED part of the expression. append: if `True`, add to any existing expressions. Otherwise, this resets the expressions. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified expression. rrrrrr rLrr1rrrrrrr.r.r/r " z Insert.with_NNTNT)rrOr1rOrr/rr/rrPrrrrPrOr=)r0r1r2rrr.r.r.r/r=sT     r=c@rH)ConditionalInsertTF)r4r?else_Nrr.r.r.r/rLC rKrLc@r])MultitableInsertsT)rlr%rFNrr.r.r.r/rNG rKrNc@r3) OnConflictF) duplicaterlaction conflict_keys constraintrNrr.r.r.r/rOK rPrOc@r]) OnConditionF)erroremptynullNrr.r.r.r/rTV rKrTc@r)r#TF)rlrNrr.r.r.r/r#Z rr#c@r) IntroducerTr2Nrr.r.r.r/rX_ rrXc@r)NationalNrr.r.r.r/rYd rrYc@s eZdZddddddddZdS)LoadDataTF)r4r rinpathrF input_formatrNrr.r.r.r/rZh r?rZc@r) PartitionTF)rl subpartitionNrr.r.r.r/r]t rr]c@r)PartitionRangeTr2Nrr.r.r.r/r_x rr_c@r) PartitionIdNrr.r.r.r/r`} rr`c@r])FetchF) directioncount limit_optionsNrr.r.r.r/ra  rac@seZdZddddddZdS)GrantTF)rur% securable principals grant_optionNrr.r.r.r/rf rfrfc@r3)GroupF)rl grouping_setscuberolluptotalsallNrr.r.r.r/rj rPrjc@rW)CuberlFNrr.r.r.r/rp rYrpc@rW)RolluprlFNrr.r.r.r/rq rYrqc@rW) GroupingSetsrlTNrr.r.r.r/rr rYrrc@rZ)LambdaTF)r4rlcolonNrr.r.r.r/rs rKrsc@seZdZddddddZdS)rFT)r4r?rrdrlNrr.r.r.r/r rfrc@r]) LimitOptionsF)percentrows with_tiesNrr.r.r.r/ru reruc@sXeZdZdddZedddZedddZedd d Zedd d Z dddZ dS)rpTr4rwrOrHcCs|j|jdfS)Nrw)r4r@rhrbr.r.r/rc zLiteral.hashable_argscC|t|ddS)NFryrm)r'numberr.r.r/r} rzLiteral.numbercCr{)NTryr|)r'stringr.r.r/r~ rzLiteral.stringrmcCrrIrrbr.r.r/r rzLiteral.output_nameint | str | DecimalcCs6|jrzt|jWStyt|jYSw|jSrI)rzrdr4r{rrbr.r.r/r| s  z Literal.to_pyNr)rOrpr)rOr) r0r1r2rrrcrr}r~rr|r.r.r.r/rp s     rpc @seZdZdddddddddddd ZedddZeddd Zedd d Zedd d ZedddZ ed ddZ ddddd!ddZ ddddd!ddZ dS)"JoinTF) r4r<sider%r|methodrer>match_conditionrlpivotsrOrmcC|dS)Nrrvr3rbr.r.r/r z Join.methodcCrr1rrbr.r.r/r% rz Join.kindcCrNrrrbr.r.r/r rz Join.sidecCr)Nr>rrbr.r.r/r> rz Join.hintcCr*rIr-rbr.r.r/r r,zJoin.alias_or_namerPcCs |jdvS)N)SEMIANTI)r%rbr.r.r/is_semi_or_anti_join rzJoin.is_semi_or_anti_joinNrrlrrrrrcO4t||d|||d|}|jdkr|dd|S)aG 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' Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator. append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Join expression. r<rrrrrCROSSr%N)rr%rrLrrrrlrrr.r.r/r< s zJoin.oncOr)a 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)' Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. append: if `True`, concatenate the new expressions to the existing "using" list. Otherwise, this resets the expression. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Join expression. r|rrr%N)_apply_list_builderr%rrr.r.r/r|/ s z Join.usingrr) rlrrrPrrrrPrOr) r0r1r2rrrr%rr>rrr<r|r.r.r.r/r sB      /rc@rL)LateralTF)r4viewouterr cross_apply ordinalityNrr.r.r.r/r[ rPrc@r) TableFromRowsTF)r4rjoinsrsampleNrr.r.r.r/rh rfrc@r)MatchRecognizeMeasureTF)r4 window_frameNrr.r.r.r/rr  rc @r7)MatchRecognizeF)r;rmeasuresrwafterpatterndefinerNrr.r.r.r/ry rGrc@r)FinalNrr.r.r.r/r rrc@r)rFTrNrr.r.r.r/r rKrc@r)rFT)r4rlsiblingsNrr.r.r.r/r rKrc@eZdZdddddZdS)WithFillF)rlrstep interpolateNrr.r.r.r/r rrc@r)ClusterNrr.r.r.r/r rrc@r) DistributeNrr.r.r.r/r rrc@r)SortNrr.r.r.r/r rrc@s(eZdZdddddZed ddZdS) rpTF)r4ruro with_fillrOrmcCr*rIr+rbr.r.r/rt r,z Ordered.nameNrr0r1r2rrrtr.r.r.r/rp srpc@r)PropertyTr4rMNrr.r.r.r/r rrc@r)GrantPrivilegeTFr=Nrr.r.r.r/r rrc@r)GrantPrincipalTFrUNrr.r.r.r/r rrc@rW)AllowedValuesPropertyrlTNrr.r.r.r/r rYrc@rW)AlgorithmPropertyr4TNrr.r.r.r/r rYrc@rW)AutoIncrementPropertyr4TNrr.r.r.r/r rYrc@rW)AutoRefreshPropertyr4TNrr.r.r.r/r rYrc@rW)BackupPropertyr4TNrr.r.r.r/r rYrc@rb)BlockCompressionPropertyF)autotempalwaysr\manualneverNrr.r.r.r/r rfrc@r)CharacterSetPropertyTryNrr.r.r.r/r rrc@r)ChecksumPropertyF)r<r\Nrr.r.r.r/r rrc@r)CollatePropertyTFryNrr.r.r.r/r rrc@r)CopyGrantsPropertyNrr.r.r.r/r rrc@rb)DataBlocksizePropertyF)sizeunitsminimummaximumr\Nrr.r.r.r/r rfrc@rH)DataDeletionPropertyTF)r< filter_colretention_periodNrr.r.r.r/r rKrc@rW)DefinerPropertyr4TNrr.r.r.r/r rYrc@rW)DistKeyPropertyr4TNrr.r.r.r/r rYrc@seZdZdddddZdS)DistributedByPropertyFT)rlr%bucketsrNrr.r.r.r/r r}rc@rW)DistStylePropertyr4TNrr.r.r.r/r rYrc@rW)DuplicateKeyPropertyrlTNrr.r.r.r/r rYrc@rW)EnginePropertyr4TNrr.r.r.r/r rYrc@r) HeapPropertyNrr.r.r.r/r rrc@rW)ToTablePropertyr4TNrr.r.r.r/r rYrc@rW)ExecuteAsPropertyr4TNrr.r.r.r/r rYrc@rW)ExternalPropertyr4FNrr.r.r.r/r# rYrc@r)FallbackPropertyTF)no protectionNrr.r.r.r/r' rrc@r])FileFormatPropertyF)r4rl hive_formatNrr.r.r.r/r, rKrc@rW)CredentialsPropertyrlTNrr.r.r.r/r0 rYrc@r)FreespacePropertyTF)r4rvNrr.r.r.r/r4 rrc@r)GlobalPropertyNrr.r.r.r/r8 rrc@r)IcebergPropertyNrr.r.r.r/r< rrc@rW)InheritsPropertyrlTNrr.r.r.r/r@ rYrc@rW)InputModelPropertyr4TNrr.r.r.r/rD rYrc@rW)OutputModelPropertyr4TNrr.r.r.r/rH rYrc@r])IsolatedLoadingPropertyF)r concurrentrjNrr.r.r.r/rL rKrc@rb)JournalPropertyF)rdualbeforer rNrr.r.r.r/rP rfrc@rW)LanguagePropertyr4TNrr.r.r.r/rZ rYrc@rW)EnviromentPropertyrlTNrr.r.r.r/r^ rYrc@r)ClusteredByPropertyTF)rl sorted_byrNrr.r.r.r/rc rKrc@rZ) DictPropertyTF)r4r%rENrr.r.r.r/rg rKrc@r)DictSubPropertyNrr.r.r.r/rk rrc@r]) DictRangeT)r4minmaxNrr.r.r.r/ro rKrc@r)DynamicPropertyNrr.r.r.r/rs rrc@rW) OnClusterr4TNrr.r.r.r/ry rYrc@r) EmptyPropertyNrr.r.r.r/r~ rrc@r) LikePropertyTFr=Nrr.r.r.r/r rrc@rW)LocationPropertyr4TNrr.r.r.r/r rYrc@rW) LockPropertyr4TNrr.r.r.r/r rYrc@seZdZddddddZdS)LockingPropertyFT)r4r% for_or_in lock_typeoverrideNrr.r.r.r/r rfrc@rW) LogPropertyrTNrr.r.r.r/r rYrc@rW)MaterializedPropertyr4FNrr.r.r.r/r rYrc@r)MergeBlockRatioPropertyF)r4rr\rvNrr.r.r.r/r r}rc@r)NoPrimaryIndexPropertyNrr.r.r.r/r rrc@rW) OnPropertyr4TNrr.r.r.r/r rYrc@rW)OnCommitPropertyrFNrr.r.r.r/r rYrc@rW)PartitionedByPropertyr4TNrr.r.r.r/r rYrc@r)PartitionedByBucketTr2Nrr.r.r.r/r rrc@r)PartitionByTruncateTr2Nrr.r.r.r/r rrc@r)PartitionByRangePropertyT)partition_expressionscreate_expressionsNrr.r.r.r/r rrc@r)PartitionByRangePropertyDynamicFT)r4r<r=everyNrr.r.r.r/r r}rc@rW)UniqueKeyPropertyrlTNrr.r.r.r/r rYrc@r)PartitionBoundSpecF)r4r?from_expressionsto_expressionsNrr.r.r.r/r s  rc@r)PartitionedOfPropertyTr2Nrr.r.r.r/r src@r)StreamingTablePropertyNrr.r.r.r/r rrc@rW)!RemoteWithConnectionModelPropertyr4TNrr.r.r.r/r  rYr c@r)ReturnsPropertyF)r4is_tabler8rWNrr.r.r.r/r  r}r c@r)StrictPropertyNrr.r.r.r/r  rr c@rW)RowFormatPropertyr4TNrr.r.r.r/r  rYr c@r8)RowFormatDelimitedPropertyF)fieldsescapedcollection_itemsmap_keyslinesrWrNrr.r.r.r/r s rc@r)RowFormatSerdePropertyTF)r4serde_propertiesNrr.r.r.r/r rrc@s eZdZddddddddZdS)QueryTransformTF)rlcommand_scriptschemarow_format_before record_writerrow_format_after record_readerNrr.r.r.r/r r?rc@rW)SamplePropertyr4TNrr.r.r.r/r rYrc@rW)SecurityPropertyr4TNrr.r.r.r/r rYrc@rW)SchemaCommentPropertyr4TNrr.r.r.r/r rYrc@r)SerdePropertiesTF)rlrNrr.r.r.r/r  rr c@rW) SetPropertymultiTNrr.r.r.r/r! rYr!c@rW)SharingPropertyr4FNrr.r.r.r/r#" rYr#c@rW)SetConfigPropertyr4TNrr.r.r.r/r$& rYr$c@rW)SettingsPropertyrlTNrr.r.r.r/r%* rYr%c@r)SortKeyPropertyTF)r4rNrr.r.r.r/r&. rr&c@rW)SqlReadWritePropertyr4TNrr.r.r.r/r'2 rYr'c@rW)SqlSecurityPropertydefinerTNrr.r.r.r/r(6 rYr(c@rW)StabilityPropertyr4TNrr.r.r.r/r*: rYr*c@rW)StorageHandlerPropertyr4TNrr.r.r.r/r+> rYr+c@rW)TemporaryPropertyr4FNrr.r.r.r/r,B rYr,c@r)SecurePropertyNrr.r.r.r/r-F rr-c@rW)TagsrlTNrr.r.r.r/r.K rYr.c@rW)TransformModelPropertyrlTNrr.r.r.r/r/O rYr/c@rW)TransientPropertyr4FNrr.r.r.r/r0S rYr0c@r)UnloggedPropertyNrr.r.r.r/r1W rr1c@rW)UsingTemplatePropertyr4TNrr.r.r.r/r2\ rYr2c@rW)ViewAttributePropertyr4TNrr.r.r.r/r3a rYr3c@rW)VolatilePropertyr4FNrr.r.r.r/r4e rYr4c@r)WithDataPropertyTF)r statisticsNrr.r.r.r/r5i rr5c@rW)WithJournalTablePropertyr4TNrr.r.r.r/r7m rYr7c@rW)WithSchemaBindingPropertyr4TNrr.r.r.r/r8q rYr8c@seZdZddddddZdS)WithSystemVersioningPropertyFT)r<r4data_consistencyrrNrr.r.r.r/r9u rfr9c@rW)WithProcedureOptionsrlTNrr.r.r.r/r; rYr;c@rH)EncodePropertyTF)r4r&r%Nrr.r.r.r/r< rKr<c@rH)IncludePropertyTF)r4r column_defNrr.r.r.r/r= rKr=c@r) ForcePropertyNrr.r.r.r/r? rr?c@seZdZddiZidededededede d e d e d e d e d ededededededeeeeeeedZddeDZGdddeZe dddZ!dS) PropertiesrlT ALGORITHMAUTO_INCREMENTz CHARACTER SET CLUSTERED_BYCOLLATECOMMENT CREDENTIALSDEFINERDISTKEYDISTRIBUTED_BY DISTSTYLEENGINEz EXECUTE ASFORMATLANGUAGELOCATIONLOCK)PARTITIONED_BYRETURNS ROW_FORMATSORTKEYENCODEINCLUDEcCi|]\}}||qSr.r.r^r.r.r/r) zProperties.c@s<eZdZeZeZeZeZeZeZ eZ eZ dS)zProperties.LocationN) r0r1r2r POST_CREATE POST_NAME POST_SCHEMA POST_WITH POST_ALIASPOST_EXPRESSION POST_INDEX UNSUPPORTEDr.r.r.r/Location s r`properties_dictt.DictrOcCsfg}|D]'\}}|j|}|r||t|dq|tt|t|dq||dS)NrrrR) rJNAME_TO_PROPERTYrhr3rr3rrpr~)r'rarlr%rM property_clsr.r.r/ from_dict s zProperties.from_dictN)rarbrOr@)"r0r1r2rrrrrrrrrrrrrrrrrrrr r r&r<r=rcrJPROPERTY_TO_NAMEr r`rrer.r.r.r/r@ s`      r@c@r)QualifyNrr.r.r.r/rg rrgc@r)InputOutputFormatF)r\ output_formatNrr.r.r.r/rh rrhc@r)ReturnNrr.r.r.r/rj rrjc@rH) ReferenceTF)r4rlrNrr.r.r.r/rk rKrkc@s(eZdZddiZdddddddZdS)TuplerlFNTrDrHrErrrFrrPrOrGcsbtt|fdd|D|rt|fdind|r-tfddt|DddSddS)NcrHrIr9r:rr.r/r r<zTuple.isin..rcrJrrKr:rPr.r/r rQrRrS)rGrUrLrVr)rLrErrrlrr.rPr/rW s  z Tuple.isinr)r0r1r2rrWr.r.r.r/rl s rlmatchFlateralsrrrprewhererrhavingqualifywindows distributesortrCrrr)locksrrErOrc@r) QueryOptionTFr2Nrr.r.r.r/rv rrvc@rW) WithTableHintrlTNrr.r.r.r/rw rYrwc@rH)IndexTableHintTF)r4rlrjNrr.r.r.r/rx% rKrxc@r])HistoricalDataTr4r%r?Nrr.r.r.r/ry* rKryc@rZ)PutTFr4rjr&Nrr.r.r.r/r{/ rKr{c@rZ)GetTFr|Nrr.r.r.r/r}4 rKr}c@seZdZiddddddddddddddd dd dd dd dd ddddddddddddddZed+ddZed+ddZed+ddZed,ddZed-d d!Z ed,d"d#Z d.d/d(d)Z d*S)0rr4Frr5r6rnrrhints system_timeversionrOrrwhenrBrFchanges) rows_fromrrOrmcCs|jr t|jtr dS|jjSr )r4rnrrtrbr.r.r/rtO sz Table.namecCrrrrbr.r.r/r5U rzTable.dbcCrrrrbr.r.r/r6Y rz Table.catalogrcCgSrIr.rbr.r.r/r] z Table.selectsrcCrrIr.rbr.r.r/ra rzTable.named_selectscCsLg}dD]}|j|}t|tr||qt|tr#||q|S)z8Return the parts of a table in order catalog, db, table.)r6r5r4)r@rhrnrextendrr>r)rLrrrr.r.r/re s    z Table.partsTrrPr>cCsf|j}|d}t|trtt|dd|dd|d}n|}|jd}|r1t||j|d}|S)Nrr)rrrr) rrnrocolumnrr@rhr0r4)rLrr last_partr;rr.r.r/ to_columnt s & zTable.to_columnNrrrr)rrPrOr>) r0r1r2rrrtr5r6rrrrr.r.r.r/r8 sh           rc @seZdZdddddddddeZddddd$ddZed%ddZed&ddZed'ddZ ed(ddZ ed(ddZ ed)d d!Z ed)d"d#Z dS)*rFT)rr4r?rrCrr%r<NrrLrrlrrrPrrrrOcOsJt||}|jj|||dd||jj|||dd||SNFr)rUr4rrr?rLrrrrlrr4r.r.r/r s  zSetOperation.selectrcC |jjSrI)r4rrrbr.r.r/r rzSetOperation.named_selectscCs|jjp|jjSrI)r4rr?rbr.r.r/r rzSetOperation.is_starrcCrrI)r4rrrbr.r.r/r rzSetOperation.selectsrcCrrIrrbr.r.r/left rzSetOperation.leftcCrrIr?rbr.r.r/right rzSetOperation.rightrmcCrr1rrbr.r.r/r% rzSetOperation.kindcCrrrrbr.r.r/r rzSetOperation.side) rLrrlrrrPrrrrPrOrrrr)rOrr)r0r1r2QUERY_MODIFIERSrrrrrrrrr%rr.r.r.r/r s<       c@r)rNrr.r.r.r/r rrc@r)rNrr.r.r.r/r rrc@r)rNrr.r.r.r/r rrc @seZdZdddddddddZ d d!d d Zddddd"ddZddddd#ddZ   d$d%ddZ     d&d'ddZdS)(UpdateFT)rr4rlrlrr!rrNr?rOrrrrPrOc Kstd||dtd||d|S)a Set the table to update. Example: >>> Update().table("my_table").set_("x = 1").sql() 'UPDATE my_table SET x = 1' Args: expression : the SQL code strings to parse. If a `Table` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Table`. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Update expression. r4Nr?rrrrrrr.rrr.r.r/r8 z Update.tablerrlrc Ot||d|td||d|S)a Append to or set the SET expressions. Example: >>> Update().table("my_table").set_("x = 1").sql() 'UPDATE my_table SET x = 1' Args: *expressions: the SQL code strings to parse. If `Expression` instance(s) are passed, they will be used as-is. Multiple expressions are combined with a comma. append: if `True`, add the new expressions to any existing SET expressions. Otherwise, this resets the expressions. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. rlNrrrrrrrrr>rr.r.r/set_ s z Update.set_rrc Or)aY Append to or set the WHERE expressions. Example: >>> Update().table("tbl").set_("x = 1").where("x = 'a' OR x < 'b'").sql() "UPDATE tbl SET x = 1 WHERE x = 'a' OR x < 'b'" Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator. append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: Select: the modified expression. rrrrr.r.r/rrz Update.wherec Ks,|st||Std||dtd||d|S)a Set the FROM expression. Example: >>> Update().table("my_table").set_("x = 1").from_("baz").sql() 'UPDATE my_table SET x = 1 FROM baz' Args: expression : the SQL code strings to parse. If a `From` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `From`. If nothing is passed in then a from is not applied to the expression dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Update expression. rlFROMrNr.)rUrr)rr.r.r/from_Bs z Update.from_rr1rr/rc KrG)ae Append to or set the common table expressions. Example: >>> Update().table("my_table").set_("x = 1").from_("baz").with_("baz", "SELECT id FROM foo").sql() 'WITH baz AS (SELECT id FROM foo) UPDATE my_table SET x = 1 FROM baz' Args: alias: the SQL code string to parse as the table name. If an `Expression` instance is passed, this is used as-is. as_: the SQL code string to parse as the table expression. If an `Expression` instance is passed, it will be used as-is. recursive: set the RECURSIVE part of the expression. Defaults to `False`. materialized: set the MATERIALIZED part of the expression. append: if `True`, add to any existing expressions. Otherwise, this resets the expressions. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified expression. rHrrIr.r.r/rjrJz Update.with_r)r?rOrrrrPrOr) rlrOrrPrrrrPrOr rlrrrPrrrrPrOrr)r?rrrrrPrOrrK)rrOr1rOrr/rr/rrPrrrrPrOr) r0r1r2rr8rrrrr.r.r.r/r s< #() ,rc@r)ValuesTFrlrNrr.r.r.r/rrrc@r)rqNrr.r.r.r/rqrrqc@seZdZdZddddZdS)Versiona2 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") TFrzNr0r1r2r&rr.r.r.r/rs rc@r)SchemaFr=Nrr.r.r.r/rrrc@rH)LockTF)r+rlwaitNrr.r.r.r/rrKrc @sZeZdZdddddddddeZ dEdFd d ZdddddGddZdddddGddZdddddGddZdddddGddZ dddddGddZ       dHdId#d$Z dddddGd%d&Z dddddGd'd(Z dddddGd)d*Zddd+dJd.d/Z   dKdLd4d5ZdMdNd7d8Zddd9dOd;d<ZedPd>d?ZedQd@dAZedRdCdDZdS)SrF)rr%rlr>rrrloperation_modifiersNTr?rOrrrrPrOc Kstd||dtd||d|S)a Set the FROM expression. Example: >>> Select().from_("tbl").select("x").sql() 'SELECT x FROM tbl' Args: expression : the SQL code strings to parse. If a `From` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `From`. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. rlrrNr.)rr)rr.r.r/rrz Select.from_rrlrrc Os2|s |s|S|St||d||dt|d|S)a 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' Args: *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Group`. If nothing is passed in then a group by is not applied to the expression append: if `True`, add to any existing expressions. Otherwise, this flattens all the `Group` expression into a single expression. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. rzGROUP BYr)rrrjrr.r.r/group_bys zSelect.group_byc Or)a_ 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' Args: *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `SORT`. append: if `True`, add to any existing expressions. Otherwise, this flattens all the `Order` expression into a single expression. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. rtzSORT BYr)rrrr.r.r/sort_byrzSelect.sort_byc Or)ak 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' Args: *expressions: the SQL code strings to parse. If a `Group` instance is passed, this is used as-is. If another `Expression` instance is passed, it will be wrapped in a `Cluster`. append: if `True`, add to any existing expressions. Otherwise, this flattens all the `Order` expression into a single expression. dialect: the dialect used to parse the input expression. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. rCz CLUSTER BYr)rrrr.r.r/ cluster_by:rzSelect.cluster_byc Ost||d||t|d|S)Nrl)rrrrrrrrr.r.r/rbz Select.selectc Or)a 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' Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. append: if `True`, add to any existing expressions. Otherwise, this resets the expressions. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. rnz LATERAL VIEWr)rrrr.r.r/lateralus zSelect.lateralr<r|-t.Optional[ExpOrStr | t.Collection[ExpOrStr]] join_typer/ join_aliast.Optional[Identifier | str]c Ks\d|i| } z t|ftdd| }Wnty(t|fdttfi| }Ynwt|tr0|nt|d} t| jtrD| j| j|rnt|fddi| \} } }| r\| d| j | re| d| j |rn| d |j |rt t |||d | }| d ||rt t || d ||td | } |r| dt| j|ddt | f|d||d| S)a7 Append to or set the JOIN expressions. Example: >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y").sql() 'SELECT * FROM tbl JOIN tbl2 ON tbl1.y = tbl2.y' >>> Select().select("1").from_("a").join("b", using=["x", "y", "z"]).sql() 'SELECT 1 FROM a JOIN b USING (x, y, z)' Use `join_type` to change the type of join: >>> Select().select("*").from_("tbl").join("tbl2", on="tbl1.y = tbl2.y", join_type="left outer").sql() 'SELECT * FROM tbl LEFT OUTER JOIN tbl2 ON tbl1.y = tbl2.y' Args: expression: the SQL code string to parse. If an `Expression` instance is passed, it will be used as-is. on: optionally specify the join "on" criteria as a SQL string. If an `Expression` instance is passed, it will be used as-is. using: optionally specify the join "using" criteria as a SQL string. If an `Expression` instance is passed, it will be used as-is. append: if `True`, add to any existing expressions. Otherwise, this resets the expressions. join_type: if set, alter the parsed join type. join_alias: an optional alias for the joined source. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: Select: the modified expression. rJOIN)rrrr JOIN_TYPErrr%rrr<r|)rrrrrr4Tr8r)rrrr)rLrr r>rnr4rr rTrrvrrrror0)rLr?r<r|rrrrrr parse_argsrrrr%r.r.r/rsV -    z Select.joinc Or)ay 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' Args: *expressions: the SQL code strings to parse. If an `Expression` instance is passed, it will be used as-is. Multiple expressions are combined with an AND operator. append: if `True`, AND the new expressions to any existing expression. Otherwise, this resets the expression. dialect: the dialect used to parse the input expressions. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input expressions. Returns: The modified Select expression. rpr)rr.rr.r.r/rprz Select.havingc Or)Nrrr)rWindowrr.r.r/window%rz Select.windowc Or)Nrqr)rrgrr.r.r/rq8rzSelect.qualify)rronsrcsNt|}|rtfdd|Ddnd}|d|r"t|d|Sd|S)a Set the OFFSET expression. Example: >>> Select().from_("tbl").select("x").distinct().sql() 'SELECT DISTINCT x FROM tbl' Args: 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. csg|] }|rt|dqSrIrL)rXr<rr.r/r^sz#Select.distinct..rRNr)r<)rUrlrDistinct)rLrrrrr<r.rr/rKs  zSelect.distinctr8r&t.Optional[t.Dict]r$c KsBt||}t|ft|d|}d}|rt|}t|d||dS)a Convert this expression to a CREATE TABLE AS statement. Example: >>> Select().select("*").from_("tbl").ctas("x").sql() 'CREATE TABLE x AS SELECT * FROM tbl' Args: table: the SQL code string to parse as the table name. If another `Expression` instance is passed, it will be used as-is. properties: an optional mapping of table properties dialect: the dialect used to parse the input table. copy: if `False`, modify this expression instance in-place. opts: other options to use to parse the input table. Returns: The new Create expression. rrNTABLE)r4r%r?r&)rUrLrr@rer$) rLr8r&rrrrtable_expressionproperties_expressionr.r.r/ctasbs  z Select.ctasr+cCs"t||}|dt|dg|S)ap 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" Args: update: if `True`, the locking type will be `FOR UPDATE`, else it will be `FOR SHARE`. copy: if `False`, modify this expression instance in-place. Returns: The modified expression. ru)r+)rUrr)rLr+rinstr.r.r/locks z Select.lockrr~cs0t|}|dtfdd|Dd|S)a( Set hints for this expression. Examples: >>> Select().select("x").from_("tbl").hint("BROADCAST(y)").sql(dialect="spark") 'SELECT /*+ BROADCAST(y) */ x FROM tbl' Args: hints: The SQL code strings to parse as the hints. If an `Expression` instance is passed, it will be used as-is. dialect: The dialect used to parse the hints. copy: If `False`, modify this expression instance in-place. Returns: The modified expression. r>csg|] }t|dqSrrr)rXhrr.r/rzSelect.hint..rR)rUrr/)rLrrr~rr.rr/r>s z Select.hintrcCr)NcSsg|]}|jr|jqSr.)rrr:r.r.r/rr<z(Select.named_selects..rRrbr.r.r/rrzSelect.named_selectscCstdd|jDS)Ncs|]}|jVqdSrI)rrXr?r.r.r/rZz!Select.is_star..)rrlrbr.r.r/rszSelect.is_starrcCrrIrRrbr.r.r/rrzSelect.selectsr)r?rOrrrrPrOrr)NNTNNNT)r?rOr<rr|rrrPrr/rrrrrrPrOr)rrrrPrrPrOrr) r8rOr&rrrrrPrOr$)TT)r+rPrrPrOr)r~rOrrrrPrOrrrr)r0r1r2rrrrrrrrrrprrqrrrr>rrrrr.r.r.r/rs  #/++* e* (  rc@sleZdZddddeZddZdddZdd dd dddZedddZ edddZ edddZ d S)rTF)r4rrcCs"|}t|tr|j}t|ts|S)zReturns the first non subquery.)rnrr4rr.r.r/rs   zSubquery.unnestrOcCs.|}|jr|jrtt|j}|jr|js|SrI)r is_wrapperrMrNrrArr.r.r/unwraps   zSubquery.unwrapNrrlrrrPrrrcOs*t||}|j|||dd||Sr)rUrrrr.r.r/rs zSubquery.selectcCrV)z Whether this Subquery acts as a simple wrapper around another expression. SELECT * FROM (((SELECT * FROM t))) ^ This corresponds to a "wrapper" Subquery node css$|] \}}|dkr|duVqdS)r4Nr.r^r.r.r/rZs"z&Subquery.is_wrapper..)ror@rJrbr.r.r/rs zSubquery.is_wrappercCr*rI)r4rrbr.r.r/rr,zSubquery.is_starrmcCrrIrrbr.r.r/rrzSubquery.output_name)rOr) rlrrrPrrrrPrOrrr) r0r1r2rrrrrrrrrr.r.r.r/rs&    rc @r) TableSampleF) rlrbucket_numeratorbucket_denominator bucket_fieldrvrwrseedNrr.r.r.r/rrrc@eZdZdZddddZdS)TagzFTags are used for generating arbitrary sql like SELECT x.F)r4rpostfixNrr.r.r.r/r s  rc @sDeZdZdddddddddddd Zed ddZed dd Zd S) PivotF) r4rrlrunpivotr|rr include_nullsdefault_on_nullrrOrPcCr)Nrrrbr.r.r/r'rz Pivot.unpivotrcCs|jdgS)Nrrgrbr.r.r/r+rz Pivot.fieldsNrr)r0r1r2rrrrr.r.r.r/rs" rc@r)UnpivotColumnsTr=Nrr.r.r.r/r2rrc@s eZdZddddddddZdS)rTF)r4r;rspecroverfirstNrr.r.r.r/r6r?rc@r3) WindowSpecF)r%r< start_sider=end_sideexcludeNrr.r.r.r/rBrPrc@r)PreWhereNrr.r.r.r/rMrrc@r)rNrr.r.r.r/rQrrc@s4eZdZddddZed ddZed ddZd S) rrF)exceptr renamerOrmcCr)N*r.rbr.r.r/rtXrz Star.namecCrrIrrbr.r.r/r\rzStar.output_nameNr)r0r1r2rrrtrr.r.r.r/rrUs   rrc@r) ParameterTFr2Nrr.r.r.r/rarrc@r)SessionParameterTFrUNrr.r.r.r/rerrc@s&eZdZddddZedddZdS) PlaceholderF)r4r%widgetrOrmcCs |jpdS)N?rrbr.r.r/rtmrzPlaceholder.nameNrrr.r.r.r/rjrrc@s2eZdZUiZded<ed ddZd dd Zd S) rsrrrOrmcCr)NNULLr.rbr.r.r/rturz Null.name Lit[None]cCrrIr.rbr.r.r/r|yr z Null.to_pyNr)rOr)r0r1r2rrrrtr|r.r.r.r/rsrs  rsc@seZdZdddZdS)BooleanrOrPcCrrIrrbr.r.r/r|~sz Boolean.to_pyNr)r0r1r2r|r.r.r.r/r}rrc@r) DataTypeParamTFr2rOrmcCr*rIr+rbr.r.r/rtr,zDataTypeParam.nameNrrr.r.r.r/rrrc@seZdZddddddddZGdddeZejejejej hZ ej ej hZ he e ejZejejejejejejhZejejejejejejejhZejej ej!ej"ej#ej$ej%hZ&hee&ej'Z(ej)ej*hZ+he+ej,ej-ej.ej/ej0ej1ej2ej3ej4ej5Z6he(e6Z7ej8ej9ej:ej;ejej?ej@ejAejBejCejDejEejFhZGeH   ddddZIdddddZJdS)rTF)r4rlnestedrrr%nullablec@seZdZeZeZeZeZeZeZ eZ eZ eZ eZ eZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZ eZ!eZ"eZ#eZ$eZ%eZ&eZ'eZ(eZ)eZ*eZ+eZ,eZ-eZ.eZ/eZ0eZ1eZ2eZ3eZ4eZ5eZ6eZ7eZ8eZ9eZ:eZ;eZeZ?eZ@eZAeZBeZCeZDeZEeZFeZGeZHeZIeZJeZKeZLeZMeZNeZOeZPeZQeZReZSeZTeZUeZVeZWeZXeZYeZZeZ[eZ\eZ]eZ^eZ_eZ`eZaeZbeZceZdeZeeZfeZgeZheZieZjeZkeZleZmeZneZoeZpeZqeZrdZseZteZueZveZweZxeZyeZzeZ{eZ|eZ}dS)z DataType.Typez USER-DEFINEDN)~r0r1r2rARRAYAGGREGATEFUNCTIONSIMPLEAGGREGATEFUNCTION BIGDECIMALBIGINT BIGSERIALBINARYBITBLOBBOOLEANBPCHARCHARDATEDATE32DATEMULTIRANGE DATERANGEDATETIME DATETIME2 DATETIME64DECIMAL DECIMAL32 DECIMAL64 DECIMAL128 DECIMAL256DOUBLEDYNAMICENUMENUM8ENUM16 FIXEDSTRINGFLOAT GEOGRAPHYGEOMETRYPOINTRING LINESTRINGMULTILINESTRINGPOLYGON MULTIPOLYGON HLLSKETCHHSTOREIMAGEINETINTINT128INT256INT4MULTIRANGE INT4RANGEINT8MULTIRANGE INT8RANGEINTERVAL IPADDRESSIPPREFIXIPV4IPV6JSONJSONBLISTLONGBLOBLONGTEXTLOWCARDINALITYMAP MEDIUMBLOB MEDIUMINT MEDIUMTEXTMONEYNAMENCHARNESTEDNOTHINGr NUMMULTIRANGENUMRANGENVARCHAROBJECTRANGE ROWVERSIONSERIALSET SMALLDATETIMESMALLINT SMALLMONEY SMALLSERIALSTRUCTSUPERTEXTTINYBLOBTINYTEXTTIMETIMETZ TIMESTAMP TIMESTAMPNTZ TIMESTAMPLTZ TIMESTAMPTZ TIMESTAMP_S TIMESTAMP_MS TIMESTAMP_NSTINYINT TSMULTIRANGETSRANGETSTZMULTIRANGE TSTZRANGEUBIGINTUINTUINT128UINT256 UMEDIUMINTUDECIMALUDOUBLEUNIONUNKNOWN USERDEFINED USMALLINTUTINYINTUUID VARBINARYVARCHARVARIANTVECTORXMLYEARTDIGESTr.r.r.r/Types reNr DATA_TYPErrudtrPrrOcKsddlm}t|tr@|dkrtd dtjji|Sz |||ttj d}WnMt y?|r>td tjj |d|YSwt|t t frU|rUtd tjj |d|St|tjrat|d}nt|trkt||Stdt|d td ii|j|S) a Constructs a DataType object. Args: dtype: the data type of interest. dialect: the dialect to use for parsing `dtype`, in case it's a string. udt: when set to True, `dtype` will be used as-is if it can't be parsed into a DataType, thus creating a user-defined type. copy: whether to copy the data type. kwargs: additional arguments to pass in the constructor of DataType. Returns: The constructed DataType object. r) parse_onerYr4)readr error_levelrUrzInvalid data type: z. Expected str or DataType.TypeNr.)sqlglotrhrnrmr3rrerYr IGNOREr rZrorrUr{rQr@)r'rrrgrrrh data_type_expr.r.r/rrs*         zDataType.build)check_nullablerrncGs|jd}|D]7}tj|ddd}|jd}|js/|r!|s/|s/|jtjjks/|jtjjkr4||k}n|j|jk}|r?dSqdS)aM Checks whether this DataType matches one of the provided data types. Nested types or precision will be compared using "structural equivalence" semantics, so e.g. array != array. Args: dtypes: the data types to compare this DataType to. check_nullable: whether to take the NULLABLE type constructor into account for the comparison. If false, it means that NULLABLE is equivalent to INT. Returns: True, if and only if there is a type in `dtypes` which is equal to this DataType. rFT)rrg)r@rhrrrlr4rerZ)rLrnrself_is_nullabler other_typeother_is_nullablematchesr.r.r/rs(    zDataType.is_type)NFT) rrfrrrgrPrrPrOr)rrfrnrPrOrP)Kr0r1r2rr rer0r5r>rX STRUCT_TYPESrr% ARRAY_TYPESr) NESTED_TYPESrr/r4r@r_r. TEXT_TYPESrrrrr+r;rLSIGNED_INTEGER_TYPESrQrRrSrTrUr[r\UNSIGNED_INTEGER_TYPESr INTEGER_TYPESrr  FLOAT_TYPESrrrrrrr-r<rVrW REAL_TYPES NUMERIC_TYPESrrrrrr:rCrErFrGrHrJrKrIrDTEMPORAL_TYPESrrrr.r.r.r/rs }      /rc@rW) PseudoTyper4TNrr.r.r.r/r~rYr~c@rW)ObjectIdentifierr4TNrr.r.r.r/rrYrc@r)SubqueryPredicateNrr.r.r.r/rrrc@r)AllNrr.r.r.r/rrrc@r)AnyNrr.r.r.r/rrrc@r)CommandTFr2Nrr.r.r.r/rrrc@r]) TransactionF)r4modesmarkNrr.r.r.r/rrKrc@r])CommitF)chainr4 durabilityNrr.r.r.r/rrKrc@r)RollbackF) savepointr4Nrr.r.r.r/rrrc @s>eZdZdddddddddZed ddZed d d Zd S)AlterTF)r4r%actionsrrBrrC not_validrOr/cCr0r1r2r4r.r.r/r%r5z Alter.kindrcCrk)Nrrgrbr.r.r/rrz Alter.actionsNr6r)r0r1r2rrr%rr.r.r.r/rs rc@r8)AnalyzeF)r%r4rmoderFr?r&Nrr.r.r.r/rr?rc@r)AnalyzeStatisticsTF)r%rEr4rlNrr.r.r.r/r rrc@r)AnalyzeHistogramTF)r4rlr?update_optionsNrr.r.r.r/rrrc@r) AnalyzeSampleT)r%rNrr.r.r.r/rrrc@rW)AnalyzeListChainedRowsr?FNrr.r.r.r/r#rYrc@rW) AnalyzeDeleter%FNrr.r.r.r/r'rYrc@rW) AnalyzeWithrlTNrr.r.r.r/r+rYrc@rH)AnalyzeValidateTF)r%r4r?Nrr.r.r.r/r/rerc@r)AnalyzeColumnsNrr.r.r.r/r7rrc@r) UsingDataNrr.r.r.r/r;rrc@rW) AddConstraintrlTNrr.r.r.r/r?rYrc@r) AddPartitionTFrNrr.r.r.r/rCrrc@r) AttachOptionTFr2Nrr.r.r.r/rGrrc@r) DropPartitionTF)rlrNrr.r.r.r/rKrrc@r)ReplacePartitionT)r?rFNrr.r.r.r/rPrrc@2eZdZdddZed ddZed ddZd S) r5Tr2rOr>cCrrIrrbr.r.r/rXrz Binary.leftcCrrIrrbr.r.r/r\rz Binary.rightNr)r0r1r2rrrrr.r.r.r/r5Us   r5c@r)r~Nrr.r.r.r/r~arr~c@r) ConnectorNrr.r.r.r/rerrc@r) BitwiseAndNrr.r.r.r/rirrc@r)BitwiseLeftShiftNrr.r.r.r/rmrrc@r) BitwiseOrNrr.r.r.r/rqrrc@r)BitwiseRightShiftNrr.r.r.r/rurrc@r) BitwiseXorNrr.r.r.r/ryrrc@r)rmTF)r4r?rkrlNrr.r.r.r/rm}r}rmc@r)OverlapsNrr.r.r.r/rrrc@sReZdZedddZedddZeddd Zedd d ZedddZ dS)rrOrPcCr*rI)r?rrbr.r.r/rr,z Dot.is_starrmcCr*rI)r?rtrbr.r.r/rtr,zDot.namecCrrIrrbr.r.r/rrzDot.output_namerlt.Sequence[Expression]cCs*t|dkr tdtttdd|S)z2Build a Dot object with a sequence of expressions.zDot requires >= 2 expressions.cSr#)Nr2)rxyr.r.r/rs zDot.build..)rr{rMrNrr )rLrlr.r.r/rs z Dot.buildrcCsJ|^}}|tD]}|j|}t|tr||q ||S)zAReturn the parts of a table / column in order catalog, db, table.)rr COLUMN_PARTSr@rhrnr>r)rLr4rrrr.r.r/rs    z Dot.partsNrr)rlrrOrr) r0r1r2rrrtrrrrr.r.r.r/rs    rc@rZ)DPipeTFr4r?rlNrr.r.r.r/rrKrc@r)reNrr.r.r.r/rerrec@r) NullSafeEQNrr.r.r.r/rrrc@r) NullSafeNEQNrr.r.r.r/rrrc@r) PropertyEQNrr.r.r.r/rrrc@r)DistanceNrr.r.r.r/rrrc@r)EscapeNrr.r.r.r/rrrc@r)GlobNrr.r.r.r/rrrc@r)rzNrr.r.r.r/rzrrzc@r)r|Nrr.r.r.r/r|rr|c@r)rcNrr.r.r.r/rcrrcc@r)ILikeAnyNrr.r.r.r/rrrc@r)rNrr.r.r.r/rrrc@r)r]Nrr.r.r.r/r]rr]c@r)Kwargz1Kwarg in special functions like func(kwarg => y).Nrr.r.r.r/rrrc@r)raNrr.r.r.r/rarrac@r)LikeAnyNrr.r.r.r/rrrc@r)rvNrr.r.r.r/rvrrvc@r)rxNrr.r.r.r/rxrrxc@r)rNrr.r.r.r/rrrc@r)rNrr.r.r.r/rrrc@r)rgNrr.r.r.r/rgrrgc@r])OperatorT)r4operatorr?Nrr.r.r.r/rrKrc@r) SimilarToNrr.r.r.r/r rrc@r)SliceFr2Nrr.r.r.r/rrrc@r)rNrr.r.r.r/rrrc@r)UnaryNrr.r.r.r/rrrc@r) BitwiseNotNrr.r.r.r/rrrc@r)rNrr.r.r.r/r"rrc@r )rrOrmcCr*rIr+rbr.r.r/r'r,zParen.output_nameNr)r0r1r2rrr.r.r.r/r&rrcseZdZdfdd ZZS)ryrO int | Decimalcs|jr |jdStS)Nr)rzr4r|r"rbr,r.r/r|-s z Neg.to_py)rOr)r0r1r2r|r3r.r.r,r/ry,sryc@r) rTFrrOrmcCrrIrrbr.r.r/r6rzAlias.output_nameNrr0r1r2rrrr.r.r.r/r3rrc@r) PivotAliasNrr.r.r.r/r=rrc@rW)PivotAnyr4FNrr.r.r.r/rCrYrc@r)AliasesTr=cCrrIrRrbr.r.r/aliasesJrzAliases.aliasesN)r0r1r2rrrr.r.r.r/rGrrc@r)AtIndexTr2Nrr.r.r.r/rPrrc@r) AtTimeZoneTr4zoneNrr.r.r.r/rTrrc@r) FromTimeZoneTrNrr.r.r.r/rXrrc@seZdZdZdddZdS) FormatPhrasezFormat override for a column in Teradata. Can be expanded to additional dialects as needed https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT Tr4rONrr.r.r.r/r\src@r])rZTr[Nrr.r.r.r/rZfrKrZcs2eZdZddddddZedfdd ZZS) r8TF)r4rlrrlreturns_list_for_mapsrOrmcs"t|jdkr |jdjStjS)Nrr)rrlrr"rbr,r.r/rts zBracket.output_namer)r0r1r2rrrr3r.r.r,r/r8jsr8c@r)rF)rlr<Nrr.r.r.r/r|rrc@rL)rGTF)r4rlrErru is_globalNrr.r.r.r/rGrPrGc@r)ForInTr2Nrr.r.r.r/rrrc sZeZdZdZddiZdddddd d d d d d ZeeefZ fddZ e dddZ Z S)TimeUnitz+Automatically converts unit arg into a var.unitFDAYHOURMINUTE MILLISECOND NANOSECONDQUARTERSECOND MICROSECONDWEEKrc) DHMMSNSrrUSWYc st|d}t||jrt|j|jp|jd|d<nt|tr/|dt|j jdt j di|dS)Nrrr4r.) rhrnVAR_LIKErqUNABBREVIATED_UNIT_NAMErtr3Weekrr4r"rN)rLr@rr,r.r/rNs   zTimeUnit.__init__rOt.Optional[Var | IntervalSpan]cCrfNrrgrbr.r.r/rrz TimeUnit.unit)rOr)r0r1r2r&rrr~rprqrrNrrr3r.r.r,r/rs$  rc@seZdZdddZddZdS) IntervalOpFT)rr?cCs&t|j|jr|jdSddS)Nr4r)Intervalr?rrrbr.r.r/intervals zIntervalOp.intervalN)r0r1r2rrr.r.r.r/rs  rc@r) IntervalSpanTr2Nrr.r.r.r/rrrc@r)rFrNrr.r.r.r/rrrc@r) IgnoreNullsNrr.r.r.r/rrrc@r) RespectNullsNrr.r.r.r/rrrc@r]) HavingMaxT)r4r?rNrr.r.r.r/rrKrc@sDeZdZdZdZeddZeddZeddZed d Z d S) ra The base class for all function expressions. Attributes: is_var_len_args (bool): if set to True the last argument defined in arg_types will be treated as a variable length argument and the argument's value will be stored as a list. _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this function expression. These values are used to map this node to a name during parsing as well as to provide the function's name during SQL string generation. By default the SQL name is set to the expression's class name transformed to snake case. FcCs||jr,t|j}|jr|ddn|}t|}ddt||D}||d||d<n ddt||jD}|di|S)NrcSrVr.r.rXrrBr.r.r/r)rWz&Func.from_arg_list..cSrVr.r.rr.r.r/r)rWr.)rr\rrzip)r'r@ all_arg_keysnon_var_len_arg_keys num_non_var args_dictr.r.r/ from_arg_lists zFunc.from_arg_listcCs.|turtdd|jvrt|jg|_|jS)Nz?SQL name is only supported by concrete function implementations _sql_names)rr__dict__r r0rr'r.r.r/ sql_namess zFunc.sql_namescCs |dS)Nrrrr.r.r/sql_namerz Func.sql_namecsfddDS)Ncsi|]}|jqSr.)r)rXrtrr.r/r)rz0Func.default_parser_mappings..rrr.rr/default_parser_mappingsszFunc.default_parser_mappingsN) r0r1r2r&rrrrrrr.r.r.r/rs    rc@r)TypeofNrr.r.r.r/rrrc@r)AggFuncNrr.r.r.r/r rrc@r) ArrayRemoveTr2Nrr.r.r.r/rrrc@r])ParameterizedAggTr4rlrNrr.r.r.r/rrKrc@r)AbsNrr.r.r.r/rrrc@ eZdZddddZgdZdS)ArgMaxTFr4r?rc)ARG_MAXARGMAXMAX_BYNr0r1r2rrr.r.r.r/r  rc@r)ArgMinTFr)ARG_MINARGMINMIN_BYNr r.r.r.r/r !r r c@rH) ApproxTopKTF)r4r?countersNrr.r.r.r/r&rKrc@r)FlattenNrr.r.r.r/r*rrc@r) TransformTr2Nrr.r.r.r/r/rrc@s(eZdZdddZdZed ddZdS) AnonymousTFr=rOrmcCst|jtr |jS|jjSrI)rnr4rmrtrbr.r.r/rt7zAnonymous.nameNr)r0r1r2rrrrtr.r.r.r/r3s  rc@eZdZdddZdZdS)AnonymousAggFuncTFr=Nr0r1r2rrr.r.r.r/r< rc@r)CombinedAggFuncTFr=Nrr.r.r.r/rBrrc@r])CombinedParameterizedAggTrNrr.r.r.r/rFrKrc@r)HllTFr=Nrr.r.r.r/rLrrc@eZdZdddZddgZdS)ApproxDistinctTF)r4accuracyAPPROX_DISTINCTAPPROX_COUNT_DISTINCTNr r.r.r.r/rQ  rc@r)ApplyTr2Nrr.r.r.r/r"Vrr"c@seZdZdddZdZdS)ArrayF)rlbracket_notationTNrr.r.r.r/r#Zrr#c@r)ToArrayNrr.r.r.r/r%`rr%c@eZdZddiZdZdS)ListrlFTNrr.r.r.r/r'er'c@seZdZdddddZdS)PadTF)r4r? fill_patternis_leftNrr.r.r.r/r)kr}r)c@rH)ToCharTF)r4rOnlsparamNrr.r.r.r/r,qrKr,c@r)ToNumberTF)r4rOr- precisionscaleNrr.r.r.r/r.wrfr.c@r)ToDoubleTFrNrr.r.r.r/r1rr1c@r)ColumnsTF)r4unpackNrr.r.r.r/r2rr2c@rZ)ConvertTF)r4r?rNNrr.r.r.r/r4rKr4c@rZ)ConvertToCharsetTF)r4destrFNrr.r.r.r/r5rKr5c@rH)ConvertTimezoneFT) source_tz target_tz timestampNrr.r.r.r/r7rKr7c@r)GenerateSeriesTF)r<r=ris_end_exclusiveNrr.r.r.r/r;r}r;c@r)ExplodingGenerateSeriesNrr.r.r.r/r=rr=c@r)ArrayAggTF)r4nulls_excludedNrr.r.r.r/r>rr>c@r)ArrayUniqueAggNrr.r.r.r/r@rr@c@r)ArrayAllTr2Nrr.r.r.r/rArrAc@r)ArrayAnyTr2Nrr.r.r.r/rBrrBc@s"eZdZddgZdddZdZdS) ArrayConcat ARRAY_CONCAT ARRAY_CATTFr=N)r0r1r2rrrr.r.r.r/rCs rCc@r)ArrayConcatAggNrr.r.r.r/rFrrFc@seZdZddiZdZdS)ArrayConstructCompactrlTNrr.r.r.r/rGr(rGc@eZdZddgZdS) ArrayContainsARRAY_CONTAINS ARRAY_HASNr0r1r2rr.r.r.r/rIrYrIc@rH)ArrayContainsAllARRAY_CONTAINS_ALL ARRAY_HAS_ALLNrLr.r.r.r/rMrYrMc@seZdZdddZddgZdS) ArrayFilterTr2FILTER ARRAY_FILTERNr r.r.r.r/rPr!rPc@r) ArrayFirstNrr.r.r.r/rSrrSc@r) ArrayLastNrr.r.r.r/rTrrTc@r) ArrayReverseNrr.r.r.r/rUrrUc@r) ArraySliceTF)r4r<r=rNrr.r.r.r/rVr}rVc@ eZdZddddZddgZdS) ArrayToStringTFr4r?rWARRAY_TO_STRING ARRAY_JOINNr r.r.r.r/rXr rXc@s eZdZddiZdZddgZdS)ArrayIntersectrlTARRAY_INTERSECTARRAY_INTERSECTIONNr0r1r2rrrr.r.r.r/r\s r\c@rW)StPointTFrYST_POINT ST_MAKEPOINTNr r.r.r.r/r`r r`c@rZ) StDistanceTF)r4r? use_spheroidNrr.r.r.r/rcrKrcc@r)StringTFrNrr.r.r.r/rerrec@ eZdZddddZgdZdS) StringToArrayTFrY)STRING_TO_ARRAYSPLIT_BY_STRINGSTRTOK_TO_ARRAYNr r.r.r.r/rgr rgc@r) ArrayOverlapsNrr.r.r.r/rkrrkc@r) ArraySizeTFr2 ARRAY_SIZE ARRAY_LENGTHNr r.r.r.r/rlr!rlc@r) ArraySortTFr2Nrr.r.r.r/ro rroc@r)ArraySumTFr2Nrr.r.r.r/rprrpc@r) ArrayUnionAggNrr.r.r.r/rqrrqc@r)AvgNrr.r.r.r/rrrrrc@r)AnyValueNrr.r.r.r/rsrrsc@rH)LagTFr4rr\Nrr.r.r.r/rtrKrtc@rH)LeadTFruNrr.r.r.r/rv"rKrvc@r)FirstNrr.r.r.r/rw(rrwc@r)LastNrr.r.r.r/rx,rrxc@r) FirstValueNrr.r.r.r/ry0rryc@r) LastValueNrr.r.r.r/rz4rrzc@r)NthValueT)r4rNrr.r.r.r/r{8rr{c@s0eZdZddddZddd d Zddd d ZdS)CaseFT)r4ifsr\rrOthenrrPrOc KsBt||}|dtt|fd|i|t|fd|i|d|S)Nr}r)r4true)rUrIfrL)rLrr~rrrr.r.r/r?s z Case.whencKs*t||}|dt|fd|i||S)Nr\r)rUrrL)rLrrrrr.r.r/rMJs z Case.else_Nr)rrOr~rOrrPrOr|)rrOrrPrOr|)r0r1r2rrrMr.r.r.r/r|<s   r|c@sReZdZdddddddZedddZedd d Zedd d ZdddZdS)CastTF)r4rrOrlrQr\rOrmcCr*rIr+rbr.r.r/rtZr,z Cast.namercCr)Nrrrbr.r.r/r^rzCast.tocCrrIrrbr.r.r/rbrzCast.output_namerrfrPcGs |jj|S)a Checks whether this Cast's DataType matches one of the provided data types. Nested types like arrays or structs will be compared using "structural equivalence" semantics, so e.g. array != array. Args: dtypes: the data types to compare this Cast's DataType to. Returns: True, if and only if there is a type in `dtypes` which is equal to this Cast's DataType. )rrrr.r.r/rfs z Cast.is_typeNrrOr)rrfrOrP) r0r1r2rrrtrrrr.r.r.r/rPs   rc@r)TryCastNrr.r.r.r/rurrc@r)JSONCastNrr.r.r.r/rzrrc@r)TryNrr.r.r.r/r~rrc@r) CastToStrTypeTr4rNrr.r.r.r/rrrc@rZ)TranslateCharactersTF)r4r? with_errorNrr.r.r.r/rrKrc@r)CollateNrr.r.r.r/rrrc@s eZdZddddZddgZdS)CeilTFr4decimalsrCEILCEILINGNr r.r.r.r/rr rc@s&eZdZdddddZdZgdZdS)CoalesceTF)r4rlis_nvlis_null)COALESCEIFNULLNVLNr_r.r.r.r/rs rc@s"eZdZdddZdZddgZdS)ChrTF)rlcharsetCHRrNr_r.r.r.r/rs  rc@seZdZddddZdZdS)ConcatTF)rlrlcoalesceNrr.r.r.r/r rc@eZdZdgZdS)ConcatWs CONCAT_WSNrLr.r.r.r/r rc@r)ContainsTr2Nrr.r.r.r/rrrc@r) ConnectByRootNrr.r.r.r/rrrc@eZdZddddZdZdS)CountF)r4rlbig_intTNrr.r.r.r/rrrc@rH)CountIfCOUNT_IFCOUNTIFNrLr.r.r.r/rrYrc@r)CbrtNrr.r.r.r/rrrc@rW) CurrentDater4FNrr.r.r.r/rrYrc@rW)CurrentDatetimer4FNrr.r.r.r/rrYrc@rW) CurrentTimer4FNrr.r.r.r/rrYrc@r)CurrentTimestampF)r4sysdateNrr.r.r.r/rrrc@r)CurrentTimestampLTZNrr.r.r.r/rrrc@rW) CurrentSchemar4FNrr.r.r.r/rrYrc@rW) CurrentUserr4FNrr.r.r.r/rrYrc@rZ)DateAddTFr4r?rNrr.r.r.r/rrKrc@r)DateBinTFr4r?rrNrr.r.r.r/rr}rc@rZ)DateSubTFrNrr.r.r.r/rrKrc@s"eZdZddgZdddddZdS)DateDiffDATEDIFF DATE_DIFFTFrNr0r1r2rrr.r.r.r/rrcs6eZdZddddZfddZed dd ZZS) DateTruncTF)rr4rc sh|dd}|d}t|tjr)|j}|r"|tjvr"tj|}t ||d<t j di|dS)N unabbreviateTrr.) rrhrnrrrtr3rrpr~r"rN)rLr@rr unit_namer,r.r/rNs     zDateTrunc.__init__rOr>cCrrrrbr.r.r/rrzDateTrunc.unitr)r0r1r2rrNrrr3r.r.r,r/rs   rc@r)DatetimeTFr2Nrr.r.r.r/rrrc@rZ) DatetimeAddTFrNrr.r.r.r/r rKrc@rZ) DatetimeSubTFrNrr.r.r.r/rrKrc@rZ) DatetimeDiffTFrNrr.r.r.r/rrKrc@rZ) DatetimeTruncTFr4rrNrr.r.r.r/rrKrc@rH) DayOfWeek DAY_OF_WEEK DAYOFWEEKNrLr.r.r.r/rrYrc@rH) DayOfWeekIso DAYOFWEEK_ISOISODOWNrLr.r.r.r/r rYrc@rH) DayOfMonth DAY_OF_MONTH DAYOFMONTHNrLr.r.r.r/r$rYrc@rH) DayOfYear DAY_OF_YEAR DAYOFYEARNrLr.r.r.r/r(rYrc@r)ToDaysNrr.r.r.r/r,rrc@rH) WeekOfYear WEEK_OF_YEAR WEEKOFYEARNrLr.r.r.r/r0rYrc@rZ) MonthsBetweenTF)r4r?roundoffNrr.r.r.r/r4rKrc@r3) MakeIntervalF)yearmonthdayhourminutesecondNrr.r.r.r/r8rPrc@seZdZddgZdddZdS)LastDayLAST_DAYLAST_DAY_OF_MONTHTFrNrr.r.r.r/rCrc@r)ExtractTr2Nrr.r.r.r/rHrrc@r)ExistsTFr2Nrr.r.r.r/rLrrc@r]) TimestampF)r4rwith_tzNrr.r.r.r/rPrKrc@rZ) TimestampAddTFrNrr.r.r.r/rTrKrc@rZ) TimestampSubTFrNrr.r.r.r/rXrKrc@s eZdZddgZddddZdS) TimestampDiff TIMESTAMPDIFFTIMESTAMP_DIFFTFrNrr.r.r.r/r\rc@rZ)TimestampTruncTFrNrr.r.r.r/rarKrc@rZ)TimeAddTFrNrr.r.r.r/rerKrc@rZ)TimeSubTFrNrr.r.r.r/rirKrc@rZ)TimeDiffTFrNrr.r.r.r/rmrKrc@rZ) TimeTruncTFrNrr.r.r.r/rqrKrc@ eZdZddgZddddZdS) DateFromPartsDATE_FROM_PARTS DATEFROMPARTST)rrrNrr.r.r.r/rurrc@s&eZdZddgZdddddddZdS) TimeFromPartsTIME_FROM_PARTS TIMEFROMPARTSTF)rrsecnano fractionsr/Nrr.r.r.r/rzs rc@r) DateStrToDateNrr.r.r.r/rrrc@r) DateToDateStrNrr.r.r.r/rrrc@r)DateToDiNrr.r.r.r/rrrc@r)DateF)r4rrlTNrr.r.r.r/rrrc@r)DayNrr.r.r.r/rrrc@rZ)DecodeTF)r4rr Nrr.r.r.r/rrKrc@s&eZdZUgZded<ddiZdZdS) DecodeCaserrrlTN)r0r1r2rrrrr.r.r.r/rs rc@r)DiToDateNrr.r.r.r/rrrc@r)EncodeT)r4rNrr.r.r.r/rrrc@r)ExpNrr.r.r.r/rrrc@r)ExplodeTFr=Nrr.r.r.r/rrrc@r)InlineNrr.r.r.r/rrrc@r) ExplodeOuterNrr.r.r.r/rrrc@r) PosexplodeNrr.r.r.r/rrrc@r)PosexplodeOuterNrr.r.r.r/rrrcs0eZdZdddddZedfdd ZZS) rVTF)rlrr explode_arrayrOrcs6tj}|jd}|r||durtdn|g}|S)NrT)r"rr@rhr)rLrrr,r.r/rs  zUnnest.selectsr)r0r1r2rrrr3r.r.r,r/rVsrVc@rH)FloorTFrNrr.r.r.r/r rKr c@r) FromBase64Nrr.r.r.r/r rr c@r)FeaturesAtTimeTF)r4timenum_rowsignore_feature_nullsNrr.r.r.r/r r}r c@r)ToBase64Nrr.r.r.r/rrrc@r)FromISO8601TimestampFROM_ISO8601_TIMESTAMPNrLr.r.r.r/rrrc@s eZdZddddddddZdS)GapFillTF)r4 ts_column bucket_widthpartitioning_columns value_columnsorigin ignore_nullsNrr.r.r.r/rr?rc@rZ)GenerateDateArrayTFr<r=rNrr.r.r.r/rrKrc@r])GenerateTimestampArrayTrNrr.r.r.r/rrKrc@r)GreatestTFr=Nrr.r.r.r/rrrc@r)OverflowTruncateBehaviorFT)r4 with_countNrr.r.r.r/r rrc@rH) GroupConcatTF)r4 separator on_overflowNrr.r.r.r/r rKr c@r)HexNrr.r.r.r/r#rr#c@r)LowerHexNrr.r.r.r/r$rr$c@r)rNrr.r.r.r/rrrc@r)rNrr.r.r.r/r rrc@r])XorFrNrr.r.r.r/r%$rKr%c@rW)rTFr4rfalseIFIIFNr r.r.r.r/r(r rc@r)NullifTr2Nrr.r.r.r/r*-rr*c@r)InitcapTFr2Nrr.r.r.r/r+1rr+c@r)IsAsciiNrr.r.r.r/r,5rr,c@rH)IsNanIS_NANISNANNrLr.r.r.r/r-9rYr-c@r)Int64Nrr.r.r.r/r0>rr0c@rH)IsInfIS_INFISINFNrLr.r.r.r/r1BrYr1c@r])r#F)r4rr(Nrr.r.r.r/r#GrKr#c@r) JSONPathTF)rlrrOrmcCs|jdj}t|tr |SdS)Nrr!)rlr4rnrm)rL last_segmentr.r.r/rNs zJSONPath.output_nameNrrr.r.r.r/r4Krr4c@r) JSONPathPartNrr.r.r.r/r6Trr6c@rW)JSONPathFilterr4TNrr.r.r.r/r7XrYr7c@rW) JSONPathKeyr4TNrr.r.r.r/r8\rYr8c@rW)JSONPathRecursiver4FNrr.r.r.r/r9`rYr9c@r) JSONPathRootNrr.r.r.r/r:drr:c@rW)JSONPathScriptr4TNrr.r.r.r/r;hrYr;c@r]) JSONPathSliceFrNrr.r.r.r/r<lrKr<c@rW)JSONPathSelectorr4TNrr.r.r.r/r=prYr=c@rW)JSONPathSubscriptr4TNrr.r.r.r/r>trYr>c@rW) JSONPathUnionrlTNrr.r.r.r/r?xrYr?c@r)JSONPathWildcardNrr.r.r.r/r@|rr@c@r) FormatJsonNrr.r.r.r/rArrAc@r) JSONKeyValueTr2Nrr.r.r.r/rBrrBc@rb) JSONObjectFrl null_handling unique_keys return_typeencodingNrr.r.r.r/rCrfrCc@rb) JSONObjectAggFrDNrr.r.r.r/rIrfrIc@r)JSONBObjectAggTr2Nrr.r.r.r/rJrrJc@r) JSONArrayTF)rlrErGstrictNrr.r.r.r/rKrrKc@r) JSONArrayAggTF)r4rrErGrLNrr.r.r.r/rMrfrMc@r) JSONExistsTF)r4pathpassing on_conditionNrr.r.r.r/rNr}rNc@r) JSONColumnDefF)r4r%rO nested_schemaNrr.r.r.r/rRr}rRc@rW) JSONSchemarlTNrr.r.r.r/rTrYrTc@r) JSONValueTF)r4rOr!rQNrr.r.r.r/rUrrUc@r)JSONValueArrayTFr2Nrr.r.r.r/rVrrVc@seZdZddddddZdS) JSONTableTF)r4rrOerror_handlingempty_handlingNrr.r.r.r/rWrfrWc@rz) ObjectInsertTF)r4r%rM update_flagNrr.r.r.r/rZrrZc@r)OpenJSONColumnDefTF)r4r%rOas_jsonNrr.r.r.r/r\r}r\c@rH)OpenJSONTF)r4rOrlNrr.r.r.r/r^rKr^c@r) JSONBContainsJSONB_CONTAINSNrLr.r.r.r/r_rr_c@seZdZdddZdgZdS) JSONBExistsT)r4rO JSONB_EXISTSNr r.r.r.r/ra  rac @s<eZdZdddddddddd ZdgZdZed ddZd S) JSONExtractTF) r4r?only_json_typesrlvariant_extract json_queryrEquoterQ JSON_EXTRACTrOrmcCs|js|jjSdSr )rlr?rrbr.r.r/rrzzJSONExtract.output_nameNrr0r1r2rrrrrr.r.r.r/rds rdc@r)JSONExtractQuoteTF)rErNrr.r.r.r/rk rrkc@seZdZdddZdgZdS)JSONExtractArrayTFr2JSON_EXTRACT_ARRAYNr r.r.r.r/rlrcrlc@s2eZdZdddddZdgZdZed ddZd S) JSONExtractScalarTF)r4r?rerlJSON_EXTRACT_SCALARrOrmcCr*rI)r?rrbr.r.r/rr,zJSONExtractScalar.output_nameNrrjr.r.r.r/rns rnc@r) JSONBExtract JSONB_EXTRACTNrLr.r.r.r/rp#rrpc@r)JSONBExtractScalarJSONB_EXTRACT_SCALARNrLr.r.r.r/rr'rrrc@seZdZddddZdgZdS) JSONFormatF)r4ris_json JSON_FORMATNr r.r.r.r/rt+s  rtc@r)JSONArrayContainsJSON_ARRAY_CONTAINSNrLr.r.r.r/rw1rrwc@ eZdZddgZddddZdS) ParseJSON PARSE_JSON JSON_PARSETFrNrr.r.r.r/rz5srzc@r)LeastTFr=Nrr.r.r.r/r}<rr}c@r)LeftTr2Nrr.r.r.r/r~Arr~c@r)RightTr2Nrr.r.r.r/rErrc@rf)LengthTF)r4binaryrH)LENGTHLEN CHAR_LENGTHCHARACTER_LENGTHNr r.r.r.r/rIr rc@rL) LevenshteinTF)r4r?ins_costdel_costsub_costmax_distNrr.r.r.r/rNrPrc@r)LnNrr.r.r.r/rYrrc@r)LogTFr2Nrr.r.r.r/r]rrc@eZdZgdZdS) LogicalOr) LOGICAL_ORBOOL_OR BOOLOR_AGGNrLr.r.r.r/rarYrc@r) LogicalAnd) LOGICAL_ANDBOOL_AND BOOLAND_AGGNrLr.r.r.r/rerYrc@rH)LowerLOWERLCASENrLr.r.r.r/rirYrc@r) MapFkeysrrOrcCrNrr)rLrr.r.r/rpr zMap.keyscCrNrr)rLrr.r.r/rur z Map.valuesNr)r0r1r2rrrrr.r.r.r/rms   rc@r)ToMapNrr.r.r.r/r|rrc@r)MapFromEntriesNrr.r.r.r/rrrc@r)ScopeResolutionFTr2Nrr.r.r.r/rrrc@r)StreamNrr.r.r.r/rrrc@r)StarMapNrr.r.r.r/rrrc@s6eZdZdddZdZed ddZed ddZd S) VarMapTrrOrcC |jdjSrr@rlrbr.r.r/rrz VarMap.keyscCrrrrbr.r.r/rrz VarMap.valuesNr)r0r1r2rrrrrr.r.r.r/rs  rc@rZ) MatchAgainstTF)r4rlmodifierNrr.r.r.r/rrKrc@r)MaxTFr=Nrr.r.r.r/rrrc@seZdZdgZdS)MD5NrLr.r.r.r/rrrc@r) MD5Digest MD5_DIGESTNrLr.r.r.r/rrrc@r)MedianNrr.r.r.r/rrrc@r)MinTFr=Nrr.r.r.r/rrrc@r)MonthNrr.r.r.r/rrrc@r) AddMonthsTr2Nrr.r.r.r/rrrc@rZ)Nvl2TFr&Nrr.r.r.r/rrKrc@r) NormalizeTF)r4formNrr.r.r.r/rrrc@rz)OverlayTF)r4r?rlforNrr.r.r.r/rr}rc@rZ)PredictTF)r4r? params_structNrr.r.r.r/rrKrc@rH)rPOWERPOWNrLr.r.r.r/rrYrc@r)PercentileContTFr2Nrr.r.r.r/rrrc@r)PercentileDiscTFr2Nrr.r.r.r/rrrc@r)QuantileT)r4quantileNrr.r.r.r/rrrc@r)ApproxQuantileTF)r4rrweightNrr.r.r.r/rr}rc@r)QuarterNrr.r.r.r/rrrc@r)RandRANDRANDOMF)r4r$r3Nrr.r.r.r/rrrc@rW)Randnr4FNrr.r.r.r/rrYrc@rZ)RangeNTF)r4rleachNrr.r.r.r/rrKrc@s eZdZdgZdZdddZdS)ReadCSVREAD_CSVTFr=N)r0r1r2rrrr.r.r.r/rsrc@rz)ReduceTF)r4initialmergefinishNrr.r.r.r/rr}rc@eZdZdddddddZdS) RegexpExtractTFr4r?rs occurrence parametersrNrr.r.r.r/rrPrc@r)RegexpExtractAllTFrNrr.r.r.r/rrPrc@r) RegexpReplaceTF)r4r? replacementrsr modifiersNrr.r.r.r/rrPrc@rZ)riTFr4r?flagNrr.r.r.r/ri%rKric@rZ) RegexpILikeTFrNrr.r.r.r/r)rKrc@rZ) RegexpSplitTFr4r?rNrr.r.r.r/r/rKrc@r)RepeatT)r4timesNrr.r.r.r/r3rrc@rZ)ReplaceTF)r4r?rNrr.r.r.r/r8rKrc@rH)RoundTF)r4rtruncateNrr.r.r.r/r>rKrc@rW) RowNumberr4FNrr.r.r.r/rBrYrc@r) SafeDivideTr2Nrr.r.r.r/rFrrc@seZdZddgZdS)SHASHA1NrLr.r.r.r/rJrYrc@seZdZdgZdddZdS)SHA2TF)r4lengthNrr.r.r.r/rNrc@rH)SignSIGNSIGNUMNrLr.r.r.r/rSrYrc@r) SortArrayTF)r4rsNrr.r.r.r/rWrrc@rZ)SplitTFrNrr.r.r.r/r[rKrc@r]) SplitPartT)r4 delimiter part_indexNrr.r.r.r/r`rKrc@ry) Substring SUBSTRINGSUBSTRTF)r4r<rNrr.r.r.r/rfrrc@r)SubstringIndexu SUBSTRING_INDEX(str, delim, count) *count* > 0 → left slice before the *count*-th delimiter *count* < 0 → right slice after the |count|-th delimiter T)r4rrcNrr.r.r.r/rksrc@r) StandardHashTFr2Nrr.r.r.r/rvrrc@eZdZddgZdddZdS) StartsWith STARTS_WITH STARTSWITHTr2Nrr.r.r.r/rzrrc@r)EndsWith ENDS_WITHENDSWITHTr2Nrr.r.r.r/rrrc@r) StrPositionTF)r4substrrsrNrr.r.r.r/rrrc@rH) StrToDateTFr4rOrlNrr.r.r.r/rrKrc@r) StrToTimeTF)r4rOrrlNrr.r.r.r/rr}rc@r) StrToUnixFrNrr.r.r.r/rrrc@r)StrToMapTF)r4 pair_delimkey_value_delimduplicate_resolution_callbackNrr.r.r.r/rrrc@rZ) NumberToStrTF)r4rOcultureNrr.r.r.r/rrKrc@r)FromBaseTr2Nrr.r.r.r/rrrc@r)Spaceu> SPACE(n) → string consisting of n blank characters Nrr.r.r.r/rsrc@r&)StructrlFTNrr.r.r.r/rr(rc@r) StructExtractTr2Nrr.r.r.r/r rr c@s"eZdZddgZdddddZdS)StuffSTUFFINSERTT)r4r<rr?Nrr.r.r.r/r rr c@r)SumNrr.r.r.r/r rr c@r)SqrtNrr.r.r.r/rrrc@rH)StddevSTDDEVSTDEVNrLr.r.r.r/rrYrc@r) StddevPopNrr.r.r.r/rrrc@r) StddevSampNrr.r.r.r/rrrc@r)TimeFrNrr.r.r.r/rrrc@r) TimeToStrTF)r4rOrrNrr.r.r.r/rr}rc@r) TimeToTimeStrNrr.r.r.r/rrrc@r) TimeToUnixNrr.r.r.r/rrrc@r) TimeStrToDateNrr.r.r.r/rrrc@r) TimeStrToTimeTFrNrr.r.r.r/rrrc@r) TimeStrToUnixNrr.r.r.r/rrrc@r)TrimTF)r4r?rs collationNrr.r.r.r/rrrc@s(eZdZdddddZed ddZdS) TsOrDsAddTF)r4r?rrGrOrcCst|jdp tjjS)NrG)rrr@rhrerrbr.r.r/rGrzTsOrDsAdd.return_typeNr)r0r1r2rrrGr.r.r.r/rsrc@rZ) TsOrDsDiffTFrNrr.r.r.r/r rKrc@r)TsOrDsToDateStrNrr.r.r.r/r rrc@rH) TsOrDsToDateTFrNrr.r.r.r/r rKr c@r)TsOrDsToDatetimeNrr.r.r.r/r!rr!c@rH) TsOrDsToTimeTFrNrr.r.r.r/r"rKr"c@r)TsOrDsToTimestampNrr.r.r.r/r#rr#c@r) TsOrDiToDiNrr.r.r.r/r$!rr$c@r)UnhexTFr2Nrr.r.r.r/r%%rr%c@r)UnicodeNrr.r.r.r/r&)rr&c@r)UnixDateNrr.r.r.r/r'.rr'c@r) UnixToStrTFrNrr.r.r.r/r(2rr(c@seZdZdddddddZedZedZedZedZ edZ ed Z ed Z ed Z ed Zed ZdS) UnixToTimeTF)r4r0rhoursminutesrOrrrr N)r0r1r2rrpr}SECONDSDECISCENTISMILLIS DECIMILLIS CENTIMILLISMICROS DECIMICROS CENTIMICROSNANOSr.r.r.r/r)8s$        r)c@r) UnixToTimeStrNrr.r.r.r/r<Nrr<c@r) UnixSecondsNrr.r.r.r/r=Rrr=c@seZdZgdZdddZdS)Uuid)r]GEN_RANDOM_UUID GENERATE_UUID UUID_STRINGFr+Nrr.r.r.r/r>Vsr>c @s,eZdZddgZdddddddddd ZdS)TimestampFromPartsTIMESTAMP_FROM_PARTSTIMESTAMPFROMPARTSTF) rrrrrrrrmilliNrr.r.r.r/rB\s rBc@rH)UpperUPPERUCASENrLr.r.r.r/rFkrYrFc@r)CorrNrr.r.r.r/rIorrIc@r)Variance)VARIANCE VARIANCE_SAMPVAR_SAMPNrLr.r.r.r/rJsrYrJc@rH) VariancePop VARIANCE_POPVAR_POPNrLr.r.r.r/rNwrYrNc@r) CovarSampNrr.r.r.r/rQ{rrQc@r)CovarPopNrr.r.r.r/rRrrRc@r)rTF)r4rNrr.r.r.r/rrrc@seZdZdgZdddZdS) XMLElement XMLELEMENTTFr=Nrr.r.r.r/rSrrSc@r)XMLTableTF)r4 namespacesrPrby_refNrr.r.r.r/rUrfrUc@r) XMLNamespaceNrr.r.r.r/rXrrXc@r)XMLKeyValueOptionTFr2Nrr.r.r.r/rYrrYc@r)YearNrr.r.r.r/rZrrZc@r])UseF)r4rlr%Nrr.r.r.r/r[rKr[c@seZdZdddddddZdS)MergeTF)r4r|r<whensrr!Nrr.r.r.r/r\rPr\c@seZdZdddddZdS)WhenTF)matchedrFrr~Nrr.r.r.r/r^r}r^c@seZdZdZddiZdS)Whensz:Wraps around one or more WHEN [NOT] MATCHED [...] clauses.rlTNrr.r.r.r/r`s r`c@r) NextValueForTF)r4rNrr.r.r.r/rarrac@r) SemicolonNrr.r.r.r/rbrrbc@r) TableColumnNrr.r.r.r/rcrrccCst|tur |S|SrI)rQrmr$)rr.r.r/rWrWcCs i|] }|D]}||qqSr.r)rXfuncrtr.r.r/r)rr))rrrsql_or_expressionrOrrrrrr/rrPrOrcKrrIr.rfrrrrrr.r.r/rL rL)rrrrstr | Et.Optional[IntoType]cKrrIr.rgr.r.r/rLrhcKsdt|tr |r |S|S|durtdddl}t|}|r&|d|}|j|f||d|S)aUGracefully 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) Args: sql_or_expression: the SQL code string or an expression into: the SQLGlot Expression to parse into dialect: the dialect used to parse the input expressions (in the case that an input expression is a SQL string). prefix: a string to prefix the sql with before it gets parsed (automatically includes a space) copy: whether to copy the expression. **opts: other options to use to parse the input expressions (again, in the case that an input expression is a SQL string). Returns: Expression: the parsed or given expression. NzSQL cannot be Noner )rir)rnr>rr rkrmrh)rfrrrrrrkrr.r.r/rLs TrrcCrrIr.rrr.r.r/rU#r rUcCrrIr.rlr.r.r/rU'r cCs|r|r|S|SrIrrlr.r.r/rU+rrrHrlevelrdrepr_strrmcsTddd}d|}t|trnfdd|jD}|js#r-t|ts-|j|d<|js2r7|j|d<r?t||d <|rGd }d }|j pQt|t oQ|j | fd d |D}|j jd||dSt|tr| fdd|D}|r||nd }d|dSrt|trt|}| tt|dS)z7Generate a textual representation of an Expression tree z rrcs*i|]\}}|dur|gksr||qSrIr.r^rr.r/r)5s*z_to_s..rE _comments_idr!z, c s.g|]\}}|dt|ddqS)rr)rnrr^rmrnrr.r/rFs.z_to_s..(rc3s |] }t|dVqdS)rNr)rXi)rmrr.r/rZKsz_to_s..[])rnr>r@rJrQrrDidrrwror.rr-r0r\rmreprtextwrapdedentr splitlines)rrrmrnindentdelimr@rJr.rrr/r/s2        rcCst|to t|| SrI)rnr>)r?rr.r.r/_is_wrong_expressionWrr~r4c KsNt||r|di||i}t||}td||||d|}||||S)N)rfrrrr.)r~rUrLr) r?rrrrrrrrr.r.r/r[s   r)rrrrrr&cOst||}g} |dur in|}|D]5} | durFt| |r"|| gd} t| f|||d| } | jD]\} } | dkrA| | q3| || <q3q|j|}|rV|rV|j| } || d}|D] \} } || | q_||||S)NrRrrrrl) rUr~rLr@rJrrhrlr)rrrrrrrr&rlrparsedr?r_r`existingchildr.r.r/rts:         r)rrrrrc sNt||} fdd|D}| j|} |r| r| |}| ||| S)Nc s,g|]}|durtd|dqS)N)rfrrrr.rrrrrrr.r/rsz'_apply_list_builder..)rUr@rhr) rrrrrrrrlrrexisting_expressionsr.rr/rs   r)rrrrc Osdd|D}|s |St||}|j|} |r(| dur(|r!| jn| gt|}t|||d|} |||r?|| d|S| |S)NcSs g|] }|dur|dkr|qSr r.)rXexpr.r.r/rrz._apply_conjunction_builder..rr)rUr@rhr4r\rr) rrrrrrrlrrrrr.r.r/rs    rrr1rr/rrrc Ksrt|f|td| } t|f||d| } |r"t| ts"t| d} t| | ||d} t| |d||td|p5didS) Nrrrr)r4rrrrrF)rrrrrr&)rLrrnrrrr~) rrr1rrrrrrralias_expression as_expressioncter.r.r/rs   rrl t.Sequence[t.Optional[ExpOrStr]]rt.Type[Connector]rc  sXfdd|D}|^}}|r|rt|t}|D]} |||r%t| tn| d}q|S)Ncs*g|]}|durt|fdqS)Nr)rrrrrr.r/rs z_combine..r2)r4r) rlrrrrr conditionsr4restr?r.rr/_combines rr?r%t.Type[Expression]cCrrIr.r?r%r.r.r/r4r r4 E | ParencCrrIr.rr.r.r/r4r rt.Optional[E] | ParencCst||r t|dS|Sr)rnrrr.r.r/r4rd)rrr set_operation t.Type[S]rcs(tfddfdd|DS)Ncsd||dS)N)r4r?rr.r.r)rrrr.r/r&rWz&_apply_set_operation..c3s&|]}t|fdVqdS)rNrr:rr.r/rZ's$z'_apply_set_operation..r)rrrrrlrr.)rrrrrr/_apply_set_operationsrcO,t|dks Jdt|t|||d|S)a Initializes a syntax tree for the `UNION` operation. Example: >>> union("SELECT * FROM foo", "SELECT * FROM bla").sql() 'SELECT * FROM foo UNION SELECT * FROM bla' Args: expressions: the SQL code strings, corresponding to the `UNION`'s operands. If `Expression` instances are passed, they will be used as-is. distinct: set the DISTINCT flag if and only if this is true. dialect: the dialect used to parse the input expression. copy: whether to copy the expression. opts: other options to use to parse the input expressions. Returns: The new Union instance. rz1At least two expressions are required by `union`.rrrr)rrrrrrrlrr.r.r/r+  rcOr)a Initializes a syntax tree for the `INTERSECT` operation. Example: >>> intersect("SELECT * FROM foo", "SELECT * FROM bla").sql() 'SELECT * FROM foo INTERSECT SELECT * FROM bla' Args: expressions: the SQL code strings, corresponding to the `INTERSECT`'s operands. If `Expression` instances are passed, they will be used as-is. distinct: set the DISTINCT flag if and only if this is true. dialect: the dialect used to parse the input expression. copy: whether to copy the expression. opts: other options to use to parse the input expressions. Returns: The new Intersect instance. rz5At least two expressions are required by `intersect`.r)rrrrr.r.r/rJrrcOr)a Initializes a syntax tree for the `EXCEPT` operation. Example: >>> except_("SELECT * FROM foo", "SELECT * FROM bla").sql() 'SELECT * FROM foo EXCEPT SELECT * FROM bla' Args: expressions: the SQL code strings, corresponding to the `EXCEPT`'s operands. If `Expression` instances are passed, they will be used as-is. distinct: set the DISTINCT flag if and only if this is true. dialect: the dialect used to parse the input expression. copy: whether to copy the expression. opts: other options to use to parse the input expressions. Returns: The new Except instance. rz3At least two expressions are required by `except_`.r)rrrrr.r.r/rirrrcOstj|d|i|S)a Initializes a syntax tree from one or multiple SELECT expressions. Example: >>> select("col1", "col2").from_("tbl").sql() 'SELECT col1, col2 FROM tbl' Args: *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. r)rr)rrlrr.r.r/rsrcKstj|fd|i|S)a Initializes a syntax tree from a FROM expression. Example: >>> from_("tbl").select("col1", "col2").sql() 'SELECT col1, col2 FROM tbl' Args: *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. r)rr)r?rrr.r.r/rsrr8 str | Tabler&t.Optional[dict]rr!t.Optional[t.Dict[str, ExpOrStr]]c stt|tdd}|r|dfdd|D|r.|dt|ftddt|tr8t|d}|rJ|d t|ftd d|rafd d|D}|d t |d |S)a Creates an update statement. Example: >>> update("my_table", {"x": 1, "y": "2", "z": None}, from_="baz_cte", where="baz_cte.id > 1 and my_table.id = baz_cte.id", with_={"baz_cte": "SELECT id FROM foo"}).sql() "WITH baz_cte AS (SELECT id FROM foo) UPDATE my_table SET x = 1, y = '2', z = NULL FROM baz_cte WHERE baz_cte.id > 1 AND my_table.id = baz_cte.id" Args: properties: dictionary of properties to SET which are auto converted to sql objects eg None -> NULL where: sql conditional parsed into a WHERE statement from_: sql statement parsed into a FROM statement with_: dictionary of CTE aliases / select statements to include in a WITH clause. dialect: the dialect used to parse the input expressions. **opts: other options to use to parse the input expressions. Returns: Update: the syntax tree for the UPDATE statement. rrrlcs0g|]\}}tt|fdit|dqS)rr2)rerLr3r^rrr.r/rszupdate..rlrrrWHEREcs4g|]\}}ttt|fdid|ddqS)rrTr)r0rrL)rXrqryrr.r/rs"rrR) rrLrrrJr)rnrrr~) r8r&rrrrr update_exprcte_listr.rr/r+s:    r+r!cKsVtj|f|dd|}|r|j|f|dd|}|r)|j|f|dd|}|S)a Builds a delete statement. Example: >>> delete("my_table", where="id > 1").sql() 'DELETE FROM my_table WHERE id > 1' Args: 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. Fr)rrrr!)r8rr!rr delete_exprr.r.r/rs rr(t.Optional[t.Sequence[str | Identifier]]rc  szt|f|d|}t|ft|d|} |r&t| fdd|Dd} t| ||d} |r;| j|f|dd|} | S)a Builds an INSERT statement. Example: >>> insert("VALUES (1, 2, 3)", "tbl").sql() 'INSERT INTO tbl VALUES (1, 2, 3)' Args: expression: the sql string or expression of the INSERT statement into: the tbl to insert data to. columns: optionally the table's column names. overwrite: whether to INSERT OVERWRITE or not. returning: sql conditional parsed into a RETURNING statement dialect: the dialect used to parse the input expressions. copy: whether to copy the expression. **opts: other options to use to parse the input expressions. Returns: Insert: the syntax tree for the INSERT statement. rrrrcrHrIrrrr.r/r2r<zinsert..r=)r4r?rF)rLrrr=r!) r?rrrr!rrrrr4rr.rr/rsr)r!rr when_exprsr|r<c Osg}|D]} t| f||td|} |t| tr| gn| jqtt|f||d|t|f||d|t|f||d|t|dd} |rU| j|f|dd|} | S)aK Builds a MERGE statement. Example: >>> merge("WHEN MATCHED THEN UPDATE SET col1 = source_table.col1", ... "WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)", ... into="my_table", ... using="source_table", ... on="my_table.id = source_table.id").sql() 'MERGE INTO my_table USING source_table ON my_table.id = source_table.id WHEN MATCHED THEN UPDATE SET col1 = source_table.col1 WHEN NOT MATCHED THEN INSERT (col1) VALUES (source_table.col1)' Args: *when_exprs: The WHEN clauses specifying actions for matched and unmatched rows. into: The target table to merge data into. using: The source table to merge data from. on: The join condition for the merge. returning: The columns to return from the merge. dialect: The dialect used to parse the input expressions. copy: Whether to copy the expression. **opts: Other options to use to parse the input expressions. Returns: Merge: The syntax tree for the MERGE statement. )rrrrrR)r4r|r<r]F)rLr`rrnr^rlr\r!) rr|r<r!rrrrrl when_exprr?rr.r.r/r<s"rcKst|ft||d|S)a 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' Args: *expression: the SQL code string to parse. If an Expression instance is passed, this is used as-is. dialect: the dialect used to parse the input expression (in the case that the input expression is a SQL string). copy: Whether to copy `expression` (only applies to expressions). **opts: other options to use to parse the input expressions (again, in the case that the input expression is a SQL string). Returns: The new Condition instance r)rLr)r?rrrr.r.r/rosrrcO"ttt|t|f||d|S)a 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)' Args: *expressions: the SQL code strings to parse. If an Expression instance is passed, this is used as-is. dialect: the dialect used to parse the input expression. copy: whether to copy `expressions` (only applies to Expressions). wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues. **opts: other options to use to parse the input expressions. Returns: The new condition rr)rMrNrrrrrrrlrr.r.r/r"rcOr)a 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)' Args: *expressions: the SQL code strings to parse. If an Expression instance is passed, this is used as-is. dialect: the dialect used to parse the input expression. copy: whether to copy `expressions` (only applies to Expressions). wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues. **opts: other options to use to parse the input expressions. Returns: The new condition r)rMrNrrrrr.r.r/r"rr"cOr)a Combine multiple conditions with an XOR logical operator. Example: >>> xor("x=1", xor("y=1", "z=1")).sql() 'x = 1 XOR (y = 1 XOR z = 1)' Args: *expressions: the SQL code strings to parse. If an Expression instance is passed, this is used as-is. dialect: the dialect used to parse the input expression. copy: whether to copy `expressions` (only applies to Expressions). wrap: whether to wrap the operands in `Paren`s. This is true by default to avoid precedence issues, but can be turned off when the produced AST is too deep and causes recursion-related issues. **opts: other options to use to parse the input expressions. Returns: The new condition r)rMrNrrr%rr.r.r/xorrrcKs&t|f||d|}tt|tdS)a Wrap a condition with a NOT operator. Example: >>> not_("this_suit='black'").sql() "NOT this_suit = 'black'" Args: 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. rr)rrr4r)r?rrrr4r.r.r/r$sr$cCstt||ddS)aR Wrap an expression in parentheses. Example: >>> paren("5 + 3").sql() '(5 + 3)' Args: 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. rr)rrL)r?rr.r.r/paren srz^[_a-zA-Z][\w]*$zt.Pattern[str]SAFE_IDENTIFIER_RErtr.cCrrIr.rtr.rr.r.r/rr rr-cCrrIr.rr.r.r/r#scCsb|durdSt|trt||}|St|tr)t||dur#t| n|d}|Std|j)zBuilds an identifier. Args: name: The name to turn into an identifier. quoted: Whether to force quote the identifier. copy: Whether to copy name if it's an Identifier. Returns: The identifier ast node. Nr1z1Name needs to be a string or an Identifier, got: )rnrorUrmrrmr{r-)rtr.r identifierr.r.r/r)s    c Cs6z t||td}W|Sttfyt|}Y|Sw)z Parses a given string into an identifier. Args: name: The name to parse into an identifier. dialect: The dialect to parse against. Returns: The identifier ast node. r)rLror rr)rtrr?r.r.r/parse_identifierDs  rz+\s*(-?[0-9]+(?:\.[0-9]+)?)\s*([a-zA-Z]+)\s*r str | LiteralcCs>t|tr|js td|j}td|}t|tsJ|S)zGBuilds an interval expression from a string like '1 day' or '5 months'.zInvalid interval string.z INTERVAL )rnrprwr{r4rLr)rr.r.r/ to_intervalZs rsql_pathc Kst|tr t||dSz t|t|d}Wnty0t|dd\}}}|s't|||d}Ynw|D] \}} ||| q5|S)a 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. Args: sql_path: a `[catalog].[schema].[table]` string. dialect: the source dialect according to which the table name will be parsed. copy: Whether to copy a table if it is passed in. kwargs: the kwargs to instantiate the resulting `Table` expression with. Returns: A table expression. rrr r,)r5r6) rnrrUrLr rtable_rJr) rrrrr8r6r5r4r_r`r.r.r/to_tablegs   r str | Columnc Kst|tr t||dSz t|t|d}Wnty+tt|dd|i|YSw|D] \}}| ||q0|rK| t D]}| ddqB|S)a Create a column from a `[table].[column]` sql path. Table is optional. If a column is passed in then that column is returned. Args: sql_path: a `[table].[column]` string. quoted: Whether or not to force quote identifiers. dialect: the source dialect according to which the column name will be parsed. copy: Whether to copy a column if it is passed in. kwargs: the kwargs to instantiate the resulting `Column` expression with. Returns: A column expression. rrr r.T) rnr~rUrLr rrrrJrrro) rr.rrrr;r_r`rtr.r.r/rs    rt.Optional[str | Identifier]#bool | t.Sequence[str | Identifier]c Kst|f||d|}t||d}|r4t|d}|d|t|ts2|D] } |dt| |dq%|Sd|jvrFt|tsF|d||St ||dS)aCreate 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)' Args: expression: the SQL code strings to parse. If an Expression instance is passed, this is used as-is. alias: the alias name to use. If the name has special characters it is quoted. table: Whether to create a table alias, can also be a list of columns. quoted: whether to quote the alias dialect: the dialect used to parse the input expression. copy: Whether to copy the expression. **opts: other options to use to parse the input expressions. Returns: Alias: the aliased expression rr.rrrr) rLrrrrnrPrrrr) r?rr8r.rrrrrrr.r.r/r0s      r0rcKs:t|fd|i|j|fi|}tj|fd|i|S)aA Build a subquery expression that's selected from. Example: >>> subquery('select x from tbl', 'bar').select('x').sql() 'SELECT x FROM (SELECT x FROM tbl) AS bar' Args: 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. r)rLrTrr)r?rrrr.r.r/rTs"rTr.rr;r5r6r&t.Collection[t.Union[str, Identifier]]cCrrIr.r;r8r5r6rr.rr.r.r/r  r)rr.rstr | Identifier | StarrcCrrIr.rr.r.r/r rc spt|ts t|d}t|t|dt|dt|dd}|r6t|gfdd|DR}|S)am Build a Column. Args: col: Column name. table: Table name. db: Database name. catalog: Catalog name. fields: Additional fields using dots. quoted: Whether to force quotes on the column's identifiers. copy: Whether to copy identifiers if passed in. Returns: The new Column instance. rr7c3s|] }t|dVqdS)rNr)rXrurr.r.r/rZG rzcolumn..)rnrrrr~rr)r;r8r5r6rr.rr4r.rr/r" s    rrfc Kst|f||d|}tj|f||d|}t|trIddlm}||}|jj } |j j } |j } | | | j | | | j k} ||sG| rI|St||d}||_|S)a/Cast an expression to a data type. Example: >>> cast('x + 1', 'int').sql() 'CAST(x + 1 AS INT)' Args: expression: The expression to cast. to: The datatype to cast to. copy: Whether to copy the supplied expressions. dialect: The target dialect. This is used to prevent a re-cast in the following scenario: - The expression to be cast is already a exp.Cast expression - The existing cast is to a type that is logically equivalent to new type For example, if :expression='CAST(x as DATETIME)' and :to=Type.TIMESTAMP, but in the target dialect DATETIME is mapped to TIMESTAMP, then we will NOT return `CAST(x (as DATETIME) as TIMESTAMP)` and instead just return the original expression `CAST(x as DATETIME)`. This is to prevent it being output as a double cast `CAST(x (as TIMESTAMP) as TIMESTAMP)` once the DATETIME -> TIMESTAMP mapping is applied in the target dialect generator. Returns: The new Cast instance. rrrr)rLrrrnrsqlglot.dialects.dialectrrgenerator_class TYPE_MAPPINGrr4rhrMrrQ) r?rrrrr data_typertarget_dialect type_mappingexisting_cast_type new_cast_typetypes_are_equivalentr.r.r/rNL s$     rNIdentifier | strcCsVt|r t||dnd|rt||dnd|rt||dnd|r'tt|ddSddS)aBuild a Table. Args: 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. rNr)r4r5r6r)rrr)r8r5r6r.rr.r.r/r srrt.Iterable[t.Tuple[t.Any, ...]]3t.Optional[t.Iterable[str] | t.Dict[str, DataType]]cCs^|r|stdtdd|D|r tt|dd|DddS|r+tt|ddSddS) aBuild VALUES statement. Example: >>> values([(1, '2')]).sql() "VALUES (1, '2')" Args: 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 z(Alias is required when providing columnscSg|]}t|qSr.r9)rXtupr.r.r/r rzvalues..cSrr.r)rXrr.r.r/r rrrNr)r{rrr)rrrr.r.r/r s cCs&|stdt|tr|j}t|dS)a)Build a SQL variable. Example: >>> repr(var('x')) 'Var(this=x)' >>> repr(var(column('x', table='y'))) 'Var(this=x)' Args: name: The name of the var or an expression who's name will become the var. Returns: The new variable node. z#Cannot convert empty name into var.r)r{rnr>rtrqrr.r.r/var s   rold_namenew_namecCs.t||d}t||d}t|dt|dgdS)zBuild ALTER TABLE... RENAME... expression Args: old_name: The old name of the table new_name: The new name of the table dialect: The dialect to parse the table. Returns: Alter table expression rrrr4r%r)rrr)rrr old_table new_tabler.r.r/ rename_table s  r table_nameold_column_namenew_column_namercCs>t||d}t||d}t||d}t|dt|||dgdS)a_Build ALTER TABLE... RENAME COLUMN... expression Args: table_name: Name of the table old_column: The old name of the column new_column: The new name of the column exists: Whether to add the `IF EXISTS` clause dialect: The dialect to parse the table/column. Returns: Alter table expression rrrr)rrrr)rrrrrr8 old_column new_columnr.r.r/ rename_column s    rrMcsttr tSttrtSttrtdSdus,ttr/t r/t Stt j r:tSttrFtdSttjrhtjdd}d}jrbttj}t||dSttjr{td}t|dSttrtdrtfdd jDd Stfd d Dd Sttrtfd d Dd Stt rt!tfd d Dd tfdd "Dd dStdrtfdd j#$Dd St%d)a$Convert a python value into an expression object. Raises an error if a conversion is not possible. Args: value: A python object. copy: Whether to copy `value` (only applies to Expressions and collections). Returns: The equivalent expression object. rNrk)seprz%Y-%m-%d_fieldscs*g|]}tt|tt|ddqSrr2)rrr3getattrrXr_rrMr.r/r5!s zconvert..rRcrHrIr9rrr.r/r!r<crHrIr9rrr.r/rA!r<crHrIr9rrr.r/rB!r<rrcs(g|]\}}tt|t|ddqSr)rrr3r^rr.r/rF!szCannot convert )&rnr>rUrmrpr~rPrfloatmathisnanrWnumbersNumberr}bytesrhexdatetime isoformattzinfordatestrftimerr]rrrrlr\r#dictrrrrJr{)rMrdatetime_literaltz date_literalr.rr/r3 !sV                   r3rrc Ost|jD]E\}}t|tu}|r|n|g}g}|D]"} t| tr9t|| g|Ri|D]} || q0q|| q| ||rF|nt |dqdS)zZ Replace children of an expression with the result of a lambda fun(child) -> exp. rN) r]r@rJrQr\rnr>rrrr) r?rr@rr_r` is_list_arg child_nodesnew_child_nodescn child_noder.r.r/replace_childrenN!s    rrrcCsRt|j|d}|r'|}||}||ur%||t|tr%|||s |S)z Replace an entire tree with the result of function calls on each node. This will be traversed in reverse dfs, so leaves first. If new nodes are created as a result of function calls, they will also be traversed. r)r\rrr rnr>r)r?rrrrrr.r.r/ replace_treeb!s     rr!r t.Set[str]cs"fdddd|tDDS)ap 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'] Args: expression: expression to find table names. exclude: a table name to exclude Returns: A list of unique names. csh|] }|r |kr|qSr.r.)rXr8rr.r/ !sz%column_table_names..csrrIr)rXrr.r.r/rZ!rz%column_table_names..)rr~)r?rr.rr/column_table_names|!s r Table | stridentifycs<t|td}|std|dfdd|jDS)a9Get the full name of a table as a string. Args: table: Table expression node or string. dialect: The dialect to generate the table name for. identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True: Always quote. Examples: >>> from sqlglot import exp, parse_one >>> table_name(parse_one("select * from a.b.c").find(exp.Table)) 'a.b.c' Returns: The table name. rz Cannot parse r c3s8|]}s t|js|jddddn|jVqdS)TF)rr rrDN)rrmrtrrrr r.r/rZ!s  ztable_name..)rLrr{rr)r8rr r.r r/r!s c Cs4ddlm}ddd|t|||d|djDS)a3Returns a case normalized table name without quotes. Args: table: the table to normalize dialect: the dialect to use for normalization rules copy: whether to copy the expression. Examples: >>> normalize_table_name("`A-B`.c", dialect="bigquery") 'A-B.c' r)normalize_identifiersr csrrIr)rXpr.r.r/rZ!s  z'normalize_table_name..rr)'sqlglot.optimizer.normalize_identifiersr rrr)r8rrr r.r.r/normalize_table_name!s r mappingt.Dict[str, str]cs4fddDd fdd }|j||dS) aReplace all tables in expression according to the mapping. Args: expression: expression node to be transformed and replaced. mapping: mapping of table names. dialect: the dialect of the mapping table copy: whether to copy the expression. Examples: >>> from sqlglot import exp, parse_one >>> replace_tables(parse_one("select * from a.b"), {"a.b": "c"}).sql() 'SELECT * FROM c /* a.b */' Returns: The mapped expression. ci|] \}}t|d|qSrr r^rr.r/r)!r*z"replace_tables..rr>rOcspt|tr6|jddur6t|d}|}|r6t|fidd|jDdi}||g|S|S)Nr FrcSsi|] \}}|tvr||qSr.) TABLE_PARTSr^r.r.r/r)!r*z;replace_tables.._replace_tables..r) rnrrrhr rr@rJr)roriginalrr8rr r.r/_replace_tables!s   z'replace_tables.._replace_tablesrNrr>rOr>rJr)r?r rrr r.r r/replace_tables!sr cOs"ddd}|j|t|fi|S)aReplace placeholders in an expression. Args: 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. rr>rOc[sXt|tr*|jr||j}|durt|S|Sztt|WSty)Y|Sw|SrI)rnrr4rhr3r StopIteration)rr@rrr.r.r/_replace_placeholders"s   z3replace_placeholders.._replace_placeholdersNr )rrA)r?r@rr r.r.r/replace_placeholders!s  r sources*t.Dict[str, Query | t.Callable[[], Query]]cs6fdd|Dd fdd |j|dS) aoTransforms 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 */' Args: expression: The expression to expand. sources: A dict of name to query or a callable that provides a query on demand. dialect: The dialect of the sources dict or the callable. copy: Whether to copy the expression during transformation. Defaults to True. Returns: The transformed expression. cr r r r^rr.r/r)0"r*zexpand..rr>csft|tr1t|d}|}|r1t|r|n|}||jp!|}d|g|_|jddS|S)Nrzsource: Fr) rnrr rhcallablerTrrDr)rrtrF parsed_sourcerT_expandrnormalized_sourcesr.r/r 2"s   zexpand.._expandrN)rr>r )r?r rrr.r r/expand"sr rc s|r|rtdddlm}|fdd|D}fdd|D}jj|}|ro|rHd|j j vrC||d }n;||}n6|j d krV|j di|}n(t |}|rg|di|}ntd |d |ptd |i}tdd|i|}||D]} t| |S)a Returns a Func expression. Examples: >>> func("abs", 5).sql() 'ABS(5)' >>> func("cast", this=5, to=DataType.build("DOUBLE")).sql() 'CAST(5 AS DOUBLE)' Args: name: the name of the function to build. args: the args used to instantiate the function of interest. copy: whether to copy the argument expressions. dialect: the source dialect. kwargs: the kwargs used to instantiate the function of interest. Note: The arguments `args` and `kwargs` are mutually exclusive. Returns: An instance of the function of interest, or an anonymous function, if `name` doesn't correspond to an existing `sqlglot.expressions.Func` class. z9Can't use both args and kwargs to instantiate a function.rrcsg|] }t|dqSrrrrr.r/re"rzfunc..cs i|] \}}|t|dqSr r)rXr%rMrr.r/r)f"rzfunc..rrrzUnable to convert 'zd' into a Func. Either manually construct the Func expression of interest or parse the function call.rlr4Nr.)r{rrrrJ parser_class FUNCTIONSrhr3__code__ co_varnamesr0__self__FUNCTION_BY_NAMErr) rtrrr@rr converted constructorfunction error_messager.rr/reE"s2       recKs*|dur t|fi|}nd}t|gdS)a Initialize a CASE statement. Example: case().when("a = 1", "foo").else_("bar") Args: expression: Optionally, the input expression (not all dialects support this) **opts: Extra keyword arguments for parsing `expression` N)r4r})rLr|)r?rr4r.r.r/case"s r( ctfdd|DdS)av Returns an array. Examples: >>> array(1, 'x').sql() 'ARRAY(1, x)' Args: expressions: the expressions to add to the array. copy: whether to copy the argument expressions. dialect: the source dialect. kwargs: the kwargs used to instantiate the function of interest. Returns: An array expression. c"g|] }t|fdqSrrrrrrr.r/r"zarray..rR)r#rrrlrr.r+ r/array" r. cr) )aq Returns an tuple. Examples: >>> tuple_(1, 'x').sql() '(1, x)' Args: expressions: the expressions to add to the tuple. copy: whether to copy the argument expressions. dialect: the source dialect. kwargs: the kwargs used to instantiate the function of interest. Returns: A tuple expression. cr* rrrr+ r.r/r"r, ztuple_..rR)rlr- r.r+ r/tuple_"r/ r0 cC tddS)z, Returns a true Boolean expression. Trrr.r.r.r/r" rcCr1 )z- Returns a false Boolean expression. Frr2 r.r.r.r/r'"r3 r'cCstS)z$ Returns a Null expression. )rsr.r.r.r/rW"srW) rfrOrrrrrr/rrPrOr) rfrirrjrrrr/rrPrOr) rfrOrrjrrrr/rrPrOr>r)rrrrPrOr)rrrrPrOr)FrF) rrHrrPrmrdrnrPrOrm)TNNNr4r )rrrrOr1rOrr/rr/rrPrrrrPrrPrOr)NTT) rlrrrrrrrPrrPrOr>)r?rr%rrOr)r?rr%rrOr)r?rr%rrOr) rlrOrrrrPrrrrPrOr) rlrOrrPrrrrPrOr) rlrOrrPrrrrPrOr) rlrOrrPrrrrPrOr)rlrOrrrOrrI)r?rOrrrOr)NNNNN)r8rr&rrrrrrrrrrOr)NNN) r8rOrrr!rrrrOr)NNNNT)r?rOrrOrrrr/r!rrrrrPrOr=)rrOrrOr|rOr<rOr!rrrrrPrOr\r)r?rOrrrrPrOrr)r?rOrrrrPrOr)r?rOrrPrOr)rtrr.r/rrPrOr)rtr-r.r/rrPrOro)rtr-rrrOro)rrrOr)rrrrrrPrOrr) rrr.r/rrrrPrOr~)FNNT) r?rOrrr8rr.r/rrrrP)NN)r?rOrrrrrOr)r;r-r8rr5rr6rrrr.r/rrPrOr)r;rr8rr5rr6rrrr.r/rrPrOr~r) r?rOrrfrrPrrrOr)NNNN) r8rr5rr6rr.r/rrrOr)rrrr/rrrOr)rtrrOrq)rrrrrrrOr) rrrrrrrr/rrrOrr)rMrHrrPrOr>)r?r>rrrOr)r?r>rrrrrOr>)r!)r?r>rrmrOrr)r8rrrr rPrOrm)r8rrrrrPrOrm) r?rr r rrrrPrOr)r?r>rOr>) r?r>r r rrrrPrOr>)rtrmrrPrrrOr)r?rrOr|)rlrOrrPrrrOr#)rlrOrrPrrrOrl)rOr)rOrs(Ar& __future__rrrrrerytypingrM collectionsrrrdecimalrenumr functoolsr sqlglot.errorsr r sqlglot.helperr r rrrrrrsqlglot.tokensrr TYPE_CHECKINGtyping_extensionsrsqlglot._typingrrrrTypeVarrrrQrrSQLGLOT_ANONYMOUSr rr(r>rrmre CollectionIntoTyperOrrrrr rrrrrr$r9r@rIrMrQrRrSrTrVrXr[r^rarcrgrvrxr{r~rrrrrrrrrr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r r rrrrrrr"r$r%r&r)r.r/r0ror2r4r8r=rLrNrOrTr#rXrYrZr]r_r`rarfrjrprqrrrsrrurprrrrrrrrrrrrrprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r r rrrrrrr r!r#r$r%r&r'r(r*r+r,r-r.r/r0r1r2r3r4r5r7r8r9r;r<r=r?r@rgrhrjrkrlrrvrwrxryr{r}rrrrrrrqrrrrUNWRAPPED_QUERIESrrrrrrrrrrrrrrrsrrrr~rrrrrrrrrrrrrrrrrrrrrrrrr5r~rrrrrrrmrrrfrrerrrrrrrzr|rcrrr]rrarrvrxrrrgrrrrrrrrryrrrrrrrrrZr8rrGrrrrrrrrrrrrrrrr rrrrrrrrrr"r#r%r'r)r,r.r1r2r4r5r7r;r=r>r@rArBrCrFrGrIrMrPrSrTrUrVrXr\r`rcrergrkrlrorprqrrrsrtrvrwrxryrzr{r|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrVr r r rrrrrrrr r#r$rrr%rr*r+r,r-r0r1r#r4r6r7r8r9r:r;r<r=r>r?r@rArBrCrIrJrKrMrNrRrTrUrVrWrZr\r^r_rardrkrlrnrprrrtrwrzr}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrirrrrrrrrrrrrrrrrrrrrrrrrrrrr r r rrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r<r=r>rBrFrIrJrNrQrRrrSrUrXrYrZr[r\r^r`rarbrcrWr0 ALL_FUNCTIONSr# JSON_PATH_PARTS PERCENTILESrrLrUrr~rrrrrrr4rrrrrrr+rrrrrr"rr$rcompilerrrrINTERVAL_STRING_RErrrr0rTrrNrrrrrr3rrrrr r r r rer( r. r0 rr'rWNONNULL_CONSTANTS CONSTANTSr.r.r.r/s      (   X M %    )      U       D                C      M9P5      9    &    $ 1  %                         0(2% !!?"14'  %*; +6!A"('.@