You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by gi...@apache.org on 2026/04/17 10:04:31 UTC
(datafusion) branch gh-readonly-queue/main/pr-21473-e5966b529fc3523793d7a052cd9821fa769859c0 created (now 2f0ca3de45)
This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a change to branch gh-readonly-queue/main/pr-21473-e5966b529fc3523793d7a052cd9821fa769859c0
in repository https://gitbox.apache.org/repos/asf/datafusion.git
at 2f0ca3de45 feat: extend single ndv optimization to non-arithmetic supporting types for equality predicates (#21473)
This branch includes the following new commits:
new 2f0ca3de45 feat: extend single ndv optimization to non-arithmetic supporting types for equality predicates (#21473)
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org
(datafusion) 01/01: feat: extend single ndv optimization to non-arithmetic supporting types for equality predicates (#21473)
Posted by gi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a commit to branch gh-readonly-queue/main/pr-21473-e5966b529fc3523793d7a052cd9821fa769859c0
in repository https://gitbox.apache.org/repos/asf/datafusion.git
commit 2f0ca3de45adcc69ad98d5bf52a88a0bf40e563f
Author: Burak Şen <bu...@gmail.com>
AuthorDate: Fri Apr 17 13:04:08 2026 +0300
feat: extend single ndv optimization to non-arithmetic supporting types for equality predicates (#21473)
## Which issue does this PR close?
- Closes #21109.
## Rationale for this change
In the case of equality we can say ndv is 1 for non-numeric types as
well. Please check issue for detailed explanation
## What changes are included in this PR?
Adding a type-agnostic pattern-matching layer that inspects the
predicate tree for col = literal shapes and sets NDV=Exact(1) regardless
of column type
## Are these changes tested?
Yes existing and additional unit tests.
## Are there any user-facing changes?
No
---
datafusion/physical-plan/src/filter.rs | 697 ++++++++++++++++++++++++++++-----
1 file changed, 603 insertions(+), 94 deletions(-)
diff --git a/datafusion/physical-plan/src/filter.rs b/datafusion/physical-plan/src/filter.rs
index 0b3ddbf1de..ed24033d69 100644
--- a/datafusion/physical-plan/src/filter.rs
+++ b/datafusion/physical-plan/src/filter.rs
@@ -15,6 +15,8 @@
// specific language governing permissions and limitations
// under the License.
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll, ready};
@@ -58,7 +60,7 @@ use datafusion_common::{
use datafusion_execution::TaskContext;
use datafusion_expr::Operator;
use datafusion_physical_expr::equivalence::ProjectionMapping;
-use datafusion_physical_expr::expressions::{BinaryExpr, Column, lit};
+use datafusion_physical_expr::expressions::{BinaryExpr, Column, Literal, lit};
use datafusion_physical_expr::intervals::utils::check_support;
use datafusion_physical_expr::utils::{collect_columns, reassign_expr_columns};
use datafusion_physical_expr::{
@@ -308,44 +310,77 @@ impl FilterExec {
&self.projection
}
- /// Calculates `Statistics` for `FilterExec`, by applying selectivity (either default, or estimated) to input statistics.
+ /// Calculates `Statistics` for `FilterExec`, by applying selectivity
+ /// (either default, or estimated) to input statistics.
+ ///
+ /// Equality predicates (`col = literal`) set NDV to `Exact(1)`, or
+ /// `Exact(0)` when the predicate is contradictory (e.g. `a = 1 AND a = 2`).
pub(crate) fn statistics_helper(
schema: &SchemaRef,
input_stats: Statistics,
predicate: &Arc<dyn PhysicalExpr>,
default_selectivity: u8,
) -> Result<Statistics> {
- if !check_support(predicate, schema) {
+ let (eq_columns, is_infeasible) = collect_equality_columns(predicate);
+
+ let input_num_rows = input_stats.num_rows;
+ let input_total_byte_size = input_stats.total_byte_size;
+
+ let (selectivity, num_rows, column_statistics) = if is_infeasible {
+ // Contradictory predicate: zero rows, and null/min/max are
+ // undefined on an empty column.
+ let mut cs = input_stats.to_inexact().column_statistics;
+ for col_stat in &mut cs {
+ col_stat.distinct_count = Precision::Exact(0);
+ col_stat.null_count = Precision::Exact(0);
+ col_stat.min_value = Precision::Absent;
+ col_stat.max_value = Precision::Absent;
+ col_stat.sum_value = Precision::Absent;
+ col_stat.byte_size = Precision::Exact(0);
+ }
+ (0.0, Precision::Exact(0), cs)
+ } else if !check_support(predicate, schema) {
+ // Interval analysis is not applicable; fall back to the default
+ // selectivity but still pin NDV=1 for every `col = literal` column.
let selectivity = default_selectivity as f64 / 100.0;
- let mut stats = input_stats.to_inexact();
- stats.num_rows = stats.num_rows.with_estimated_selectivity(selectivity);
- stats.total_byte_size = stats
- .total_byte_size
- .with_estimated_selectivity(selectivity);
- return Ok(stats);
- }
-
- let num_rows = input_stats.num_rows;
- let total_byte_size = input_stats.total_byte_size;
- let input_analysis_ctx =
- AnalysisContext::try_from_statistics(schema, &input_stats.column_statistics)?;
-
- let analysis_ctx = analyze(predicate, input_analysis_ctx, schema)?;
+ let mut cs = input_stats.to_inexact().column_statistics;
+ for &idx in &eq_columns {
+ if idx < cs.len() && cs[idx].distinct_count != Precision::Exact(0) {
+ cs[idx].distinct_count = Precision::Exact(1);
+ }
+ }
+ (
+ selectivity,
+ input_num_rows.with_estimated_selectivity(selectivity),
+ cs,
+ )
+ } else {
+ // Interval-analysis path. `collect_new_statistics` already sets
+ // distinct_count = Exact(1) when an interval collapses to a single
+ // value, so no post-fix is needed here.
+ let input_analysis_ctx = AnalysisContext::try_from_statistics(
+ schema,
+ &input_stats.column_statistics,
+ )?;
+ let analysis_ctx = analyze(predicate, input_analysis_ctx, schema)?;
+ let selectivity = analysis_ctx.selectivity.unwrap_or(1.0);
+ let filtered_num_rows =
+ input_num_rows.with_estimated_selectivity(selectivity);
+ let cs = collect_new_statistics(
+ schema,
+ &input_stats.column_statistics,
+ analysis_ctx.boundaries,
+ match &filtered_num_rows {
+ Precision::Absent => None,
+ p => Some(*p),
+ },
+ );
+ (selectivity, filtered_num_rows, cs)
+ };
- // Estimate (inexact) selectivity of predicate
- let selectivity = analysis_ctx.selectivity.unwrap_or(1.0);
- let num_rows = num_rows.with_estimated_selectivity(selectivity);
- let total_byte_size = total_byte_size.with_estimated_selectivity(selectivity);
+ let total_byte_size =
+ input_total_byte_size.with_estimated_selectivity(selectivity);
- let column_statistics = collect_new_statistics(
- schema,
- &input_stats.column_statistics,
- analysis_ctx.boundaries,
- match &num_rows {
- Precision::Absent => None,
- p => Some(*p),
- },
- );
Ok(Statistics {
num_rows,
total_byte_size,
@@ -762,6 +797,62 @@ impl EmbeddedProjection for FilterExec {
}
}
+/// Collects column equality information from `col = literal` predicates in a
+/// conjunction.
+///
+/// Returns `(eq_columns, is_infeasible)`:
+/// - `eq_columns`: set of column indices constrained to a single literal value.
+/// - `is_infeasible`: `true` when the same column is equated to two different
+/// non-null literals (e.g. `name = 'alice' AND name = 'bob'`), which is
+/// always unsatisfiable.
+///
+/// Only AND conjunctions are traversed; OR is intentionally skipped
+/// since `a = 1 OR a = 2` does not pin NDV to 1.
+fn collect_equality_columns(predicate: &Arc<dyn PhysicalExpr>) -> (HashSet<usize>, bool) {
+ let mut eq_values: HashMap<usize, ScalarValue> = HashMap::new();
+ let mut infeasible = false;
+
+ for expr in split_conjunction(predicate) {
+ let Some(binary) = expr.downcast_ref::<BinaryExpr>() else {
+ continue;
+ };
+ if *binary.op() != Operator::Eq {
+ continue;
+ }
+ let left = binary.left();
+ let right = binary.right();
+ let pair = if let Some(col) = left.downcast_ref::<Column>()
+ && let Some(lit) = right.downcast_ref::<Literal>()
+ && !lit.value().is_null()
+ {
+ Some((col.index(), lit.value().clone()))
+ } else if let Some(col) = right.downcast_ref::<Column>()
+ && let Some(lit) = left.downcast_ref::<Literal>()
+ && !lit.value().is_null()
+ {
+ Some((col.index(), lit.value().clone()))
+ } else {
+ None
+ };
+
+ if let Some((idx, value)) = pair {
+ match eq_values.entry(idx) {
+ Entry::Occupied(prev) => {
+ if *prev.get() != value {
+ infeasible = true;
+ break;
+ }
+ }
+ Entry::Vacant(slot) => {
+ slot.insert(value);
+ }
+ }
+ }
+ }
+
+ (eq_values.into_keys().collect(), infeasible)
+}
+
/// Converts an interval bound to a [`Precision`] value. NULL bounds (which
/// represent "unbounded" in the interval type) map to [`Precision::Absent`].
fn interval_bound_to_precision(
@@ -2264,78 +2355,291 @@ mod tests {
}
#[tokio::test]
- async fn test_filter_statistics_equality_sets_ndv_to_one() -> Result<()> {
- // a: min=1, max=100, ndv=80
- let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
- let input = Arc::new(StatisticsExec::new(
- Statistics {
- num_rows: Precision::Inexact(100),
- total_byte_size: Precision::Inexact(400),
- column_statistics: vec![ColumnStatistics {
- min_value: Precision::Inexact(ScalarValue::Int32(Some(1))),
- max_value: Precision::Inexact(ScalarValue::Int32(Some(100))),
- distinct_count: Precision::Inexact(80),
+ async fn test_filter_statistics_equality_ndv() -> Result<()> {
+ #[expect(clippy::type_complexity)]
+ let cases: Vec<(
+ &str,
+ Vec<Field>,
+ Vec<ColumnStatistics>,
+ Arc<dyn PhysicalExpr>,
+ Vec<Precision<usize>>,
+ )> = vec![
+ (
+ "utf8 equality",
+ vec![Field::new("name", DataType::Utf8, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(50),
..Default::default()
}],
- },
- schema.clone(),
- ));
-
- // a = 42 collapses interval to a single value
- let predicate = Arc::new(BinaryExpr::new(
- Arc::new(Column::new("a", 0)),
- Operator::Eq,
- Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
- ));
- let filter: Arc<dyn ExecutionPlan> =
- Arc::new(FilterExec::try_new(predicate, input)?);
- let statistics = filter.partition_statistics(None)?;
- assert_eq!(
- statistics.column_statistics[0].distinct_count,
- Precision::Exact(1)
- );
- Ok(())
- }
-
- #[tokio::test]
- async fn test_filter_statistics_or_equality_preserves_ndv() -> Result<()> {
- // a: min=1, max=100, ndv=80
- let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
- let input = Arc::new(StatisticsExec::new(
- Statistics {
- num_rows: Precision::Inexact(100),
- total_byte_size: Precision::Inexact(400),
- column_statistics: vec![ColumnStatistics {
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some("hello".to_string())))),
+ )),
+ vec![Precision::Exact(1)],
+ ),
+ (
+ "utf8view equality",
+ vec![Field::new("name", DataType::Utf8View, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(50),
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8View(Some(
+ "hello".to_string(),
+ )))),
+ )),
+ vec![Precision::Exact(1)],
+ ),
+ (
+ "largeutf8 equality",
+ vec![Field::new("name", DataType::LargeUtf8, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(50),
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::LargeUtf8(Some(
+ "hello".to_string(),
+ )))),
+ )),
+ vec![Precision::Exact(1)],
+ ),
+ (
+ "utf8 reversed (literal = column)",
+ vec![Field::new("name", DataType::Utf8, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(50),
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(Literal::new(ScalarValue::Utf8(Some("hello".to_string())))),
+ Operator::Eq,
+ Arc::new(Column::new("name", 0)),
+ )),
+ vec![Precision::Exact(1)],
+ ),
+ (
+ "OR preserves original NDV",
+ vec![Field::new("name", DataType::Utf8, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(50),
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some("a".to_string())))),
+ )),
+ Operator::Or,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some("b".to_string())))),
+ )),
+ )),
+ vec![Precision::Inexact(50)],
+ ),
+ (
+ "AND with mixed types (Utf8 + Int32)",
+ vec![
+ Field::new("name", DataType::Utf8, false),
+ Field::new("age", DataType::Int32, false),
+ ],
+ vec![
+ ColumnStatistics {
+ distinct_count: Precision::Inexact(50),
+ ..Default::default()
+ },
+ ColumnStatistics {
+ distinct_count: Precision::Inexact(80),
+ ..Default::default()
+ },
+ ],
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some(
+ "hello".to_string(),
+ )))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("age", 1)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ )),
+ vec![Precision::Exact(1), Precision::Exact(1)],
+ ),
+ (
+ "numeric equality with min/max bounds (interval analysis path)",
+ vec![Field::new("a", DataType::Int32, false)],
+ vec![ColumnStatistics {
min_value: Precision::Inexact(ScalarValue::Int32(Some(1))),
max_value: Precision::Inexact(ScalarValue::Int32(Some(100))),
distinct_count: Precision::Inexact(80),
..Default::default()
}],
- },
- schema.clone(),
- ));
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ vec![Precision::Exact(1)],
+ ),
+ (
+ "timestamp equality",
+ vec![Field::new(
+ "ts",
+ DataType::Timestamp(arrow::datatypes::TimeUnit::Nanosecond, None),
+ false,
+ )],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(500),
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("ts", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::TimestampNanosecond(
+ Some(1_609_459_200_000_000_000),
+ None,
+ ))),
+ )),
+ vec![Precision::Exact(1)],
+ ),
+ (
+ "contradictory numeric equality (infeasible)",
+ vec![Field::new("a", DataType::Int32, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(50),
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(99)))),
+ )),
+ )),
+ vec![Precision::Exact(0)],
+ ),
+ (
+ "utf8 equality with absent input NDV",
+ vec![Field::new("name", DataType::Utf8, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Absent,
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some("hello".to_string())))),
+ )),
+ vec![Precision::Exact(1)],
+ ),
+ (
+ "contradictory utf8 equality (infeasible)",
+ vec![Field::new("name", DataType::Utf8, false)],
+ vec![ColumnStatistics {
+ distinct_count: Precision::Inexact(100),
+ ..Default::default()
+ }],
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some(
+ "alice".to_string(),
+ )))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("name", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some(
+ "bob".to_string(),
+ )))),
+ )),
+ )),
+ vec![Precision::Exact(0)],
+ ),
+ (
+ "redundant same-value equality combined with another column",
+ vec![
+ Field::new("a", DataType::Int32, false),
+ Field::new("b", DataType::Int32, false),
+ ],
+ vec![
+ ColumnStatistics {
+ distinct_count: Precision::Inexact(80),
+ ..Default::default()
+ },
+ ColumnStatistics {
+ distinct_count: Precision::Inexact(40),
+ ..Default::default()
+ },
+ ],
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(1)))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(1)))),
+ )),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("b", 1)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(2)))),
+ )),
+ )),
+ vec![Precision::Exact(1), Precision::Exact(1)],
+ ),
+ ];
- // a = 42 OR a = 22: interval stays [1, 100], not a single value
- let predicate = Arc::new(BinaryExpr::new(
- Arc::new(BinaryExpr::new(
- Arc::new(Column::new("a", 0)),
- Operator::Eq,
- Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
- )),
- Operator::Or,
- Arc::new(BinaryExpr::new(
- Arc::new(Column::new("a", 0)),
- Operator::Eq,
- Arc::new(Literal::new(ScalarValue::Int32(Some(22)))),
- )),
- ));
- let filter: Arc<dyn ExecutionPlan> =
- Arc::new(FilterExec::try_new(predicate, input)?);
- let statistics = filter.partition_statistics(None)?;
- assert_eq!(
- statistics.column_statistics[0].distinct_count,
- Precision::Inexact(80)
- );
+ for (desc, fields, col_stats, predicate, expected_ndvs) in cases {
+ let schema = Schema::new(fields);
+ let input = Arc::new(StatisticsExec::new(
+ Statistics {
+ num_rows: Precision::Inexact(100),
+ total_byte_size: Precision::Inexact(1000),
+ column_statistics: col_stats,
+ },
+ schema.clone(),
+ ));
+ let filter: Arc<dyn ExecutionPlan> =
+ Arc::new(FilterExec::try_new(predicate, input)?);
+ let statistics = filter.partition_statistics(None)?;
+
+ for (i, expected) in expected_ndvs.iter().enumerate() {
+ assert_eq!(
+ statistics.column_statistics[i].distinct_count, *expected,
+ "case '{desc}': column {i} NDV mismatch"
+ );
+ }
+ }
Ok(())
}
@@ -2588,6 +2892,211 @@ mod tests {
Ok(())
}
+ #[test]
+ fn test_collect_equality_columns() {
+ use std::collections::HashSet;
+ // (description, predicate, expected_column_indices, expected_infeasible)
+ #[expect(clippy::type_complexity)]
+ let cases: Vec<(&str, Arc<dyn PhysicalExpr>, Vec<usize>, bool)> = vec![
+ (
+ "simple col = literal",
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ vec![0],
+ false,
+ ),
+ (
+ "reversed literal = col",
+ Arc::new(BinaryExpr::new(
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ Operator::Eq,
+ Arc::new(Column::new("a", 0)),
+ )),
+ vec![0],
+ false,
+ ),
+ (
+ "AND with two equalities",
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("b", 1)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some(
+ "hello".to_string(),
+ )))),
+ )),
+ )),
+ vec![0, 1],
+ false,
+ ),
+ (
+ "OR produces empty set",
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ Operator::Or,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(99)))),
+ )),
+ )),
+ vec![],
+ false,
+ ),
+ (
+ "greater-than produces empty set",
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Gt,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ vec![],
+ false,
+ ),
+ (
+ "col = col produces empty set",
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Column::new("b", 1)),
+ )),
+ vec![],
+ false,
+ ),
+ (
+ "nested AND with three equalities",
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(1)))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("b", 1)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(2)))),
+ )),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("c", 2)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(3)))),
+ )),
+ )),
+ vec![0, 1, 2],
+ false,
+ ),
+ (
+ "AND with mixed equality and non-equality",
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("b", 1)),
+ Operator::Gt,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(10)))),
+ )),
+ )),
+ vec![0],
+ false,
+ ),
+ (
+ "col = NULL is excluded",
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(None))),
+ )),
+ vec![],
+ false,
+ ),
+ (
+ "NULL = col is excluded",
+ Arc::new(BinaryExpr::new(
+ Arc::new(Literal::new(ScalarValue::Utf8(None))),
+ Operator::Eq,
+ Arc::new(Column::new("a", 0)),
+ )),
+ vec![],
+ false,
+ ),
+ (
+ "contradictory: same col, different literals",
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some(
+ "alice".to_string(),
+ )))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Utf8(Some(
+ "bob".to_string(),
+ )))),
+ )),
+ )),
+ vec![0],
+ true,
+ ),
+ (
+ "same col, same literal is not contradictory",
+ Arc::new(BinaryExpr::new(
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ Operator::And,
+ Arc::new(BinaryExpr::new(
+ Arc::new(Column::new("a", 0)),
+ Operator::Eq,
+ Arc::new(Literal::new(ScalarValue::Int32(Some(42)))),
+ )),
+ )),
+ vec![0],
+ false,
+ ),
+ ];
+
+ for (desc, expr, expected_cols, expected_infeasible) in cases {
+ let (result, infeasible) = collect_equality_columns(&expr);
+ let expected: HashSet<usize> = expected_cols.into_iter().collect();
+ if expected_infeasible {
+ // When infeasible, the scan is short-circuited, so we only
+ // assert the infeasibility flag — the partial column set
+ // contents are an implementation detail.
+ assert!(infeasible, "case '{desc}': expected infeasible");
+ } else {
+ assert_eq!(result, expected, "case '{desc}': columns mismatch");
+ assert!(!infeasible, "case '{desc}': expected feasible");
+ }
+ }
+ }
+
/// Regression test: ProjectionExec on top of a FilterExec that already has
/// an explicit projection must not panic when `try_swapping_with_projection`
/// attempts to swap the two nodes.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org