Merging upstream version 17.3.0.

Signed-off-by: Daniel Baumann <daniel@debian.org>

CHANGELOG.md

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+## [v17.2.0] - 2023-07-06
+### :bug: Bug Fixes
+- [`1f575db`](https://github.com/tobymao/sqlglot/commit/1f575db44f9c75c92fd5abf6c514c9933b1175b6) - **duckdb**: improve transpilation of BigQuery DATE function *(PR [#1895](https://github.com/tobymao/sqlglot/pull/1895) by [@GeorgeSittas](https://github.com/GeorgeSittas))*
+
+
 ## [v17.1.0] - 2023-07-04
 ### :sparkles: New Features
 - [`b178e1c`](https://github.com/tobymao/sqlglot/commit/b178e1c3f48c2460c59d525a40363cbda488cad8) - dialect argument for parse_one *(commit by [@tobymao](https://github.com/tobymao))*
@@ -812,3 +817,4 @@ Changelog
 [v16.8.1]: https://github.com/tobymao/sqlglot/compare/v16.8.0...v16.8.1
 [v17.0.0]: https://github.com/tobymao/sqlglot/compare/v16.8.1...v17.0.0
 [v17.1.0]: https://github.com/tobymao/sqlglot/compare/v17.0.0...v17.1.0
+[v17.2.0]: https://github.com/tobymao/sqlglot/compare/v17.1.0...v17.2.0

docs/sqlglot/_version.html

@@ -51,8 +51,8 @@
 
                         <div class="pdoc-code codehilite"><pre><span></span><span id="L-1"><a href="#L-1"><span class="linenos">1</span></a><span class="c1"># file generated by setuptools_scm</span>
 </span><span id="L-2"><a href="#L-2"><span class="linenos">2</span></a><span class="c1"># don&#39;t change, don&#39;t track in version control</span>
-</span><span id="L-3"><a href="#L-3"><span class="linenos">3</span></a><span class="n">__version__</span> <span class="o">=</span> <span class="n">version</span> <span class="o">=</span> <span class="s1">&#39;17.1.0&#39;</span>
+</span><span id="L-3"><a href="#L-3"><span class="linenos">3</span></a><span class="n">__version__</span> <span class="o">=</span> <span class="n">version</span> <span class="o">=</span> <span class="s1">&#39;17.2.0&#39;</span>
-</span><span id="L-4"><a href="#L-4"><span class="linenos">4</span></a><span class="n">__version_tuple__</span> <span class="o">=</span> <span class="n">version_tuple</span> <span class="o">=</span> <span class="p">(</span><span class="mi">17</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
+</span><span id="L-4"><a href="#L-4"><span class="linenos">4</span></a><span class="n">__version_tuple__</span> <span class="o">=</span> <span class="n">version_tuple</span> <span class="o">=</span> <span class="p">(</span><span class="mi">17</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
 </span></pre></div>
 
 

docs/sqlglot/dataframe/sql.html

@@ -777,7 +777,7 @@
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">createDataFrame</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">data</span><span class="p">:</span> <span class="n">Sequence</span><span class="p">[</span><span class="n">Union</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082675204736&#39;</span><span class="o">&gt;</span><span class="p">],</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082675204736&#39;</span><span class="o">&gt;</span><span class="p">],</span> <span class="n">Tuple</span><span class="p">]]</span>,</span><span class="param">	<span class="n">schema</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674859984&#39;</span><span class="o">&gt;</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">samplingRatio</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">float</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">verifySchema</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="kc">False</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
+        <span class="name">createDataFrame</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">data</span><span class="p">:</span> <span class="n">Sequence</span><span class="p">[</span><span class="n">Union</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616969344&#39;</span><span class="o">&gt;</span><span class="p">],</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616969344&#39;</span><span class="o">&gt;</span><span class="p">],</span> <span class="n">Tuple</span><span class="p">]]</span>,</span><span class="param">	<span class="n">schema</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963617390416&#39;</span><span class="o">&gt;</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">samplingRatio</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">float</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">verifySchema</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="kc">False</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
 
                 <label class="view-source-button" for="SparkSession.createDataFrame-view-source"><span>View Source</span></label>
 
@@ -1681,7 +1681,7 @@
                                         <input id="DataFrame.__init__-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
 <div class="attr function">
             
-        <span class="name">DataFrame</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="n">spark</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082679872432&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">expression</span><span class="p">:</span> <span class="n"><a href="../expressions.html#Select">sqlglot.expressions.Select</a></span>,</span><span class="param">	<span class="n">branch_id</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">sequence_id</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">last_op</span><span class="p">:</span> <span class="n">sqlglot</span><span class="o">.</span><span class="n">dataframe</span><span class="o">.</span><span class="n">sql</span><span class="o">.</span><span class="n">operations</span><span class="o">.</span><span class="n">Operation</span> <span class="o">=</span> <span class="o">&lt;</span><span class="n">Operation</span><span class="o">.</span><span class="n">INIT</span><span class="p">:</span> <span class="o">-</span><span class="mi">1</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">pending_hints</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">List</span><span class="p">[</span><span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">output_expression_container</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082680049728&#39;</span><span class="o">&gt;</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span>)</span>
+        <span class="name">DataFrame</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="n">spark</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963621507328&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">expression</span><span class="p">:</span> <span class="n"><a href="../expressions.html#Select">sqlglot.expressions.Select</a></span>,</span><span class="param">	<span class="n">branch_id</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">sequence_id</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">last_op</span><span class="p">:</span> <span class="n">sqlglot</span><span class="o">.</span><span class="n">dataframe</span><span class="o">.</span><span class="n">sql</span><span class="o">.</span><span class="n">operations</span><span class="o">.</span><span class="n">Operation</span> <span class="o">=</span> <span class="o">&lt;</span><span class="n">Operation</span><span class="o">.</span><span class="n">INIT</span><span class="p">:</span> <span class="o">-</span><span class="mi">1</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">pending_hints</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">List</span><span class="p">[</span><span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">output_expression_container</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963621708112&#39;</span><span class="o">&gt;</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span>)</span>
 
                 <label class="view-source-button" for="DataFrame.__init__-view-source"><span>View Source</span></label>
 
@@ -2611,7 +2611,7 @@ is unlikely to come up.</p>
                     <div class="decorator">@operation(Operation.FROM)</div>
 
         <span class="def">def</span>
-        <span class="name">fillna</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">value</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082675519776&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">subset</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="o">...</span><span class="p">],</span> <span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span> <span class="n">NoneType</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
+        <span class="name">fillna</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">value</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963617155808&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">subset</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="o">...</span><span class="p">],</span> <span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span> <span class="n">NoneType</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
 
                 <label class="view-source-button" for="DataFrame.fillna-view-source"><span>View Source</span></label>
 
@@ -2680,7 +2680,7 @@ and check if it matches the type of the value provided. If not then make it null
                     <div class="decorator">@operation(Operation.FROM)</div>
 
         <span class="def">def</span>
-        <span class="name">replace</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">to_replace</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">bool</span><span class="p">,</span> <span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="nb">str</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">Dict</span><span class="p">]</span>,</span><span class="param">	<span class="n">value</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">bool</span><span class="p">,</span> <span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="nb">str</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">subset</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="n">Collection</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673819296&#39;</span><span class="o">&gt;</span><span class="p">],</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673819296&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
+        <span class="name">replace</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">to_replace</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">bool</span><span class="p">,</span> <span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="nb">str</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">Dict</span><span class="p">]</span>,</span><span class="param">	<span class="n">value</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">bool</span><span class="p">,</span> <span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="nb">str</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>,</span><span class="param">	<span class="n">subset</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="n">Collection</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615469216&#39;</span><span class="o">&gt;</span><span class="p">],</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615469216&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
 
                 <label class="view-source-button" for="DataFrame.replace-view-source"><span>View Source</span></label>
 
@@ -2885,7 +2885,7 @@ and check if it matches the type of the value provided. If not then make it null
                     <div class="decorator">@operation(Operation.NO_OP)</div>
 
         <span class="def">def</span>
-        <span class="name">repartition</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">numPartitions</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">int</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674028640&#39;</span><span class="o">&gt;</span><span class="p">]</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674107200&#39;</span><span class="o">&gt;</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
+        <span class="name">repartition</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">numPartitions</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">int</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615678464&#39;</span><span class="o">&gt;</span><span class="p">]</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615757024&#39;</span><span class="o">&gt;</span></span><span class="return-annotation">) -> <span class="n"><a href="#DataFrame">sqlglot.dataframe.sql.DataFrame</a></span>:</span></span>
 
                 <label class="view-source-button" for="DataFrame.repartition-view-source"><span>View Source</span></label>
 
@@ -3590,7 +3590,7 @@ and check if it matches the type of the value provided. If not then make it null
                                         <input id="Column.__init__-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
 <div class="attr function">
             
-        <span class="name">Column</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="n">expression</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082675992320&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span></span>)</span>
+        <span class="name">Column</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="n">expression</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963617714832&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span></span>)</span>
 
                 <label class="view-source-button" for="Column.__init__-view-source"><span>View Source</span></label>
 
@@ -3633,7 +3633,7 @@ and check if it matches the type of the value provided. If not then make it null
                     <div class="decorator">@classmethod</div>
 
         <span class="def">def</span>
-        <span class="name">ensure_col</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">value</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674172592&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span></span><span class="return-annotation">):</span></span>
+        <span class="name">ensure_col</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">value</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615805936&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">,</span> <span class="n">NoneType</span><span class="p">]</span></span><span class="return-annotation">):</span></span>
 
                 <label class="view-source-button" for="Column.ensure_col-view-source"><span>View Source</span></label>
 
@@ -3654,7 +3654,7 @@ and check if it matches the type of the value provided. If not then make it null
                     <div class="decorator">@classmethod</div>
 
         <span class="def">def</span>
-        <span class="name">ensure_cols</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">args</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674653344&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n">List</span><span class="p">[</span><span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span><span class="p">]</span>:</span></span>
+        <span class="name">ensure_cols</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">args</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616303168&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n"><a href="../expressions.html#Expression">sqlglot.expressions.Expression</a></span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n">List</span><span class="p">[</span><span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span><span class="p">]</span>:</span></span>
 
                 <label class="view-source-button" for="Column.ensure_cols-view-source"><span>View Source</span></label>
 
@@ -3675,7 +3675,7 @@ and check if it matches the type of the value provided. If not then make it null
                     <div class="decorator">@classmethod</div>
 
         <span class="def">def</span>
-        <span class="name">invoke_anonymous_function</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">column</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674342144&#39;</span><span class="o">&gt;</span><span class="p">]</span>,</span><span class="param">	<span class="n">func_name</span><span class="p">:</span> <span class="nb">str</span>,</span><span class="param">	<span class="o">*</span><span class="n">args</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674481808&#39;</span><span class="o">&gt;</span><span class="p">]</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
+        <span class="name">invoke_anonymous_function</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">column</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616124384&#39;</span><span class="o">&gt;</span><span class="p">]</span>,</span><span class="param">	<span class="n">func_name</span><span class="p">:</span> <span class="nb">str</span>,</span><span class="param">	<span class="o">*</span><span class="n">args</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616115248&#39;</span><span class="o">&gt;</span><span class="p">]</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
 
                 <label class="view-source-button" for="Column.invoke_anonymous_function-view-source"><span>View Source</span></label>
 
