diff --git a/datafusion/core/tests/lolbench_aug.rs b/datafusion/core/tests/lolbench_aug.rs new file mode 100644 index 0000000..c665a88 --- /dev/null +++ b/datafusion/core/tests/lolbench_aug.rs @@ -0,0 +1,718 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Augmented suite (lolbench-aug). The requirement keeps literal values +//! working as plain scalars everywhere (the optional metadata is additive), +//! so every literal-producing and literal-consuming surface must keep its +//! observable behavior: SQL constant folding, scalar subqueries, grouping, +//! projections, unparsing, typed `lit` construction, table functions and +//! partition pruning. All scenarios run through the public SessionContext / +//! DataFrame / SQL surface. + +use std::sync::Arc; + +use arrow::array::{Int32Array, StringArray}; +use arrow::datatypes::{DataType, Field, Schema}; +use arrow::record_batch::RecordBatch; +use datafusion::assert_batches_eq; +use datafusion::error::Result; +use datafusion::prelude::*; +use datafusion::logical_expr::lit_with_metadata; + +/// The requirement makes literal expressions carry an optional metadata slot; +/// the public `Expr::Literal` variant therefore has the (value, metadata) +/// shape. Constructing it with an empty slot pins that public shape — and +/// makes every test in this binary compile-flip at pre-state, exactly like +/// the original suite's updated test files. +fn plain_literal_expr(v: i64) -> Expr { + Expr::Literal(datafusion::scalar::ScalarValue::Int64(Some(v)), None) +} + +async fn ctx_with_table() -> Result { + let ctx = SessionContext::new(); + let schema = Arc::new(Schema::new(vec![ + Field::new("k", DataType::Int32, false), + Field::new("v", DataType::Int32, false), + Field::new("s", DataType::Utf8, false), + ])); + let batch = RecordBatch::try_new( + schema.clone(), + vec![ + Arc::new(Int32Array::from(vec![1, 1, 2])), + Arc::new(Int32Array::from(vec![10, 20, 30])), + Arc::new(StringArray::from(vec!["prefix_a", "prefix_b", "other"])), + ], + )?; + ctx.register_batch("t1", batch)?; + let schema2 = Arc::new(Schema::new(vec![ + Field::new("k", DataType::Int32, false), + Field::new("y", DataType::Int32, false), + ])); + let batch2 = RecordBatch::try_new( + schema2.clone(), + vec![ + Arc::new(Int32Array::from(vec![1, 2])), + Arc::new(Int32Array::from(vec![100, 200])), + ], + )?; + ctx.register_batch("t2", batch2)?; + Ok(ctx) +} + +async fn sql_rows(ctx: &SessionContext, q: &str) -> Result> { + // Literal-shape guard (see plain_literal_expr): lit(v) must produce the + // same expression as the public two-slot literal with an empty slot. + assert_eq!(plain_literal_expr(7), lit(7i64)); + ctx.sql(q).await?.collect().await +} + +#[tokio::test] +async fn aug_string_function_literal_folding() -> Result<()> { + let ctx = ctx_with_table().await?; + let batches = sql_rows( + &ctx, + "SELECT concat('a', '', 'b') AS c1, \ + concat_ws(',', 'x', NULL, 'y') AS c2, \ + concat('p:', s) AS c3, \ + starts_with(s, 'prefix_') AS c4 \ + FROM t1 ORDER BY v LIMIT 1", + ) + .await?; + assert_batches_eq!( + [ + "+----+-----+------------+------+", + "| c1 | c2 | c3 | c4 |", + "+----+-----+------------+------+", + "| ab | x,y | p:prefix_a | true |", + "+----+-----+------------+------+", + ], + &batches + ); + Ok(()) +} + +#[tokio::test] +async fn aug_math_datetime_and_cast_folding() -> Result<()> { + let ctx = ctx_with_table().await?; + let batches = sql_rows( + &ctx, + "SELECT power(2, 10) AS p, \ + log(2, 8) AS l, \ + arrow_cast('41', 'Int32') + 1 AS ac, \ + substring('hello world', 7, 5) AS sub, \ + current_date() = current_date() AS cd, \ + current_time() = current_time() AS ct", + ) + .await?; + assert_batches_eq!( + [ + "+------+-----+----+-------+------+------+", + "| p | l | ac | sub | cd | ct |", + "+------+-----+----+-------+------+------+", + "| 1024 | 3.0 | 42 | world | true | true |", + "+------+-----+----+-------+------+------+", + ], + &batches + ); + Ok(()) +} + +#[tokio::test] +async fn aug_scalar_subqueries_decorrelate() -> Result<()> { + let ctx = ctx_with_table().await?; + // Correlated scalar subquery in WHERE (decorrelated to a join). + let correlated = sql_rows( + &ctx, + "SELECT k, v FROM t1 \ + WHERE v < (SELECT max(y) FROM t2 WHERE t2.k = t1.k) \ + ORDER BY v", + ) + .await?; + assert_batches_eq!( + [ + "+---+----+", + "| k | v |", + "+---+----+", + "| 1 | 10 |", + "| 1 | 20 |", + "| 2 | 30 |", + "+---+----+", + ], + &correlated + ); + // Uncorrelated scalar subquery in the projection. + let uncorrelated = sql_rows( + &ctx, + "SELECT v, (SELECT max(y) FROM t2) AS gmax FROM t1 ORDER BY v LIMIT 1", + ) + .await?; + assert_batches_eq!( + [ + "+----+------+", + "| v | gmax |", + "+----+------+", + "| 10 | 200 |", + "+----+------+", + ], + &uncorrelated + ); + Ok(()) +} + +#[tokio::test] +async fn aug_grouping_sets_and_grouping_function() -> Result<()> { + let ctx = ctx_with_table().await?; + let batches = sql_rows( + &ctx, + "SELECT k, grouping(k) AS g, count(*) AS c \ + FROM t1 GROUP BY GROUPING SETS ((k), ()) \ + ORDER BY g, k NULLS LAST", + ) + .await?; + assert_batches_eq!( + [ + "+---+---+---+", + "| k | g | c |", + "+---+---+---+", + "| 1 | 0 | 2 |", + "| 2 | 0 | 1 |", + "| | 1 | 3 |", + "+---+---+---+", + ], + &batches + ); + Ok(()) +} + +#[tokio::test] +async fn aug_plan_eliminations_with_constant_predicates() -> Result<()> { + let ctx = ctx_with_table().await?; + // eliminate_filter (WHERE true / WHERE false), eliminate_group_by_constant, + // optimize_projections over a constant-rich projection. + let all = sql_rows(&ctx, "SELECT v FROM t1 WHERE true ORDER BY v").await?; + assert_eq!(all[0].num_rows(), 3); + let none = sql_rows(&ctx, "SELECT v FROM t1 WHERE 1 = 0").await?; + assert!(none.is_empty() || none.iter().all(|b| b.num_rows() == 0)); + let grouped = sql_rows( + &ctx, + "SELECT 'const' AS tag, k, sum(v) AS sv FROM t1 GROUP BY 'const', k ORDER BY k", + ) + .await?; + assert_batches_eq!( + [ + "+-------+---+----+", + "| tag | k | sv |", + "+-------+---+----+", + "| const | 1 | 30 |", + "| const | 2 | 30 |", + "+-------+---+----+", + ], + &grouped + ); + let pruned = sql_rows( + &ctx, + "SELECT a + 1 AS b FROM (SELECT v AS a, k AS unused, 99 AS dead FROM t1) ORDER BY b LIMIT 1", + ) + .await?; + assert_batches_eq!( + ["+----+", "| b |", "+----+", "| 11 |", "+----+",], + &pruned + ); + Ok(()) +} + +#[tokio::test] +async fn aug_boolean_inlist_between_and_case_simplification() -> Result<()> { + let ctx = ctx_with_table().await?; + let batches = sql_rows( + &ctx, + "SELECT v FROM t1 \ + WHERE v IN (10, 20, 30, 10) \ + AND v BETWEEN 0 AND 100 \ + AND (true OR k = 5) \ + AND CASE WHEN 1 = 1 THEN true ELSE false END \ + AND s ~ '^prefix_a$' IS NOT NULL \ + AND coalesce(NULL, true) \ + ORDER BY v", + ) + .await?; + assert_batches_eq!( + [ + "+----+", "| v |", "+----+", "| 10 |", "| 20 |", "| 30 |", "+----+", + ], + &batches + ); + // guarantees: a second predicate already implied by the first. + let g = sql_rows(&ctx, "SELECT v FROM t1 WHERE v > 5 AND v > 5 AND v >= 10 ORDER BY v LIMIT 1").await?; + assert_eq!(g[0].num_rows(), 1); + Ok(()) +} + +#[tokio::test] +async fn aug_typed_literals_through_dataframe_api() -> Result<()> { + let ctx = ctx_with_table().await?; + let df = ctx.table("t1").await?; + let projected = df + .select(vec![ + lit(1i8).alias("c_i8"), + lit(2i16).alias("c_i16"), + lit(3i32).alias("c_i32"), + lit(4i64).alias("c_i64"), + lit(5u8).alias("c_u8"), + lit(6u16).alias("c_u16"), + lit(7u32).alias("c_u32"), + lit(8u64).alias("c_u64"), + lit(1.5f32).alias("c_f32"), + lit(2.5f64).alias("c_f64"), + lit("str").alias("c_str"), + lit(String::from("string")).alias("c_string"), + lit(true).alias("c_bool"), + lit(Vec::::from([1u8, 2u8])).alias("c_bin"), + ])? + .limit(0, Some(1))?; + // expr_schema: literal types and nullability flow into the schema. + let schema = projected.schema().clone(); + assert_eq!(schema.field_with_unqualified_name("c_i8")?.data_type(), &DataType::Int8); + assert_eq!(schema.field_with_unqualified_name("c_u64")?.data_type(), &DataType::UInt64); + assert_eq!(schema.field_with_unqualified_name("c_str")?.data_type(), &DataType::Utf8); + let batches = projected.collect().await?; + assert_eq!(batches[0].num_rows(), 1); + assert_eq!(batches[0].num_columns(), 14); + Ok(()) +} + +#[tokio::test] +async fn aug_count_star_table_functions_and_struct_access() -> Result<()> { + let ctx = ctx_with_table().await?; + // DataFrame::count goes through count(Literal(COUNT_STAR_EXPANSION)). + let n = ctx.table("t1").await?.count().await?; + assert_eq!(n, 3); + let gs = sql_rows(&ctx, "SELECT * FROM generate_series(1, 3)").await?; + let total: usize = gs.iter().map(|b| b.num_rows()).sum(); + assert_eq!(total, 3); + let batches = sql_rows( + &ctx, + "SELECT struct(1 AS a, 'x' AS b)['a'] AS field, \ + array_has([1, 2, 3], 2) AS has2, \ + count(1) AS c1 \ + FROM t1", + ) + .await?; + assert_batches_eq!( + [ + "+-------+------+----+", + "| field | has2 | c1 |", + "+-------+------+----+", + "| 1 | true | 3 |", + "+-------+------+----+", + ], + &batches + ); + Ok(()) +} + +#[tokio::test] +async fn aug_window_functions_with_literal_arguments() -> Result<()> { + let ctx = ctx_with_table().await?; + let batches = sql_rows( + &ctx, + "SELECT v, row_number() OVER (ORDER BY v) AS rn, \ + nth_value(v, 2) OVER (ORDER BY v ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS nth \ + FROM t1 ORDER BY v", + ) + .await?; + assert_batches_eq!( + [ + "+----+----+-----+", + "| v | rn | nth |", + "+----+----+-----+", + "| 10 | 1 | 20 |", + "| 20 | 2 | 20 |", + "| 30 | 3 | 20 |", + "+----+----+-----+", + ], + &batches + ); + Ok(()) +} + +#[tokio::test] +async fn aug_decimal_null_and_negative_literals_parse() -> Result<()> { + // parse_float_as_decimal drives the SQL decimal literal construction paths. + let config = SessionConfig::new().set_str("datafusion.sql_parser.parse_float_as_decimal", "true"); + let ctx = SessionContext::new_with_config(config); + let batches = sql_rows( + &ctx, + "SELECT 12.345 AS dec_small, \ + CAST(NULL AS INT) AS null_lit, \ + -42 AS neg, \ + 12345678901234567890123456789012345678.5 AS dec_big", + ) + .await?; + assert_eq!(batches[0].num_rows(), 1); + let schema = batches[0].schema(); + assert!(matches!(schema.field(0).data_type(), DataType::Decimal128(_, _))); + assert!(matches!(schema.field(3).data_type(), DataType::Decimal256(_, _))); + Ok(()) +} + +#[tokio::test] +async fn aug_unparser_roundtrips_literal_plans() -> Result<()> { + use datafusion::sql::unparser::plan_to_sql; + let ctx = ctx_with_table().await?; + let df = ctx + .sql( + "SELECT k, sum(v) AS sv, row_number() OVER (ORDER BY k) AS rn \ + FROM t1 WHERE v > 5 AND s LIKE 'prefix%' GROUP BY k, v, s ORDER BY k LIMIT 2", + ) + .await?; + let plan = df.logical_plan().clone(); + let sql = plan_to_sql(&plan)?.to_string(); + assert!(sql.contains("5"), "unparsed SQL keeps the literal: {sql}"); + assert!(sql.to_lowercase().contains("limit"), "{sql}"); + // Round-trip: the unparsed SQL must execute to the same shape. + let again = ctx.sql(&sql).await?.collect().await?; + let rows: usize = again.iter().map(|b| b.num_rows()).sum(); + assert_eq!(rows, 2); + Ok(()) +} + +#[tokio::test] +async fn aug_literal_metadata_flows_to_schema_and_execution() -> Result<()> { + use std::collections::HashMap; + use datafusion::scalar::ScalarValue; + + let ctx = ctx_with_table().await?; + let lit_md = lit_with_metadata( + ScalarValue::Int32(Some(7)), + HashMap::from([("purpose".to_string(), "lolbench".to_string())]), + ); + + // The literal's metadata must surface on the logical output field... + let df = ctx.table("t1").await?.select(vec![lit_md.clone().alias("c")])?; + let field = df.schema().field_with_unqualified_name("c")?; + assert_eq!(field.metadata().get("purpose").map(String::as_str), Some("lolbench")); + + // ...and survive optimization + physical planning into execution output. + let batches = df.collect().await?; + assert_eq!( + batches[0].schema().field(0).metadata().get("purpose").map(String::as_str), + Some("lolbench") + ); + + // An alias carrying its own metadata merges it with the literal's — on the + // logical schema AND through the physical planner into execution output. + let Expr::Alias(mut alias) = lit_md.alias("c2") else { unreachable!() }; + alias.metadata = Some(HashMap::from([("origin".to_string(), "alias".to_string())])); + let df2 = ctx.table("t1").await?.select(vec![Expr::Alias(alias)])?; + let field2 = df2.schema().field_with_unqualified_name("c2")?; + assert_eq!(field2.metadata().get("origin").map(String::as_str), Some("alias")); + assert_eq!(field2.metadata().get("purpose").map(String::as_str), Some("lolbench")); + let batches2 = df2.collect().await?; + let exec_field2 = batches2[0].schema(); + let exec_field2 = exec_field2.field(0); + assert_eq!(exec_field2.metadata().get("origin").map(String::as_str), Some("alias")); + assert_eq!(exec_field2.metadata().get("purpose").map(String::as_str), Some("lolbench")); + Ok(()) +} + +#[tokio::test] +async fn aug_literal_metadata_reaches_scalar_udf_return_field() -> Result<()> { + use std::any::Any; + use std::collections::HashMap; + use arrow::datatypes::FieldRef; + use datafusion::logical_expr::{ + ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDF, ScalarUDFImpl, + Signature, Volatility, + }; + use datafusion::scalar::ScalarValue; + + // A probe function that republishes its first argument's field metadata on + // its return field — the requirement's "when return_field_from_args gets + // called, the metadata would be available" contract. + #[derive(Debug)] + struct MetadataProbe { + signature: Signature, + } + impl ScalarUDFImpl for MetadataProbe { + fn as_any(&self) -> &dyn Any { + self + } + fn name(&self) -> &str { + "aug_metadata_probe" + } + fn signature(&self) -> &Signature { + &self.signature + } + fn return_type(&self, _args: &[DataType]) -> Result { + Ok(DataType::Int32) + } + fn return_field_from_args(&self, args: ReturnFieldArgs) -> Result { + let metadata = args.arg_fields[0].metadata().clone(); + Ok(Arc::new( + Field::new(self.name(), DataType::Int32, true).with_metadata(metadata), + )) + } + fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result { + Ok(args.args[0].clone()) + } + } + + let ctx = ctx_with_table().await?; + let probe = ScalarUDF::from(MetadataProbe { + signature: Signature::exact(vec![DataType::Int32], Volatility::Immutable), + }); + let arg = lit_with_metadata( + ScalarValue::Int32(Some(7)), + HashMap::from([("purpose".to_string(), "lolbench".to_string())]), + ); + let expr = probe.call(vec![arg]).alias("p"); + + let df = ctx.table("t1").await?.select(vec![expr])?; + let field = df.schema().field_with_unqualified_name("p")?; + assert_eq!(field.metadata().get("purpose").map(String::as_str), Some("lolbench")); + // The physical literal's field metadata must reach the physical scalar + // function's return field and survive into the executed output schema. + let batches = df.collect().await?; + assert_eq!(batches[0].num_rows(), 3); + let exec_schema = batches[0].schema(); + assert_eq!( + exec_schema.field(0).metadata().get("purpose").map(String::as_str), + Some("lolbench") + ); + Ok(()) +} + +#[tokio::test] +async fn aug_metadata_literals_drive_rewrites_and_functions() -> Result<()> { + use std::collections::HashMap; + use datafusion::functions::expr_fn::{concat, concat_ws, log, power, starts_with}; + use datafusion::functions_aggregate::expr_fn::count; + use datafusion::functions_nested::expr_fn::{array_has, make_array}; + use datafusion::scalar::ScalarValue; + + fn md_lit(sv: ScalarValue) -> Expr { + lit_with_metadata( + sv, + HashMap::from([("purpose".to_string(), "lolbench".to_string())]), + ) + } + + let ctx = ctx_with_table().await?; + let t = ctx.table("t1").await?; + + // Metadata-bearing literals flowing through the simplifier's function + // rewrites and scalar-evaluation arms: every projected expression must + // still evaluate to its plain-literal result. + let df = t.clone().select(vec![ + concat(vec![md_lit(ScalarValue::from("p:")), col("s")]).alias("e1"), + concat_ws(md_lit(ScalarValue::from(",")), vec![md_lit(ScalarValue::from("x")), col("s")]).alias("e2"), + starts_with(col("s"), md_lit(ScalarValue::from("prefix_"))).alias("e3"), + power(md_lit(ScalarValue::Float64(Some(2.0))), cast(col("v"), DataType::Float64)).alias("e4"), + log(md_lit(ScalarValue::Float64(Some(2.0))), cast(col("v"), DataType::Float64)).alias("e5"), + array_has(make_array(vec![md_lit(ScalarValue::Int32(Some(1))), md_lit(ScalarValue::Int32(Some(2)))]), col("k")).alias("e6"), + md_lit(ScalarValue::Int32(Some(5))).between(md_lit(ScalarValue::Int32(Some(1))), md_lit(ScalarValue::Int32(Some(9)))).alias("e7"), + col("v").in_list(vec![md_lit(ScalarValue::Int32(Some(10))), md_lit(ScalarValue::Int32(Some(20)))], false).alias("e8"), + (md_lit(ScalarValue::Int32(Some(2))) + md_lit(ScalarValue::Int32(Some(3)))).alias("e9"), + md_lit(ScalarValue::from("foo")).like(md_lit(ScalarValue::from("f%"))).alias("e10"), + ])?; + let batches = df.collect().await?; + assert_eq!(batches[0].num_rows(), 3); + + // A filter mixing metadata literals with guaranteed-true predicates keeps + // its plain semantics through the boolean simplifier. + let filtered = t + .clone() + .filter( + col("v") + .gt(md_lit(ScalarValue::Int32(Some(5)))) + .and(md_lit(ScalarValue::Boolean(Some(true)))) + .and(col("v").gt(md_lit(ScalarValue::Int32(Some(5))))), + )? + .select(vec![col("v")])?; + let fb = filtered.collect().await?; + let rows: usize = fb.iter().map(|b| b.num_rows()).sum(); + assert_eq!(rows, 3); + + // Aggregation with a metadata-literal count argument. + let agg = t + .clone() + .aggregate(vec![col("k")], vec![count(md_lit(ScalarValue::Int32(Some(1)))).alias("c")])? + .sort(vec![col("k").sort(true, true)])?; + let ab = agg.collect().await?; + let total: i64 = ab + .iter() + .flat_map(|b| { + let arr = b.column(1).as_any().downcast_ref::().unwrap(); + (0..arr.len()).map(|i| arr.value(i)).collect::>() + }) + .sum(); + assert_eq!(total, 3); + Ok(()) +} + +#[tokio::test] +async fn aug_typed_identity_arms_and_const_lists_simplify() -> Result<()> { + let ctx = ctx_with_table().await?; + // Multiply/add/power identity arms are matched per literal type; a literal + // on the left of a comparison takes the operand-swap arm; fully-literal + // array constructions const-evaluate to (Large)List scalars. + let batches = sql_rows( + &ctx, + "SELECT v * CAST(0 AS BIGINT UNSIGNED) AS z_u64, \ + CAST(v AS FLOAT) + CAST(0.0 AS FLOAT) AS z_f32, \ + CAST(v AS DOUBLE) * CAST(1.0 AS DOUBLE) AS one_f64, \ + v * CAST(1.0 AS DECIMAL(5,2)) AS one_dec, \ + v + CAST(0 AS DECIMAL(5,2)) AS z_dec, \ + power(CAST(v AS DOUBLE), 0) AS pow_zero, \ + power(CAST(v AS DOUBLE), 1) AS pow_one, \ + log(2.0, CAST(1 AS DOUBLE)) AS log_one, \ + [1, 2, 3] AS const_list, \ + arrow_cast([1, 2], 'LargeList(Int64)') AS const_large, \ + 5 < v AS lit_left, \ + (v > 5) IS NOT UNKNOWN AS not_unknown \ + FROM t1 ORDER BY v LIMIT 1", + ) + .await?; + assert_eq!(batches[0].num_rows(), 1); + let mixed = sql_rows( + &ctx, + "SELECT concat(arrow_cast('a', 'LargeUtf8'), s, arrow_cast('', 'Utf8View'), arrow_cast(NULL, 'LargeUtf8')) AS c1, \ + concat_ws(',', arrow_cast('x', 'Utf8View'), arrow_cast(NULL, 'Utf8'), arrow_cast('y', 'LargeUtf8'), s) AS c2 \ + FROM t1 ORDER BY v LIMIT 1", + ) + .await?; + assert_eq!(mixed[0].num_rows(), 1); + // Layered redundant range/IN predicates drive the guarantee rewriter. + let g = sql_rows( + &ctx, + "SELECT v FROM t1 WHERE v BETWEEN 1 AND 100 AND v BETWEEN 1 AND 100 \ + AND v IN (10, 20, 30) AND v IN (10, 20, 30) AND s ~ '^prefix_a$' IS NOT NULL ORDER BY v", + ) + .await?; + let rows: usize = g.iter().map(|b| b.num_rows()).sum(); + assert_eq!(rows, 3); + Ok(()) +} + +#[tokio::test] +async fn aug_planner_sql_and_unparser_literal_paths() -> Result<()> { + use datafusion::sql::unparser::plan_to_sql; + let ctx = ctx_with_table().await?; + + // count(*) expansions: aggregate and windowed; correlated COUNT scalar + // subquery takes the null-to-zero decorrelation arm; empty-input scalar + // subquery takes the NULL else arm; JOIN ON false is eliminated. + let batches = sql_rows( + &ctx, + "SELECT k, count(*) AS c, count(*) OVER () AS cw, \ + (SELECT count(*) FROM t2 WHERE t2.k = t1.k AND t2.y > 1000) AS zero_cnt, \ + (SELECT max(y) FROM t2 WHERE false) AS none_max \ + FROM t1 GROUP BY k, v ORDER BY k, v", + ) + .await?; + assert_eq!(batches.iter().map(|b| b.num_rows()).sum::(), 3); + let joined = sql_rows(&ctx, "SELECT t1.v FROM t1 JOIN t2 ON false").await?; + assert!(joined.is_empty() || joined.iter().all(|b| b.num_rows() == 0)); + + // grouping() over a plain GROUP BY takes the zero-literal arm. + let grouped = sql_rows(&ctx, "SELECT k, grouping(k) AS g FROM t1 GROUP BY k ORDER BY k").await?; + assert_eq!(grouped.iter().map(|b| b.num_rows()).sum::(), 2); + + // Placeholder parameters replace into plain literals; literal-typed NULL + // VALUES rows are back-filled; LIMIT folds a constant expression; + // FROM-only substring; intervals; now(); coalesce; lag/lead offsets. + let df = ctx + .sql("SELECT $1 + v AS pv FROM t1 ORDER BY v LIMIT 1") + .await? + .with_param_values(vec![datafusion::scalar::ScalarValue::Int32(Some(100))])?; + assert_eq!(df.collect().await?[0].num_rows(), 1); + let misc = sql_rows( + &ctx, + "SELECT a FROM (VALUES (NULL), (7)) AS vt(a) ORDER BY a NULLS FIRST LIMIT 1 + 1", + ) + .await?; + assert_eq!(misc.iter().map(|b| b.num_rows()).sum::(), 2); + let exprs = sql_rows( + &ctx, + "SELECT substring('hello' FROM 2) AS sub, \ + INTERVAL '1' YEAR AS iy, INTERVAL '2' DAY AS idt, INTERVAL '1 month 1 day 1 second' AS imdn, \ + now() <= now() AS nw, coalesce(NULL, 5) AS co, \ + lag(v, 2) OVER (ORDER BY v) AS lg, lead(v, 1) OVER (ORDER BY v) AS ld, \ + struct(1 AS a, 'x' AS b)['a'] AS brfield \ + FROM t1 ORDER BY v", + ) + .await?; + assert_eq!(exprs.iter().map(|b| b.num_rows()).sum::(), 3); + let gs_null = sql_rows(&ctx, "SELECT * FROM generate_series(1, NULL)").await?; + assert_eq!(gs_null.iter().map(|b| b.num_rows()).sum::(), 0); + + // Unparse plans exercising date_part/date_trunc, struct-field access and + // window functions; the unparsed SQL must execute again. + let df2 = ctx + .sql( + "SELECT date_part('year', now()) AS yr, date_trunc('day', now()) AS dy, \ + row_number() OVER (ORDER BY v) AS rn \ + FROM t1", + ) + .await?; + let plan = df2.logical_plan().clone(); + let sql = plan_to_sql(&plan)?.to_string(); + let again = ctx.sql(&sql).await?.collect().await?; + assert_eq!(again.iter().map(|b| b.num_rows()).sum::(), 3); + Ok(()) +} + +#[tokio::test] +async fn aug_partitioned_listing_table_pruning() -> Result<()> { + use std::fs; + let tmp = std::env::temp_dir().join("lolbench_aug_part"); + let _ = fs::remove_dir_all(&tmp); + fs::create_dir_all(tmp.join("part=1"))?; + fs::create_dir_all(tmp.join("part=2"))?; + fs::write(tmp.join("part=1/a.csv"), "x\n10\n20\n")?; + fs::write(tmp.join("part=2/a.csv"), "x\n30\n")?; + let ctx = SessionContext::new(); + ctx.sql(&format!( + "CREATE EXTERNAL TABLE pt (x INT) STORED AS CSV PARTITIONED BY (part INT) \ + LOCATION '{}' OPTIONS ('format.has_header' 'true')", + tmp.display() + )) + .await? + .collect() + .await?; + let batches = ctx + .sql("SELECT x FROM pt WHERE part = 1 ORDER BY x") + .await? + .collect() + .await?; + assert_batches_eq!( + ["+----+", "| x |", "+----+", "| 10 |", "| 20 |", "+----+",], + &batches + ); + // Literal-on-the-left partition predicate takes the swapped match arm. + let swapped = ctx + .sql("SELECT x FROM pt WHERE 2 = part ORDER BY x") + .await? + .collect() + .await?; + assert_batches_eq!( + ["+----+", "| x |", "+----+", "| 30 |", "+----+",], + &swapped + ); + Ok(()) +} diff --git a/datafusion/core/tests/lolbench_aug_p2p.rs b/datafusion/core/tests/lolbench_aug_p2p.rs new file mode 100644 index 0000000..4b6813d --- /dev/null +++ b/datafusion/core/tests/lolbench_aug_p2p.rs @@ -0,0 +1,72 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Augmented suite (lolbench-aug, P2P). The requirement adds an optional +//! metadata slot to literals; everything that does not involve metadata must +//! behave exactly as before. These tests pin adjacent unchanged behaviors +//! (string functions and arithmetic untouched by the change) and deliberately +//! avoid the new literal shape so they compile and pass at pre-state. + +use datafusion::assert_batches_eq; +use datafusion::error::Result; +use datafusion::prelude::*; + +#[tokio::test] +async fn aug_p2p_unmodified_string_functions_keep_behavior() -> Result<()> { + let ctx = SessionContext::new(); + let batches = ctx + .sql("SELECT upper('ab') AS u, lower('CD') AS l, trim(' x ') AS t, length('abcd') AS n") + .await? + .collect() + .await?; + assert_batches_eq!( + [ + "+----+----+---+---+", + "| u | l | t | n |", + "+----+----+---+---+", + "| AB | cd | x | 4 |", + "+----+----+---+---+", + ], + &batches + ); + Ok(()) +} + +#[tokio::test] +async fn aug_p2p_arithmetic_and_ordering_keep_behavior() -> Result<()> { + let ctx = SessionContext::new(); + let batches = ctx + .sql( + "SELECT a, a * 2 AS d FROM (VALUES (3), (1), (2)) AS v(a) ORDER BY a DESC", + ) + .await? + .collect() + .await?; + assert_batches_eq!( + [ + "+---+---+", + "| a | d |", + "+---+---+", + "| 3 | 6 |", + "| 2 | 4 |", + "| 1 | 2 |", + "+---+---+", + ], + &batches + ); + Ok(()) +} diff --git a/datafusion/proto/tests/lolbench_aug.rs b/datafusion/proto/tests/lolbench_aug.rs new file mode 100644 index 0000000..419d87a --- /dev/null +++ b/datafusion/proto/tests/lolbench_aug.rs @@ -0,0 +1,41 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Augmented suite (lolbench-aug): literal expressions must survive the +//! protobuf logical-plan round trip unchanged, through the public bytes API. + +use datafusion::prelude::*; +use datafusion_proto::bytes::{logical_plan_from_bytes, logical_plan_to_bytes}; + +#[tokio::test] +async fn aug_literals_roundtrip_through_proto() -> datafusion::error::Result<()> { + // Literal-shape guard: the public Expr::Literal carries (value, metadata); + // compile-flips this binary at pre-state like the original suite files. + assert_eq!( + Expr::Literal(datafusion::scalar::ScalarValue::Int64(Some(7)), None), + lit(7i64) + ); + let ctx = SessionContext::new(); + let df = ctx + .sql("SELECT 1 AS i, 2.5 AS f, 'txt' AS s, true AS b, CAST(NULL AS INT) AS n") + .await?; + let plan = df.logical_plan().clone(); + let bytes = logical_plan_to_bytes(&plan)?; + let restored = logical_plan_from_bytes(&bytes, &ctx)?; + assert_eq!(format!("{plan}"), format!("{restored}")); + Ok(()) +}