remove debug printlns

Author: andygrove

datafusion/common/src/dfschema.rs

@@ -525,9 +525,6 @@ impl DFField {
         data_type: DataType,
         nullable: bool,
     ) -> Self {
-        if name.starts_with("substr(substr(") {
-            todo!()
-        }
         DFField {
             qualifier: qualifier.map(|s| s.to_owned()),
             field: Field::new(name, data_type, nullable),

datafusion/core/src/logical_plan/builder.rs

@@ -1113,7 +1113,6 @@ pub fn project_with_alias(
     let mut projected_expr = vec![];
     for e in expr {
         let e = e.into();
-        println!("project_with_alias() e = {:?}", e);
         match e {
             Expr::Wildcard => {
                 projected_expr.extend(expand_wildcard(input_schema, &plan)?)
@@ -1124,31 +1123,21 @@ pub fn project_with_alias(
                 .push(columnize_expr(normalize_col(e, &plan)?, input_schema)),
         }
     }
-    println!("project_with_alias() projected_expr = {:?}", projected_expr);
-    println!("project_with_alias() input_schema = {:?}", input_schema);
     validate_unique_names("Projections", projected_expr.iter(), input_schema)?;
-    println!("project_with_alias() calling exprlist_to_fields()");
-    match exprlist_to_fields(&projected_expr, &plan) {
-        Ok(x) => {
-            let input_schema =
-                DFSchema::new_with_metadata(x, plan.schema().metadata().clone())?;
-            println!("C");
-            let schema = match alias {
-                Some(ref alias) => input_schema.replace_qualifier(alias.as_str()),
-                None => input_schema,
-            };
-            Ok(LogicalPlan::Projection(Projection {
-                expr: projected_expr,
-                input: Arc::new(plan.clone()),
-                schema: DFSchemaRef::new(schema),
-                alias,
-            }))
-        }
-        Err(_) => {
-            println!("uh oh");
-            todo!();
-        }
-    }
+    let input_schema = DFSchema::new_with_metadata(
+        exprlist_to_fields(&projected_expr, &plan)?,
+        plan.schema().metadata().clone(),
+    )?;
+    let schema = match alias {
+        Some(ref alias) => input_schema.replace_qualifier(alias.as_str()),
+        None => input_schema,
+    };
+    Ok(LogicalPlan::Projection(Projection {
+        expr: projected_expr,
+        input: Arc::new(plan.clone()),
+        schema: DFSchemaRef::new(schema),
+        alias,
+    }))
 }
 
 /// Resolves an `Expr::Wildcard` to a collection of `Expr::Column`'s.

datafusion/core/src/logical_plan/expr.rs

@@ -144,7 +144,6 @@ pub fn exprlist_to_fields<'a>(
     let exprs: Vec<Expr> = expr.into_iter().cloned().collect();
     match plan {
         LogicalPlan::Aggregate(agg) => {
-            println!("exprlist_to_fields() aggregate case");
             let mut fields = vec![];
             let group_columns: Vec<Expr> = agg
                 .columns_in_group_expr()?
@@ -160,10 +159,7 @@ pub fn exprlist_to_fields<'a>(
             }
             Ok(fields)
         }
-        _ => {
-            println!("exprlist_to_fields() legacy case");
-            exprs.iter().map(|e| e.to_field(input_schema)).collect()
-        }
+        _ => exprs.iter().map(|e| e.to_field(input_schema)).collect(),
     }
 }
 

datafusion/core/src/sql/planner.rs

@@ -1003,27 +1003,21 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         let aggr_exprs = find_aggregate_exprs(&aggr_expr_haystack);
 
         // All of the group by expressions
-
-        println!("select_to_plan OLD group_by_exprs = {:?}", select.group_by);
-
         let group_by_exprs = select
             .group_by
             .into_iter()
             .map(|e| {
                 let group_by_expr =
                     self.sql_expr_to_logical_expr(e, &combined_schema, ctes)?;
-                println!("select_to_plan 1 group_by_exprs = {:?}", group_by_expr);
-
+                //println!("select_to_plan 1 group_by_exprs = {:?}", group_by_expr);
                 // TODO fix this
                 // let group_by_expr = resolve_aliases_to_exprs(&group_by_expr, &alias_map)?;
                 // println!("select_to_plan 2 group_by_exprs = {:?}", group_by_expr);
 
                 let group_by_expr =
                     resolve_positions_to_exprs(&group_by_expr, &select_exprs)
                         .unwrap_or(group_by_expr);
-                println!("select_to_plan 3 group_by_exprs = {:?}", group_by_expr);
                 let group_by_expr = normalize_col(group_by_expr, &projected_plan)?;
-                println!("select_to_plan 4 group_by_exprs = {:?}", group_by_expr);
                 self.validate_schema_satisfies_exprs(
                     plan.schema(),
                     &[group_by_expr.clone()],
@@ -1032,8 +1026,6 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
             })
             .collect::<Result<Vec<Expr>>>()?;
 
-        println!("select_to_plan NEW group_by_exprs = {:?}", group_by_exprs);
-
         // process group by, aggregation or having
         let (plan, select_exprs_post_aggr, having_expr_post_aggr_opt) =
             if !group_by_exprs.is_empty() || !aggr_exprs.is_empty() {
@@ -1131,33 +1123,15 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         group_by_exprs: Vec<Expr>,
         aggr_exprs: Vec<Expr>,
     ) -> Result<(LogicalPlan, Vec<Expr>, Option<Expr>)> {
-        println!("aggregate() group_by_exprs={:?}", group_by_exprs);
-        println!("aggregate() input={:?}", input);
-
         let aggr_projection_exprs = group_by_exprs
             .iter()
             .chain(aggr_exprs.iter())
             .cloned()
             .collect::<Vec<Expr>>();
 
-        /*
-         let group_by_columns: Vec<Column> = group_by_exprs.iter().flat_map(|e| find_columns_referenced_by_expr(e)).collect();
-
-        let aggr_projection_exprs = group_by_columns
-            .iter()
-            .cloned()
-            .map(|c| Expr::Column(c))
-            .chain(aggr_exprs.iter().cloned())
-            .collect::<Vec<Expr>>();
-         */
-
         let plan = LogicalPlanBuilder::from(input.clone())
             .aggregate(group_by_exprs, aggr_exprs)?
             .build()?;
-        println!(
-            "aggregate() plan after calling aggregate() on builder ={:?}",
-            plan
-        );
 
         // After aggregation, these are all of the columns that will be
         // available to next phases of planning.
@@ -1173,12 +1147,11 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
             .map(|expr| rebase_expr(expr, &aggr_projection_exprs, &input))
             .collect::<Result<Vec<Expr>>>()?;
 
-        //TODO
-        // check_columns_satisfy_exprs(
-        //     &column_exprs_post_aggr,
-        //     &select_exprs_post_aggr,
-        //     "Projection references non-aggregate values",
-        // )?;
+        check_columns_satisfy_exprs(
+            &column_exprs_post_aggr,
+            &select_exprs_post_aggr,
+            "Projection references non-aggregate values",
+        )?;
 
         // Rewrite the HAVING expression to use the columns produced by the
         // aggregation.