@@ -3702,7 +3702,7 @@ and check if it matches the type of the value provided. If not then make it null
                     <div class="decorator">@classmethod</div>
 
         <span class="def">def</span>
-        <span class="name">invoke_expression_over_column</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">column</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674285632&#39;</span><span class="o">&gt;</span><span class="p">]</span>,</span><span class="param">	<span class="n">callable_expression</span><span class="p">:</span> <span class="n">Callable</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
+        <span class="name">invoke_expression_over_column</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="n">column</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615935648&#39;</span><span class="o">&gt;</span><span class="p">]</span>,</span><span class="param">	<span class="n">callable_expression</span><span class="p">:</span> <span class="n">Callable</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
 
                 <label class="view-source-button" for="Column.invoke_expression_over_column-view-source"><span>View Source</span></label>
 
@@ -3739,7 +3739,7 @@ and check if it matches the type of the value provided. If not then make it null
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">binary_op</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">klass</span><span class="p">:</span> <span class="n">Callable</span>,</span><span class="param">	<span class="n">other</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674587952&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
+        <span class="name">binary_op</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">klass</span><span class="p">:</span> <span class="n">Callable</span>,</span><span class="param">	<span class="n">other</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616221392&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
 
                 <label class="view-source-button" for="Column.binary_op-view-source"><span>View Source</span></label>
 
@@ -3760,7 +3760,7 @@ and check if it matches the type of the value provided. If not then make it null
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">inverse_binary_op</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">klass</span><span class="p">:</span> <span class="n">Callable</span>,</span><span class="param">	<span class="n">other</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674599728&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
+        <span class="name">inverse_binary_op</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">klass</span><span class="p">:</span> <span class="n">Callable</span>,</span><span class="param">	<span class="n">other</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616249648&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="o">**</span><span class="n">kwargs</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
 
                 <label class="view-source-button" for="Column.inverse_binary_op-view-source"><span>View Source</span></label>
 
@@ -4314,7 +4314,7 @@ Sqlglot doesn't currently replicate this class so it only accepts a string</p>
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">isin</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674779280&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">Iterable</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082674779280&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">):</span></span>
+        <span class="name">isin</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616428672&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">Iterable</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963616428672&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">):</span></span>
 
                 <label class="view-source-button" for="Column.isin-view-source"><span>View Source</span></label>
 
@@ -4335,7 +4335,7 @@ Sqlglot doesn't currently replicate this class so it only accepts a string</p>
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">between</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">lowerBound</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082672805456&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">upperBound</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082672859936&#39;</span><span class="o">&gt;</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
+        <span class="name">between</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">lowerBound</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614455280&#39;</span><span class="o">&gt;</span>,</span><span class="param">	<span class="n">upperBound</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614509760&#39;</span><span class="o">&gt;</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
 
                 <label class="view-source-button" for="Column.between-view-source"><span>View Source</span></label>
 
@@ -4370,7 +4370,7 @@ Sqlglot doesn't currently replicate this class so it only accepts a string</p>
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">over</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">window</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082672917648&#39;</span><span class="o">&gt;</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
+        <span class="name">over</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="n">window</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614567472&#39;</span><span class="o">&gt;</span></span><span class="return-annotation">) -> <span class="n"><a href="#Column">sqlglot.dataframe.sql.Column</a></span>:</span></span>
 
                 <label class="view-source-button" for="Column.over-view-source"><span>View Source</span></label>
 
@@ -4615,7 +4615,7 @@ Sqlglot doesn't currently replicate this class so it only accepts a string</p>
                     <div class="decorator">@classmethod</div>
 
         <span class="def">def</span>
-        <span class="name">partitionBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673666752&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673666752&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
+        <span class="name">partitionBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615316912&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963615316912&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
 
                 <label class="view-source-button" for="Window.partitionBy-view-source"><span>View Source</span></label>
 
@@ -4636,7 +4636,7 @@ Sqlglot doesn't currently replicate this class so it only accepts a string</p>
                     <div class="decorator">@classmethod</div>
 
         <span class="def">def</span>
-        <span class="name">orderBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673062752&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673062752&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
+        <span class="name">orderBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">cls</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614725072&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614725072&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
 
                 <label class="view-source-button" for="Window.orderBy-view-source"><span>View Source</span></label>
 
@@ -4872,7 +4872,7 @@ Sqlglot doesn't currently replicate this class so it only accepts a string</p>
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">partitionBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673242832&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673242832&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
+        <span class="name">partitionBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614810736&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614810736&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
 
                 <label class="view-source-button" for="WindowSpec.partitionBy-view-source"><span>View Source</span></label>
 
@@ -4899,7 +4899,7 @@ Sqlglot doesn't currently replicate this class so it only accepts a string</p>
 <div class="attr function">
             
         <span class="def">def</span>
