Skip to content

Apache DataFusion SQL Query Engine

EliminateOuterJoin with Like, IsTrue, IsFalse, IsNotUnknown (#21549)

Subham Singhalcda7b5cc4194
diff --git a/datafusion/optimizer/src/eliminate_outer_join.rs b/datafusion/optimizer/src/eliminate_outer_join.rs
index c6e27b2603..db21f0eb6c 100644
--- a/datafusion/optimizer/src/eliminate_outer_join.rs
+++ b/datafusion/optimizer/src/eliminate_outer_join.rs
@@ -23,7 +23,7 @@ use datafusion_expr::{Expr, Filter, Operator};
use crate::optimizer::ApplyOrder;
use datafusion_common::tree_node::Transformed;
-use datafusion_expr::expr::{BinaryExpr, Cast, InList, TryCast};
+use datafusion_expr::expr::{BinaryExpr, Cast, InList, Like, TryCast};
use std::sync::Arc;
///
@@ -315,6 +315,37 @@ fn extract_non_nullable_columns(
right_schema,
false,
),
+ // LIKE is null-rejecting: if either the input column or the pattern
+ // is NULL, the result is NULL (filtered out by WHERE).
+ Expr::Like(Like { expr, pattern, .. }) => {
+ extract_non_nullable_columns(
+ expr,
+ non_nullable_cols,
+ left_schema,
+ right_schema,
+ false,
+ );
+ extract_non_nullable_columns(
+ pattern,
+ non_nullable_cols,
+ left_schema,
+ right_schema,
+ false,
+ );
+ }
+ // IS TRUE, IS FALSE, and IS NOT UNKNOWN are null-rejecting:
+ // if the input is NULL, they return false (filtered out by WHERE).
+ // Note: IS NOT TRUE, IS NOT FALSE, and IS UNKNOWN are NOT null-rejecting
+ // because they return true for NULL input.
+ Expr::IsTrue(arg) | Expr::IsFalse(arg) | Expr::IsNotUnknown(arg) => {
+ extract_non_nullable_columns(
+ arg,
+ non_nullable_cols,
+ left_schema,
+ right_schema,
+ false,
+ )
+ }
_ => {}
}
}
@@ -669,6 +700,204 @@ mod tests {
")
}
+ #[test]
+ fn eliminate_left_with_like() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // LIKE rejects nulls: if t2.b is NULL, the result is NULL (filtered out)
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").like(lit("%pattern%")))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r#"
+ Filter: t2.b LIKE Utf8("%pattern%")
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ "#)
+ }
+
+ #[test]
+ fn eliminate_left_with_like_pattern_column() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // LIKE with nullable column on the pattern side:
+ // 'x' LIKE t2.b → if t2.b is NULL, result is NULL (filtered out)
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(lit("x").like(col("t2.b")))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r#"
+ Filter: Utf8("x") LIKE t2.b
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ "#)
+ }
+
+ #[test]
+ fn eliminate_full_with_like_cross_side() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // LIKE with columns from both sides: t1.c LIKE t2.b
+ // If t1 is NULL → NULL LIKE t2.b → NULL → filtered out (left non-nullable)
+ // If t2 is NULL → t1.c LIKE NULL → NULL → filtered out (right non-nullable)
+ // Both sides are non-nullable → FULL → INNER
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Full,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t1.c").like(col("t2.b")))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t1.c LIKE t2.b
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn eliminate_left_with_is_true() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // IS TRUE rejects nulls: if the expression is NULL, IS TRUE returns false
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").gt(lit(10u32)).is_true())?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(10) IS TRUE
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn eliminate_left_with_is_false() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // IS FALSE rejects nulls: if the expression is NULL, IS FALSE returns false
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").gt(lit(10u32)).is_false())?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(10) IS FALSE
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn eliminate_left_with_is_not_unknown() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // IS NOT UNKNOWN rejects nulls: if the expression is NULL, IS NOT UNKNOWN returns false
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").gt(lit(10u32)).is_not_unknown())?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(10) IS NOT UNKNOWN
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn no_eliminate_left_with_is_not_true() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // IS NOT TRUE is NOT null-rejecting: if the expression is NULL,
+ // IS NOT TRUE returns true, so null rows pass through
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").gt(lit(10u32)).is_not_true())?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(10) IS NOT TRUE
+ Left Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn no_eliminate_left_with_is_unknown() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // IS UNKNOWN is NOT null-rejecting: if the expression is NULL,
+ // IS UNKNOWN returns true, so null rows pass through
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").gt(lit(10u32)).is_unknown())?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(10) IS UNKNOWN
+ Left Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
#[test]
fn eliminate_full_with_type_cast() -> Result<()> {
let t1 = test_table_scan_with_name("t1")?;
@@ -696,4 +925,252 @@ mod tests {
TableScan: t2
")
}
+
+ // ----- FULL JOIN → LEFT / RIGHT tests -----
+ #[test]
+ fn eliminate_full_to_left_with_left_filter() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // FULL JOIN with null-rejecting filter only on left side → LEFT JOIN
+ // (left side becomes non-nullable, right side stays nullable)
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Full,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t1.b").gt(lit(10u32)))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t1.b > UInt32(10)
+ Left Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn eliminate_full_to_right_with_right_filter() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // FULL JOIN with null-rejecting filter only on right side → RIGHT JOIN
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Full,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").in_list(vec![lit(1u32), lit(2u32)], false))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b IN ([UInt32(1), UInt32(2)])
+ Right Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn eliminate_full_to_left_with_like() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // FULL JOIN with LIKE on left side only → LEFT JOIN
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Full,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t1.b").like(lit("%val%")))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r#"
+ Filter: t1.b LIKE Utf8("%val%")
+ Left Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ "#)
+ }
+
+ #[test]
+ fn eliminate_full_to_right_with_is_true() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // FULL JOIN with IS TRUE on right side only → RIGHT JOIN
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Full,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(col("t2.b").gt(lit(10u32)).is_true())?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(10) IS TRUE
+ Right Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ // ----- Nested AND / OR tests -----
+
+ #[test]
+ fn eliminate_left_with_and_multiple_null_rejecting() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // Multiple null-rejecting predicates combined with AND on nullable side
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(binary_expr(
+ col("t2.b").in_list(vec![lit(1u32), lit(2u32)], false),
+ And,
+ col("t2.c").between(lit(5u32), lit(20u32)),
+ ))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b IN ([UInt32(1), UInt32(2)]) AND t2.c BETWEEN UInt32(5) AND UInt32(20)
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn eliminate_left_with_or_same_side() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // OR of two null-rejecting predicates on different columns of the same
+ // nullable side. If t2 rows are NULL (from LEFT JOIN), both t2.b and
+ // t2.c are NULL, so the entire OR evaluates to NULL → filtered out.
+ // This IS null-rejecting, so join should be eliminated.
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(binary_expr(
+ col("t2.b").gt(lit(10u32)),
+ Or,
+ col("t2.c").lt(lit(20u32)),
+ ))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(10) OR t2.c < UInt32(20)
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ #[test]
+ fn no_eliminate_left_with_or_cross_side() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // OR with columns from different sides — t1.b (preserved) OR t2.b
+ // (nullable). When t2 is NULL, t1.b > 10 can still be true, so the
+ // OR is NOT null-rejecting. Join must be preserved.
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(binary_expr(
+ col("t1.b").gt(lit(10u32)),
+ Or,
+ col("t2.b").lt(lit(20u32)),
+ ))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t1.b > UInt32(10) OR t2.b < UInt32(20)
+ Left Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
+
+ // ----- Mixed predicate tests -----
+
+ #[test]
+ fn eliminate_full_with_mixed_predicates() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // FULL JOIN with different null-rejecting expr types on each side:
+ // LIKE on left, BETWEEN on right → INNER JOIN
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Full,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(binary_expr(
+ col("t1.b").like(lit("%pattern%")),
+ And,
+ col("t2.b").between(lit(1u32), lit(10u32)),
+ ))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r#"
+ Filter: t1.b LIKE Utf8("%pattern%") AND t2.b BETWEEN UInt32(1) AND UInt32(10)
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ "#)
+ }
+
+ #[test]
+ fn eliminate_left_with_is_true_and_in_list() -> Result<()> {
+ let t1 = test_table_scan_with_name("t1")?;
+ let t2 = test_table_scan_with_name("t2")?;
+
+ // AND of IS TRUE and IN on nullable side — both null-rejecting
+ let plan = LogicalPlanBuilder::from(t1)
+ .join(
+ t2,
+ JoinType::Left,
+ (vec![Column::from_name("a")], vec![Column::from_name("a")]),
+ None,
+ )?
+ .filter(binary_expr(
+ col("t2.b").gt(lit(5u32)).is_true(),
+ And,
+ col("t2.c").in_list(vec![lit(1u32), lit(2u32)], false),
+ ))?
+ .build()?;
+
+ assert_optimized_plan_equal!(plan, @r"
+ Filter: t2.b > UInt32(5) IS TRUE AND t2.c IN ([UInt32(1), UInt32(2)])
+ Inner Join: t1.a = t2.a
+ TableScan: t1
+ TableScan: t2
+ ")
+ }
}
diff --git a/datafusion/sqllogictest/test_files/eliminate_outer_join.slt b/datafusion/sqllogictest/test_files/eliminate_outer_join.slt
index a44d9af77c..dff7692a44 100644
--- a/datafusion/sqllogictest/test_files/eliminate_outer_join.slt
+++ b/datafusion/sqllogictest/test_files/eliminate_outer_join.slt
@@ -198,6 +198,286 @@ select * from t1 left join t2 on t1.a = t2.x where t2.x in (1, 2) or t2.x is nul
3 30 c NULL NULL NULL
NULL 40 d NULL NULL NULL
+###
+### LIKE tests
+###
+
+# LEFT JOIN + WHERE t2.z LIKE ... -> INNER JOIN
+# LIKE is null-rejecting: if t2.z is NULL, LIKE returns NULL (filtered out).
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where t2.z like 'p%';
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--TableScan: t1 projection=[a, b, c]
+03)--Filter: t2.z LIKE Utf8View("p%")
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where t2.z like 'p%';
+----
+1 10 a 1 100 p
+
+# RIGHT JOIN + WHERE t1.c LIKE ... -> INNER JOIN
+query TT
+explain select * from t1 right join t2 on t1.a = t2.x where t1.c like '%b%';
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--Filter: t1.c LIKE Utf8View("%b%")
+03)----TableScan: t1 projection=[a, b, c]
+04)--TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 right join t2 on t1.a = t2.x where t1.c like '%b%';
+----
+2 20 b 2 200 q
+
+# LEFT JOIN + nullable column on pattern side: 'x' LIKE t2.z -> INNER JOIN
+# LIKE returns NULL when the pattern is NULL, so this is null-rejecting.
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where 'x' like t2.z;
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--TableScan: t1 projection=[a, b, c]
+03)--Filter: Utf8View("x") LIKE t2.z
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where 'x' like t2.z;
+----
+
+# FULL JOIN + LIKE with columns from both sides: t1.c LIKE t2.z -> INNER JOIN
+# Either side being NULL makes LIKE return NULL, so both sides are non-nullable.
+query TT
+explain select * from t1 full join t2 on t1.a = t2.x where t1.c like t2.z;
+----
+logical_plan
+01)Inner Join: t1.a = t2.x Filter: t1.c LIKE t2.z
+02)--TableScan: t1 projection=[a, b, c]
+03)--TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 full join t2 on t1.a = t2.x where t1.c like t2.z;
+----
+
+# LEFT JOIN + LIKE on preserved side pattern — should NOT eliminate
+# t1.c is from the preserved (left) side, never NULL from the join.
+# This does not reject null t2 rows, so LEFT JOIN must stay.
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where 'hello' like t1.c;
+----
+logical_plan
+01)Left Join: t1.a = t2.x
+02)--Filter: Utf8View("hello") LIKE t1.c
+03)----TableScan: t1 projection=[a, b, c]
+04)--TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where 'hello' like t1.c;
+----
+
+###
+### IS TRUE / IS FALSE / IS NOT UNKNOWN tests
+###
+
+# LEFT JOIN + WHERE (t2.y > 150) IS TRUE -> INNER JOIN
+# IS TRUE is null-rejecting: if the expression is NULL, IS TRUE returns false.
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is true;
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--TableScan: t1 projection=[a, b, c]
+03)--Filter: t2.y > Int32(150) IS TRUE
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is true;
+----
+2 20 b 2 200 q
+
+# LEFT JOIN + WHERE (t2.y > 150) IS FALSE -> INNER JOIN
+# IS FALSE is null-rejecting: if the expression is NULL, IS FALSE returns false.
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is false;
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--TableScan: t1 projection=[a, b, c]
+03)--Filter: t2.y > Int32(150) IS FALSE
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is false;
+----
+1 10 a 1 100 p
+
+# LEFT JOIN + WHERE (t2.y > 150) IS NOT UNKNOWN -> INNER JOIN
+# IS NOT UNKNOWN is null-rejecting: if the expression is NULL, IS NOT UNKNOWN returns false.
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is not unknown;
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--TableScan: t1 projection=[a, b, c]
+03)--Filter: t2.y > Int32(150) IS NOT UNKNOWN
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is not unknown;
+----
+1 10 a 1 100 p
+2 20 b 2 200 q
+
+###
+### Negative: IS NOT TRUE / IS UNKNOWN should NOT eliminate
+###
+
+# LEFT JOIN + WHERE (t2.y > 150) IS NOT TRUE -> stays LEFT JOIN
+# IS NOT TRUE returns true for NULL, so it is NOT null-rejecting.
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is not true;
+----
+logical_plan
+01)Filter: t2.y > Int32(150) IS NOT TRUE
+02)--Left Join: t1.a = t2.x
+03)----TableScan: t1 projection=[a, b, c]
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is not true;
+----
+1 10 a 1 100 p
+3 30 c NULL NULL NULL
+NULL 40 d NULL NULL NULL
+
+# LEFT JOIN + WHERE (t2.y > 150) IS UNKNOWN -> stays LEFT JOIN
+# IS UNKNOWN returns true for NULL, so it is NOT null-rejecting.
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is unknown;
+----
+logical_plan
+01)Filter: t2.y > Int32(150) IS UNKNOWN
+02)--Left Join: t1.a = t2.x
+03)----TableScan: t1 projection=[a, b, c]
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is unknown;
+----
+3 30 c NULL NULL NULL
+NULL 40 d NULL NULL NULL
+
+###
+### FULL JOIN → LEFT / RIGHT conversion tests
+###
+
+# FULL JOIN + filter on left side only → LEFT JOIN
+# Left side becomes non-nullable, right side stays nullable.
+query TT
+explain select * from t1 full join t2 on t1.a = t2.x where t1.a > 0;
+----
+logical_plan
+01)Left Join: t1.a = t2.x
+02)--Filter: t1.a > Int32(0)
+03)----TableScan: t1 projection=[a, b, c]
+04)--Filter: t2.x > Int32(0)
+05)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 full join t2 on t1.a = t2.x where t1.a > 0;
+----
+1 10 a 1 100 p
+2 20 b 2 200 q
+3 30 c NULL NULL NULL
+
+# FULL JOIN + filter on right side only → RIGHT JOIN
+query TT
+explain select * from t1 full join t2 on t1.a = t2.x where t2.x in (1, 2);
+----
+logical_plan
+01)Right Join: t1.a = t2.x
+02)--Filter: t1.a = Int32(1) OR t1.a = Int32(2)
+03)----TableScan: t1 projection=[a, b, c]
+04)--Filter: t2.x = Int32(1) OR t2.x = Int32(2)
+05)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 full join t2 on t1.a = t2.x where t2.x in (1, 2);
+----
+1 10 a 1 100 p
+2 20 b 2 200 q
+
+# FULL JOIN + LIKE on left, BETWEEN on right → INNER JOIN (mixed predicates)
+query TT
+explain select * from t1 full join t2 on t1.a = t2.x where t1.c like '%a%' and t2.y between 50 and 250;
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--Filter: t1.c LIKE Utf8View("%a%")
+03)----TableScan: t1 projection=[a, b, c]
+04)--Filter: t2.y >= Int32(50) AND t2.y <= Int32(250)
+05)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 full join t2 on t1.a = t2.x where t1.c like '%a%' and t2.y between 50 and 250;
+----
+1 10 a 1 100 p
+
+# FULL JOIN + IS TRUE on right only → RIGHT JOIN
+query TT
+explain select * from t1 full join t2 on t1.a = t2.x where (t2.y > 150) is true;
+----
+logical_plan
+01)Right Join: t1.a = t2.x
+02)--TableScan: t1 projection=[a, b, c]
+03)--Filter: t2.y > Int32(150) IS TRUE
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 full join t2 on t1.a = t2.x where (t2.y > 150) is true;
+----
+2 20 b 2 200 q
+NULL NULL NULL NULL 300 r
+
+###
+### Nested AND / OR tests
+###
+
+# AND of multiple null-rejecting predicates on nullable side → INNER JOIN
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where t2.x in (1, 2) and t2.y between 50 and 250;
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--Filter: t1.a = Int32(1) OR t1.a = Int32(2)
+03)----TableScan: t1 projection=[a, b, c]
+04)--Filter: (t2.x = Int32(1) OR t2.x = Int32(2)) AND t2.y >= Int32(50) AND t2.y <= Int32(250)
+05)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where t2.x in (1, 2) and t2.y between 50 and 250;
+----
+1 10 a 1 100 p
+2 20 b 2 200 q
+
+# IS TRUE AND IN on nullable side → INNER JOIN (mixed null-rejecting types)
+query TT
+explain select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is true and t2.z like 'q%';
+----
+logical_plan
+01)Inner Join: t1.a = t2.x
+02)--TableScan: t1 projection=[a, b, c]
+03)--Filter: t2.y > Int32(150) IS TRUE AND t2.z LIKE Utf8View("q%")
+04)----TableScan: t2 projection=[x, y, z]
+
+query IITIIT rowsort
+select * from t1 left join t2 on t1.a = t2.x where (t2.y > 150) is true and t2.z like 'q%';
+----
+2 20 b 2 200 q
+
###
### Cleanup
###