Skip to content

Apache DataFusion SQL Query Engine

Infer placeholder type from ANY/ALL subquery, unit tests (#22545)

Heb45093bdf14
diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rs
index 7e43089761..b6ffd74ea2 100644
--- a/datafusion/expr/src/expr.rs
+++ b/datafusion/expr/src/expr.rs
@@ -2191,26 +2191,23 @@ impl Expr {
subquery,
negated: _,
}) => {
- let subquery_schema = subquery.subquery.schema();
- match &subquery_schema.fields()[..] {
- [subquery_field] => {
- let column = Expr::Column(Column::new_unqualified(
- subquery_field.name().clone(),
- ));
- rewrite_placeholder(
- expr.as_mut(),
- &column,
- subquery_schema,
- )?;
- }
- _ => {
- return plan_err!(
- "InSubquery should only return one column, but found {}: {}",
- subquery_schema.fields().len(),
- subquery_schema.field_names().join(", ")
- );
- }
- }
+ rewrite_placeholder_from_subquery(
+ "InSubquery",
+ expr.as_mut(),
+ subquery,
+ )?;
+ }
+ Expr::SetComparison(SetComparison {
+ expr,
+ subquery,
+ op: _,
+ quantifier: _,
+ }) => {
+ rewrite_placeholder_from_subquery(
+ "SetComparison",
+ expr.as_mut(),
+ subquery,
+ )?;
}
Expr::Like(Like { expr, pattern, .. })
| Expr::SimilarTo(Like { expr, pattern, .. }) => {
@@ -2938,6 +2935,26 @@ macro_rules! expr_vec_fmt {
.join(", ")
}};
}
+/// Infer an untyped placeholder on the left of a single-column subquery predicate from the subquery projection
+fn rewrite_placeholder_from_subquery(
+ kind: &str,
+ expr: &mut Expr,
+ subquery: &Subquery,
+) -> Result<()> {
+ let subquery_schema = subquery.subquery.schema();
+ match &subquery_schema.fields()[..] {
+ [subquery_field] => {
+ let column =
+ Expr::Column(Column::new_unqualified(subquery_field.name().clone()));
+ rewrite_placeholder(expr, &column, subquery_schema)
+ }
+ _ => plan_err!(
+ "{kind} should only return one column, but found {}: {}",
+ subquery_schema.fields().len(),
+ subquery_schema.field_names().join(", ")
+ ),
+ }
+}
struct SchemaDisplay<'a>(&'a Expr);
impl Display for SchemaDisplay<'_> {
@@ -3946,6 +3963,112 @@ mod test {
}
}
+ #[test]
+ fn infer_placeholder_set_comparison_any() {
+ // WHERE $1 = ANY (SELECT a FROM t) -- parallel to infer_placeholder_in_subquery
+ let subquery_field = Field::new("a", DataType::Int32, false);
+ let subquery_schema = Arc::new(
+ DFSchema::from_unqualified_fields(
+ vec![subquery_field].into(),
+ Default::default(),
+ )
+ .unwrap(),
+ );
+ let subquery = Subquery {
+ subquery: Arc::new(LogicalPlan::EmptyRelation(EmptyRelation {
+ produce_one_row: false,
+ schema: subquery_schema,
+ })),
+ outer_ref_columns: vec![],
+ spans: Spans::new(),
+ };
+
+ let set_cmp = Expr::SetComparison(SetComparison {
+ expr: Box::new(Expr::Placeholder(Placeholder {
+ id: "$1".to_string(),
+ field: None,
+ })),
+ subquery,
+ op: Operator::Eq,
+ quantifier: SetQuantifier::Any,
+ });
+
+ let outer_schema = DFSchema::empty();
+ let (inferred_expr, contains_placeholder) =
+ set_cmp.infer_placeholder_types(&outer_schema).unwrap();
+
+ assert!(contains_placeholder);
+
+ match inferred_expr {
+ Expr::SetComparison(sc) => {
+ assert_eq!(sc.quantifier, SetQuantifier::Any);
+ match *sc.expr {
+ Expr::Placeholder(p) => {
+ let inferred =
+ p.field.expect("placeholder field should be Int32");
+ assert_eq!(inferred.data_type(), &DataType::Int32);
+ assert!(inferred.is_nullable());
+ }
+ _ => panic!("Expected Placeholder expression in SetComparison"),
+ }
+ }
+ _ => panic!("Expected SetComparison expression"),
+ }
+ }
+
+ #[test]
+ fn infer_placeholder_set_comparison_all() {
+ // WHERE $1 <> ALL (SELECT a FROM t)
+ let subquery_field = Field::new("a", DataType::Int32, false);
+ let subquery_schema = Arc::new(
+ DFSchema::from_unqualified_fields(
+ vec![subquery_field].into(),
+ Default::default(),
+ )
+ .unwrap(),
+ );
+ let subquery = Subquery {
+ subquery: Arc::new(LogicalPlan::EmptyRelation(EmptyRelation {
+ produce_one_row: false,
+ schema: subquery_schema,
+ })),
+ outer_ref_columns: vec![],
+ spans: Spans::new(),
+ };
+
+ let set_cmp = Expr::SetComparison(SetComparison {
+ expr: Box::new(Expr::Placeholder(Placeholder {
+ id: "$1".to_string(),
+ field: None,
+ })),
+ subquery,
+ op: Operator::NotEq,
+ quantifier: SetQuantifier::All,
+ });
+
+ let outer_schema = DFSchema::empty();
+ let (inferred_expr, contains_placeholder) =
+ set_cmp.infer_placeholder_types(&outer_schema).unwrap();
+
+ assert!(contains_placeholder);
+
+ match inferred_expr {
+ Expr::SetComparison(sc) => {
+ assert_eq!(sc.quantifier, SetQuantifier::All);
+ match *sc.expr {
+ Expr::Placeholder(p) => {
+ let inferred =
+ p.field.expect("placeholder field should be Int32");
+ assert_eq!(inferred.data_type(), &DataType::Int32);
+ assert!(inferred.is_nullable());
+ }
+ _ => panic!("Expected Placeholder expression in SetComparison"),
+ }
+ }
+ _ => panic!("Expected SetComparison expression"),
+ }
+ }
+
#[test]
fn infer_placeholder_like_and_similar_to() {
// name LIKE $1
diff --git a/datafusion/sqllogictest/test_files/prepare.slt b/datafusion/sqllogictest/test_files/prepare.slt
index bf91d95d5d..a3fe7cfb90 100644
--- a/datafusion/sqllogictest/test_files/prepare.slt
+++ b/datafusion/sqllogictest/test_files/prepare.slt
@@ -139,6 +139,54 @@ EXECUTE my_plan(20);
statement ok
DEALLOCATE my_plan
+# Allow prepare $1 = ANY (subquery)
+statement ok
+PREPARE my_plan AS SELECT id FROM person WHERE $1 = ANY (SELECT age FROM person);
+
+query I rowsort
+EXECUTE my_plan(20);
+----
+1
+
+query I rowsort
+EXECUTE my_plan(99);
+----
+
+statement ok
+DEALLOCATE my_plan
+
+# Allow prepare $1 <> ALL (subquery)
+statement ok
+PREPARE my_plan AS SELECT id FROM person WHERE $1 <> ALL (SELECT age FROM person);
+
+query I rowsort
+EXECUTE my_plan(99);
+----
+1
+
+query I rowsort
+EXECUTE my_plan(20);
+----
+
+statement ok
+DEALLOCATE my_plan
+
+# Allow prepare $1 < ALL (subquery)
+statement ok
+PREPARE my_plan AS SELECT id FROM person WHERE $1 < ALL (SELECT age FROM person);
+
+query I rowsort
+EXECUTE my_plan(10);
+----
+1
+
+query I rowsort
+EXECUTE my_plan(50);
+----
+
+statement ok
+DEALLOCATE my_plan
+
# Check for missing parameters
statement ok
PREPARE my_plan AS SELECT * FROM person WHERE id < $1;