-        <span class="name">orderBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673125984&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;140082673125984&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
+        <span class="name">orderBy</span><span class="signature pdoc-code multiline">(<span class="param">	<span class="bp">self</span>,</span><span class="param">	<span class="o">*</span><span class="n">cols</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614775808&#39;</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="o">&lt;</span><span class="n">MagicMock</span> <span class="nb">id</span><span class="o">=</span><span class="s1">&#39;139963614775808&#39;</span><span class="o">&gt;</span><span class="p">]]</span></span><span class="return-annotation">) -> <span class="n"><a href="#WindowSpec">sqlglot.dataframe.sql.WindowSpec</a></span>:</span></span>
 
                 <label class="view-source-button" for="WindowSpec.orderBy-view-source"><span>View Source</span></label>
 

docs/sqlglot/dialects/redshift.html

@@ -1504,7 +1504,7 @@ Default: True</li>
                             <div id="Redshift.Generator.RESERVED_KEYWORDS" class="classattr">
                                 <div class="attr variable">
             <span class="name">RESERVED_KEYWORDS</span>        =
-<span class="default_value">{&#39;type&#39;, &#39;snapshot&#39;}</span>
+<span class="default_value">{&#39;snapshot&#39;, &#39;type&#39;}</span>
 
         
     </div>

docs/sqlglot/dialects/tsql.html

@@ -1946,7 +1946,7 @@ Default: 3</li>
                             <div id="TSQL.Parser.JOIN_HINTS" class="classattr">
                                 <div class="attr variable">
             <span class="name">JOIN_HINTS</span>        =
-<span class="default_value">{&#39;REMOTE&#39;, &#39;MERGE&#39;, &#39;HASH&#39;, &#39;LOOP&#39;}</span>
+<span class="default_value">{&#39;LOOP&#39;, &#39;REMOTE&#39;, &#39;MERGE&#39;, &#39;HASH&#39;}</span>
 
         
     </div>
@@ -1958,7 +1958,7 @@ Default: 3</li>
                             <div id="TSQL.Parser.VAR_LENGTH_DATATYPES" class="classattr">
                                 <div class="attr variable">
             <span class="name">VAR_LENGTH_DATATYPES</span>        =
-<span class="default_value">{&lt;Type.NVARCHAR: &#39;NVARCHAR&#39;&gt;, &lt;Type.NCHAR: &#39;NCHAR&#39;&gt;, &lt;Type.VARCHAR: &#39;VARCHAR&#39;&gt;, &lt;Type.CHAR: &#39;CHAR&#39;&gt;}</span>
+<span class="default_value">{&lt;Type.CHAR: &#39;CHAR&#39;&gt;, &lt;Type.NVARCHAR: &#39;NVARCHAR&#39;&gt;, &lt;Type.NCHAR: &#39;NCHAR&#39;&gt;, &lt;Type.VARCHAR: &#39;VARCHAR&#39;&gt;}</span>
 
         
     </div>
@@ -1971,7 +1971,7 @@ Default: 3</li>
                                 <div class="attr variable">
             <span class="name">RETURNS_TABLE_TOKENS</span>        =
 <input id="TSQL.Parser.RETURNS_TABLE_TOKENS-view-value" class="view-value-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
-            <label class="view-value-button pdoc-button" for="TSQL.Parser.RETURNS_TABLE_TOKENS-view-value"></label><span class="default_value">{&lt;TokenType.CURRENT_TIMESTAMP: &#39;CURRENT_TIMESTAMP&#39;&gt;, &lt;TokenType.OVERWRITE: &#39;OVERWRITE&#39;&gt;, &lt;TokenType.DELETE: &#39;DELETE&#39;&gt;, &lt;TokenType.OFFSET: &#39;OFFSET&#39;&gt;, &lt;TokenType.UPDATE: &#39;UPDATE&#39;&gt;, &lt;TokenType.PROCEDURE: &#39;PROCEDURE&#39;&gt;, &lt;TokenType.CURRENT_TIME: &#39;CURRENT_TIME&#39;&gt;, &lt;TokenType.TOP: &#39;TOP&#39;&gt;, &lt;TokenType.DESC: &#39;DESC&#39;&gt;, &lt;TokenType.INDEX: &#39;INDEX&#39;&gt;, &lt;TokenType.RANGE: &#39;RANGE&#39;&gt;, &lt;TokenType.VIEW: &#39;VIEW&#39;&gt;, &lt;TokenType.APPLY: &#39;APPLY&#39;&gt;, &lt;TokenType.DATABASE: &#39;DATABASE&#39;&gt;, &lt;TokenType.END: &#39;END&#39;&gt;, &lt;TokenType.CONSTRAINT: &#39;CONSTRAINT&#39;&gt;, &lt;TokenType.AUTO_INCREMENT: &#39;AUTO_INCREMENT&#39;&gt;, &lt;TokenType.ASC: &#39;ASC&#39;&gt;, &lt;TokenType.ISNULL: &#39;ISNULL&#39;&gt;, &lt;TokenType.SHOW: &#39;SHOW&#39;&gt;, &lt;TokenType.VAR: &#39;VAR&#39;&gt;, &lt;TokenType.SEMI: &#39;SEMI&#39;&gt;, &lt;TokenType.COMMAND: &#39;COMMAND&#39;&gt;, &lt;TokenType.DIV: &#39;DIV&#39;&gt;, &lt;TokenType.ESCAPE: &#39;ESCAPE&#39;&gt;, &lt;TokenType.RIGHT: &#39;RIGHT&#39;&gt;, &lt;TokenType.SETTINGS: &#39;SETTINGS&#39;&gt;, &lt;TokenType.ROW: &#39;ROW&#39;&gt;, &lt;TokenType.DEFAULT: &#39;DEFAULT&#39;&gt;, &lt;TokenType.CURRENT_USER: &#39;CURRENT_USER&#39;&gt;, &lt;TokenType.FULL: &#39;FULL&#39;&gt;, &lt;TokenType.PERCENT: &#39;PERCENT&#39;&gt;, &lt;TokenType.ANY: &#39;ANY&#39;&gt;, &lt;TokenType.NATURAL: &#39;NATURAL&#39;&gt;, &lt;TokenType.COLLATE: &#39;COLLATE&#39;&gt;, &lt;TokenType.KEEP: &#39;KEEP&#39;&gt;, &lt;TokenType.FIRST: &#39;FIRST&#39;&gt;, &lt;TokenType.FILTER: &#39;FILTER&#39;&gt;, &lt;TokenType.FUNCTION: &#39;FUNCTION&#39;&gt;, &lt;TokenType.FORMAT: &#39;FORMAT&#39;&gt;, &lt;TokenType.UNPIVOT: &#39;UNPIVOT&#39;&gt;, &lt;TokenType.NEXT: &#39;NEXT&#39;&gt;, &lt;TokenType.LEFT: &#39;LEFT&#39;&gt;, &lt;TokenType.UNIQUE: &#39;UNIQUE&#39;&gt;, &lt;TokenType.LOAD: &#39;LOAD&#39;&gt;, &lt;TokenType.FALSE: &#39;FALSE&#39;&gt;, &lt;TokenType.SET: &#39;SET&#39;&gt;, &lt;TokenType.WINDOW: &#39;WINDOW&#39;&gt;, &lt;TokenType.EXISTS: &#39;EXISTS&#39;&gt;, &lt;TokenType.ANTI: &#39;ANTI&#39;&gt;, &lt;TokenType.ORDINALITY: &#39;ORDINALITY&#39;&gt;, &lt;TokenType.COMMENT: &#39;COMMENT&#39;&gt;, &lt;TokenType.EXECUTE: &#39;EXECUTE&#39;&gt;, &lt;TokenType.PIVOT: &#39;PIVOT&#39;&gt;, &lt;TokenType.SCHEMA: &#39;SCHEMA&#39;&gt;, &lt;TokenType.CACHE: &#39;CACHE&#39;&gt;, &lt;TokenType.PARTITION: &#39;PARTITION&#39;&gt;, &lt;TokenType.TEMPORARY: &#39;TEMPORARY&#39;&gt;, &lt;TokenType.CURRENT_DATE: &#39;CURRENT_DATE&#39;&gt;, &lt;TokenType.TRUE: &#39;TRUE&#39;&gt;, &lt;TokenType.CURRENT_DATETIME: &#39;CURRENT_DATETIME&#39;&gt;, &lt;TokenType.COLUMN: &#39;COLUMN&#39;&gt;, &lt;TokenType.PRAGMA: &#39;PRAGMA&#39;&gt;, &lt;TokenType.DICTIONARY: &#39;DICTIONARY&#39;&gt;, &lt;TokenType.DESCRIBE: &#39;DESCRIBE&#39;&gt;, &lt;TokenType.IS: &#39;IS&#39;&gt;, &lt;TokenType.REFERENCES: &#39;REFERENCES&#39;&gt;, &lt;TokenType.COMMIT: &#39;COMMIT&#39;&gt;, &lt;TokenType.IF: &#39;IF&#39;&gt;, &lt;TokenType.ROWS: &#39;ROWS&#39;&gt;, &lt;TokenType.VOLATILE: &#39;VOLATILE&#39;&gt;, &lt;TokenType.MERGE: &#39;MERGE&#39;&gt;, &lt;TokenType.SOME: &#39;SOME&#39;&gt;, &lt;TokenType.CASE: &#39;CASE&#39;&gt;, &lt;TokenType.ALL: &#39;ALL&#39;&gt;, &lt;TokenType.BEGIN: &#39;BEGIN&#39;&gt;}</span>
+            <label class="view-value-button pdoc-button" for="TSQL.Parser.RETURNS_TABLE_TOKENS-view-value"></label><span class="default_value">{&lt;TokenType.SET: &#39;SET&#39;&gt;, &lt;TokenType.COMMIT: &#39;COMMIT&#39;&gt;, &lt;TokenType.AUTO_INCREMENT: &#39;AUTO_INCREMENT&#39;&gt;, &lt;TokenType.CACHE: &#39;CACHE&#39;&gt;, &lt;TokenType.DEFAULT: &#39;DEFAULT&#39;&gt;, &lt;TokenType.DELETE: &#39;DELETE&#39;&gt;, &lt;TokenType.ROW: &#39;ROW&#39;&gt;, &lt;TokenType.LEFT: &#39;LEFT&#39;&gt;, &lt;TokenType.MERGE: &#39;MERGE&#39;&gt;, &lt;TokenType.ANTI: &#39;ANTI&#39;&gt;, &lt;TokenType.IS: &#39;IS&#39;&gt;, &lt;TokenType.CASE: &#39;CASE&#39;&gt;, &lt;TokenType.CURRENT_TIMESTAMP: &#39;CURRENT_TIMESTAMP&#39;&gt;, &lt;TokenType.COLLATE: &#39;COLLATE&#39;&gt;, &lt;TokenType.CURRENT_USER: &#39;CURRENT_USER&#39;&gt;, &lt;TokenType.FUNCTION: &#39;FUNCTION&#39;&gt;, &lt;TokenType.ESCAPE: &#39;ESCAPE&#39;&gt;, &lt;TokenType.FILTER: &#39;FILTER&#39;&gt;, &lt;TokenType.DATABASE: &#39;DATABASE&#39;&gt;, &lt;TokenType.NATURAL: &#39;NATURAL&#39;&gt;, &lt;TokenType.PIVOT: &#39;PIVOT&#39;&gt;, &lt;TokenType.FIRST: &#39;FIRST&#39;&gt;, &lt;TokenType.TEMPORARY: &#39;TEMPORARY&#39;&gt;, &lt;TokenType.ASC: &#39;ASC&#39;&gt;, &lt;TokenType.IF: &#39;IF&#39;&gt;, &lt;TokenType.APPLY: &#39;APPLY&#39;&gt;, &lt;TokenType.DIV: &#39;DIV&#39;&gt;, &lt;TokenType.WINDOW: &#39;WINDOW&#39;&gt;, &lt;TokenType.DESC: &#39;DESC&#39;&gt;, &lt;TokenType.SCHEMA: &#39;SCHEMA&#39;&gt;, &lt;TokenType.PERCENT: &#39;PERCENT&#39;&gt;, &lt;TokenType.PROCEDURE: &#39;PROCEDURE&#39;&gt;, &lt;TokenType.DESCRIBE: &#39;DESCRIBE&#39;&gt;, &lt;TokenType.FALSE: &#39;FALSE&#39;&gt;, &lt;TokenType.COMMENT: &#39;COMMENT&#39;&gt;, &lt;TokenType.FULL: &#39;FULL&#39;&gt;, &lt;TokenType.EXECUTE: &#39;EXECUTE&#39;&gt;, &lt;TokenType.UNPIVOT: &#39;UNPIVOT&#39;&gt;, &lt;TokenType.PRAGMA: &#39;PRAGMA&#39;&gt;, &lt;TokenType.TRUE: &#39;TRUE&#39;&gt;, &lt;TokenType.OFFSET: &#39;OFFSET&#39;&gt;, &lt;TokenType.ALL: &#39;ALL&#39;&gt;, &lt;TokenType.COMMAND: &#39;COMMAND&#39;&gt;, &lt;TokenType.VAR: &#39;VAR&#39;&gt;, &lt;TokenType.REFERENCES: &#39;REFERENCES&#39;&gt;, &lt;TokenType.CONSTRAINT: &#39;CONSTRAINT&#39;&gt;, &lt;TokenType.VOLATILE: &#39;VOLATILE&#39;&gt;, &lt;TokenType.RANGE: &#39;RANGE&#39;&gt;, &lt;TokenType.VIEW: &#39;VIEW&#39;&gt;, &lt;TokenType.RIGHT: &#39;RIGHT&#39;&gt;, &lt;TokenType.INDEX: &#39;INDEX&#39;&gt;, &lt;TokenType.ROWS: &#39;ROWS&#39;&gt;, &lt;TokenType.FORMAT: &#39;FORMAT&#39;&gt;, &lt;TokenType.SOME: &#39;SOME&#39;&gt;, &lt;TokenType.UNIQUE: &#39;UNIQUE&#39;&gt;, &lt;TokenType.BEGIN: &#39;BEGIN&#39;&gt;, &lt;TokenType.ISNULL: &#39;ISNULL&#39;&gt;, &lt;TokenType.CURRENT_TIME: &#39;CURRENT_TIME&#39;&gt;, &lt;TokenType.ANY: &#39;ANY&#39;&gt;, &lt;TokenType.DICTIONARY: &#39;DICTIONARY&#39;&gt;, &lt;TokenType.ORDINALITY: &#39;ORDINALITY&#39;&gt;, &lt;TokenType.UPDATE: &#39;UPDATE&#39;&gt;, &lt;TokenType.COLUMN: &#39;COLUMN&#39;&gt;, &lt;TokenType.SETTINGS: &#39;SETTINGS&#39;&gt;, &lt;TokenType.NEXT: &#39;NEXT&#39;&gt;, &lt;TokenType.END: &#39;END&#39;&gt;, &lt;TokenType.OVERWRITE: &#39;OVERWRITE&#39;&gt;, &lt;TokenType.SHOW: &#39;SHOW&#39;&gt;, &lt;TokenType.SEMI: &#39;SEMI&#39;&gt;, &lt;TokenType.EXISTS: &#39;EXISTS&#39;&gt;, &lt;TokenType.CURRENT_DATE: &#39;CURRENT_DATE&#39;&gt;, &lt;TokenType.KEEP: &#39;KEEP&#39;&gt;, &lt;TokenType.LOAD: &#39;LOAD&#39;&gt;, &lt;TokenType.CURRENT_DATETIME: &#39;CURRENT_DATETIME&#39;&gt;, &lt;TokenType.PARTITION: &#39;PARTITION&#39;&gt;, &lt;TokenType.TOP: &#39;TOP&#39;&gt;}</span>
 
         
     </div>

docs/sqlglot/expressions.html

@@ -4295,9 +4295,6 @@
                         <li>
                                 <a class="variable" href="#Date.arg_types">arg_types</a>
                         </li>
-                        <li>
-                                <a class="variable" href="#Date.is_var_len_args">is_var_len_args</a>
-                        </li>
                         <li>
                                 <a class="variable" href="#Date.key">key</a>
                         </li>
@@ -9805,9 +9802,9 @@ SQL expressions, such as <code><a href="#select">sqlglot.expressions.select</a><
 </span><span id="L-4133"><a href="#L-4133"><span class="linenos">4133</span></a>    <span class="k">pass</span>
 </span><span id="L-4134"><a href="#L-4134"><span class="linenos">4134</span></a>
 </span><span id="L-4135"><a href="#L-4135"><span class="linenos">4135</span></a>
-</span><span id="L-4136"><a href="#L-4136"><span class="linenos">4136</span></a><span class="k">class</span> <span class="nc">Date</span><span class="p">(</span><span class="n">Func</span><span class="p">):</span>
+</span><span id="L-4136"><a href="#L-4136"><span class="linenos">4136</span></a><span class="c1"># https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions#date</span>
-</span><span id="L-4137"><a href="#L-4137"><span class="linenos">4137</span></a>    <span class="n">arg_types</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;expressions&quot;</span><span class="p">:</span> <span class="kc">True</span><span class="p">}</span>
+</span><span id="L-4137"><a href="#L-4137"><span class="linenos">4137</span></a><span class="k">class</span> <span class="nc">Date</span><span class="p">(</span><span class="n">Func</span><span class="p">):</span>
-</span><span id="L-4138"><a href="#L-4138"><span class="linenos">4138</span></a>    <span class="n">is_var_len_args</span> <span class="o">=</span> <span class="kc">True</span>
+</span><span id="L-4138"><a href="#L-4138"><span class="linenos">4138</span></a>    <span class="n">arg_types</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;this&quot;</span><span class="p">:</span> <span class="kc">True</span><span class="p">,</span> <span class="s2">&quot;zone&quot;</span><span class="p">:</span> <span class="kc">False</span><span class="p">}</span>
 </span><span id="L-4139"><a href="#L-4139"><span class="linenos">4139</span></a>
 </span><span id="L-4140"><a href="#L-4140"><span class="linenos">4140</span></a>
 </span><span id="L-4141"><a href="#L-4141"><span class="linenos">4141</span></a><span class="k">class</span> <span class="nc">Day</span><span class="p">(</span><span class="n">Func</span><span class="p">):</span>
@@ -36676,7 +36673,7 @@ If an <code><a href="#Expression">Expression</a></code> instance is passed, it w
                                 <div class="attr variable">
             <span class="name">TEXT_TYPES</span>        =
 <input id="DataType.TEXT_TYPES-view-value" class="view-value-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
-            <label class="view-value-button pdoc-button" for="DataType.TEXT_TYPES-view-value"></label><span class="default_value">{&lt;Type.TEXT: &#39;TEXT&#39;&gt;, &lt;Type.NVARCHAR: &#39;NVARCHAR&#39;&gt;, &lt;Type.CHAR: &#39;CHAR&#39;&gt;, &lt;Type.NCHAR: &#39;NCHAR&#39;&gt;, &lt;Type.VARCHAR: &#39;VARCHAR&#39;&gt;}</span>
+            <label class="view-value-button pdoc-button" for="DataType.TEXT_TYPES-view-value"></label><span class="default_value">{&lt;Type.CHAR: &#39;CHAR&#39;&gt;, &lt;Type.VARCHAR: &#39;VARCHAR&#39;&gt;, &lt;Type.NCHAR: &#39;NCHAR&#39;&gt;, &lt;Type.TEXT: &#39;TEXT&#39;&gt;, &lt;Type.NVARCHAR: &#39;NVARCHAR&#39;&gt;}</span>
 
         
     </div>
@@ -36689,7 +36686,7 @@ If an <code><a href="#Expression">Expression</a></code> instance is passed, it w
                                 <div class="attr variable">
             <span class="name">INTEGER_TYPES</span>        =
 <input id="DataType.INTEGER_TYPES-view-value" class="view-value-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
-            <label class="view-value-button pdoc-button" for="DataType.INTEGER_TYPES-view-value"></label><span class="default_value">{&lt;Type.INT256: &#39;INT256&#39;&gt;, &lt;Type.TINYINT: &#39;TINYINT&#39;&gt;, &lt;Type.BIGINT: &#39;BIGINT&#39;&gt;, &lt;Type.INT: &#39;INT&#39;&gt;, &lt;Type.INT128: &#39;INT128&#39;&gt;, &lt;Type.SMALLINT: &#39;SMALLINT&#39;&gt;}</span>
+            <label class="view-value-button pdoc-button" for="DataType.INTEGER_TYPES-view-value"></label><span class="default_value">{&lt;Type.INT256: &#39;INT256&#39;&gt;, &lt;Type.SMALLINT: &#39;SMALLINT&#39;&gt;, &lt;Type.INT: &#39;INT&#39;&gt;, &lt;Type.BIGINT: &#39;BIGINT&#39;&gt;, &lt;Type.INT128: &#39;INT128&#39;&gt;, &lt;Type.TINYINT: &#39;TINYINT&#39;&gt;}</span>
 
         
     </div>
@@ -36714,7 +36711,7 @@ If an <code><a href="#Expression">Expression</a></code> instance is passed, it w
                                 <div class="attr variable">
             <span class="name">NUMERIC_TYPES</span>        =
 <input id="DataType.NUMERIC_TYPES-view-value" class="view-value-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
-            <label class="view-value-button pdoc-button" for="DataType.NUMERIC_TYPES-view-value"></label><span class="default_value">{&lt;Type.SMALLINT: &#39;SMALLINT&#39;&gt;, &lt;Type.FLOAT: &#39;FLOAT&#39;&gt;, &lt;Type.DOUBLE: &#39;DOUBLE&#39;&gt;, &lt;Type.INT256: &#39;INT256&#39;&gt;, &lt;Type.INT: &#39;INT&#39;&gt;, &lt;Type.INT128: &#39;INT128&#39;&gt;, &lt;Type.BIGINT: &#39;BIGINT&#39;&gt;, &lt;Type.TINYINT: &#39;TINYINT&#39;&gt;}</span>
+            <label class="view-value-button pdoc-button" for="DataType.NUMERIC_TYPES-view-value"></label><span class="default_value">{&lt;Type.INT256: &#39;INT256&#39;&gt;, &lt;Type.SMALLINT: &#39;SMALLINT&#39;&gt;, &lt;Type.FLOAT: &#39;FLOAT&#39;&gt;, &lt;Type.DOUBLE: &#39;DOUBLE&#39;&gt;, &lt;Type.INT128: &#39;INT128&#39;&gt;, &lt;Type.INT: &#39;INT&#39;&gt;, &lt;Type.BIGINT: &#39;BIGINT&#39;&gt;, &lt;Type.TINYINT: &#39;TINYINT&#39;&gt;}</span>
 
         
     </div>
@@ -36727,7 +36724,7 @@ If an <code><a href="#Expression">Expression</a></code> instance is passed, it w
                                 <div class="attr variable">
             <span class="name">TEMPORAL_TYPES</span>        =
 <input id="DataType.TEMPORAL_TYPES-view-value" class="view-value-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
-            <label class="view-value-button pdoc-button" for="DataType.TEMPORAL_TYPES-view-value"></label><span class="default_value">{&lt;Type.DATE: &#39;DATE&#39;&gt;, &lt;Type.DATETIME64: &#39;DATETIME64&#39;&gt;, &lt;Type.DATETIME: &#39;DATETIME&#39;&gt;, &lt;Type.TIMESTAMPLTZ: &#39;TIMESTAMPLTZ&#39;&gt;, &lt;Type.TIME: &#39;TIME&#39;&gt;, &lt;Type.TIMESTAMPTZ: &#39;TIMESTAMPTZ&#39;&gt;, &lt;Type.TIMESTAMP: &#39;TIMESTAMP&#39;&gt;}</span>
+            <label class="view-value-button pdoc-button" for="DataType.TEMPORAL_TYPES-view-value"></label><span class="default_value">{&lt;Type.TIMESTAMP: &#39;TIMESTAMP&#39;&gt;, &lt;Type.DATETIME64: &#39;DATETIME64&#39;&gt;, &lt;Type.TIME: &#39;TIME&#39;&gt;, &lt;Type.DATE: &#39;DATE&#39;&gt;, &lt;Type.DATETIME: &#39;DATETIME&#39;&gt;, &lt;Type.TIMESTAMPTZ: &#39;TIMESTAMPTZ&#39;&gt;, &lt;Type.TIMESTAMPLTZ: &#39;TIMESTAMPLTZ&#39;&gt;}</span>
 
         
     </div>
@@ -53619,9 +53616,8 @@ name is set to the expression's class name transformed to snake case.</li>
 
     </div>
     <a class="headerlink" href="#Date"></a>
-            <div class="pdoc-code codehilite"><pre><span></span><span id="Date-4137"><a href="#Date-4137"><span class="linenos">4137</span></a><span class="k">class</span> <span class="nc">Date</span><span class="p">(</span><span class="n">Func</span><span class="p">):</span>
+            <div class="pdoc-code codehilite"><pre><span></span><span id="Date-4138"><a href="#Date-4138"><span class="linenos">4138</span></a><span class="k">class</span> <span class="nc">Date</span><span class="p">(</span><span class="n">Func</span><span class="p">):</span>
-</span><span id="Date-4138"><a href="#Date-4138"><span class="linenos">4138</span></a>    <span class="n">arg_types</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;expressions&quot;</span><span class="p">:</span> <span class="kc">True</span><span class="p">}</span>
+</span><span id="Date-4139"><a href="#Date-4139"><span class="linenos">4139</span></a>    <span class="n">arg_types</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;this&quot;</span><span class="p">:</span> <span class="kc">True</span><span class="p">,</span> <span class="s2">&quot;zone&quot;</span><span class="p">:</span> <span class="kc">False</span><span class="p">}</span>
-</span><span id="Date-4139"><a href="#Date-4139"><span class="linenos">4139</span></a>    <span class="n">is_var_len_args</span> <span class="o">=</span> <span class="kc">True</span>
 </span></pre></div>
 
 
@@ -53630,7 +53626,7 @@ name is set to the expression's class name transformed to snake case.</li>
                             <div id="Date.arg_types" class="classattr">
                                 <div class="attr variable">
             <span class="name">arg_types</span>        =
-<span class="default_value">{&#39;expressions&#39;: True}</span>
+<span class="default_value">{&#39;this&#39;: True, &#39;zone&#39;: False}</span>
 
         
     </div>
@@ -53638,18 +53634,6 @@ name is set to the expression's class name transformed to snake case.</li>
     
     
 
-                            </div>
-                            <div id="Date.is_var_len_args" class="classattr">
-                                <div class="attr variable">
-            <span class="name">is_var_len_args</span>        =
-<span class="default_value">True</span>
-
-        
-    </div>
-    <a class="headerlink" href="#Date.is_var_len_args"></a>
-    
-    
-
                             </div>
                             <div id="Date.key" class="classattr">
                                 <div class="attr variable">
@@ -53717,6 +53701,7 @@ name is set to the expression's class name transformed to snake case.</li>
 
             </div>
             <div><dt><a href="#Func">Func</a></dt>
+                                <dd id="Date.is_var_len_args" class="variable"><a href="#Func.is_var_len_args">is_var_len_args</a></dd>
                 <dd id="Date.from_arg_list" class="function"><a href="#Func.from_arg_list">from_arg_list</a></dd>
                 <dd id="Date.sql_names" class="function"><a href="#Func.sql_names">sql_names</a></dd>
                 <dd id="Date.sql_name" class="function"><a href="#Func.sql_name">sql_name</a></dd>

docs/sqlglot/optimizer/merge_subqueries.html

@@ -565,7 +565,7 @@ queries if it would result in multiple table selects in a single query:</p>
                     <div class="attr variable">
             <span class="name">UNMERGABLE_ARGS</span>        =
 <input id="UNMERGABLE_ARGS-view-value" class="view-value-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
-            <label class="view-value-button pdoc-button" for="UNMERGABLE_ARGS-view-value"></label><span class="default_value">{&#39;cluster&#39;, &#39;laterals&#39;, &#39;into&#39;, &#39;match&#39;, &#39;qualify&#39;, &#39;locks&#39;, &#39;sort&#39;, &#39;sample&#39;, &#39;group&#39;, &#39;format&#39;, &#39;with&#39;, &#39;offset&#39;, &#39;windows&#39;, &#39;limit&#39;, &#39;kind&#39;, &#39;distribute&#39;, &#39;having&#39;, &#39;distinct&#39;, &#39;pivots&#39;, &#39;settings&#39;}</span>
+            <label class="view-value-button pdoc-button" for="UNMERGABLE_ARGS-view-value"></label><span class="default_value">{&#39;sample&#39;, &#39;group&#39;, &#39;having&#39;, &#39;windows&#39;, &#39;offset&#39;, &#39;into&#39;, &#39;qualify&#39;, &#39;pivots&#39;, &#39;match&#39;, &#39;laterals&#39;, &#39;settings&#39;, &#39;cluster&#39;, &#39;format&#39;, &#39;limit&#39;, &#39;distinct&#39;, &#39;locks&#39;, &#39;distribute&#39;, &#39;with&#39;, &#39;kind&#39;, &#39;sort&#39;}</span>
 
         
     </div>

docs/sqlglot/tokens.html

@@ -7308,7 +7308,7 @@
                                 <div class="attr variable">
             <span class="name">COMMANDS</span>        =
 <input id="Tokenizer.COMMANDS-view-value" class="view-value-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1">
-            <label class="view-value-button pdoc-button" for="Tokenizer.COMMANDS-view-value"></label><span class="default_value">{&lt;<a href="#TokenType.FETCH">TokenType.FETCH</a>: &#39;FETCH&#39;&gt;, &lt;<a href="#TokenType.EXECUTE">TokenType.EXECUTE</a>: &#39;EXECUTE&#39;&gt;, &lt;<a href="#TokenType.SHOW">TokenType.SHOW</a>: &#39;SHOW&#39;&gt;, &lt;<a href="#TokenType.COMMAND">TokenType.COMMAND</a>: &#39;COMMAND&#39;&gt;}</span>
+            <label class="view-value-button pdoc-button" for="Tokenizer.COMMANDS-view-value"></label><span class="default_value">{&lt;<a href="#TokenType.FETCH">TokenType.FETCH</a>: &#39;FETCH&#39;&gt;, &lt;<a href="#TokenType.SHOW">TokenType.SHOW</a>: &#39;SHOW&#39;&gt;, &lt;<a href="#TokenType.COMMAND">TokenType.COMMAND</a>: &#39;COMMAND&#39;&gt;, &lt;<a href="#TokenType.EXECUTE">TokenType.EXECUTE</a>: &#39;EXECUTE&#39;&gt;}</span>
 
         
     </div>

sqlglot/dialects/bigquery.py

@@ -174,6 +174,12 @@ def _parse_date(args: t.List) -> exp.Date | exp.DateFromParts:
     return expr_type.from_arg_list(args)
 
 
+def _parse_to_hex(args: t.List) -> exp.Hex | exp.MD5:
+    # TO_HEX(MD5(..)) is common in BigQuery, so it's parsed into MD5 to simplify its transpilation
+    arg = seq_get(args, 0)
+    return exp.MD5(this=arg.this) if isinstance(arg, exp.MD5Digest) else exp.Hex(this=arg)
+
+
 class BigQuery(Dialect):
     UNNEST_COLUMN_ONLY = True
 
@@ -275,6 +281,8 @@ class BigQuery(Dialect):
             "DATETIME_SUB": parse_date_delta_with_interval(exp.DatetimeSub),
             "DIV": lambda args: exp.IntDiv(this=seq_get(args, 0), expression=seq_get(args, 1)),
             "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
+            "MD5": exp.MD5Digest.from_arg_list,
+            "TO_HEX": _parse_to_hex,
             "PARSE_DATE": lambda args: format_time_lambda(exp.StrToDate, "bigquery")(
                 [seq_get(args, 1), seq_get(args, 0)]
             ),
@@ -379,22 +387,27 @@ class BigQuery(Dialect):
             exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
             exp.ArraySize: rename_func("ARRAY_LENGTH"),
             exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
+            exp.Create: _create_sql,
             exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
             exp.DateAdd: _date_add_sql("DATE", "ADD"),
+            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
             exp.DateFromParts: rename_func("DATE"),
+            exp.DateStrToDate: datestrtodate_sql,
             exp.DateSub: _date_add_sql("DATE", "SUB"),
             exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"),
             exp.DatetimeSub: _date_add_sql("DATETIME", "SUB"),
-            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
-            exp.DateStrToDate: datestrtodate_sql,
             exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
-            exp.JSONFormat: rename_func("TO_JSON_STRING"),
             exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
             exp.GroupConcat: rename_func("STRING_AGG"),
+            exp.Hex: rename_func("TO_HEX"),
             exp.ILike: no_ilike_sql,
             exp.IntDiv: rename_func("DIV"),
+            exp.JSONFormat: rename_func("TO_JSON_STRING"),
             exp.Max: max_or_greatest,
+            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
+            exp.MD5Digest: rename_func("MD5"),
             exp.Min: min_or_least,
+            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
             exp.RegexpExtract: lambda self, e: self.func(
                 "REGEXP_EXTRACT",
                 e.this,
@@ -403,6 +416,7 @@ class BigQuery(Dialect):
                 e.args.get("occurrence"),
             ),
             exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
+            exp.ReturnsProperty: _returnsproperty_sql,
             exp.Select: transforms.preprocess(
                 [
                     transforms.explode_to_unnest,
@@ -411,6 +425,9 @@ class BigQuery(Dialect):
                     _alias_ordered_group,
                 ]
             ),
+            exp.StabilityProperty: lambda self, e: f"DETERMINISTIC"
+            if e.name == "IMMUTABLE"
+            else "NOT DETERMINISTIC",
             exp.StrToDate: lambda self, e: f"PARSE_DATE({self.format_time(e)}, {self.sql(e, 'this')})",
             exp.StrToTime: lambda self, e: self.func(
                 "PARSE_TIMESTAMP", self.format_time(e), e.this, e.args.get("zone")
@@ -420,17 +437,12 @@ class BigQuery(Dialect):
             exp.TimestampAdd: _date_add_sql("TIMESTAMP", "ADD"),
             exp.TimestampSub: _date_add_sql("TIMESTAMP", "SUB"),
             exp.TimeStrToTime: timestrtotime_sql,
-            exp.TsOrDsToDate: ts_or_ds_to_date_sql("bigquery"),
-            exp.TsOrDsAdd: _date_add_sql("DATE", "ADD"),
-            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
-            exp.VariancePop: rename_func("VAR_POP"),
-            exp.Values: _derived_table_values_to_unnest,
-            exp.ReturnsProperty: _returnsproperty_sql,
-            exp.Create: _create_sql,
             exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
-            exp.StabilityProperty: lambda self, e: f"DETERMINISTIC"
+            exp.TsOrDsAdd: _date_add_sql("DATE", "ADD"),
-            if e.name == "IMMUTABLE"
+            exp.TsOrDsToDate: ts_or_ds_to_date_sql("bigquery"),
-            else "NOT DETERMINISTIC",
+            exp.Unhex: rename_func("FROM_HEX"),
+            exp.Values: _derived_table_values_to_unnest,
+            exp.VariancePop: rename_func("VAR_POP"),
         }
 
         TYPE_MAPPING = {

sqlglot/dialects/hive.py

@@ -357,6 +357,7 @@ class Hive(Dialect):
             exp.Left: left_to_substring_sql,
             exp.Map: var_map_sql,
             exp.Max: max_or_greatest,
+            exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
             exp.Min: min_or_least,
             exp.VarMap: var_map_sql,
             exp.Create: create_with_partitions_sql,

sqlglot/dialects/postgres.py

@@ -263,6 +263,7 @@ class Postgres(Dialect):
             "DO": TokenType.COMMAND,
             "HSTORE": TokenType.HSTORE,
             "JSONB": TokenType.JSONB,
+            "MONEY": TokenType.MONEY,
             "REFRESH": TokenType.COMMAND,
             "REINDEX": TokenType.COMMAND,
             "RESET": TokenType.COMMAND,

sqlglot/dialects/spark.py

@@ -41,6 +41,12 @@ class Spark(Spark2):
         }
 
     class Generator(Spark2.Generator):
+        TYPE_MAPPING = {
+            **Spark2.Generator.TYPE_MAPPING,
+            exp.DataType.Type.MONEY: "DECIMAL(15, 4)",
+            exp.DataType.Type.SMALLMONEY: "DECIMAL(6, 4)",
+            exp.DataType.Type.UNIQUEIDENTIFIER: "STRING",
+        }
         TRANSFORMS = Spark2.Generator.TRANSFORMS.copy()
         TRANSFORMS.pop(exp.DateDiff)
         TRANSFORMS.pop(exp.Group)

sqlglot/dialects/spark2.py

@@ -177,9 +177,6 @@ class Spark2(Hive):
 
         TYPE_MAPPING = {
             **Hive.Generator.TYPE_MAPPING,
-            exp.DataType.Type.TINYINT: "BYTE",
-            exp.DataType.Type.SMALLINT: "SHORT",
-            exp.DataType.Type.BIGINT: "LONG",
         }
 
         PROPERTIES_LOCATION = {

sqlglot/dialects/sqlite.py

@@ -192,7 +192,7 @@ class SQLite(Dialect):
             if len(expression.expressions) > 1:
                 return rename_func("MIN")(self, expression)
 
-            return self.expressions(expression)
+            return self.sql(expression, "this")
 
         def transaction_sql(self, expression: exp.Transaction) -> str:
             this = expression.this

sqlglot/expressions.py

@@ -274,12 +274,16 @@ class Expression(metaclass=_Expression):
 
     def set(self, arg_key: str, value: t.Any) -> None:
         """
-        Sets `arg_key` to `value`.
+        Sets arg_key to value.
 
         Args:
-            arg_key (str): name of the expression arg.
+            arg_key: name of the expression arg.
             value: value to set the arg to.
         """
+        if value is None:
+            self.args.pop(arg_key, None)
+            return
+
         self.args[arg_key] = value
         self._set_parent(arg_key, value)
 
@@ -2278,6 +2282,7 @@ class Table(Expression):
         "pivots": False,
         "hints": False,
         "system_time": False,
+        "wrapped": False,
     }
 
     @property
@@ -4249,7 +4254,7 @@ class JSONArrayContains(Binary, Predicate, Func):
 
 
 class Least(Func):
-    arg_types = {"expressions": False}
+    arg_types = {"this": True, "expressions": False}
     is_var_len_args = True
 
 
@@ -4342,6 +4347,11 @@ class MD5(Func):
     _sql_names = ["MD5"]
 
 
+# Represents the variant of the MD5 function that returns a binary value
+class MD5Digest(Func):
+    _sql_names = ["MD5_DIGEST"]
+
+
 class Min(AggFunc):
     arg_types = {"this": True, "expressions": False}
     is_var_len_args = True

sqlglot/generator.py

@@ -1215,7 +1215,8 @@ class Generator:
         system_time = expression.args.get("system_time")
         system_time = f" {self.sql(expression, 'system_time')}" if system_time else ""
 
-        return f"{table}{system_time}{alias}{hints}{pivots}{joins}{laterals}"
+        sql = f"{table}{system_time}{alias}{hints}{pivots}{joins}{laterals}"
+        return f"({sql})" if expression.args.get("wrapped") else sql
 
     def tablesample_sql(
         self, expression: exp.TableSample, seed_prefix: str = "SEED", sep=" AS "
@@ -2289,11 +2290,14 @@ class Generator:
 
     def function_fallback_sql(self, expression: exp.Func) -> str:
         args = []
-        for arg_value in expression.args.values():
+
+        for key in expression.arg_types:
+            arg_value = expression.args.get(key)
+
             if isinstance(arg_value, list):
                 for value in arg_value:
                     args.append(value)
-            else:
+            elif arg_value is not None:
                 args.append(arg_value)
 
         return self.func(expression.sql_name(), *args)

sqlglot/optimizer/qualify_tables.py

@@ -15,8 +15,7 @@ def qualify_tables(
     schema: t.Optional[Schema] = None,
 ) -> E:
     """
-    Rewrite sqlglot AST to have fully qualified tables. Additionally, this
+    Rewrite sqlglot AST to have fully qualified, unnested tables.
-    replaces "join constructs" (*) by equivalent SELECT * subqueries.
 
     Examples:
         >>> import sqlglot
@@ -24,9 +23,18 @@ def qualify_tables(
         >>> qualify_tables(expression, db="db").sql()
         'SELECT 1 FROM db.tbl AS tbl'
         >>>
+        >>> expression = sqlglot.parse_one("SELECT * FROM (tbl)")
+        >>> qualify_tables(expression).sql()
+        'SELECT * FROM tbl AS tbl'
+        >>>
         >>> expression = sqlglot.parse_one("SELECT * FROM (tbl1 JOIN tbl2 ON id1 = id2)")
         >>> qualify_tables(expression).sql()
-        'SELECT * FROM (SELECT * FROM tbl1 AS tbl1 JOIN tbl2 AS tbl2 ON id1 = id2) AS _q_0'
+        'SELECT * FROM tbl1 AS tbl1 JOIN tbl2 AS tbl2 ON id1 = id2'
+
+    Note:
+        This rule effectively enforces a left-to-right join order, since all joins
+        are unnested. This means that the optimizer doesn't necessarily preserve the
+        original join order, e.g. when parentheses are used to specify it explicitly.
 
     Args:
         expression: Expression to qualify
@@ -36,19 +44,11 @@ def qualify_tables(
 
     Returns:
         The qualified expression.
-
-    (*) See section 7.2.1.2 in https://www.postgresql.org/docs/current/queries-table-expressions.html
     """
     next_alias_name = name_sequence("_q_")
 
     for scope in traverse_scope(expression):
         for derived_table in itertools.chain(scope.ctes, scope.derived_tables):
-            # Expand join construct
-            if isinstance(derived_table, exp.Subquery):
-                unnested = derived_table.unnest()
-                if isinstance(unnested, exp.Table):
-                    derived_table.this.replace(exp.select("*").from_(unnested.copy(), copy=False))
-
             if not derived_table.args.get("alias"):
                 alias_ = next_alias_name()
                 derived_table.set("alias", exp.TableAlias(this=exp.to_identifier(alias_)))
@@ -66,13 +66,17 @@ def qualify_tables(
                     if not source.args.get("catalog"):
                         source.set("catalog", exp.to_identifier(catalog))
 
+                # Unnest joins attached in tables by appending them to the closest query
+                for join in source.args.get("joins") or []:
+                    scope.expression.append("joins", join)
+
+                source.set("joins", None)
+                source.set("wrapped", None)
+
                 if not source.alias:
                     source = source.replace(
                         alias(
-                            source,
+                            source, name or source.name or next_alias_name(), copy=True, table=True
-                            name or source.name or next_alias_name(),
-                            copy=True,
-                            table=True,
                         )
                     )
 

sqlglot/optimizer/scope.py

@@ -548,9 +548,6 @@ def _traverse_scope(scope):
         yield from _traverse_union(scope)
     elif isinstance(scope.expression, exp.Subquery):
         yield from _traverse_subqueries(scope)
-    elif isinstance(scope.expression, exp.Table):
-        # This case corresponds to a "join construct", i.e. (tbl1 JOIN tbl2 ON ..)
-        yield from _traverse_tables(scope)
     elif isinstance(scope.expression, exp.UDTF):
         pass
     else:
@@ -632,7 +629,8 @@ def _traverse_tables(scope):
     if from_:
         expressions.append(from_.this)
 
-    for join in scope.expression.args.get("joins") or []:
+    for expression in (scope.expression, *scope.find_all(exp.Table)):
+        for join in expression.args.get("joins") or []:
             expressions.append(join.this)
 
     if isinstance(scope.expression, exp.Table):

sqlglot/parser.py

@@ -1969,10 +1969,31 @@ class Parser(metaclass=_Parser):
 
             self._match_r_paren()
 
-            # early return so that subquery unions aren't parsed again
+            alias = None
-            # SELECT * FROM (SELECT 1) UNION ALL SELECT 1
+
-            # Union ALL should be a property of the top select node, not the subquery
+            # Ensure "wrapped" tables are not parsed as Subqueries. The exception to this is when there's
-            return self._parse_subquery(this, parse_alias=parse_subquery_alias)
+            # an alias that can be applied to the parentheses, because that would shadow all wrapped table
+            # names, and so we want to parse it as a Subquery to represent the inner scope appropriately.
+            # Additionally, we want the node under the Subquery to be an actual query, so we will replace
+            # the table reference with a star query that selects from it.
+            if isinstance(this, exp.Table):
+                alias = self._parse_table_alias()
+                if not alias:
+                    this.set("wrapped", True)
+                    return this
+
+                this.set("wrapped", None)
+                joins = this.args.pop("joins", None)
+                this = this.replace(exp.select("*").from_(this.copy(), copy=False))
+                this.set("joins", joins)
+
+            subquery = self._parse_subquery(this, parse_alias=parse_subquery_alias and not alias)
+            if subquery and alias:
+                subquery.set("alias", alias)
+
+            # We return early here so that the UNION isn't attached to the subquery by the
+            # following call to _parse_set_operations, but instead becomes the parent node
+            return subquery
         elif self._match(TokenType.VALUES):
             this = self.expression(
                 exp.Values,
@@ -2292,6 +2313,7 @@ class Parser(metaclass=_Parser):
             else:
                 joins = None
                 self._retreat(index)
+
             kwargs["this"].set("joins", joins)
 
         return self.expression(exp.Join, **kwargs)

tests/dialects/test_bigquery.py

@@ -107,6 +107,27 @@ class TestBigQuery(Validator):
         self.validate_all("CAST(x AS NVARCHAR)", write={"bigquery": "CAST(x AS STRING)"})
         self.validate_all("CAST(x AS TIMESTAMPTZ)", write={"bigquery": "CAST(x AS TIMESTAMP)"})
         self.validate_all("CAST(x AS RECORD)", write={"bigquery": "CAST(x AS STRUCT)"})
+        self.validate_all(
+            "MD5(x)",
+            write={
+                "": "MD5_DIGEST(x)",
+                "bigquery": "MD5(x)",
+                "hive": "UNHEX(MD5(x))",
+                "spark": "UNHEX(MD5(x))",
+            },
+        )
+        self.validate_all(
+            "SELECT TO_HEX(MD5(some_string))",
+            read={
+                "duckdb": "SELECT MD5(some_string)",
+                "spark": "SELECT MD5(some_string)",
+            },
+            write={
+                "": "SELECT MD5(some_string)",
+                "bigquery": "SELECT TO_HEX(MD5(some_string))",
+                "duckdb": "SELECT MD5(some_string)",
+            },
+        )
         self.validate_all(
             "SELECT CAST('20201225' AS TIMESTAMP FORMAT 'YYYYMMDD' AT TIME ZONE 'America/New_York')",
             write={"bigquery": "SELECT PARSE_TIMESTAMP('%Y%m%d', '20201225', 'America/New_York')"},
@@ -263,7 +284,7 @@ class TestBigQuery(Validator):
                 "duckdb": "CAST(a AS BIGINT)",
                 "presto": "CAST(a AS BIGINT)",
                 "hive": "CAST(a AS BIGINT)",
-                "spark": "CAST(a AS LONG)",
+                "spark": "CAST(a AS BIGINT)",
             },
         )
         self.validate_all(
@@ -413,7 +434,7 @@ class TestBigQuery(Validator):
                 "duckdb": "CREATE TABLE db.example_table (col_a STRUCT(struct_col_a BIGINT, struct_col_b STRUCT(nested_col_a TEXT, nested_col_b TEXT)))",
                 "presto": "CREATE TABLE db.example_table (col_a ROW(struct_col_a BIGINT, struct_col_b ROW(nested_col_a VARCHAR, nested_col_b VARCHAR)))",
                 "hive": "CREATE TABLE db.example_table (col_a STRUCT<struct_col_a BIGINT, struct_col_b STRUCT<nested_col_a STRING, nested_col_b STRING>>)",
-                "spark": "CREATE TABLE db.example_table (col_a STRUCT<struct_col_a: LONG, struct_col_b: STRUCT<nested_col_a: STRING, nested_col_b: STRING>>)",
+                "spark": "CREATE TABLE db.example_table (col_a STRUCT<struct_col_a: BIGINT, struct_col_b: STRUCT<nested_col_a: STRING, nested_col_b: STRING>>)",
             },
         )
         self.validate_all(

tests/dialects/test_dialect.py

@@ -218,7 +218,7 @@ class TestDialect(Validator):
                 "presto": "CAST(a AS SMALLINT)",
                 "redshift": "CAST(a AS SMALLINT)",
                 "snowflake": "CAST(a AS SMALLINT)",
-                "spark": "CAST(a AS SHORT)",
+                "spark": "CAST(a AS SMALLINT)",
                 "sqlite": "CAST(a AS INTEGER)",
                 "starrocks": "CAST(a AS SMALLINT)",
             },

tests/dialects/test_duckdb.py

@@ -532,7 +532,7 @@ class TestDuckDB(Validator):
                 "duckdb": "CAST(COL AS BIGINT[])",
                 "presto": "CAST(COL AS ARRAY(BIGINT))",
                 "hive": "CAST(COL AS ARRAY<BIGINT>)",
-                "spark": "CAST(COL AS ARRAY<LONG>)",
+                "spark": "CAST(COL AS ARRAY<BIGINT>)",
                 "postgres": "CAST(COL AS BIGINT[])",
                 "snowflake": "CAST(COL AS ARRAY)",
             },

tests/dialects/test_hive.py

@@ -73,7 +73,7 @@ class TestHive(Validator):
                 "duckdb": "TRY_CAST(1 AS SMALLINT)",
                 "presto": "TRY_CAST(1 AS SMALLINT)",
                 "hive": "CAST(1 AS SMALLINT)",
-                "spark": "CAST(1 AS SHORT)",
+                "spark": "CAST(1 AS SMALLINT)",
             },
         )
         self.validate_all(
@@ -82,7 +82,7 @@ class TestHive(Validator):
                 "duckdb": "TRY_CAST(1 AS SMALLINT)",
                 "presto": "TRY_CAST(1 AS SMALLINT)",
                 "hive": "CAST(1 AS SMALLINT)",
-                "spark": "CAST(1 AS SHORT)",
+                "spark": "CAST(1 AS SMALLINT)",
             },
         )
         self.validate_all(
@@ -91,7 +91,7 @@ class TestHive(Validator):
                 "duckdb": "TRY_CAST(1 AS TINYINT)",
                 "presto": "TRY_CAST(1 AS TINYINT)",
                 "hive": "CAST(1 AS TINYINT)",
-                "spark": "CAST(1 AS BYTE)",
+                "spark": "CAST(1 AS TINYINT)",
             },
         )
         self.validate_all(
@@ -100,7 +100,7 @@ class TestHive(Validator):
                 "duckdb": "TRY_CAST(1 AS BIGINT)",
                 "presto": "TRY_CAST(1 AS BIGINT)",
                 "hive": "CAST(1 AS BIGINT)",
-                "spark": "CAST(1 AS LONG)",
+                "spark": "CAST(1 AS BIGINT)",
             },
         )
         self.validate_all(

tests/dialects/test_postgres.py

@@ -121,6 +121,7 @@ class TestPostgres(Validator):
         )
 
     def test_postgres(self):
+        self.validate_identity("CAST(x AS MONEY)")
         self.validate_identity("CAST(x AS INT4RANGE)")
         self.validate_identity("CAST(x AS INT4MULTIRANGE)")
         self.validate_identity("CAST(x AS INT8RANGE)")

tests/dialects/test_presto.py

@@ -65,7 +65,7 @@ class TestPresto(Validator):
                 "bigquery": "CAST([1, 2] AS ARRAY<INT64>)",
                 "duckdb": "CAST(LIST_VALUE(1, 2) AS BIGINT[])",
                 "presto": "CAST(ARRAY[1, 2] AS ARRAY(BIGINT))",
-                "spark": "CAST(ARRAY(1, 2) AS ARRAY<LONG>)",
+                "spark": "CAST(ARRAY(1, 2) AS ARRAY<BIGINT>)",
                 "snowflake": "CAST([1, 2] AS ARRAY)",
             },
         )

tests/dialects/test_spark.py

@@ -232,6 +232,13 @@ TBLPROPERTIES (
         self.validate_identity("TRIM(TRAILING 'SL' FROM 'SSparkSQLS')")
         self.validate_identity("SPLIT(str, pattern, lim)")
 
+        self.validate_all(
+            "UNHEX(MD5(x))",
+            write={
+                "bigquery": "FROM_HEX(TO_HEX(MD5(x)))",
+                "spark": "UNHEX(MD5(x))",
+            },
+        )
         self.validate_all(
             "SELECT * FROM ((VALUES 1))", write={"spark": "SELECT * FROM (VALUES (1))"}
         )

tests/dialects/test_sqlite.py

@@ -95,7 +95,7 @@ class TestSQLite(Validator):
             "SELECT CAST([a].[b] AS SMALLINT) FROM foo",
             write={
                 "sqlite": 'SELECT CAST("a"."b" AS INTEGER) FROM foo',
-                "spark": "SELECT CAST(`a`.`b` AS SHORT) FROM foo",
+                "spark": "SELECT CAST(`a`.`b` AS SMALLINT) FROM foo",
             },
         )
         self.validate_all(

tests/dialects/test_tsql.py

@@ -43,7 +43,7 @@ class TestTSQL(Validator):
             "SELECT CAST([a].[b] AS SMALLINT) FROM foo",
             write={
                 "tsql": 'SELECT CAST("a"."b" AS SMALLINT) FROM foo',
-                "spark": "SELECT CAST(`a`.`b` AS SHORT) FROM foo",
+                "spark": "SELECT CAST(`a`.`b` AS SMALLINT) FROM foo",
             },
         )
         self.validate_all(
@@ -84,7 +84,7 @@ class TestTSQL(Validator):
             "SELECT CAST([a].[b] AS SMALLINT) FROM foo",
             write={
                 "tsql": 'SELECT CAST("a"."b" AS SMALLINT) FROM foo',
-                "spark": "SELECT CAST(`a`.`b` AS SHORT) FROM foo",
+                "spark": "SELECT CAST(`a`.`b` AS SMALLINT) FROM foo",
             },
         )
         self.validate_all(
@@ -155,6 +155,211 @@ class TestTSQL(Validator):
             },
         )
 
+    def test__types_ints(self):
+        self.validate_all(
+            "CAST(X AS INT)",
+            write={
+                "hive": "CAST(X AS INT)",
+                "spark2": "CAST(X AS INT)",
+                "spark": "CAST(X AS INT)",
+                "tsql": "CAST(X AS INTEGER)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(X AS BIGINT)",
+            write={
+                "hive": "CAST(X AS BIGINT)",
+                "spark2": "CAST(X AS BIGINT)",
+                "spark": "CAST(X AS BIGINT)",
+                "tsql": "CAST(X AS BIGINT)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(X AS SMALLINT)",
+            write={
+                "hive": "CAST(X AS SMALLINT)",
+                "spark2": "CAST(X AS SMALLINT)",
+                "spark": "CAST(X AS SMALLINT)",
+                "tsql": "CAST(X AS SMALLINT)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(X AS TINYINT)",
+            write={
+                "hive": "CAST(X AS TINYINT)",
+                "spark2": "CAST(X AS TINYINT)",
+                "spark": "CAST(X AS TINYINT)",
+                "tsql": "CAST(X AS TINYINT)",
+            },
+        )
+
+    def test_types_decimals(self):
+        self.validate_all(
+            "CAST(x as FLOAT)",
+            write={
+                "spark": "CAST(x AS FLOAT)",
+                "tsql": "CAST(x AS FLOAT)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as DOUBLE)",
+            write={
+                "spark": "CAST(x AS DOUBLE)",
+                "tsql": "CAST(x AS DOUBLE)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as DECIMAL(15, 4))",
+            write={
+                "spark": "CAST(x AS DECIMAL(15, 4))",
+                "tsql": "CAST(x AS NUMERIC(15, 4))",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as NUMERIC(13,3))",
+            write={
+                "spark": "CAST(x AS DECIMAL(13, 3))",
+                "tsql": "CAST(x AS NUMERIC(13, 3))",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as MONEY)",
+            write={
+                "spark": "CAST(x AS DECIMAL(15, 4))",
+                "tsql": "CAST(x AS MONEY)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as SMALLMONEY)",
+            write={
+                "spark": "CAST(x AS DECIMAL(6, 4))",
+                "tsql": "CAST(x AS SMALLMONEY)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as REAL)",
+            write={
+                "spark": "CAST(x AS FLOAT)",
+                "tsql": "CAST(x AS FLOAT)",
+            },
+        )
+
+    def test_types_string(self):
+        self.validate_all(
+            "CAST(x as CHAR(1))",
+            write={
+                "spark": "CAST(x AS CHAR(1))",
+                "tsql": "CAST(x AS CHAR(1))",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as VARCHAR(2))",
+            write={
+                "spark": "CAST(x AS VARCHAR(2))",
+                "tsql": "CAST(x AS VARCHAR(2))",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as NCHAR(1))",
+            write={
+                "spark": "CAST(x AS CHAR(1))",
+                "tsql": "CAST(x AS CHAR(1))",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as NVARCHAR(2))",
+            write={
+                "spark": "CAST(x AS VARCHAR(2))",
+                "tsql": "CAST(x AS VARCHAR(2))",
+            },
+        )
+
+    def test_types_date(self):
+        self.validate_all(
+            "CAST(x as DATE)",
+            write={
+                "spark": "CAST(x AS DATE)",
+                "tsql": "CAST(x AS DATE)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as DATE)",
+            write={
+                "spark": "CAST(x AS DATE)",
+                "tsql": "CAST(x AS DATE)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as TIME(4))",
+            write={
+                "spark": "CAST(x AS TIMESTAMP)",
+                "tsql": "CAST(x AS TIMESTAMP(4))",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as DATETIME2)",
+            write={
+                "spark": "CAST(x AS TIMESTAMP)",
+                "tsql": "CAST(x AS DATETIME2)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as DATETIMEOFFSET)",
+            write={
+                "spark": "CAST(x AS TIMESTAMP)",
+                "tsql": "CAST(x AS TIMESTAMPTZ)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as SMALLDATETIME)",
+            write={
+                "spark": "CAST(x AS TIMESTAMP)",
+                "tsql": "CAST(x AS DATETIME2)",
+            },
+        )
+
+    def test_types_bin(self):
+        self.validate_all(
+            "CAST(x as BIT)",
+            write={
+                "spark": "CAST(x AS BOOLEAN)",
+                "tsql": "CAST(x AS BIT)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as UNIQUEIDENTIFIER)",
+            write={
+                "spark": "CAST(x AS STRING)",
+                "tsql": "CAST(x AS UNIQUEIDENTIFIER)",
+            },
+        )
+
+        self.validate_all(
+            "CAST(x as VARBINARY)",
+            write={
+                "spark": "CAST(x AS BINARY)",
+                "tsql": "CAST(x AS VARBINARY)",
+            },
+        )
+
     def test_udf(self):
         self.validate_identity(
             "CREATE PROCEDURE foo @a INTEGER, @b INTEGER AS SELECT @a = SUM(bla) FROM baz AS bar"

tests/fixtures/identity.sql

@@ -423,7 +423,6 @@ SELECT 1 INTERSECT SELECT 2
 SELECT 1 INTERSECT SELECT 2
 SELECT 1 AS delete, 2 AS alter
 SELECT * FROM (x)
-SELECT * FROM ((x))
 SELECT * FROM ((SELECT 1))
 SELECT * FROM (x CROSS JOIN foo LATERAL VIEW EXPLODE(y))
 SELECT * FROM (SELECT 1) AS x
@@ -838,3 +837,4 @@ SELECT * FROM schema.case
 SELECT * FROM current_date
 SELECT * FROM schema.current_date
 SELECT /*+ SOME_HINT(foo) */ 1
+SELECT * FROM (tbl1 CROSS JOIN (SELECT * FROM tbl2) AS t1)

tests/fixtures/optimizer/qualify_tables.sql

@@ -1,43 +1,103 @@
+# title: single table
 SELECT 1 FROM z;
 SELECT 1 FROM c.db.z AS z;
 
+# title: single table with db
 SELECT 1 FROM y.z;
 SELECT 1 FROM c.y.z AS z;
 
+# title: single table with db, catalog
 SELECT 1 FROM x.y.z;
 SELECT 1 FROM x.y.z AS z;
 
+# title: single table with db, catalog, alias
 SELECT 1 FROM x.y.z AS z;
 SELECT 1 FROM x.y.z AS z;
 
+# title: cte can't be qualified
 WITH a AS (SELECT 1 FROM z) SELECT 1 FROM a;
 WITH a AS (SELECT 1 FROM c.db.z AS z) SELECT 1 FROM a;
 
+# title: query that yields a single column as projection
 SELECT (SELECT y.c FROM y AS y) FROM x;
 SELECT (SELECT y.c FROM c.db.y AS y) FROM c.db.x AS x;
 
+# title: pivoted table
 SELECT * FROM x PIVOT (SUM(a) FOR b IN ('a', 'b'));
 SELECT * FROM c.db.x AS x PIVOT(SUM(a) FOR b IN ('a', 'b')) AS _q_0;
 
-----------------------------
+-----------------------------------------------------------
--- Expand join constructs
+--- Unnest wrapped tables / joins, expand join constructs
-----------------------------
+-----------------------------------------------------------
 
--- This is valid in Trino, so we treat the (tbl AS tbl) as a "join construct" per postgres' terminology.
+# title: wrapped table without alias
-SELECT * FROM (tbl AS tbl) AS _q_0;
+SELECT * FROM (tbl);
-SELECT * FROM (SELECT * FROM c.db.tbl AS tbl) AS _q_0;
+SELECT * FROM c.db.tbl AS tbl;
 
+# title: wrapped table with alias
+SELECT * FROM (tbl AS tbl);
+SELECT * FROM c.db.tbl AS tbl;
+
+# title: wrapped table with alias and multiple redundant parentheses
+SELECT * FROM ((((tbl AS tbl))));
+SELECT * FROM c.db.tbl AS tbl;
+
+# title: chained wrapped joins without aliases (1)
+SELECT * FROM ((a CROSS JOIN b) CROSS JOIN c);
+SELECT * FROM c.db.a AS a CROSS JOIN c.db.b AS b CROSS JOIN c.db.c AS c;
+
+# title: chained wrapped joins without aliases (2)
+SELECT * FROM (a CROSS JOIN (b CROSS JOIN c));
+SELECT * FROM c.db.a AS a CROSS JOIN c.db.b AS b CROSS JOIN c.db.c AS c;
+
+# title: chained wrapped joins without aliases (3)
+SELECT * FROM ((a CROSS JOIN ((b CROSS JOIN c) CROSS JOIN d)));
+SELECT * FROM c.db.a AS a CROSS JOIN c.db.b AS b CROSS JOIN c.db.c AS c CROSS JOIN c.db.d AS d;
+
+# title: chained wrapped joins without aliases (4)
+SELECT * FROM ((a CROSS JOIN ((b CROSS JOIN c) CROSS JOIN (d CROSS JOIN e))));
+SELECT * FROM c.db.a AS a CROSS JOIN c.db.b AS b CROSS JOIN c.db.c AS c CROSS JOIN c.db.d AS d CROSS JOIN c.db.e AS e;
+
+# title: chained wrapped joins with aliases
+SELECT * FROM ((a AS foo CROSS JOIN b AS bar) CROSS JOIN c AS baz);
+SELECT * FROM c.db.a AS foo CROSS JOIN c.db.b AS bar CROSS JOIN c.db.c AS baz;
+
+# title: wrapped join with subquery without alias
+SELECT * FROM (tbl1 CROSS JOIN (SELECT * FROM tbl2) AS t1);
+SELECT * FROM c.db.tbl1 AS tbl1 CROSS JOIN (SELECT * FROM c.db.tbl2 AS tbl2) AS t1;
+
+# title: wrapped join with subquery with alias, parentheses can't be omitted because of alias
+SELECT * FROM (tbl1 CROSS JOIN (SELECT * FROM tbl2) AS t1) AS t2;
+SELECT * FROM (SELECT * FROM c.db.tbl1 AS tbl1 CROSS JOIN (SELECT * FROM c.db.tbl2 AS tbl2) AS t1) AS t2;
+
+# title: join construct as the right operand of a left join
+SELECT * FROM a LEFT JOIN (b INNER JOIN c ON c.id = b.id) ON b.id = a.id;
+SELECT * FROM c.db.a AS a LEFT JOIN c.db.b AS b ON b.id = a.id INNER JOIN c.db.c AS c ON c.id = b.id;
+
+# title: nested joins converted to canonical form
+SELECT * FROM a LEFT JOIN b INNER JOIN c ON c.id = b.id ON b.id = a.id;
+SELECT * FROM c.db.a AS a LEFT JOIN c.db.b AS b ON b.id = a.id INNER JOIN c.db.c AS c ON c.id = b.id;
+
+# title: parentheses can't be omitted because alias shadows inner table names
+SELECT t.a FROM (tbl AS tbl) AS t;
+SELECT t.a FROM (SELECT * FROM c.db.tbl AS tbl) AS t;
+
+# title: outermost set of parentheses can't be omitted due to shadowing (1)
 SELECT * FROM ((tbl AS tbl)) AS _q_0;
 SELECT * FROM (SELECT * FROM c.db.tbl AS tbl) AS _q_0;
 
-SELECT * FROM (((tbl AS tbl))) AS _q_0;
+# title: outermost set of parentheses can't be omitted due to shadowing (2)
+SELECT * FROM ((((tbl AS tbl)))) AS _q_0;
 SELECT * FROM (SELECT * FROM c.db.tbl AS tbl) AS _q_0;
 
+# title: join construct with three tables in canonical form
 SELECT * FROM (tbl1 AS tbl1 JOIN tbl2 AS tbl2 ON id1 = id2 JOIN tbl3 AS tbl3 ON id1 = id3) AS _q_0;
 SELECT * FROM (SELECT * FROM c.db.tbl1 AS tbl1 JOIN c.db.tbl2 AS tbl2 ON id1 = id2 JOIN c.db.tbl3 AS tbl3 ON id1 = id3) AS _q_0;
 
+# title: join construct with three tables in canonical form and redundant set of parentheses
 SELECT * FROM ((tbl1 AS tbl1 JOIN tbl2 AS tbl2 ON id1 = id2 JOIN tbl3 AS tbl3 ON id1 = id3)) AS _q_0;
 SELECT * FROM (SELECT * FROM c.db.tbl1 AS tbl1 JOIN c.db.tbl2 AS tbl2 ON id1 = id2 JOIN c.db.tbl3 AS tbl3 ON id1 = id3) AS _q_0;
 
+# title: nested join construct in canonical form
 SELECT * FROM (tbl1 AS tbl1 JOIN (tbl2 AS tbl2 JOIN tbl3 AS tbl3 ON id2 = id3) AS _q_0 ON id1 = id3) AS _q_1;
 SELECT * FROM (SELECT * FROM c.db.tbl1 AS tbl1 JOIN (SELECT * FROM c.db.tbl2 AS tbl2 JOIN c.db.tbl3 AS tbl3 ON id2 = id3) AS _q_0 ON id1 = id3) AS _q_1;

tests/test_expressions.py

@@ -442,12 +442,15 @@ class TestExpressions(unittest.TestCase):
         expression.find(exp.Table).replace(parse_one("y"))
         self.assertEqual(expression.sql(), "SELECT c, b FROM y")
 
-    def test_pop(self):
+    def test_arg_deletion(self):
+        # Using the pop helper method
         expression = parse_one("SELECT a, b FROM x")
         expression.find(exp.Column).pop()
         self.assertEqual(expression.sql(), "SELECT b FROM x")
+
         expression.find(exp.Column).pop()
         self.assertEqual(expression.sql(), "SELECT FROM x")
+
         expression.pop()
         self.assertEqual(expression.sql(), "SELECT FROM x")
 
@@ -455,6 +458,15 @@ class TestExpressions(unittest.TestCase):
         expression.find(exp.With).pop()
         self.assertEqual(expression.sql(), "SELECT * FROM x")
 
+        # Manually deleting by setting to None
+        expression = parse_one("SELECT * FROM foo JOIN bar")
+        self.assertEqual(len(expression.args.get("joins", [])), 1)
+
+        expression.set("joins", None)
+        self.assertEqual(expression.sql(), "SELECT * FROM foo")
+        self.assertEqual(expression.args.get("joins", []), [])
+        self.assertIsNone(expression.args.get("joins"))
+
     def test_walk(self):
         expression = parse_one("SELECT * FROM (SELECT * FROM x)")
         self.assertEqual(len(list(expression.walk())), 9)
@@ -539,6 +551,9 @@ class TestExpressions(unittest.TestCase):
         self.assertIsInstance(parse_one("ARRAY(time, foo)"), exp.Array)
         self.assertIsInstance(parse_one("STANDARD_HASH('hello', 'sha256')"), exp.StandardHash)
         self.assertIsInstance(parse_one("DATE(foo)"), exp.Date)
+        self.assertIsInstance(parse_one("HEX(foo)"), exp.Hex)
+        self.assertIsInstance(parse_one("TO_HEX(foo)", read="bigquery"), exp.Hex)
+        self.assertIsInstance(parse_one("TO_HEX(MD5(foo))", read="bigquery"), exp.MD5)
 
     def test_column(self):
         column = parse_one("a.b.c.d")

tests/test_generator.py

@@ -1,6 +1,6 @@
 import unittest
 
-from sqlglot import parse_one
+from sqlglot import exp, parse_one
 from sqlglot.expressions import Func
 from sqlglot.parser import Parser
 from sqlglot.tokens import Tokenizer
@@ -30,6 +30,11 @@ class TestGenerator(unittest.TestCase):
         expression = NewParser().parse(tokens)[0]
         self.assertEqual(expression.sql(), "SELECT SPECIAL_UDF(a, b, c, d + 1) FROM x")
 
+        self.assertEqual(
+            exp.DateTrunc(this=exp.to_column("event_date"), unit=exp.var("MONTH")).sql(),
+            "DATE_TRUNC(MONTH, event_date)",
+        )
+
     def test_identify(self):
         assert parse_one("x").sql(identify=True) == '"x"'
         assert parse_one("x").sql(identify="always") == '"x"'

tests/test_parser.py

@@ -580,3 +580,58 @@ class TestParser(unittest.TestCase):
 
     def test_parse_floats(self):
         self.assertTrue(parse_one("1. ").is_number)
+
+    def test_parse_wrapped_tables(self):
+        expr = parse_one("select * from (table)")
+        self.assertIsInstance(expr.args["from"].this, exp.Table)
+        self.assertTrue(expr.args["from"].this.args["wrapped"])
+
+        expr = parse_one("select * from (((table)))")
+        self.assertIsInstance(expr.args["from"].this, exp.Table)
+        self.assertTrue(expr.args["from"].this.args["wrapped"])
+
+        self.assertEqual(expr.sql(), "SELECT * FROM (table)")
+
+        expr = parse_one("select * from (tbl1 join tbl2)")
+        self.assertIsInstance(expr.args["from"].this, exp.Table)
+        self.assertTrue(expr.args["from"].this.args["wrapped"])
+        self.assertEqual(len(expr.args["from"].this.args["joins"]), 1)
+
+        expr = parse_one("select * from (tbl1 join tbl2) t")
+        self.assertIsInstance(expr.args["from"].this, exp.Subquery)
+        self.assertIsInstance(expr.args["from"].this.this, exp.Select)
+        self.assertEqual(expr.sql(), "SELECT * FROM (SELECT * FROM tbl1, tbl2) AS t")
+
+        expr = parse_one("select * from (tbl as tbl) t")
+        self.assertEqual(expr.sql(), "SELECT * FROM (SELECT * FROM tbl AS tbl) AS t")
+
+        expr = parse_one("select * from ((a cross join b) cross join c)")
+        self.assertIsInstance(expr.args["from"].this, exp.Table)
+        self.assertTrue(expr.args["from"].this.args["wrapped"])
+        self.assertEqual(len(expr.args["from"].this.args["joins"]), 2)
+        self.assertEqual(expr.sql(), "SELECT * FROM (a CROSS JOIN b CROSS JOIN c)")
+
+        expr = parse_one("select * from ((a cross join b) cross join c) t")
+        self.assertIsInstance(expr.args["from"].this, exp.Subquery)
+        self.assertEqual(len(expr.args["from"].this.this.args["joins"]), 2)
+        self.assertEqual(
+            expr.sql(), "SELECT * FROM (SELECT * FROM a CROSS JOIN b CROSS JOIN c) AS t"
+        )
+
+        expr = parse_one("select * from (a cross join (b cross join c))")
+        self.assertIsInstance(expr.args["from"].this, exp.Table)
+        self.assertTrue(expr.args["from"].this.args["wrapped"])
+        self.assertEqual(len(expr.args["from"].this.args["joins"]), 1)
+        self.assertIsInstance(expr.args["from"].this.args["joins"][0].this, exp.Table)
+        self.assertTrue(expr.args["from"].this.args["joins"][0].this.args["wrapped"])
+        self.assertEqual(expr.sql(), "SELECT * FROM (a CROSS JOIN (b CROSS JOIN c))")
+
+        expr = parse_one("select * from ((a cross join ((b cross join c) cross join d)))")
+        self.assertEqual(expr.sql(), "SELECT * FROM (a CROSS JOIN (b CROSS JOIN c CROSS JOIN d))")
+
+        expr = parse_one(
+            "select * from ((a cross join ((b cross join c) cross join (d cross join e))))"
+        )
+        self.assertEqual(
+            expr.sql(), "SELECT * FROM (a CROSS JOIN (b CROSS JOIN c CROSS JOIN (d CROSS JOIN e)))"
+        )