diff --git a/datafusion-examples/examples/rewrite_expr.rs b/datafusion-examples/examples/rewrite_expr.rs index 9b94a71a501c..4943fee444d5 100644 --- a/datafusion-examples/examples/rewrite_expr.rs +++ b/datafusion-examples/examples/rewrite_expr.rs @@ -51,7 +51,7 @@ pub fn main() -> Result<()> { let config = OptimizerContext::default().with_skip_failing_rules(false); let analyzer = Analyzer::with_rules(vec![Arc::new(MyAnalyzerRule {})]); let analyzed_plan = - analyzer.execute_and_check(&logical_plan, config.options(), |_, _| {})?; + analyzer.execute_and_check(logical_plan, config.options(), |_, _| {})?; println!( "Analyzed Logical Plan:\n\n{}\n", analyzed_plan.display_indent() diff --git a/datafusion/core/src/execution/context/mod.rs b/datafusion/core/src/execution/context/mod.rs index d83644597e78..538c5c5585b2 100644 --- a/datafusion/core/src/execution/context/mod.rs +++ b/datafusion/core/src/execution/context/mod.rs @@ -1864,7 +1864,7 @@ impl SessionState { // analyze & capture output of each rule let analyzer_result = self.analyzer.execute_and_check( - e.plan.as_ref(), + e.plan.as_ref().clone(), self.options(), |analyzed_plan, analyzer| { let analyzer_name = analyzer.name().to_string(); @@ -1923,9 +1923,11 @@ impl SessionState { logical_optimization_succeeded, })) } else { - let analyzed_plan = - self.analyzer - .execute_and_check(plan, self.options(), |_, _| {})?; + let analyzed_plan = self.analyzer.execute_and_check( + plan.clone(), + self.options(), + |_, _| {}, + )?; self.optimizer.optimize(analyzed_plan, self, |_, _| {}) } } diff --git a/datafusion/core/tests/optimizer_integration.rs b/datafusion/core/tests/optimizer_integration.rs index 5a7870b7a01c..8acf8618c738 100644 --- a/datafusion/core/tests/optimizer_integration.rs +++ b/datafusion/core/tests/optimizer_integration.rs @@ -135,7 +135,7 @@ fn test_sql(sql: &str) -> Result { let analyzer = Analyzer::new(); let optimizer = Optimizer::new(); // analyze and optimize the logical plan - let plan = analyzer.execute_and_check(&plan, config.options(), |_, _| {})?; + let plan = analyzer.execute_and_check(plan, config.options(), |_, _| {})?; optimizer.optimize(plan, &config, |_, _| {}) } diff --git a/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs b/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs index 1ab3d1a81038..a607d49ef967 100644 --- a/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs +++ b/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs @@ -112,7 +112,7 @@ mod tests { }; use std::sync::Arc; - fn assert_plan_eq(plan: &LogicalPlan, expected: &str) -> Result<()> { + fn assert_plan_eq(plan: LogicalPlan, expected: &str) -> Result<()> { assert_analyzed_plan_eq_display_indent( Arc::new(CountWildcardRule::new()), plan, @@ -132,7 +132,7 @@ mod tests { \n Projection: COUNT(*) [COUNT(*):Int64;N]\ \n Aggregate: groupBy=[[test.b]], aggr=[[COUNT(Int64(1)) AS COUNT(*)]] [b:UInt32, COUNT(*):Int64;N]\ \n TableScan: test [a:UInt32, b:UInt32, c:UInt32]"; - assert_plan_eq(&plan, expected) + assert_plan_eq(plan, expected) } #[test] @@ -158,7 +158,7 @@ mod tests { \n Aggregate: groupBy=[[]], aggr=[[COUNT(Int64(1)) AS COUNT(*)]] [COUNT(*):Int64;N]\ \n TableScan: t2 [a:UInt32, b:UInt32, c:UInt32]\ \n TableScan: t1 [a:UInt32, b:UInt32, c:UInt32]"; - assert_plan_eq(&plan, expected) + assert_plan_eq(plan, expected) } #[test] @@ -181,7 +181,7 @@ mod tests { \n Aggregate: groupBy=[[]], aggr=[[COUNT(Int64(1)) AS COUNT(*)]] [COUNT(*):Int64;N]\ \n TableScan: t2 [a:UInt32, b:UInt32, c:UInt32]\ \n TableScan: t1 [a:UInt32, b:UInt32, c:UInt32]"; - assert_plan_eq(&plan, expected) + assert_plan_eq(plan, expected) } #[test] @@ -214,7 +214,7 @@ mod tests { \n Filter: outer_ref(t1.a) = t2.a [a:UInt32, b:UInt32, c:UInt32]\ \n TableScan: t2 [a:UInt32, b:UInt32, c:UInt32]\ \n TableScan: t1 [a:UInt32, b:UInt32, c:UInt32]"; - assert_plan_eq(&plan, expected) + assert_plan_eq(plan, expected) } #[test] fn test_count_wildcard_on_window() -> Result<()> { @@ -239,7 +239,7 @@ mod tests { let expected = "Projection: COUNT(Int64(1)) AS COUNT(*) [COUNT(*):Int64;N]\ \n WindowAggr: windowExpr=[[COUNT(Int64(1)) ORDER BY [test.a DESC NULLS FIRST] RANGE BETWEEN 6 PRECEDING AND 2 FOLLOWING AS COUNT(*) ORDER BY [test.a DESC NULLS FIRST] RANGE BETWEEN 6 PRECEDING AND 2 FOLLOWING]] [a:UInt32, b:UInt32, c:UInt32, COUNT(*) ORDER BY [test.a DESC NULLS FIRST] RANGE BETWEEN 6 PRECEDING AND 2 FOLLOWING:Int64;N]\ \n TableScan: test [a:UInt32, b:UInt32, c:UInt32]"; - assert_plan_eq(&plan, expected) + assert_plan_eq(plan, expected) } #[test] @@ -253,7 +253,7 @@ mod tests { let expected = "Projection: COUNT(*) [COUNT(*):Int64;N]\ \n Aggregate: groupBy=[[]], aggr=[[COUNT(Int64(1)) AS COUNT(*)]] [COUNT(*):Int64;N]\ \n TableScan: test [a:UInt32, b:UInt32, c:UInt32]"; - assert_plan_eq(&plan, expected) + assert_plan_eq(plan, expected) } #[test] @@ -278,6 +278,6 @@ mod tests { let expected = "Projection: COUNT(Int64(1)) AS COUNT(*) [COUNT(*):Int64;N]\ \n Aggregate: groupBy=[[]], aggr=[[MAX(COUNT(Int64(1))) AS MAX(COUNT(*))]] [MAX(COUNT(*)):Int64;N]\ \n TableScan: test [a:UInt32, b:UInt32, c:UInt32]"; - assert_plan_eq(&plan, expected) + assert_plan_eq(plan, expected) } } diff --git a/datafusion/optimizer/src/analyzer/inline_table_scan.rs b/datafusion/optimizer/src/analyzer/inline_table_scan.rs index db1ce18e86f5..73ab37cb11d8 100644 --- a/datafusion/optimizer/src/analyzer/inline_table_scan.rs +++ b/datafusion/optimizer/src/analyzer/inline_table_scan.rs @@ -181,7 +181,7 @@ mod tests { \n Projection: y.a, y.b\ \n TableScan: y"; - assert_analyzed_plan_eq(Arc::new(InlineTableScan::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(InlineTableScan::new()), plan, expected) } #[test] @@ -197,6 +197,6 @@ mod tests { \n Projection: y.a\ \n TableScan: y"; - assert_analyzed_plan_eq(Arc::new(InlineTableScan::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(InlineTableScan::new()), plan, expected) } } diff --git a/datafusion/optimizer/src/analyzer/mod.rs b/datafusion/optimizer/src/analyzer/mod.rs index fb0eb14da659..1553f95266c8 100644 --- a/datafusion/optimizer/src/analyzer/mod.rs +++ b/datafusion/optimizer/src/analyzer/mod.rs @@ -115,7 +115,7 @@ impl Analyzer { /// do necessary check and fail the invalid plans pub fn execute_and_check( &self, - plan: &LogicalPlan, + plan: LogicalPlan, config: &ConfigOptions, mut observer: F, ) -> Result @@ -123,7 +123,7 @@ impl Analyzer { F: FnMut(&LogicalPlan, &dyn AnalyzerRule), { let start_time = Instant::now(); - let mut new_plan = plan.clone(); + let mut new_plan = plan; // Create an analyzer pass that rewrites `Expr`s to function_calls, as // appropriate. diff --git a/datafusion/optimizer/src/analyzer/type_coercion.rs b/datafusion/optimizer/src/analyzer/type_coercion.rs index 9295b08f419e..10479f29a583 100644 --- a/datafusion/optimizer/src/analyzer/type_coercion.rs +++ b/datafusion/optimizer/src/analyzer/type_coercion.rs @@ -774,7 +774,7 @@ mod test { let empty = empty_with_type(DataType::Float64); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); let expected = "Projection: a < CAST(UInt32(2) AS Float64)\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[test] @@ -788,7 +788,7 @@ mod test { )?); let expected = "Projection: a < CAST(UInt32(2) AS Float64) OR a < CAST(UInt32(2) AS Float64)\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[derive(Debug, Clone)] @@ -829,7 +829,7 @@ mod test { let plan = LogicalPlan::Projection(Projection::try_new(vec![udf], empty)?); let expected = "Projection: TestScalarUDF(CAST(Int32(123) AS Float32))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[test] @@ -864,7 +864,7 @@ mod test { )?); let expected = "Projection: TestScalarUDF(CAST(Int64(10) AS Float32))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[test] @@ -888,7 +888,7 @@ mod test { )); let plan = LogicalPlan::Projection(Projection::try_new(vec![udaf], empty)?); let expected = "Projection: MY_AVG(CAST(Int64(10) AS Float64))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[test] @@ -916,7 +916,7 @@ mod test { None, )); let plan = LogicalPlan::Projection(Projection::try_new(vec![udaf], empty)?); - let err = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, "") + let err = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, "") .err() .unwrap(); assert_eq!( @@ -940,7 +940,7 @@ mod test { )); let plan = LogicalPlan::Projection(Projection::try_new(vec![agg_expr], empty)?); let expected = "Projection: AVG(CAST(Int64(12) AS Float64))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; let empty = empty_with_type(DataType::Int32); let fun: AggregateFunction = AggregateFunction::Avg; @@ -954,7 +954,7 @@ mod test { )); let plan = LogicalPlan::Projection(Projection::try_new(vec![agg_expr], empty)?); let expected = "Projection: AVG(CAST(a AS Float64))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1015,7 +1015,7 @@ mod test { let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); let expected = "Projection: CAST(Utf8(\"1998-03-18\") AS Date32) + IntervalDayTime(\"386547056640\")\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1028,7 +1028,7 @@ mod test { let expected = "Projection: a IN ([CAST(Int32(1) AS Int64), CAST(Int8(4) AS Int64), Int64(8)]) AS a IN (Map { iter: Iter([Literal(Int32(1)), Literal(Int8(4)), Literal(Int64(8))]) })\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; // a in (1,4,8), a is decimal let expr = col("a").in_list(vec![lit(1_i32), lit(4_i8), lit(8_i64)], false); @@ -1043,7 +1043,7 @@ mod test { let expected = "Projection: CAST(a AS Decimal128(24, 4)) IN ([CAST(Int32(1) AS Decimal128(24, 4)), CAST(Int8(4) AS Decimal128(24, 4)), CAST(Int64(8) AS Decimal128(24, 4))]) AS a IN (Map { iter: Iter([Literal(Int32(1)), Literal(Int8(4)), Literal(Int64(8))]) })\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[test] @@ -1059,7 +1059,7 @@ mod test { let expected = "Filter: a BETWEEN Utf8(\"2002-05-08\") AND CAST(CAST(Utf8(\"2002-05-08\") AS Date32) + IntervalYearMonth(\"1\") AS Utf8)\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[test] @@ -1076,7 +1076,7 @@ mod test { let expected = "Filter: CAST(a AS Date32) BETWEEN CAST(Utf8(\"2002-05-08\") AS Date32) + IntervalYearMonth(\"1\") AND CAST(Utf8(\"2002-12-08\") AS Date32)\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected) + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected) } #[test] @@ -1087,11 +1087,11 @@ mod test { let plan = LogicalPlan::Projection(Projection::try_new(vec![expr.clone()], empty)?); let expected = "Projection: a IS TRUE\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; let empty = empty_with_type(DataType::Int64); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); - let ret = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, ""); + let ret = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, ""); let err = ret.unwrap_err().to_string(); assert!(err.contains("Cannot infer common argument type for comparison operation Int64 IS DISTINCT FROM Boolean"), "{err}"); @@ -1100,21 +1100,21 @@ mod test { let empty = empty_with_type(DataType::Boolean); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); let expected = "Projection: a IS NOT TRUE\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; // is false let expr = col("a").is_false(); let empty = empty_with_type(DataType::Boolean); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); let expected = "Projection: a IS FALSE\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; // is not false let expr = col("a").is_not_false(); let empty = empty_with_type(DataType::Boolean); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); let expected = "Projection: a IS NOT FALSE\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1128,7 +1128,7 @@ mod test { let empty = empty_with_type(DataType::Utf8); let plan = LogicalPlan::Projection(Projection::try_new(vec![like_expr], empty)?); let expected = "Projection: a LIKE Utf8(\"abc\")\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; let expr = Box::new(col("a")); let pattern = Box::new(lit(ScalarValue::Null)); @@ -1137,14 +1137,14 @@ mod test { let plan = LogicalPlan::Projection(Projection::try_new(vec![like_expr], empty)?); let expected = "Projection: a LIKE CAST(NULL AS Utf8) AS a LIKE NULL \ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; let expr = Box::new(col("a")); let pattern = Box::new(lit(ScalarValue::new_utf8("abc"))); let like_expr = Expr::Like(Like::new(false, expr, pattern, None, false)); let empty = empty_with_type(DataType::Int64); let plan = LogicalPlan::Projection(Projection::try_new(vec![like_expr], empty)?); - let err = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected); + let err = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected); assert!(err.is_err()); assert!(err.unwrap_err().to_string().contains( "There isn't a common type to coerce Int64 and Utf8 in LIKE expression" @@ -1157,7 +1157,7 @@ mod test { let empty = empty_with_type(DataType::Utf8); let plan = LogicalPlan::Projection(Projection::try_new(vec![ilike_expr], empty)?); let expected = "Projection: a ILIKE Utf8(\"abc\")\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; let expr = Box::new(col("a")); let pattern = Box::new(lit(ScalarValue::Null)); @@ -1166,14 +1166,14 @@ mod test { let plan = LogicalPlan::Projection(Projection::try_new(vec![ilike_expr], empty)?); let expected = "Projection: a ILIKE CAST(NULL AS Utf8) AS a ILIKE NULL \ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; let expr = Box::new(col("a")); let pattern = Box::new(lit(ScalarValue::new_utf8("abc"))); let ilike_expr = Expr::Like(Like::new(false, expr, pattern, None, true)); let empty = empty_with_type(DataType::Int64); let plan = LogicalPlan::Projection(Projection::try_new(vec![ilike_expr], empty)?); - let err = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected); + let err = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected); assert!(err.is_err()); assert!(err.unwrap_err().to_string().contains( "There isn't a common type to coerce Int64 and Utf8 in ILIKE expression" @@ -1189,11 +1189,11 @@ mod test { let plan = LogicalPlan::Projection(Projection::try_new(vec![expr.clone()], empty)?); let expected = "Projection: a IS UNKNOWN\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; let empty = empty_with_type(DataType::Utf8); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); - let ret = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected); + let ret = assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected); let err = ret.unwrap_err().to_string(); assert!(err.contains("Cannot infer common argument type for comparison operation Utf8 IS DISTINCT FROM Boolean"), "{err}"); @@ -1202,7 +1202,7 @@ mod test { let empty = empty_with_type(DataType::Boolean); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); let expected = "Projection: a IS NOT UNKNOWN\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1222,7 +1222,7 @@ mod test { LogicalPlan::Projection(Projection::try_new(vec![expr], empty.clone())?); let expected = "Projection: TestScalarUDF(a, Utf8(\"b\"), CAST(Boolean(true) AS Utf8), CAST(Boolean(false) AS Utf8), CAST(Int32(13) AS Utf8))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; } Ok(()) @@ -1278,7 +1278,7 @@ mod test { dbg!(&plan); let expected = "Projection: CAST(Utf8(\"1998-03-18\") AS Timestamp(Nanosecond, None)) = CAST(CAST(Utf8(\"1998-03-18\") AS Date32) AS Timestamp(Nanosecond, None))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1443,7 +1443,7 @@ mod test { let empty = empty(); let plan = LogicalPlan::Projection(Projection::try_new(vec![expr], empty)?); let expected = "Projection: IntervalYearMonth(\"12\") + CAST(Utf8(\"2000-01-01T00:00:00\") AS Timestamp(Nanosecond, None))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1465,7 +1465,7 @@ mod test { dbg!(&plan); let expected = "Projection: CAST(Utf8(\"1998-03-18\") AS Timestamp(Nanosecond, None)) - CAST(Utf8(\"1998-03-18\") AS Timestamp(Nanosecond, None))\n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1490,7 +1490,7 @@ mod test { \n Projection: CAST(a AS Int64)\ \n EmptyRelation\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1514,7 +1514,7 @@ mod test { \n Subquery:\ \n EmptyRelation\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } @@ -1538,7 +1538,7 @@ mod test { \n Projection: CAST(a AS Decimal128(13, 8))\ \n EmptyRelation\ \n EmptyRelation"; - assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), &plan, expected)?; + assert_analyzed_plan_eq(Arc::new(TypeCoercion::new()), plan, expected)?; Ok(()) } } diff --git a/datafusion/optimizer/src/decorrelate_predicate_subquery.rs b/datafusion/optimizer/src/decorrelate_predicate_subquery.rs index b2650ac933e3..58fd8557194f 100644 --- a/datafusion/optimizer/src/decorrelate_predicate_subquery.rs +++ b/datafusion/optimizer/src/decorrelate_predicate_subquery.rs @@ -852,7 +852,7 @@ mod tests { let expected = "check_analyzed_plan\ \ncaused by\ \nError during planning: InSubquery should only return one column, but found 4"; - assert_analyzer_check_err(vec![], &plan, expected); + assert_analyzer_check_err(vec![], plan, expected); Ok(()) } @@ -947,7 +947,7 @@ mod tests { let expected = "check_analyzed_plan\ \ncaused by\ \nError during planning: InSubquery should only return one column"; - assert_analyzer_check_err(vec![], &plan, expected); + assert_analyzer_check_err(vec![], plan, expected); Ok(()) } diff --git a/datafusion/optimizer/src/scalar_subquery_to_join.rs b/datafusion/optimizer/src/scalar_subquery_to_join.rs index 3ee6af415e08..b7fce68fb3cc 100644 --- a/datafusion/optimizer/src/scalar_subquery_to_join.rs +++ b/datafusion/optimizer/src/scalar_subquery_to_join.rs @@ -620,7 +620,7 @@ mod tests { \ncaused by\ \nError during planning: Correlated column is not allowed in predicate: outer_ref(customer.c_custkey) != orders.o_custkey"; - assert_analyzer_check_err(vec![], &plan, expected); + assert_analyzer_check_err(vec![], plan, expected); Ok(()) } @@ -647,7 +647,7 @@ mod tests { \ncaused by\ \nError during planning: Correlated column is not allowed in predicate: outer_ref(customer.c_custkey) < orders.o_custkey"; - assert_analyzer_check_err(vec![], &plan, expected); + assert_analyzer_check_err(vec![], plan, expected); Ok(()) } @@ -675,7 +675,7 @@ mod tests { \ncaused by\ \nError during planning: Correlated column is not allowed in predicate: outer_ref(customer.c_custkey) = orders.o_custkey OR orders.o_orderkey = Int32(1)"; - assert_analyzer_check_err(vec![], &plan, expected); + assert_analyzer_check_err(vec![], plan, expected); Ok(()) } @@ -696,7 +696,7 @@ mod tests { let expected = "check_analyzed_plan\ \ncaused by\ \nError during planning: Scalar subquery should only return one column"; - assert_analyzer_check_err(vec![], &plan, expected); + assert_analyzer_check_err(vec![], plan, expected); Ok(()) } @@ -758,7 +758,7 @@ mod tests { let expected = "check_analyzed_plan\ \ncaused by\ \nError during planning: Scalar subquery should only return one column"; - assert_analyzer_check_err(vec![], &plan, expected); + assert_analyzer_check_err(vec![], plan, expected); Ok(()) } diff --git a/datafusion/optimizer/src/test/mod.rs b/datafusion/optimizer/src/test/mod.rs index cafda8359aa3..98d19956df3c 100644 --- a/datafusion/optimizer/src/test/mod.rs +++ b/datafusion/optimizer/src/test/mod.rs @@ -110,7 +110,7 @@ pub fn get_tpch_table_schema(table: &str) -> Schema { pub fn assert_analyzed_plan_eq( rule: Arc, - plan: &LogicalPlan, + plan: LogicalPlan, expected: &str, ) -> Result<()> { let options = ConfigOptions::default(); @@ -123,7 +123,7 @@ pub fn assert_analyzed_plan_eq( } pub fn assert_analyzed_plan_eq_display_indent( rule: Arc, - plan: &LogicalPlan, + plan: LogicalPlan, expected: &str, ) -> Result<()> { let options = ConfigOptions::default(); @@ -137,7 +137,7 @@ pub fn assert_analyzed_plan_eq_display_indent( pub fn assert_analyzer_check_err( rules: Vec>, - plan: &LogicalPlan, + plan: LogicalPlan, expected: &str, ) { let options = ConfigOptions::default(); diff --git a/datafusion/optimizer/tests/optimizer_integration.rs b/datafusion/optimizer/tests/optimizer_integration.rs index adf62efa0b67..2936d825ee39 100644 --- a/datafusion/optimizer/tests/optimizer_integration.rs +++ b/datafusion/optimizer/tests/optimizer_integration.rs @@ -330,7 +330,7 @@ fn test_sql(sql: &str) -> Result { let analyzer = Analyzer::new(); let optimizer = Optimizer::new(); // analyze and optimize the logical plan - let plan = analyzer.execute_and_check(&plan, config.options(), |_, _| {})?; + let plan = analyzer.execute_and_check(plan, config.options(), |_, _| {})?; optimizer.optimize(plan, &config, observe) }