[feat]:fast check has column

datafusion/common/src/dfschema.rs

@@ -270,6 +270,21 @@ impl DFSchema {
  .collect()
  }
 
+ /// Find all fields match the given qualified name
+ pub fn fields_with_qualified_name(
+ &self,
+ qualifier: &str,
+ name: &str,
+ ) -> Vec<&DFField> {
+ self.fields
+ .iter()
+ .filter(|field| {
+ field.qualifier().map(|q| q.eq(qualifier)).unwrap_or(false)
+ && field.name() == name
+ })
+ .collect()
+ }
+
  /// Find all fields match the given name
  pub fn fields_with_unqualified_name(&self, name: &str) -> Vec<&DFField> {
  self.fields
@@ -314,6 +329,32 @@ impl DFSchema {
  }
  }
 
+ /// Find if the field exists with the given name
+ pub fn has_column_with_unqualified_name(&self, name: &str) -> bool {
+ let matches = self.fields_with_unqualified_name(name);
+ match matches.len() {
+ 1 => true,
+ _ => false,
+ }
+ }
+
+ /// Find if the field exists with the given qualified name
+ pub fn has_column_with_qualified_name(&self, qualifier: &str, name: &str) -> bool {
+ let matches = self.fields_with_qualified_name(qualifier, name);
+ match matches.len() {
+ 1 => true,
+ _ => false,
+ }
+ }
+
+ /// Find if the field exists with the given qualified column
+ pub fn has_column(&self, column: &Column) -> bool {
+ match &column.relation {
+ Some(r) => self.has_column_with_qualified_name(r, &column.name),
+ None => self.has_column_with_unqualified_name(&column.name),
+ }
+ }
+
  /// Check to see if unqualified field names matches field names in Arrow schema
  pub fn matches_arrow_schema(&self, arrow_schema: &Schema) -> bool {
  self.fields

datafusion/expr/src/logical_plan/builder.rs

@@ -349,10 +349,7 @@ impl LogicalPlanBuilder {
  input,
  mut expr,
  schema: _,
- }) if missing_cols
- .iter()
- .all(|c| input.schema().field_from_column(c).is_ok()) =>
- {
+ }) if missing_cols.iter().all(|c| input.schema().has_column(c)) => {
  let mut missing_exprs = missing_cols
  .iter()
  .map(|c| normalize_col(Expr::Column(c.clone()), &input))
@@ -656,13 +653,13 @@ impl LogicalPlanBuilder {
  let mut join_on: Vec<(Expr, Expr)> = vec![];
  let mut filters: Option<Expr> = None;
  for (l, r) in &on {
- if self.plan.schema().field_from_column(l).is_ok()
- && right.schema().field_from_column(r).is_ok()
+ if self.plan.schema().has_column(l)
+ && right.schema().has_column(r)
  && can_hash(self.plan.schema().field_from_column(l)?.data_type())
  {
  join_on.push((Expr::Column(l.clone()), Expr::Column(r.clone())));
- } else if self.plan.schema().field_from_column(r).is_ok()
- && right.schema().field_from_column(l).is_ok()
+ } else if self.plan.schema().has_column(l)
+ && right.schema().has_column(r)
  && can_hash(self.plan.schema().field_from_column(r)?.data_type())
  {
  join_on.push((Expr::Column(r.clone()), Expr::Column(l.clone())));

datafusion/optimizer/src/decorrelate_where_in.rs

@@ -167,7 +167,7 @@ fn optimize_where_in(
  let using_cols: Vec<Column> = expr
  .to_columns()?
  .into_iter()
- .filter(|col| input_schema.field_from_column(col).is_ok())
+ .filter(|col| input_schema.has_column(col))
  .collect::<_>();
 
  cols.extend(using_cols);

datafusion/optimizer/src/eliminate_outer_join.rs

@@ -84,10 +84,10 @@ impl OptimizerRule for EliminateOuterJoin {
  let mut left_non_nullable = false;
  let mut right_non_nullable = false;
  for col in non_nullable_cols.iter() {
- if join.left.schema().field_from_column(col).is_ok() {
+ if join.left.schema().has_column(col) {
  left_non_nullable = true;
  }
- if join.right.schema().field_from_column(col).is_ok() {
+ if join.right.schema().has_column(col) {
  right_non_nullable = true;
  }
  }
@@ -251,10 +251,10 @@ fn extract_non_nullable_columns(
  {
  for left_col in &left_non_nullable_cols {
  for right_col in &right_non_nullable_cols {
- if (left_schema.field_from_column(left_col).is_ok()
- && left_schema.field_from_column(right_col).is_ok())
- || (right_schema.field_from_column(left_col).is_ok()
- && right_schema.field_from_column(right_col).is_ok())
+ if (left_schema.has_column(left_col)
+ && left_schema.has_column(right_col))
+ || (right_schema.has_column(left_col)
+ && right_schema.has_column(right_col))
  {
  non_nullable_cols.push(left_col.clone());
  break;

datafusion/sql/src/query.rs

@@ -177,11 +177,12 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
  .try_for_each::<_, Result<()>>(|expr| {
  let columns = expr.to_columns()?;
 
- columns.into_iter().for_each(|c| {
- if schema.field_from_column(&c).is_err() {
+ columns.into_iter().try_for_each::<_, Result<()>>(|c| {
+ if !schema.has_column(&c) {
  missing_cols.push(c);
  }
- });
+ Ok(())
+ })?;
 
  Ok(())
  })?;