You are viewing a plain text version of this content. The canonical link for it is here.
Posted to github@arrow.apache.org by "avantgardnerio (via GitHub)" <gi...@apache.org> on 2023/02/24 19:29:22 UTC
[GitHub] [arrow-datafusion] avantgardnerio commented on a diff in pull request #5374: minor: port predicates tests to sqllogictests
avantgardnerio commented on code in PR #5374:
URL: https://github.com/apache/arrow-datafusion/pull/5374#discussion_r1117525690
##########
datafusion/core/tests/sql/predicates.rs:
##########
@@ -17,286 +17,6 @@
use super::*;
-#[tokio::test]
-async fn csv_query_with_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c12 FROM aggregate_test_100 WHERE c12 > 0.376 AND c12 < 0.4";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+---------------------+",
- "| c1 | c12 |",
- "+----+---------------------+",
- "| e | 0.39144436569161134 |",
- "| d | 0.38870280983958583 |",
- "+----+---------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negative_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c4 FROM aggregate_test_100 WHERE c3 < -55 AND -c4 > 30000";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+--------+",
- "| c1 | c4 |",
- "+----+--------+",
- "| e | -31500 |",
- "| c | -30187 |",
- "+----+--------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negated_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE NOT(c1 != 'a')";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 21 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_not_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NOT NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 100 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 0 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn query_where_neg_num() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
-
- // Negative numbers do not parse correctly as of Arrow 2.0.0
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+-------+",
- "| c7 | c8 |",
- "+----+-------+",
- "| 7 | 45465 |",
- "| 5 | 40622 |",
- "| 0 | 61069 |",
- "| 2 | 20120 |",
- "| 4 | 39363 |",
- "+----+-------+",
- ];
- assert_batches_eq!(expected, &actual);
-
- // Also check floating point neg numbers
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2.9 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
- let sql = "SELECT COUNT(c1) FROM aggregate_test_100 WHERE c13 LIKE '%FB%'";
- // check that the physical and logical schemas are equal
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+------------------------------+",
- "| COUNT(aggregate_test_100.c1) |",
- "+------------------------------+",
- "| 1 |",
- "+------------------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 BETWEEN 0.995 AND 1.0";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr_negated() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 NOT BETWEEN 0 AND 0.995";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_strings() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
Review Comment:
I don't see this one in the sqlogictest?
##########
datafusion/core/tests/sql/predicates.rs:
##########
@@ -17,286 +17,6 @@
use super::*;
-#[tokio::test]
-async fn csv_query_with_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c12 FROM aggregate_test_100 WHERE c12 > 0.376 AND c12 < 0.4";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+---------------------+",
- "| c1 | c12 |",
- "+----+---------------------+",
- "| e | 0.39144436569161134 |",
- "| d | 0.38870280983958583 |",
- "+----+---------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negative_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c4 FROM aggregate_test_100 WHERE c3 < -55 AND -c4 > 30000";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+--------+",
- "| c1 | c4 |",
- "+----+--------+",
- "| e | -31500 |",
- "| c | -30187 |",
- "+----+--------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negated_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE NOT(c1 != 'a')";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 21 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_not_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NOT NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 100 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 0 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn query_where_neg_num() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
-
- // Negative numbers do not parse correctly as of Arrow 2.0.0
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+-------+",
- "| c7 | c8 |",
- "+----+-------+",
- "| 7 | 45465 |",
- "| 5 | 40622 |",
- "| 0 | 61069 |",
- "| 2 | 20120 |",
- "| 4 | 39363 |",
- "+----+-------+",
- ];
- assert_batches_eq!(expected, &actual);
-
- // Also check floating point neg numbers
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2.9 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
- let sql = "SELECT COUNT(c1) FROM aggregate_test_100 WHERE c13 LIKE '%FB%'";
- // check that the physical and logical schemas are equal
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+------------------------------+",
- "| COUNT(aggregate_test_100.c1) |",
- "+------------------------------+",
- "| 1 |",
- "+------------------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 BETWEEN 0.995 AND 1.0";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr_negated() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 NOT BETWEEN 0 AND 0.995";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_strings() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c1 |",
- "+-------+",
- "| bar |",
- "| fazzz |",
- "+-------+",
- ];
-
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_string_dictionaries() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<DictionaryArray<Int32Type>>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
Review Comment:
Missing in sqllogictest?
##########
datafusion/core/tests/sql/predicates.rs:
##########
@@ -17,286 +17,6 @@
use super::*;
-#[tokio::test]
-async fn csv_query_with_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c12 FROM aggregate_test_100 WHERE c12 > 0.376 AND c12 < 0.4";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+---------------------+",
- "| c1 | c12 |",
- "+----+---------------------+",
- "| e | 0.39144436569161134 |",
- "| d | 0.38870280983958583 |",
- "+----+---------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negative_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c4 FROM aggregate_test_100 WHERE c3 < -55 AND -c4 > 30000";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+--------+",
- "| c1 | c4 |",
- "+----+--------+",
- "| e | -31500 |",
- "| c | -30187 |",
- "+----+--------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negated_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE NOT(c1 != 'a')";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 21 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_not_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NOT NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 100 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 0 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn query_where_neg_num() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
-
- // Negative numbers do not parse correctly as of Arrow 2.0.0
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+-------+",
- "| c7 | c8 |",
- "+----+-------+",
- "| 7 | 45465 |",
- "| 5 | 40622 |",
- "| 0 | 61069 |",
- "| 2 | 20120 |",
- "| 4 | 39363 |",
- "+----+-------+",
- ];
- assert_batches_eq!(expected, &actual);
-
- // Also check floating point neg numbers
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2.9 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
- let sql = "SELECT COUNT(c1) FROM aggregate_test_100 WHERE c13 LIKE '%FB%'";
- // check that the physical and logical schemas are equal
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+------------------------------+",
- "| COUNT(aggregate_test_100.c1) |",
- "+------------------------------+",
- "| 1 |",
- "+------------------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 BETWEEN 0.995 AND 1.0";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr_negated() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 NOT BETWEEN 0 AND 0.995";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_strings() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c1 |",
- "+-------+",
- "| bar |",
- "| fazzz |",
- "+-------+",
- ];
-
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_string_dictionaries() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<DictionaryArray<Int32Type>>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c1 |",
- "+-------+",
- "| bar |",
- "| fazzz |",
- "+-------+",
- ];
-
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn test_regexp_is_match() -> Result<()> {
- let input = vec![Some("foo"), Some("Barrr"), Some("Bazzz"), Some("ZZZZZ")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 ~ 'z'";
Review Comment:
Went missing?
##########
datafusion/core/tests/sql/predicates.rs:
##########
@@ -17,286 +17,6 @@
use super::*;
-#[tokio::test]
-async fn csv_query_with_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c12 FROM aggregate_test_100 WHERE c12 > 0.376 AND c12 < 0.4";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+---------------------+",
- "| c1 | c12 |",
- "+----+---------------------+",
- "| e | 0.39144436569161134 |",
- "| d | 0.38870280983958583 |",
- "+----+---------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negative_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c4 FROM aggregate_test_100 WHERE c3 < -55 AND -c4 > 30000";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+--------+",
- "| c1 | c4 |",
- "+----+--------+",
- "| e | -31500 |",
- "| c | -30187 |",
- "+----+--------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negated_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE NOT(c1 != 'a')";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 21 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_not_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NOT NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 100 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 0 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn query_where_neg_num() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
-
- // Negative numbers do not parse correctly as of Arrow 2.0.0
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+-------+",
- "| c7 | c8 |",
- "+----+-------+",
- "| 7 | 45465 |",
- "| 5 | 40622 |",
- "| 0 | 61069 |",
- "| 2 | 20120 |",
- "| 4 | 39363 |",
- "+----+-------+",
- ];
- assert_batches_eq!(expected, &actual);
-
- // Also check floating point neg numbers
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2.9 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
- let sql = "SELECT COUNT(c1) FROM aggregate_test_100 WHERE c13 LIKE '%FB%'";
- // check that the physical and logical schemas are equal
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+------------------------------+",
- "| COUNT(aggregate_test_100.c1) |",
- "+------------------------------+",
- "| 1 |",
- "+------------------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 BETWEEN 0.995 AND 1.0";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr_negated() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 NOT BETWEEN 0 AND 0.995";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_strings() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
Review Comment:
Oh, `c1` -> `column1`
##########
datafusion/core/tests/sql/predicates.rs:
##########
@@ -17,286 +17,6 @@
use super::*;
-#[tokio::test]
-async fn csv_query_with_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c12 FROM aggregate_test_100 WHERE c12 > 0.376 AND c12 < 0.4";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+---------------------+",
- "| c1 | c12 |",
- "+----+---------------------+",
- "| e | 0.39144436569161134 |",
- "| d | 0.38870280983958583 |",
- "+----+---------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negative_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c4 FROM aggregate_test_100 WHERE c3 < -55 AND -c4 > 30000";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+--------+",
- "| c1 | c4 |",
- "+----+--------+",
- "| e | -31500 |",
- "| c | -30187 |",
- "+----+--------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negated_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE NOT(c1 != 'a')";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 21 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_not_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NOT NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 100 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 0 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn query_where_neg_num() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
-
- // Negative numbers do not parse correctly as of Arrow 2.0.0
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+-------+",
- "| c7 | c8 |",
- "+----+-------+",
- "| 7 | 45465 |",
- "| 5 | 40622 |",
- "| 0 | 61069 |",
- "| 2 | 20120 |",
- "| 4 | 39363 |",
- "+----+-------+",
- ];
- assert_batches_eq!(expected, &actual);
-
- // Also check floating point neg numbers
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2.9 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
- let sql = "SELECT COUNT(c1) FROM aggregate_test_100 WHERE c13 LIKE '%FB%'";
- // check that the physical and logical schemas are equal
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+------------------------------+",
- "| COUNT(aggregate_test_100.c1) |",
- "+------------------------------+",
- "| 1 |",
- "+------------------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 BETWEEN 0.995 AND 1.0";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr_negated() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 NOT BETWEEN 0 AND 0.995";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_strings() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c1 |",
- "+-------+",
- "| bar |",
- "| fazzz |",
- "+-------+",
- ];
-
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_string_dictionaries() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<DictionaryArray<Int32Type>>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
Review Comment:
Oh, c1 -> column1
##########
datafusion/core/tests/sql/predicates.rs:
##########
@@ -17,286 +17,6 @@
use super::*;
-#[tokio::test]
-async fn csv_query_with_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c12 FROM aggregate_test_100 WHERE c12 > 0.376 AND c12 < 0.4";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+---------------------+",
- "| c1 | c12 |",
- "+----+---------------------+",
- "| e | 0.39144436569161134 |",
- "| d | 0.38870280983958583 |",
- "+----+---------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negative_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c1, c4 FROM aggregate_test_100 WHERE c3 < -55 AND -c4 > 30000";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+--------+",
- "| c1 | c4 |",
- "+----+--------+",
- "| e | -31500 |",
- "| c | -30187 |",
- "+----+--------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_negated_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE NOT(c1 != 'a')";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 21 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_not_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NOT NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 100 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_query_with_is_null_predicate() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT COUNT(1) FROM aggregate_test_100 WHERE c1 IS NULL";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-----------------+",
- "| COUNT(Int64(1)) |",
- "+-----------------+",
- "| 0 |",
- "+-----------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn query_where_neg_num() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
-
- // Negative numbers do not parse correctly as of Arrow 2.0.0
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+----+-------+",
- "| c7 | c8 |",
- "+----+-------+",
- "| 7 | 45465 |",
- "| 5 | 40622 |",
- "| 0 | 61069 |",
- "| 2 | 20120 |",
- "| 4 | 39363 |",
- "+----+-------+",
- ];
- assert_batches_eq!(expected, &actual);
-
- // Also check floating point neg numbers
- let sql = "select c7, c8 from aggregate_test_100 where c7 >= -2.9 and c7 < 10";
- let actual = execute_to_batches(&ctx, sql).await;
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv_by_sql(&ctx).await;
- let sql = "SELECT COUNT(c1) FROM aggregate_test_100 WHERE c13 LIKE '%FB%'";
- // check that the physical and logical schemas are equal
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+------------------------------+",
- "| COUNT(aggregate_test_100.c1) |",
- "+------------------------------+",
- "| 1 |",
- "+------------------------------+",
- ];
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 BETWEEN 0.995 AND 1.0";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn csv_between_expr_negated() -> Result<()> {
- let ctx = SessionContext::new();
- register_aggregate_csv(&ctx).await?;
- let sql = "SELECT c4 FROM aggregate_test_100 WHERE c12 NOT BETWEEN 0 AND 0.995";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c4 |",
- "+-------+",
- "| 10837 |",
- "+-------+",
- ];
- assert_batches_sorted_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_strings() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c1 |",
- "+-------+",
- "| bar |",
- "| fazzz |",
- "+-------+",
- ];
-
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn like_on_string_dictionaries() -> Result<()> {
- let input = vec![Some("foo"), Some("bar"), None, Some("fazzz")]
- .into_iter()
- .collect::<DictionaryArray<Int32Type>>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 LIKE '%a%'";
- let actual = execute_to_batches(&ctx, sql).await;
- let expected = vec![
- "+-------+",
- "| c1 |",
- "+-------+",
- "| bar |",
- "| fazzz |",
- "+-------+",
- ];
-
- assert_batches_eq!(expected, &actual);
- Ok(())
-}
-
-#[tokio::test]
-async fn test_regexp_is_match() -> Result<()> {
- let input = vec![Some("foo"), Some("Barrr"), Some("Bazzz"), Some("ZZZZZ")]
- .into_iter()
- .collect::<StringArray>();
-
- let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap();
-
- let ctx = SessionContext::new();
- ctx.register_batch("test", batch)?;
-
- let sql = "SELECT * FROM test WHERE c1 ~ 'z'";
Review Comment:
Oh, c1 -> column1
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org