mbutrovich opened a new issue, #26948:
URL: https://github.com/apache/datafusion/issues/26948

   # `repeat` on `LargeUtf8` aborts the process on a result size no allocation 
can satisfy
   
   ### Describe the bug
   
   `repeat` caps the result at `i32::MAX` bytes for `Utf8` and `Utf8View`, and 
returns an error above that. For `LargeUtf8` the cap is `i64::MAX`, in both the 
[scalar 
path](https://github.com/apache/datafusion/blob/926901f9001977e85df617b96328801b42f6af4a/datafusion/functions/src/string/repeat.rs#L127-L128)
 and the [array 
path](https://github.com/apache/datafusion/blob/926901f9001977e85df617b96328801b42f6af4a/datafusion/functions/src/string/repeat.rs#L227-L228).
 That cap admits sizes no allocation can satisfy. A result of 2^60 bytes (1 
EiB) is larger than the virtual address space of x86_64 (48 or 57 bits) and 
aarch64 (at most 52 bits), so the allocator refuses it at once, whatever memory 
the machine has:
   
   - With both arguments scalar, 
[`s.repeat(count)`](https://github.com/apache/datafusion/blob/926901f9001977e85df617b96328801b42f6af4a/datafusion/functions/src/string/repeat.rs#L167)
 cannot fail gracefully, so the refused allocation aborts the process: `memory 
allocation of 1152921504606846976 bytes failed`.
   - With an array of strings, the builder panics: `failed to allocate memory 
for layout Layout { size: 1152921504606846976, align: 64 (1 << 6) }`.
   
   The existing `test_repeat_string_array_overflow` uses a count of `i64::MAX`, 
which the overflow check catches before any allocation.
   
   ### To Reproduce
   
   On `main` at 926901f90:
   
   ```rust
   use std::sync::Arc;
   
   use arrow::datatypes::Field;
   use datafusion_common::ScalarValue;
   use datafusion_common::config::ConfigOptions;
   use datafusion_expr::{ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs};
   use datafusion_functions::string::repeat;
   
   let udf = repeat();
   let s = ScalarValue::LargeUtf8(Some("a".to_string()));
   // With ScalarValue::Utf8: Err(Execution("string size overflow on repeat, 
max size is 2147483647, but got 1152921504606846976"))
   let n = ScalarValue::Int64(Some(1 << 60));
   let arg_fields = vec![
       Arc::new(Field::new("s", s.data_type(), true)),
       Arc::new(Field::new("n", n.data_type(), true)),
   ];
   let return_field = udf
       .return_field_from_args(ReturnFieldArgs {
           arg_fields: &arg_fields,
           scalar_arguments: &[Some(&s), Some(&n)],
       })
       .unwrap();
   let result = udf.invoke_with_args(ScalarFunctionArgs {
       args: vec![ColumnarValue::Scalar(s), ColumnarValue::Scalar(n)],
       arg_fields,
       number_rows: 1,
       return_field,
       config_options: Arc::new(ConfigOptions::default()),
   });
   // aborts: memory allocation of 1152921504606846976 bytes failed
   ```
   
   ### Expected behavior
   
   An error, as for `Utf8`, instead of an abort. Two fixes seem possible:
   
   - A fixed cap for `LargeUtf8`. PostgreSQL's `repeat` returns "requested 
length too large" above 
[`MaxAllocSize`](https://github.com/postgres/postgres/blob/884aca9b96989b9bc1b65d42e731e90f098ee2ee/src/include/utils/memutils.h#L40),
 1 GB minus 1 
([`oracle_compat.c`](https://github.com/postgres/postgres/blob/884aca9b96989b9bc1b65d42e731e90f098ee2ee/src/backend/utils/adt/oracle_compat.c#L1177-L1182)).
 DuckDB's strings are limited to `u32::MAX` bytes 
([`MAX_STRING_SIZE`](https://github.com/duckdb/duckdb/blob/bca3953c739d90390fdbf9f1c295909d89d87fa8/src/include/duckdb/common/types/string_type.hpp#L31)).
   - Fallible allocation, such as `try_reserve`, so that a refused allocation 
becomes an error.
   
   Which one should `repeat` use? Neither guards against an allocation that 
succeeds under overcommit and fails later when the pages are touched. Both turn 
this case, where the allocator refuses up front, into an error. #22688 tracks 
checked size accounting for string builders in general.
   
   ### Additional context
   
   Found by property-based tests that call each function with generated 
arguments, including large counts.
   
   ### Willingness to contribute
   
   I cannot contribute a fix for this bug at this time


-- 
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: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to