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.rsindex 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 $1diff --git a/datafusion/sqllogictest/test_files/prepare.slt b/datafusion/sqllogictest/test_files/prepare.sltindex 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 okDEALLOCATE 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 parametersstatement okPREPARE my_plan AS SELECT * FROM person WHERE id < $1;