[arrow-datafusion] branch master updated: remove redundant outer_query_schema (#4576)

[al...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

alamb 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 119f90f0a remove redundant outer_query_schema (#4576)
119f90f0a is described below

commit 119f90f0a1e681639d630fe616bb4599e1d20dee
Author: jakevin <ja...@gmail.com>
AuthorDate: Wed Dec 14 01:31:39 2022 +0800

    remove redundant outer_query_schema (#4576)
---
 datafusion/sql/src/planner.rs | 34 +++++++---------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)

diff --git a/datafusion/sql/src/planner.rs b/datafusion/sql/src/planner.rs
index ca3d20893..6cf279eda 100644
--- a/datafusion/sql/src/planner.rs
+++ b/datafusion/sql/src/planner.rs
@@ -701,20 +701,17 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         &self,
         mut from: Vec<TableWithJoins>,
         planner_context: &mut PlannerContext,
-        outer_query_schema: Option<&DFSchema>,
     ) -> Result<LogicalPlan> {
         match from.len() {
             0 => Ok(LogicalPlanBuilder::empty(true).build()?),
             1 => {
                 let from = from.remove(0);
-                self.plan_table_with_joins(from, planner_context, outer_query_schema)
+                self.plan_table_with_joins(from, planner_context)
             }
             _ => {
                 let plans = from
                     .into_iter()
-                    .map(|t| {
-                        self.plan_table_with_joins(t, planner_context, outer_query_schema)
-                    })
+                    .map(|t| self.plan_table_with_joins(t, planner_context))
                     .collect::<Result<Vec<_>>>()?;
                 let mut left = plans[0].clone();
                 for right in plans.iter().skip(1) {
@@ -729,7 +726,6 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         &self,
         t: TableWithJoins,
         planner_context: &mut PlannerContext,
-        outer_query_schema: Option<&DFSchema>,
     ) -> Result<LogicalPlan> {
         // From clause may exist CTEs, we should separate them from global CTEs.
         // CTEs in from clause are allowed to be duplicated.
@@ -737,8 +733,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         // So always use original global CTEs to plan CTEs in from clause.
         // Btw, don't need to add CTEs in from to global CTEs.
         let origin_planner_context = planner_context.clone();
-        let left =
-            self.create_relation(t.relation, planner_context, outer_query_schema)?;
+        let left = self.create_relation(t.relation, planner_context)?;
         match t.joins.len() {
             0 => {
                 *planner_context = origin_planner_context;
@@ -751,16 +746,10 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                     left,
                     joins.next().unwrap(), // length of joins > 0
                     planner_context,
-                    outer_query_schema,
                 )?;
                 for join in joins {
                     *planner_context = origin_planner_context.clone();
-                    left = self.parse_relation_join(
-                        left,
-                        join,
-                        planner_context,
-                        outer_query_schema,
-                    )?;
+                    left = self.parse_relation_join(left, join, planner_context)?;
                 }
                 *planner_context = origin_planner_context;
                 Ok(left)
@@ -773,10 +762,8 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         left: LogicalPlan,
         join: Join,
         planner_context: &mut PlannerContext,
-        outer_query_schema: Option<&DFSchema>,
     ) -> Result<LogicalPlan> {
-        let right =
-            self.create_relation(join.relation, planner_context, outer_query_schema)?;
+        let right = self.create_relation(join.relation, planner_context)?;
         match join.join_operator {
             JoinOperator::LeftOuter(constraint) => {
                 self.parse_join(left, right, constraint, JoinType::Left, planner_context)
@@ -914,7 +901,6 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         &self,
         relation: TableFactor,
         planner_context: &mut PlannerContext,
-        outer_query_schema: Option<&DFSchema>,
     ) -> Result<LogicalPlan> {
         let (plan, alias) = match relation {
             TableFactor::Table { name, alias, .. } => {
@@ -946,11 +932,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                 table_with_joins,
                 alias,
             } => (
-                self.plan_table_with_joins(
-                    *table_with_joins,
-                    planner_context,
-                    outer_query_schema,
-                )?,
+                self.plan_table_with_joins(*table_with_joins, planner_context)?,
                 alias,
             ),
             // @todo Support TableFactory::TableFunction?
@@ -1095,9 +1077,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         }
 
         // process `from` clause
-        let plan =
-            self.plan_from_tables(select.from, planner_context, outer_query_schema)?;
-
+        let plan = self.plan_from_tables(select.from, planner_context)?;
         let empty_from = matches!(plan, LogicalPlan::EmptyRelation(_));
         // build from schema for unqualifier column ambiguous check
         // we should get only one field for unqualifier column from schema.