refactor: split relation of planner into one part.

datafusion/core/tests/sqllogictests/src/insert/mod.rs

@@ -66,7 +66,7 @@ pub async fn insert(ctx: &SessionContext, insert_stmt: SQLStatement) -> Result<D
         let logical_exprs = row
             .into_iter()
             .map(|expr| {
-                sql_to_rel.sql_to_rex(
+                sql_to_rel.sql_to_expr(
                     expr,
                     &DFSchema::empty(),
                     &mut PlannerContext::new(),

datafusion/sql/src/expr/mod.rs

@@ -28,7 +28,7 @@ mod value;
 use crate::planner::{ContextProvider, PlannerContext, SqlToRel};
 use crate::utils::normalize_ident;
 use arrow_schema::DataType;
-use datafusion_common::{DFSchema, DataFusionError, Result, ScalarValue};
+use datafusion_common::{Column, DFSchema, DataFusionError, Result, ScalarValue};
 use datafusion_expr::{
     col, expr, lit, AggregateFunction, Between, BinaryExpr, BuiltinScalarFunction, Cast,
     Expr, ExprSchemable, GetIndexedField, Like, Operator, TryCast,
@@ -66,6 +66,47 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         }
     }
 
+    /// Generate a relational expression from a SQL expression
+    pub fn sql_to_expr(
+        &self,
+        sql: SQLExpr,
+        schema: &DFSchema,
+        planner_context: &mut PlannerContext,
+    ) -> Result<Expr> {
+        let mut expr = self.sql_expr_to_logical_expr(sql, schema, planner_context)?;
+        expr = self.rewrite_partial_qualifier(expr, schema);
+        self.validate_schema_satisfies_exprs(schema, &[expr.clone()])?;
+        Ok(expr)
+    }
+
+    /// Rewrite aliases which are not-complete (e.g. ones that only include only table qualifier in a schema.table qualified relation)
+    fn rewrite_partial_qualifier(&self, expr: Expr, schema: &DFSchema) -> Expr {
+        match expr {
+            Expr::Column(col) => match &col.relation {
+                Some(q) => {
+                    match schema
+                        .fields()
+                        .iter()
+                        .find(|field| match field.qualifier() {
+                            Some(field_q) => {
+                                field.name() == &col.name
+                                    && field_q.ends_with(&format!(".{q}"))
+                            }
+                            _ => false,
+                        }) {
+                        Some(df_field) => Expr::Column(Column {
+                            relation: df_field.qualifier().cloned(),
+                            name: df_field.name().clone(),
+                        }),
+                        None => Expr::Column(col),
+                    }
+                }
+                None => Expr::Column(col),
+            },
+            _ => expr,
+        }
+    }
+
     /// Internal implementation. Use
     /// [`Self::sql_expr_to_logical_expr`] to plan exprs.
     fn sql_expr_to_logical_expr_internal(

datafusion/sql/src/expr/subquery.rs

@@ -51,7 +51,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         planner_context: &mut PlannerContext,
     ) -> Result<Expr> {
         Ok(Expr::InSubquery {
-            expr: Box::new(self.sql_to_rex(expr, input_schema, planner_context)?),
+            expr: Box::new(self.sql_to_expr(expr, input_schema, planner_context)?),
             subquery: Subquery {
                 subquery: Arc::new(self.subquery_to_plan(
                     subquery,

datafusion/sql/src/lib.rs

@@ -21,7 +21,13 @@
 mod expr;
 pub mod parser;
 pub mod planner;
+mod query;
+mod relation;
+mod select;
+mod set_expr;
+mod statement;
 pub mod utils;
+mod values;
 
 pub use datafusion_common::{ResolvedTableReference, TableReference};
 pub use sqlparser;