This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datafusion.git
The following commit(s) were added to refs/heads/main by this push:
new 1f23703b5c Minor: Do not force analyzer to copy logical plans (#10367)
1f23703b5c is described below
commit 1f23703b5cd07315d93188d238778ddb3963faab
Author: Andrew Lamb <[email protected]>
AuthorDate: Sun May 5 07:25:40 2024 -0400
Minor: Do not force analyzer to copy logical plans (#10367)
* Minor: Do not force analyzer to copy logical plans
* remove clone
---
datafusion-examples/examples/rewrite_expr.rs | 2 +-
datafusion/core/src/execution/context/mod.rs | 10 ++--
datafusion/core/tests/optimizer_integration.rs | 2 +-
.../optimizer/src/analyzer/count_wildcard_rule.rs | 16 ++---
.../optimizer/src/analyzer/inline_table_scan.rs | 4 +-
datafusion/optimizer/src/analyzer/mod.rs | 4 +-
datafusion/optimizer/src/analyzer/type_coercion.rs | 68 +++++++++++-----------
.../src/decorrelate_predicate_subquery.rs | 4 +-
.../optimizer/src/scalar_subquery_to_join.rs | 10 ++--
datafusion/optimizer/src/test/mod.rs | 6 +-
.../optimizer/tests/optimizer_integration.rs | 2 +-
11 files changed, 65 insertions(+), 63 deletions(-)
diff --git a/datafusion-examples/examples/rewrite_expr.rs
b/datafusion-examples/examples/rewrite_expr.rs
index 9b94a71a50..4943fee444 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 d9efd1a037..35c5c67910 100644
--- a/datafusion/core/src/execution/context/mod.rs
+++ b/datafusion/core/src/execution/context/mod.rs
@@ -1877,7 +1877,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();
@@ -1936,9 +1936,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 5a7870b7a0..8acf8618c7 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<LogicalPlan> {
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 1ab3d1a810..a607d49ef9 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 db1ce18e86..73ab37cb11 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 fb0eb14da6..1553f95266 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<F>(
&self,
- plan: &LogicalPlan,
+ plan: LogicalPlan,
config: &ConfigOptions,
mut observer: F,
) -> Result<LogicalPlan>
@@ -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 9295b08f41..10479f29a5 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 b2650ac933..58fd855719 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 3ee6af415e..b7fce68fb3 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 cafda8359a..98d19956df 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<dyn AnalyzerRule + Send + Sync>,
- 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<dyn AnalyzerRule + Send + Sync>,
- 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<Arc<dyn AnalyzerRule + Send + Sync>>,
- 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 adf62efa0b..2936d825ee 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<LogicalPlan> {
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)
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
