sunchao commented on code in PR #7316: URL: https://github.com/apache/datafusion-comet/pull/7316#discussion_r4485831227
########## native/core/src/execution/planner/scalar_expansion.rs: ########## @@ -0,0 +1,313 @@ +// 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. + +//! Bounds the rows per batch under an operator that expands a large string scalar. +//! +//! An aggregate, a hash partitioner and most string kernels expand a scalar argument to the +//! batch's length: a 256 KiB string over the default 8192-row batch needs 2 GiB of value bytes, +//! past the 32-bit offsets of Arrow's `Utf8` and `Binary` arrays. Spark evaluates such scalars +//! row by row and never materializes the column. See +//! <https://github.com/apache/datafusion-comet/issues/7247>. +//! +//! The bound is enforced right under the operator that evaluates the expressions, with a +//! [`BatchSplitExec`], because the operators below do not keep the batch size they were +//! handed: a filter coalesces its output back up to the session's batch size, a window emits +//! its whole partition and a broadcast arrives as a few wide batches. No width can be assumed, +//! so the split is installed whenever the operator expands a string or binary scalar at all. + +use std::sync::Arc; + +use arrow::datatypes::{DataType, Schema}; +use arrow::record_batch::{RecordBatch, RecordBatchOptions}; +use datafusion::common::ScalarValue; +use datafusion::logical_expr::{ColumnarValue, Volatility}; +use datafusion::physical_expr::expressions::{Column, InListExpr}; +use datafusion::physical_expr::{PhysicalExpr, ScalarFunctionExpr}; +use datafusion::physical_plan::ExecutionPlan; +use datafusion_comet_operators::BatchSplitExec; +use datafusion_comet_spark_expr::jvm_udf::JvmScalarUdfExpr; +use datafusion_comet_spark_expr::monotonically_increasing_id::MonotonicallyIncreasingId; +use datafusion_comet_spark_expr::{ + RandExpr, RandStrExpr, RandnExpr, ShuffleExpr, Subquery, UuidExpr, +}; + +use super::{PhysicalPlanner, TEST_EXEC_CONTEXT_ID}; + +/// The most value bytes the string and binary scalars of one operator may take once expanded to +/// a batch's length. Arrow's 32-bit offsets make 2 GiB the hard limit; half of it leaves room for +/// kernels that append to the expanded value, such as `concat`, and matches what an Arrow Java +/// vector can hold before its reallocation fails. +const SCALAR_EXPANSION_BYTES: usize = 1 << 30; + +/// The most rows per batch at which `scalar_bytes`, expanded to the batch's length, stay within +/// `SCALAR_EXPANSION_BYTES`; unbounded when there is nothing to expand. +fn scalar_rows_cap(scalar_bytes: usize) -> usize { + if scalar_bytes == 0 { + return usize::MAX; + } + (SCALAR_EXPANSION_BYTES / scalar_bytes).max(1) +} + +impl PhysicalPlanner { + /// Wraps `input` so that the batches it emits keep the string and binary scalars in `exprs`, + /// expanded to a batch's length, within `SCALAR_EXPANSION_BYTES` and the session's batch + /// size. Returns `input` as is when `exprs` expand no scalar. + pub(crate) fn bound_scalar_expansion<'a>( + &self, + input: Arc<dyn ExecutionPlan>, + exprs: impl IntoIterator<Item = &'a Arc<dyn PhysicalExpr>>, + ) -> Arc<dyn ExecutionPlan> { + let schema = input.schema(); + let bytes: usize = exprs + .into_iter() + .map(|expr| self.expanded_scalar_bytes(expr, &schema)) + .sum(); + if bytes == 0 { + return input; + } + let batch_size = self.session_ctx.copied_config().batch_size(); + Arc::new(BatchSplitExec::new( + input, + scalar_rows_cap(bytes).min(batch_size), + )) + } + + /// The bytes of the string and binary scalars that evaluating `expr` expands to the batch's + /// length, added up, so that a scalar used twice counts twice. + /// + /// A scalar is any subtree without a column reference or a volatile function, evaluated + /// here on a one-row batch: `repeat(<subquery>, 8)` is wider than the subquery result it is + /// built from. A subtree that is not a scalar is evaluated per row, so only the scalars + /// among its children count. A subtree that fails to evaluate counts nothing, so that its + /// error surfaces where Spark's would, at execution. The members of an `IN` list are + /// compared and never expanded. + fn expanded_scalar_bytes(&self, expr: &Arc<dyn PhysicalExpr>, schema: &Schema) -> usize { + if let Some(in_list) = expr.downcast_ref::<InListExpr>() { Review Comment: Could this skip constant list values while still inspecting expanding expressions inside dynamic IN candidates? This early return accounts only for the value being tested. `spark_in_list` can retain a DataFusion `InListExpr` with `concat(large_literal, column)` as its first candidate and a later infallible literal; evaluating that candidate still expands the large string for every input row. On Spark 4.1.3 with this head's freshly built JVM and native code: ```sql SELECT sum(CASE WHEN CAST(id AS STRING) IN ( concat(repeat('x', 262144), CAST(id AS STRING)), 'foo' ) THEN 1 ELSE 0 END) FROM range(0, 8192, 1, 1) ``` Spark returns `0`. Comet with the default 8192-row batch fails with `CometNativeException: byte array offset overflow`; changing only `spark.comet.batchSize` to `256` returns `0` with the same native range/aggregate plan. A focused test using the actual `spark_in_list` constructor also confirms this estimator returns `0` bytes for that candidate instead of `262144`. Recurse into dynamic list expressions without charging the direct scalar members that IN compares without expansion, and add this shape to the regression coverage. -- 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]
