From 4be021909a1deaac27f6309dcd528a2497c432f0 Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Tue, 26 Oct 2021 11:53:00 -0400 Subject: [PATCH 1/8] First test updated --- datafusion/tests/sql.rs | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index e4841529ab83..420be39afd0b 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -29,7 +29,7 @@ extern crate datafusion; use arrow::{ array::*, datatypes::*, record_batch::RecordBatch, - util::display::array_value_to_string, + util::display::array_value_to_string, util::pretty::pretty_format_batches, }; use datafusion::assert_batches_eq; @@ -1849,8 +1849,6 @@ async fn csv_query_limit_zero() -> Result<()> { Ok(()) } -// --- End Test Porting --- - #[tokio::test] async fn csv_query_create_external_table() { let mut ctx = ExecutionContext::new(); @@ -1867,16 +1865,23 @@ async fn csv_query_create_external_table() { assert_batches_eq!(expected, &actual); } +// --- End Test Porting --- + #[tokio::test] async fn csv_query_external_table_count() { let mut ctx = ExecutionContext::new(); register_aggregate_csv_by_sql(&mut ctx).await; let sql = "SELECT COUNT(c12) FROM aggregate_test_100"; - let actual = execute(&mut ctx, sql).await; - // let a = execute_to_batches(&mut ctx, sql).await; - // println!("{}", pretty_format_batches(&a).unwrap()); - let expected = vec![vec!["100"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+-------------------------------+", + "| COUNT(aggregate_test_100.c12) |", + "+-------------------------------+", + "| 100 |", + "+-------------------------------+", + ]; + + assert_batches_eq!(expected, &actual); } #[tokio::test] @@ -1887,6 +1892,8 @@ async fn csv_query_external_table_sum() { let sql = "SELECT SUM(CAST(c7 AS BIGINT)), SUM(CAST(c8 AS BIGINT)) FROM aggregate_test_100"; let actual = execute(&mut ctx, sql).await; + // let a = execute_to_batches(&mut ctx, sql).await; + // println!("{}", pretty_format_batches(&a).unwrap()); let expected = vec![vec!["13060", "3017641"]]; assert_eq!(expected, actual); } From 0245d799f28fb32420725106eda673b63f40a89c Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Wed, 27 Oct 2021 11:37:16 -0400 Subject: [PATCH 2/8] More tests --- datafusion/tests/sql.rs | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index 420be39afd0b..cb05fc6c8775 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -1865,8 +1865,6 @@ async fn csv_query_create_external_table() { assert_batches_eq!(expected, &actual); } -// --- End Test Porting --- - #[tokio::test] async fn csv_query_external_table_count() { let mut ctx = ExecutionContext::new(); @@ -1891,11 +1889,15 @@ async fn csv_query_external_table_sum() { register_aggregate_csv_by_sql(&mut ctx).await; let sql = "SELECT SUM(CAST(c7 AS BIGINT)), SUM(CAST(c8 AS BIGINT)) FROM aggregate_test_100"; - let actual = execute(&mut ctx, sql).await; - // let a = execute_to_batches(&mut ctx, sql).await; - // println!("{}", pretty_format_batches(&a).unwrap()); - let expected = vec![vec!["13060", "3017641"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+-------------------------------------------+-------------------------------------------+", + "| SUM(CAST(aggregate_test_100.c7 AS Int64)) | SUM(CAST(aggregate_test_100.c8 AS Int64)) |", + "+-------------------------------------------+-------------------------------------------+", + "| 13060 | 3017641 |", + "+-------------------------------------------+-------------------------------------------+", + ]; + assert_batches_eq!(expected, &actual); } #[tokio::test] @@ -1903,11 +1905,19 @@ async fn csv_query_count_star() { let mut ctx = ExecutionContext::new(); register_aggregate_csv_by_sql(&mut ctx).await; let sql = "SELECT COUNT(*) FROM aggregate_test_100"; - let actual = execute(&mut ctx, sql).await; - let expected = vec![vec!["100"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+-----------------+", + "| COUNT(UInt8(1)) |", + "+-----------------+", + "| 100 |", + "+-----------------+", + ]; + assert_batches_eq!(expected, &actual); } +// --- End Test Porting --- + #[tokio::test] async fn csv_query_count_one() { let mut ctx = ExecutionContext::new(); From 37ab80e8923151f2c1f2f953692c15c1aeecd066 Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Thu, 28 Oct 2021 11:55:06 -0400 Subject: [PATCH 3/8] More tests --- datafusion/tests/sql.rs | 78 ++++++++++++++++++++++++++++++++--------- 1 file changed, 61 insertions(+), 17 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index cb05fc6c8775..704d09cf8bb8 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -1916,16 +1916,20 @@ async fn csv_query_count_star() { assert_batches_eq!(expected, &actual); } -// --- End Test Porting --- - #[tokio::test] async fn csv_query_count_one() { let mut ctx = ExecutionContext::new(); register_aggregate_csv_by_sql(&mut ctx).await; let sql = "SELECT COUNT(1) FROM aggregate_test_100"; - let actual = execute(&mut ctx, sql).await; - let expected = vec![vec!["100"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+-----------------+", + "| COUNT(UInt8(1)) |", + "+-----------------+", + "| 100 |", + "+-----------------+", + ]; + assert_batches_eq!(expected, &actual); } #[tokio::test] @@ -1936,9 +1940,18 @@ async fn case_when() -> Result<()> { WHEN c1 = 'b' THEN 2 \ END \ FROM t1"; - let actual = execute(&mut ctx, sql).await; - let expected = vec![vec!["1"], vec!["2"], vec!["NULL"], vec!["NULL"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+--------------------------------------------------------------------------------------+", + "| CASE WHEN #t1.c1 = Utf8(\"a\") THEN Int64(1) WHEN #t1.c1 = Utf8(\"b\") THEN Int64(2) END |", + "+--------------------------------------------------------------------------------------+", + "| 1 |", + "| 2 |", + "| |", + "| |", + "+--------------------------------------------------------------------------------------+", + ]; + assert_batches_eq!(expected, &actual); Ok(()) } @@ -1950,9 +1963,18 @@ async fn case_when_else() -> Result<()> { WHEN c1 = 'b' THEN 2 \ ELSE 999 END \ FROM t1"; - let actual = execute(&mut ctx, sql).await; - let expected = vec![vec!["1"], vec!["2"], vec!["999"], vec!["999"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+------------------------------------------------------------------------------------------------------+", + "| CASE WHEN #t1.c1 = Utf8(\"a\") THEN Int64(1) WHEN #t1.c1 = Utf8(\"b\") THEN Int64(2) ELSE Int64(999) END |", + "+------------------------------------------------------------------------------------------------------+", + "| 1 |", + "| 2 |", + "| 999 |", + "| 999 |", + "+------------------------------------------------------------------------------------------------------+", + ]; + assert_batches_eq!(expected, &actual); Ok(()) } @@ -1964,9 +1986,18 @@ async fn case_when_with_base_expr() -> Result<()> { WHEN 'b' THEN 2 \ END \ FROM t1"; - let actual = execute(&mut ctx, sql).await; - let expected = vec![vec!["1"], vec!["2"], vec!["NULL"], vec!["NULL"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+---------------------------------------------------------------------------+", + "| CASE #t1.c1 WHEN Utf8(\"a\") THEN Int64(1) WHEN Utf8(\"b\") THEN Int64(2) END |", + "+---------------------------------------------------------------------------+", + "| 1 |", + "| 2 |", + "| |", + "| |", + "+---------------------------------------------------------------------------+", + ]; + assert_batches_eq!(expected, &actual); Ok(()) } @@ -1978,12 +2009,23 @@ async fn case_when_else_with_base_expr() -> Result<()> { WHEN 'b' THEN 2 \ ELSE 999 END \ FROM t1"; - let actual = execute(&mut ctx, sql).await; - let expected = vec![vec!["1"], vec!["2"], vec!["999"], vec!["999"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+-------------------------------------------------------------------------------------------+", + "| CASE #t1.c1 WHEN Utf8(\"a\") THEN Int64(1) WHEN Utf8(\"b\") THEN Int64(2) ELSE Int64(999) END |", + "+-------------------------------------------------------------------------------------------+", + "| 1 |", + "| 2 |", + "| 999 |", + "| 999 |", + "+-------------------------------------------------------------------------------------------+", + ]; + assert_batches_eq!(expected, &actual); Ok(()) } +// --- End Test Porting --- + fn create_case_context() -> Result { let mut ctx = ExecutionContext::new(); let schema = Arc::new(Schema::new(vec![Field::new("c1", DataType::Utf8, true)])); @@ -2013,6 +2055,8 @@ async fn equijoin() -> Result<()> { vec!["22", "b", "y"], vec!["44", "d", "x"], ]; + // let a = execute_to_batches(&mut ctx, sql).await; + // println!("{}", pretty_format_batches(&a).unwrap()); for sql in equivalent_sql.iter() { let actual = execute(&mut ctx, sql).await; assert_eq!(expected, actual); From 5d8ae36c6eae550a761f615f9c377eca66fe34fc Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Sun, 31 Oct 2021 01:44:03 -0400 Subject: [PATCH 4/8] More tests --- datafusion/tests/sql.rs | 46 +++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 15 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index 704d09cf8bb8..e0390933c8ac 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -2051,15 +2051,17 @@ async fn equijoin() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 JOIN t2 ON t2_id = t1_id ORDER BY t1_id", ]; let expected = vec![ - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["44", "d", "x"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| 11 | a | z |", + "| 22 | b | y |", + "| 44 | d | x |", + "+-------+---------+---------+", ]; - // let a = execute_to_batches(&mut ctx, sql).await; - // println!("{}", pretty_format_batches(&a).unwrap()); for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } let mut ctx = create_join_context_qualified()?; @@ -2067,10 +2069,18 @@ async fn equijoin() -> Result<()> { "SELECT t1.a, t2.b FROM t1 INNER JOIN t2 ON t1.a = t2.a ORDER BY t1.a", "SELECT t1.a, t2.b FROM t1 INNER JOIN t2 ON t2.a = t1.a ORDER BY t1.a", ]; - let expected = vec![vec!["1", "100"], vec!["2", "200"], vec!["4", "400"]]; + let expected = vec![ + "+---+-----+", + "| a | b |", + "+---+-----+", + "| 1 | 100 |", + "| 2 | 200 |", + "| 4 | 400 |", + "+---+-----+", + ]; for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } Ok(()) } @@ -2085,13 +2095,17 @@ async fn equijoin_multiple_condition_ordering() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 JOIN t2 ON t2_id = t1_id AND t2_name <> t1_name ORDER BY t1_id", ]; let expected = vec![ - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["44", "d", "x"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| 11 | a | z |", + "| 22 | b | y |", + "| 44 | d | x |", + "+-------+---------+---------+", ]; for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } Ok(()) } @@ -2102,6 +2116,8 @@ async fn equijoin_and_other_condition() -> Result<()> { let sql = "SELECT t1_id, t1_name, t2_name FROM t1 JOIN t2 ON t1_id = t2_id AND t2_name >= 'y' ORDER BY t1_id"; let actual = execute(&mut ctx, sql).await; + // let a = execute_to_batches(&mut ctx, sql).await; + // println!("{}", pretty_format_batches(&a).unwrap()); let expected = vec![vec!["11", "a", "z"], vec!["22", "b", "y"]]; assert_eq!(expected, actual); Ok(()) From 9a20a101d383438164f1ae5751729868578cb646 Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Sun, 31 Oct 2021 02:00:47 -0400 Subject: [PATCH 5/8] Move test porting comment --- datafusion/tests/sql.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index e0390933c8ac..a324bf3c2549 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -2024,8 +2024,6 @@ async fn case_when_else_with_base_expr() -> Result<()> { Ok(()) } -// --- End Test Porting --- - fn create_case_context() -> Result { let mut ctx = ExecutionContext::new(); let schema = Arc::new(Schema::new(vec![Field::new("c1", DataType::Utf8, true)])); @@ -2110,6 +2108,8 @@ async fn equijoin_multiple_condition_ordering() -> Result<()> { Ok(()) } +// --- End Test Porting --- + #[tokio::test] async fn equijoin_and_other_condition() -> Result<()> { let mut ctx = create_join_context("t1_id", "t2_id")?; From 49f66cfe19a7398b41d84558f74b03c08a262ccf Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Sun, 31 Oct 2021 21:29:59 -0400 Subject: [PATCH 6/8] More tests --- datafusion/tests/sql.rs | 90 +++++++++++++++++++++++++---------------- 1 file changed, 55 insertions(+), 35 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index a324bf3c2549..283db0a8a9aa 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -2108,18 +2108,21 @@ async fn equijoin_multiple_condition_ordering() -> Result<()> { Ok(()) } -// --- End Test Porting --- - #[tokio::test] async fn equijoin_and_other_condition() -> Result<()> { let mut ctx = create_join_context("t1_id", "t2_id")?; let sql = "SELECT t1_id, t1_name, t2_name FROM t1 JOIN t2 ON t1_id = t2_id AND t2_name >= 'y' ORDER BY t1_id"; - let actual = execute(&mut ctx, sql).await; - // let a = execute_to_batches(&mut ctx, sql).await; - // println!("{}", pretty_format_batches(&a).unwrap()); - let expected = vec![vec!["11", "a", "z"], vec!["22", "b", "y"]]; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + let expected = vec![ + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| 11 | a | z |", + "| 22 | b | y |", + "+-------+---------+---------+", + ]; + assert_batches_eq!(expected, &actual); Ok(()) } @@ -2130,15 +2133,18 @@ async fn equijoin_left_and_condition_from_right() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 LEFT JOIN t2 ON t1_id = t2_id AND t2_name >= 'y' ORDER BY t1_id"; let res = ctx.create_logical_plan(sql); assert!(res.is_ok()); - let actual = execute(&mut ctx, sql).await; - + let actual = execute_to_batches(&mut ctx, sql).await; let expected = vec![ - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["33", "c", "NULL"], - vec!["44", "d", "NULL"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| 11 | a | z |", + "| 22 | b | y |", + "| 33 | c | |", + "| 44 | d | |", + "+-------+---------+---------+", ]; - assert_eq!(expected, actual); + assert_batches_eq!(expected, &actual); Ok(()) } @@ -2150,16 +2156,18 @@ async fn equijoin_right_and_condition_from_left() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 RIGHT JOIN t2 ON t1_id = t2_id AND t1_id >= 22 ORDER BY t2_name"; let res = ctx.create_logical_plan(sql); assert!(res.is_ok()); - let actual = execute(&mut ctx, sql).await; - + let actual = execute_to_batches(&mut ctx, sql).await; let expected = vec![ - vec!["NULL", "NULL", "w"], - vec!["44", "d", "x"], - vec!["22", "b", "y"], - vec!["NULL", "NULL", "z"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| | | w |", + "| 44 | d | x |", + "| 22 | b | y |", + "| | | z |", + "+-------+---------+---------+", ]; - assert_eq!(expected, actual); - + assert_batches_eq!(expected, &actual); Ok(()) } @@ -2184,14 +2192,18 @@ async fn left_join() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 LEFT JOIN t2 ON t2_id = t1_id ORDER BY t1_id", ]; let expected = vec![ - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["33", "c", "NULL"], - vec!["44", "d", "x"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| 11 | a | z |", + "| 22 | b | y |", + "| 33 | c | |", + "| 44 | d | x |", + "+-------+---------+---------+", ]; for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } Ok(()) } @@ -2205,19 +2217,25 @@ async fn left_join_unbalanced() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 LEFT JOIN t2 ON t2_id = t1_id ORDER BY t1_id", ]; let expected = vec![ - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["33", "c", "NULL"], - vec!["44", "d", "x"], - vec!["77", "e", "NULL"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| 11 | a | z |", + "| 22 | b | y |", + "| 33 | c | |", + "| 44 | d | x |", + "| 77 | e | |", + "+-------+---------+---------+", ]; for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } Ok(()) } +// --- End Test Porting --- + #[tokio::test] async fn right_join() -> Result<()> { let mut ctx = create_join_context("t1_id", "t2_id")?; @@ -2233,6 +2251,8 @@ async fn right_join() -> Result<()> { ]; for sql in equivalent_sql.iter() { let actual = execute(&mut ctx, sql).await; + // let a = execute_to_batches(&mut ctx, sql).await; + // println!("{}", pretty_format_batches(&a).unwrap()); assert_eq!(expected, actual); } Ok(()) From 59b765964cc0ce01e3001a3925992d62e05639c7 Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Tue, 2 Nov 2021 12:40:45 -0400 Subject: [PATCH 7/8] More tests --- datafusion/tests/sql.rs | 58 ++++++++++++++++++++++++----------------- 1 file changed, 34 insertions(+), 24 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index 283db0a8a9aa..dc04c853e09b 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -29,7 +29,7 @@ extern crate datafusion; use arrow::{ array::*, datatypes::*, record_batch::RecordBatch, - util::display::array_value_to_string, util::pretty::pretty_format_batches, + util::display::array_value_to_string, }; use datafusion::assert_batches_eq; @@ -2244,16 +2244,18 @@ async fn right_join() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 RIGHT JOIN t2 ON t2_id = t1_id ORDER BY t1_id" ]; let expected = vec![ - vec!["NULL", "NULL", "w"], - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["44", "d", "x"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| | | w |", + "| 11 | a | z |", + "| 22 | b | y |", + "| 44 | d | x |", + "+-------+---------+---------+", ]; for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - // let a = execute_to_batches(&mut ctx, sql).await; - // println!("{}", pretty_format_batches(&a).unwrap()); - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } Ok(()) } @@ -2266,15 +2268,19 @@ async fn full_join() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 FULL JOIN t2 ON t2_id = t1_id ORDER BY t1_id", ]; let expected = vec![ - vec!["NULL", "NULL", "w"], - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["33", "c", "NULL"], - vec!["44", "d", "x"], + "+-------+---------+---------+", + "| t1_id | t1_name | t2_name |", + "+-------+---------+---------+", + "| | | w |", + "| 11 | a | z |", + "| 22 | b | y |", + "| 33 | c | |", + "| 44 | d | x |", + "+-------+---------+---------+", ]; for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } let equivalent_sql = [ @@ -2282,8 +2288,8 @@ async fn full_join() -> Result<()> { "SELECT t1_id, t1_name, t2_name FROM t1 FULL OUTER JOIN t2 ON t2_id = t1_id ORDER BY t1_id", ]; for sql in equivalent_sql.iter() { - let actual = execute(&mut ctx, sql).await; - assert_eq!(expected, actual); + let actual = execute_to_batches(&mut ctx, sql).await; + assert_batches_eq!(expected, &actual); } Ok(()) @@ -2293,14 +2299,18 @@ async fn full_join() -> Result<()> { async fn left_join_using() -> Result<()> { let mut ctx = create_join_context("id", "id")?; let sql = "SELECT id, t1_name, t2_name FROM t1 LEFT JOIN t2 USING (id) ORDER BY id"; - let actual = execute(&mut ctx, sql).await; + let actual = execute_to_batches(&mut ctx, sql).await; let expected = vec![ - vec!["11", "a", "z"], - vec!["22", "b", "y"], - vec!["33", "c", "NULL"], - vec!["44", "d", "x"], + "+----+---------+---------+", + "| id | t1_name | t2_name |", + "+----+---------+---------+", + "| 11 | a | z |", + "| 22 | b | y |", + "| 33 | c | |", + "| 44 | d | x |", + "+----+---------+---------+", ]; - assert_eq!(expected, actual); + assert_batches_eq!(expected, &actual); Ok(()) } From 7faeaf6be3490a9387fd12488cd73ab261032e3f Mon Sep 17 00:00:00 2001 From: Matthew Turner Date: Tue, 2 Nov 2021 12:42:00 -0400 Subject: [PATCH 8/8] Move tracker --- datafusion/tests/sql.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/datafusion/tests/sql.rs b/datafusion/tests/sql.rs index dc04c853e09b..9998fc1483aa 100644 --- a/datafusion/tests/sql.rs +++ b/datafusion/tests/sql.rs @@ -2234,8 +2234,6 @@ async fn left_join_unbalanced() -> Result<()> { Ok(()) } -// --- End Test Porting --- - #[tokio::test] async fn right_join() -> Result<()> { let mut ctx = create_join_context("t1_id", "t2_id")?; @@ -2314,6 +2312,8 @@ async fn left_join_using() -> Result<()> { Ok(()) } +// --- End Test Porting --- + #[tokio::test] async fn equijoin_implicit_syntax() -> Result<()> { let mut ctx = create_join_context("t1_id", "t2_id")?;