Align DF55 compatibility tests with fork behavior

Author: osipovartem

datafusion/physical-expr/src/expressions/binary.rs

@@ -4798,7 +4798,7 @@ mod tests {
             Field::new("b", DataType::Decimal128(10, 2), true),
         ]));
         let expect = Arc::new(create_decimal_array(
-            &[Some(1000000), None, Some(1008196), Some(1000000)],
+            &[Some(1000000), None, Some(1008197), Some(1000000)],
             16,
             4,
         )) as ArrayRef;

datafusion/physical-plan/src/joins/hash_join/spill.rs

@@ -33,7 +33,7 @@
 //!   and per-partition write buffers; held until the spill join completes.
 //! - `HashJoinSpillPartition[p.k]`: per partition-pair; covers the loaded
 //!   build batches plus the hash table built from them (moved into the
-//!   pair's [`JoinLeftData`]); dropped when the pair finishes.
+//!   pair's in-memory join state); dropped when the pair finishes.
 //!
 //! The scatter hash uses seeds distinct from both `RepartitionExec`'s
 //! `(0,0,0,0)` routing seeds and the join hash map's `HASH_JOIN_SEED`

datafusion/sql/src/parser.rs

@@ -925,23 +925,31 @@ impl<'a> DFParser<'a> {
     /// Parse a SQL `CREATE` statement handling `CREATE EXTERNAL TABLE`
     pub fn parse_create(&mut self) -> Result<Statement, DataFusionError> {
         // TODO: Change sql parser to take in `or_replace: bool` inside parse_create()
-        if self
-            .parser
-            .parse_keywords(&[Keyword::OR, Keyword::REPLACE, Keyword::EXTERNAL])
+        if self.external_is_followed_by_table(2)
+            && self.parser.parse_keywords(&[
+                Keyword::OR,
+                Keyword::REPLACE,
+                Keyword::EXTERNAL,
+            ])
         {
             self.parse_create_external_table(false, true)
-        } else if self.parser.parse_keywords(&[
-            Keyword::OR,
-            Keyword::REPLACE,
-            Keyword::UNBOUNDED,
-            Keyword::EXTERNAL,
-        ]) {
+        } else if self.external_is_followed_by_table(3)
+            && self.parser.parse_keywords(&[
+                Keyword::OR,
+                Keyword::REPLACE,
+                Keyword::UNBOUNDED,
+                Keyword::EXTERNAL,
+            ])
+        {
             self.parse_create_external_table(true, true)
-        } else if self.parser.parse_keyword(Keyword::EXTERNAL) {
+        } else if self.external_is_followed_by_table(0)
+            && self.parser.parse_keyword(Keyword::EXTERNAL)
+        {
             self.parse_create_external_table(false, false)
-        } else if self
-            .parser
-            .parse_keywords(&[Keyword::UNBOUNDED, Keyword::EXTERNAL])
+        } else if self.external_is_followed_by_table(1)
+            && self
+                .parser
+                .parse_keywords(&[Keyword::UNBOUNDED, Keyword::EXTERNAL])
         {
             self.parse_create_external_table(true, false)
         } else {
@@ -953,6 +961,23 @@ impl<'a> DFParser<'a> {
         }
     }
 
+    fn external_is_followed_by_table(&self, external_offset: usize) -> bool {
+        let next_keyword = match self.parser.peek_nth_token(external_offset + 1).token {
+            Token::Word(word) => word.keyword,
+            _ => return false,
+        };
+        if next_keyword == Keyword::TABLE {
+            return true;
+        }
+        if !matches!(next_keyword, Keyword::TEMP | Keyword::TEMPORARY) {
+            return false;
+        }
+        matches!(
+            self.parser.peek_nth_token(external_offset + 2).token,
+            Token::Word(word) if word.keyword == Keyword::TABLE
+        )
+    }
+
     fn parse_partitions(&mut self) -> Result<Vec<String>, DataFusionError> {
         let mut partitions: Vec<String> = vec![];
         if !self.parser.consume_token(&Token::LParen)
@@ -1396,6 +1421,13 @@ mod tests {
         });
         expect_parse_ok(sql, expected)?;
 
+        let sql = "CREATE EXTERNAL TEMPORARY TABLE t STORED AS CSV LOCATION 'foo.csv'";
+        let expected = Statement::CreateExternalTable(CreateExternalTable {
+            temporary: true,
+            ..make_create_external_table("foo.csv")
+        });
+        expect_parse_ok(sql, expected)?;
+
         // positive case: literal comma remains part of a single path
         let sql = "CREATE EXTERNAL TABLE t(c1 int) STORED AS CSV LOCATION 'foo,bar.csv'";
         let expected = Statement::CreateExternalTable(CreateExternalTable {
@@ -1880,6 +1912,31 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn delegate_create_stage_to_snowflake_dialect() -> Result<(), DataFusionError> {
+        let sql =
+            "CREATE OR REPLACE STAGE stage URL='s3://data.csv' FILE_FORMAT=(TYPE=csv)";
+        let dialect = SnowflakeDialect;
+        let statements = DFParser::parse_sql_with_dialect(sql, &dialect)?;
+
+        assert_eq!(statements.len(), 1);
+        let Statement::Statement(statement) = &statements[0] else {
+            panic!("expected a sqlparser statement, got {:?}", statements[0]);
+        };
+        assert_eq!(statement.to_string(), sql);
+        Ok(())
+    }
+
+    #[test]
+    fn parse_standalone_begin_with_snowflake_dialect() -> Result<(), DataFusionError> {
+        let dialect = SnowflakeDialect;
+        let statements = DFParser::parse_sql_with_dialect("BEGIN", &dialect)?;
+
+        assert_eq!(statements.len(), 1);
+        assert!(matches!(statements[0], Statement::Statement(_)));
+        Ok(())
+    }
+
     #[test]
     fn explain_copy_to_table_to_table() -> Result<(), DataFusionError> {
         let cases = vec![

datafusion/sqllogictest/test_files/decimal.slt

@@ -121,7 +121,7 @@ Decimal128(20, 6) 0.00055
 query TR
 select arrow_typeof(avg(c1)), avg(c1) from decimal_simple;
 ----
-Decimal128(14, 10) 0.0000366666
+Decimal128(14, 10) 0.0000366667
 
 
 query TR
@@ -399,19 +399,19 @@ select c1/c5 from decimal_simple;
 ----
 0.5
 0.641025641
-0.7142857142
+0.7142857143
 0.7352941176
 0.8
 0.8571428571
-0.909090909
-0.909090909
+0.9090909091
+0.9090909091
 0.9375
 0.9615384615
 1
 1
 1.0526315789
-1.5151515151
-2.7272727272
+1.5151515152
+2.7272727273
 
 
 query T
@@ -678,7 +678,7 @@ select * from decimal256_simple where c1 > c5;
 query TR
 select arrow_typeof(avg(c1)), avg(c1) from decimal256_simple;
 ----
-Decimal256(54, 10) 0.0000366666
+Decimal256(54, 10) 0.0000366667
 
 query TR
 select arrow_typeof(min(c1)), min(c1) from decimal256_simple where c4=false;

datafusion/sqllogictest/test_files/table_functions.slt

@@ -620,12 +620,16 @@ LIMIT 10;
 1
 1
 
-# Test that unsupported function argument types are properly reported
-# rather than being silently dropped (which previously caused a misleading
-# "requires 1 to 3 arguments" error instead)
+# Named table-function arguments are preserved by the SQL planner.
 
-statement error DataFusion error: Error during planning: Unsupported function argument type: start => 1
+query I
 SELECT * FROM generate_series(start => 1, stop => 5)
+----
+1
+2
+3
+4
+5
 
 statement error DataFusion error: Error during planning: Unsupported function argument type: \*
 SELECT * FROM generate_series(*)

datafusion/sqllogictest/test_files/tpch/answers/q1.slt.part

@@ -39,7 +39,7 @@ order by
     l_returnflag,
 	l_linestatus;
 ----
-A F 3774200 5320753880.69 5054096266.6828 5256751331.449234 25.537587 36002.123829 0.050144 147790
+A F 3774200 5320753880.69 5054096266.6828 5256751331.449234 25.537587 36002.123829 0.050145 147790
 N F 95257 133737795.84 127132372.6512 132286291.229445 25.300664 35521.326916 0.049394 3765
-N O 7459297 10512270008.9 9986238338.3847 10385578376.585467 25.545537 36000.924688 0.050095 292000
-R F 3785523 5337950526.47 5071818532.942 5274405503.049367 25.525943 35994.029214 0.049989 148301
+N O 7459297 10512270008.9 9986238338.3847 10385578376.585467 25.545538 36000.924688 0.050096 292000
+R F 3785523 5337950526.47 5071818532.942 5274405503.049367 25.525944 35994.029214 0.049989 148301