|
5 | 5 | use std::collections::HashMap; |
6 | 6 | use std::hash::{Hash, Hasher}; |
7 | 7 | use std::sync::Arc; |
| 8 | +use std::sync::atomic::{AtomicUsize, Ordering}; |
8 | 9 |
|
9 | 10 | use arrow::array::{ |
10 | | - Array, ArrayRef, Float32Array, Float64Array, Int16Array, Int32Array, RecordBatch, |
11 | | - StringArray, builder::BooleanBuilder, cast::AsArray, |
| 11 | + Array, ArrayRef, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array, |
| 12 | + RecordBatch, StringArray, builder::BooleanBuilder, cast::AsArray, |
12 | 13 | }; |
13 | 14 | use arrow::array::{Int8Array, UInt64Array, as_string_array, create_array, record_batch}; |
14 | 15 | use arrow::compute::kernels::numeric::add; |
@@ -2341,3 +2342,95 @@ async fn test_extension_metadata_preserve_in_uncorrelated_scalar_subquery() -> R |
2341 | 2342 | assert!(!batches.is_empty()); |
2342 | 2343 | Ok(()) |
2343 | 2344 | } |
| 2345 | + |
| 2346 | +/// Volatile UDF that counts how many values it produces. |
| 2347 | +/// |
| 2348 | +/// Each row gets the next value of the shared counter, so the counter also |
| 2349 | +/// gives the number of rows that the function was evaluated for. |
| 2350 | +#[derive(Debug)] |
| 2351 | +struct CountingVolatileUdf { |
| 2352 | + signature: Signature, |
| 2353 | + rows_evaluated: Arc<AtomicUsize>, |
| 2354 | +} |
| 2355 | + |
| 2356 | +impl PartialEq for CountingVolatileUdf { |
| 2357 | + fn eq(&self, other: &Self) -> bool { |
| 2358 | + Arc::ptr_eq(&self.rows_evaluated, &other.rows_evaluated) |
| 2359 | + } |
| 2360 | +} |
| 2361 | + |
| 2362 | +impl Eq for CountingVolatileUdf {} |
| 2363 | + |
| 2364 | +impl Hash for CountingVolatileUdf { |
| 2365 | + fn hash<H: Hasher>(&self, state: &mut H) { |
| 2366 | + self.signature.hash(state); |
| 2367 | + } |
| 2368 | +} |
| 2369 | + |
| 2370 | +impl ScalarUDFImpl for CountingVolatileUdf { |
| 2371 | + fn name(&self) -> &str { |
| 2372 | + "counting_volatile" |
| 2373 | + } |
| 2374 | + |
| 2375 | + fn signature(&self) -> &Signature { |
| 2376 | + &self.signature |
| 2377 | + } |
| 2378 | + |
| 2379 | + fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> { |
| 2380 | + Ok(DataType::Int64) |
| 2381 | + } |
| 2382 | + |
| 2383 | + fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> { |
| 2384 | + let first = self |
| 2385 | + .rows_evaluated |
| 2386 | + .fetch_add(args.number_rows, Ordering::SeqCst) as i64; |
| 2387 | + let values = (0..args.number_rows as i64).map(|offset| first + offset); |
| 2388 | + Ok(ColumnarValue::Array(Arc::new( |
| 2389 | + Int64Array::from_iter_values(values), |
| 2390 | + ))) |
| 2391 | + } |
| 2392 | +} |
| 2393 | + |
| 2394 | +/// `BETWEEN` must evaluate a volatile value one time per row. |
| 2395 | +/// |
| 2396 | +/// See <https://github.com/apache/datafusion/issues/25457>. |
| 2397 | +#[tokio::test] |
| 2398 | +async fn between_evaluates_a_volatile_value_one_time_per_row() -> Result<()> { |
| 2399 | + let row_count = 100; |
| 2400 | + |
| 2401 | + for predicate in [ |
| 2402 | + "counting_volatile() BETWEEN 0 AND 1000000", |
| 2403 | + "counting_volatile() NOT BETWEEN 0 AND 1000000", |
| 2404 | + ] { |
| 2405 | + let rows_evaluated = Arc::new(AtomicUsize::new(0)); |
| 2406 | + let udf = ScalarUDF::from(CountingVolatileUdf { |
| 2407 | + signature: Signature::exact(vec![], Volatility::Volatile), |
| 2408 | + rows_evaluated: Arc::clone(&rows_evaluated), |
| 2409 | + }); |
| 2410 | + |
| 2411 | + let ctx = SessionContext::new_with_config( |
| 2412 | + SessionConfig::new().with_target_partitions(1), |
| 2413 | + ); |
| 2414 | + ctx.register_udf(udf); |
| 2415 | + ctx.register_batch( |
| 2416 | + "t", |
| 2417 | + RecordBatch::try_from_iter(vec![( |
| 2418 | + "a", |
| 2419 | + Arc::new(Int64Array::from_iter_values(0..row_count as i64)) as ArrayRef, |
| 2420 | + )])?, |
| 2421 | + )?; |
| 2422 | + |
| 2423 | + ctx.sql(&format!("SELECT a FROM t WHERE {predicate}")) |
| 2424 | + .await? |
| 2425 | + .collect() |
| 2426 | + .await?; |
| 2427 | + |
| 2428 | + let evaluated = rows_evaluated.load(Ordering::SeqCst); |
| 2429 | + assert_eq!( |
| 2430 | + evaluated, row_count, |
| 2431 | + "{predicate} evaluated the volatile value {evaluated} times for {row_count} rows" |
| 2432 | + ); |
| 2433 | + } |
| 2434 | + |
| 2435 | + Ok(()) |
| 2436 | +} |
0 commit comments