You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by yj...@apache.org on 2022/06/06 07:04:21 UTC
[arrow-datafusion] branch master updated: Move some tests from core to expr (#2700)
This is an automated email from the ASF dual-hosted git repository.
yjshen pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git
The following commit(s) were added to refs/heads/master by this push:
new bbb674a0b Move some tests from core to expr (#2700)
bbb674a0b is described below
commit bbb674a0bf16fb754afb7b6451d42061f23e96c8
Author: Andy Grove <ag...@apache.org>
AuthorDate: Mon Jun 6 01:04:17 2022 -0600
Move some tests from core to expr (#2700)
---
datafusion/core/src/logical_plan/plan.rs | 334 -------------------------------
datafusion/expr/src/logical_plan/plan.rs | 334 +++++++++++++++++++++++++++++++
2 files changed, 334 insertions(+), 334 deletions(-)
diff --git a/datafusion/core/src/logical_plan/plan.rs b/datafusion/core/src/logical_plan/plan.rs
index 0ef1ecd81..6529695ad 100644
--- a/datafusion/core/src/logical_plan/plan.rs
+++ b/datafusion/core/src/logical_plan/plan.rs
@@ -97,337 +97,3 @@ pub fn source_as_provider(
)),
}
}
-
-#[cfg(test)]
-mod tests {
- use super::super::{col, lit};
- use super::*;
- use crate::test_util::scan_empty;
- use arrow::datatypes::{DataType, Field, Schema};
-
- fn employee_schema() -> Schema {
- Schema::new(vec![
- Field::new("id", DataType::Int32, false),
- Field::new("first_name", DataType::Utf8, false),
- Field::new("last_name", DataType::Utf8, false),
- Field::new("state", DataType::Utf8, false),
- Field::new("salary", DataType::Int32, false),
- ])
- }
-
- fn display_plan() -> LogicalPlan {
- scan_empty(Some("employee_csv"), &employee_schema(), Some(vec![0, 3]))
- .unwrap()
- .filter(col("state").eq(lit("CO")))
- .unwrap()
- .project(vec![col("id")])
- .unwrap()
- .build()
- .unwrap()
- }
-
- #[test]
- fn test_display_indent() {
- let plan = display_plan();
-
- let expected = "Projection: #employee_csv.id\
- \n Filter: #employee_csv.state = Utf8(\"CO\")\
- \n TableScan: employee_csv projection=Some([id, state])";
-
- assert_eq!(expected, format!("{}", plan.display_indent()));
- }
-
- #[test]
- fn test_display_indent_schema() {
- let plan = display_plan();
-
- let expected = "Projection: #employee_csv.id [id:Int32]\
- \n Filter: #employee_csv.state = Utf8(\"CO\") [id:Int32, state:Utf8]\
- \n TableScan: employee_csv projection=Some([id, state]) [id:Int32, state:Utf8]";
-
- assert_eq!(expected, format!("{}", plan.display_indent_schema()));
- }
-
- #[test]
- fn test_display_graphviz() {
- let plan = display_plan();
-
- // just test for a few key lines in the output rather than the
- // whole thing to make test mainteance easier.
- let graphviz = format!("{}", plan.display_graphviz());
-
- assert!(
- graphviz.contains(
- r#"// Begin DataFusion GraphViz Plan (see https://graphviz.org)"#
- ),
- "\n{}",
- plan.display_graphviz()
- );
- assert!(
- graphviz.contains(
- r#"[shape=box label="TableScan: employee_csv projection=Some([id, state])"]"#
- ),
- "\n{}",
- plan.display_graphviz()
- );
- assert!(graphviz.contains(r#"[shape=box label="TableScan: employee_csv projection=Some([id, state])\nSchema: [id:Int32, state:Utf8]"]"#),
- "\n{}", plan.display_graphviz());
- assert!(
- graphviz.contains(r#"// End DataFusion GraphViz Plan"#),
- "\n{}",
- plan.display_graphviz()
- );
- }
-
- /// Tests for the Visitor trait and walking logical plan nodes
- #[derive(Debug, Default)]
- struct OkVisitor {
- strings: Vec<String>,
- }
-
- impl PlanVisitor for OkVisitor {
- type Error = String;
-
- fn pre_visit(
- &mut self,
- plan: &LogicalPlan,
- ) -> std::result::Result<bool, Self::Error> {
- let s = match plan {
- LogicalPlan::Projection { .. } => "pre_visit Projection",
- LogicalPlan::Filter { .. } => "pre_visit Filter",
- LogicalPlan::TableScan { .. } => "pre_visit TableScan",
- _ => unimplemented!("unknown plan type"),
- };
-
- self.strings.push(s.into());
- Ok(true)
- }
-
- fn post_visit(
- &mut self,
- plan: &LogicalPlan,
- ) -> std::result::Result<bool, Self::Error> {
- let s = match plan {
- LogicalPlan::Projection { .. } => "post_visit Projection",
- LogicalPlan::Filter { .. } => "post_visit Filter",
- LogicalPlan::TableScan { .. } => "post_visit TableScan",
- _ => unimplemented!("unknown plan type"),
- };
-
- self.strings.push(s.into());
- Ok(true)
- }
- }
-
- #[test]
- fn visit_order() {
- let mut visitor = OkVisitor::default();
- let plan = test_plan();
- let res = plan.accept(&mut visitor);
- assert!(res.is_ok());
-
- assert_eq!(
- visitor.strings,
- vec![
- "pre_visit Projection",
- "pre_visit Filter",
- "pre_visit TableScan",
- "post_visit TableScan",
- "post_visit Filter",
- "post_visit Projection",
- ]
- );
- }
-
- #[derive(Debug, Default)]
- /// Counter than counts to zero and returns true when it gets there
- struct OptionalCounter {
- val: Option<usize>,
- }
-
- impl OptionalCounter {
- fn new(val: usize) -> Self {
- Self { val: Some(val) }
- }
- // Decrements the counter by 1, if any, returning true if it hits zero
- fn dec(&mut self) -> bool {
- if Some(0) == self.val {
- true
- } else {
- self.val = self.val.take().map(|i| i - 1);
- false
- }
- }
- }
-
- #[derive(Debug, Default)]
- /// Visitor that returns false after some number of visits
- struct StoppingVisitor {
- inner: OkVisitor,
- /// When Some(0) returns false from pre_visit
- return_false_from_pre_in: OptionalCounter,
- /// When Some(0) returns false from post_visit
- return_false_from_post_in: OptionalCounter,
- }
-
- impl PlanVisitor for StoppingVisitor {
- type Error = String;
-
- fn pre_visit(
- &mut self,
- plan: &LogicalPlan,
- ) -> std::result::Result<bool, Self::Error> {
- if self.return_false_from_pre_in.dec() {
- return Ok(false);
- }
- self.inner.pre_visit(plan)
- }
-
- fn post_visit(
- &mut self,
- plan: &LogicalPlan,
- ) -> std::result::Result<bool, Self::Error> {
- if self.return_false_from_post_in.dec() {
- return Ok(false);
- }
-
- self.inner.post_visit(plan)
- }
- }
-
- /// test early stopping in pre-visit
- #[test]
- fn early_stopping_pre_visit() {
- let mut visitor = StoppingVisitor {
- return_false_from_pre_in: OptionalCounter::new(2),
- ..Default::default()
- };
- let plan = test_plan();
- let res = plan.accept(&mut visitor);
- assert!(res.is_ok());
-
- assert_eq!(
- visitor.inner.strings,
- vec!["pre_visit Projection", "pre_visit Filter"]
- );
- }
-
- #[test]
- fn early_stopping_post_visit() {
- let mut visitor = StoppingVisitor {
- return_false_from_post_in: OptionalCounter::new(1),
- ..Default::default()
- };
- let plan = test_plan();
- let res = plan.accept(&mut visitor);
- assert!(res.is_ok());
-
- assert_eq!(
- visitor.inner.strings,
- vec![
- "pre_visit Projection",
- "pre_visit Filter",
- "pre_visit TableScan",
- "post_visit TableScan",
- ]
- );
- }
-
- #[derive(Debug, Default)]
- /// Visitor that returns an error after some number of visits
- struct ErrorVisitor {
- inner: OkVisitor,
- /// When Some(0) returns false from pre_visit
- return_error_from_pre_in: OptionalCounter,
- /// When Some(0) returns false from post_visit
- return_error_from_post_in: OptionalCounter,
- }
-
- impl PlanVisitor for ErrorVisitor {
- type Error = String;
-
- fn pre_visit(
- &mut self,
- plan: &LogicalPlan,
- ) -> std::result::Result<bool, Self::Error> {
- if self.return_error_from_pre_in.dec() {
- return Err("Error in pre_visit".into());
- }
-
- self.inner.pre_visit(plan)
- }
-
- fn post_visit(
- &mut self,
- plan: &LogicalPlan,
- ) -> std::result::Result<bool, Self::Error> {
- if self.return_error_from_post_in.dec() {
- return Err("Error in post_visit".into());
- }
-
- self.inner.post_visit(plan)
- }
- }
-
- #[test]
- fn error_pre_visit() {
- let mut visitor = ErrorVisitor {
- return_error_from_pre_in: OptionalCounter::new(2),
- ..Default::default()
- };
- let plan = test_plan();
- let res = plan.accept(&mut visitor);
-
- if let Err(e) = res {
- assert_eq!("Error in pre_visit", e);
- } else {
- panic!("Expected an error");
- }
-
- assert_eq!(
- visitor.inner.strings,
- vec!["pre_visit Projection", "pre_visit Filter"]
- );
- }
-
- #[test]
- fn error_post_visit() {
- let mut visitor = ErrorVisitor {
- return_error_from_post_in: OptionalCounter::new(1),
- ..Default::default()
- };
- let plan = test_plan();
- let res = plan.accept(&mut visitor);
- if let Err(e) = res {
- assert_eq!("Error in post_visit", e);
- } else {
- panic!("Expected an error");
- }
-
- assert_eq!(
- visitor.inner.strings,
- vec![
- "pre_visit Projection",
- "pre_visit Filter",
- "pre_visit TableScan",
- "post_visit TableScan",
- ]
- );
- }
-
- fn test_plan() -> LogicalPlan {
- let schema = Schema::new(vec![
- Field::new("id", DataType::Int32, false),
- Field::new("state", DataType::Utf8, false),
- ]);
-
- scan_empty(None, &schema, Some(vec![0, 1]))
- .unwrap()
- .filter(col("state").eq(lit("CO")))
- .unwrap()
- .project(vec![col("id")])
- .unwrap()
- .build()
- .unwrap()
- }
-}
diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rs
index 7174a4c77..022f50ea3 100644
--- a/datafusion/expr/src/logical_plan/plan.rs
+++ b/datafusion/expr/src/logical_plan/plan.rs
@@ -1344,3 +1344,337 @@ pub trait ToStringifiedPlan {
/// Create a stringified plan with the specified type
fn to_stringified(&self, plan_type: PlanType) -> StringifiedPlan;
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::logical_plan::table_scan;
+ use crate::{col, lit};
+ use arrow::datatypes::{DataType, Field, Schema};
+
+ fn employee_schema() -> Schema {
+ Schema::new(vec![
+ Field::new("id", DataType::Int32, false),
+ Field::new("first_name", DataType::Utf8, false),
+ Field::new("last_name", DataType::Utf8, false),
+ Field::new("state", DataType::Utf8, false),
+ Field::new("salary", DataType::Int32, false),
+ ])
+ }
+
+ fn display_plan() -> LogicalPlan {
+ table_scan(Some("employee_csv"), &employee_schema(), Some(vec![0, 3]))
+ .unwrap()
+ .filter(col("state").eq(lit("CO")))
+ .unwrap()
+ .project(vec![col("id")])
+ .unwrap()
+ .build()
+ .unwrap()
+ }
+
+ #[test]
+ fn test_display_indent() {
+ let plan = display_plan();
+
+ let expected = "Projection: #employee_csv.id\
+ \n Filter: #employee_csv.state = Utf8(\"CO\")\
+ \n TableScan: employee_csv projection=Some([id, state])";
+
+ assert_eq!(expected, format!("{}", plan.display_indent()));
+ }
+
+ #[test]
+ fn test_display_indent_schema() {
+ let plan = display_plan();
+
+ let expected = "Projection: #employee_csv.id [id:Int32]\
+ \n Filter: #employee_csv.state = Utf8(\"CO\") [id:Int32, state:Utf8]\
+ \n TableScan: employee_csv projection=Some([id, state]) [id:Int32, state:Utf8]";
+
+ assert_eq!(expected, format!("{}", plan.display_indent_schema()));
+ }
+
+ #[test]
+ fn test_display_graphviz() {
+ let plan = display_plan();
+
+ // just test for a few key lines in the output rather than the
+ // whole thing to make test mainteance easier.
+ let graphviz = format!("{}", plan.display_graphviz());
+
+ assert!(
+ graphviz.contains(
+ r#"// Begin DataFusion GraphViz Plan (see https://graphviz.org)"#
+ ),
+ "\n{}",
+ plan.display_graphviz()
+ );
+ assert!(
+ graphviz.contains(
+ r#"[shape=box label="TableScan: employee_csv projection=Some([id, state])"]"#
+ ),
+ "\n{}",
+ plan.display_graphviz()
+ );
+ assert!(graphviz.contains(r#"[shape=box label="TableScan: employee_csv projection=Some([id, state])\nSchema: [id:Int32, state:Utf8]"]"#),
+ "\n{}", plan.display_graphviz());
+ assert!(
+ graphviz.contains(r#"// End DataFusion GraphViz Plan"#),
+ "\n{}",
+ plan.display_graphviz()
+ );
+ }
+
+ /// Tests for the Visitor trait and walking logical plan nodes
+ #[derive(Debug, Default)]
+ struct OkVisitor {
+ strings: Vec<String>,
+ }
+
+ impl PlanVisitor for OkVisitor {
+ type Error = String;
+
+ fn pre_visit(
+ &mut self,
+ plan: &LogicalPlan,
+ ) -> std::result::Result<bool, Self::Error> {
+ let s = match plan {
+ LogicalPlan::Projection { .. } => "pre_visit Projection",
+ LogicalPlan::Filter { .. } => "pre_visit Filter",
+ LogicalPlan::TableScan { .. } => "pre_visit TableScan",
+ _ => unimplemented!("unknown plan type"),
+ };
+
+ self.strings.push(s.into());
+ Ok(true)
+ }
+
+ fn post_visit(
+ &mut self,
+ plan: &LogicalPlan,
+ ) -> std::result::Result<bool, Self::Error> {
+ let s = match plan {
+ LogicalPlan::Projection { .. } => "post_visit Projection",
+ LogicalPlan::Filter { .. } => "post_visit Filter",
+ LogicalPlan::TableScan { .. } => "post_visit TableScan",
+ _ => unimplemented!("unknown plan type"),
+ };
+
+ self.strings.push(s.into());
+ Ok(true)
+ }
+ }
+
+ #[test]
+ fn visit_order() {
+ let mut visitor = OkVisitor::default();
+ let plan = test_plan();
+ let res = plan.accept(&mut visitor);
+ assert!(res.is_ok());
+
+ assert_eq!(
+ visitor.strings,
+ vec![
+ "pre_visit Projection",
+ "pre_visit Filter",
+ "pre_visit TableScan",
+ "post_visit TableScan",
+ "post_visit Filter",
+ "post_visit Projection",
+ ]
+ );
+ }
+
+ #[derive(Debug, Default)]
+ /// Counter than counts to zero and returns true when it gets there
+ struct OptionalCounter {
+ val: Option<usize>,
+ }
+
+ impl OptionalCounter {
+ fn new(val: usize) -> Self {
+ Self { val: Some(val) }
+ }
+ // Decrements the counter by 1, if any, returning true if it hits zero
+ fn dec(&mut self) -> bool {
+ if Some(0) == self.val {
+ true
+ } else {
+ self.val = self.val.take().map(|i| i - 1);
+ false
+ }
+ }
+ }
+
+ #[derive(Debug, Default)]
+ /// Visitor that returns false after some number of visits
+ struct StoppingVisitor {
+ inner: OkVisitor,
+ /// When Some(0) returns false from pre_visit
+ return_false_from_pre_in: OptionalCounter,
+ /// When Some(0) returns false from post_visit
+ return_false_from_post_in: OptionalCounter,
+ }
+
+ impl PlanVisitor for StoppingVisitor {
+ type Error = String;
+
+ fn pre_visit(
+ &mut self,
+ plan: &LogicalPlan,
+ ) -> std::result::Result<bool, Self::Error> {
+ if self.return_false_from_pre_in.dec() {
+ return Ok(false);
+ }
+ self.inner.pre_visit(plan)
+ }
+
+ fn post_visit(
+ &mut self,
+ plan: &LogicalPlan,
+ ) -> std::result::Result<bool, Self::Error> {
+ if self.return_false_from_post_in.dec() {
+ return Ok(false);
+ }
+
+ self.inner.post_visit(plan)
+ }
+ }
+
+ /// test early stopping in pre-visit
+ #[test]
+ fn early_stopping_pre_visit() {
+ let mut visitor = StoppingVisitor {
+ return_false_from_pre_in: OptionalCounter::new(2),
+ ..Default::default()
+ };
+ let plan = test_plan();
+ let res = plan.accept(&mut visitor);
+ assert!(res.is_ok());
+
+ assert_eq!(
+ visitor.inner.strings,
+ vec!["pre_visit Projection", "pre_visit Filter"]
+ );
+ }
+
+ #[test]
+ fn early_stopping_post_visit() {
+ let mut visitor = StoppingVisitor {
+ return_false_from_post_in: OptionalCounter::new(1),
+ ..Default::default()
+ };
+ let plan = test_plan();
+ let res = plan.accept(&mut visitor);
+ assert!(res.is_ok());
+
+ assert_eq!(
+ visitor.inner.strings,
+ vec![
+ "pre_visit Projection",
+ "pre_visit Filter",
+ "pre_visit TableScan",
+ "post_visit TableScan",
+ ]
+ );
+ }
+
+ #[derive(Debug, Default)]
+ /// Visitor that returns an error after some number of visits
+ struct ErrorVisitor {
+ inner: OkVisitor,
+ /// When Some(0) returns false from pre_visit
+ return_error_from_pre_in: OptionalCounter,
+ /// When Some(0) returns false from post_visit
+ return_error_from_post_in: OptionalCounter,
+ }
+
+ impl PlanVisitor for ErrorVisitor {
+ type Error = String;
+
+ fn pre_visit(
+ &mut self,
+ plan: &LogicalPlan,
+ ) -> std::result::Result<bool, Self::Error> {
+ if self.return_error_from_pre_in.dec() {
+ return Err("Error in pre_visit".into());
+ }
+
+ self.inner.pre_visit(plan)
+ }
+
+ fn post_visit(
+ &mut self,
+ plan: &LogicalPlan,
+ ) -> std::result::Result<bool, Self::Error> {
+ if self.return_error_from_post_in.dec() {
+ return Err("Error in post_visit".into());
+ }
+
+ self.inner.post_visit(plan)
+ }
+ }
+
+ #[test]
+ fn error_pre_visit() {
+ let mut visitor = ErrorVisitor {
+ return_error_from_pre_in: OptionalCounter::new(2),
+ ..Default::default()
+ };
+ let plan = test_plan();
+ let res = plan.accept(&mut visitor);
+
+ if let Err(e) = res {
+ assert_eq!("Error in pre_visit", e);
+ } else {
+ panic!("Expected an error");
+ }
+
+ assert_eq!(
+ visitor.inner.strings,
+ vec!["pre_visit Projection", "pre_visit Filter"]
+ );
+ }
+
+ #[test]
+ fn error_post_visit() {
+ let mut visitor = ErrorVisitor {
+ return_error_from_post_in: OptionalCounter::new(1),
+ ..Default::default()
+ };
+ let plan = test_plan();
+ let res = plan.accept(&mut visitor);
+ if let Err(e) = res {
+ assert_eq!("Error in post_visit", e);
+ } else {
+ panic!("Expected an error");
+ }
+
+ assert_eq!(
+ visitor.inner.strings,
+ vec![
+ "pre_visit Projection",
+ "pre_visit Filter",
+ "pre_visit TableScan",
+ "post_visit TableScan",
+ ]
+ );
+ }
+
+ fn test_plan() -> LogicalPlan {
+ let schema = Schema::new(vec![
+ Field::new("id", DataType::Int32, false),
+ Field::new("state", DataType::Utf8, false),
+ ]);
+
+ table_scan(None, &schema, Some(vec![0, 1]))
+ .unwrap()
+ .filter(col("state").eq(lit("CO")))
+ .unwrap()
+ .project(vec![col("id")])
+ .unwrap()
+ .build()
+ .unwrap()
+ }
+}