refactor(cubesql): Fix useless_conversion warning

Author: mcheshkov

rust/cubesql/cubesql/Cargo.toml

@@ -141,6 +141,5 @@ unnecessary_to_owned = "allow"
 unnecessary_unwrap = "allow"
 unused_unit = "allow"
 unwrap_or_default = "allow"
-useless_conversion = "allow"
 useless_format = "allow"
 wrong_self_convention = "allow"

rust/cubesql/cubesql/e2e/tests/utils.rs

@@ -21,7 +21,7 @@ pub fn escape_snapshot_name(name: String) -> String {
 
     // Windows limit
     if name.len() > 200 {
-        name.chars().into_iter().take(200).collect()
+        name.chars().take(200).collect()
     } else {
         name
     }

rust/cubesql/cubesql/src/compile/engine/df/optimizers/filter_push_down.rs

@@ -120,7 +120,7 @@ fn filter_push_down(
             // let predicates = split_predicates(predicate)
             let predicates = vec![predicate.clone()]
                 .into_iter()
-                .chain(predicates.into_iter())
+                .chain(predicates)
                 .collect::<Vec<_>>();
             let mut pushable_predicates = vec![];
             let mut non_pushable_predicates = vec![];

rust/cubesql/cubesql/src/compile/engine/df/optimizers/utils.rs

@@ -415,25 +415,25 @@ pub fn get_expr_columns(expr: &Expr) -> Vec<Column> {
         Expr::BinaryExpr { left, right, .. } | Expr::AnyExpr { left, right, .. } => {
             get_expr_columns(left)
                 .into_iter()
-                .chain(get_expr_columns(right).into_iter())
+                .chain(get_expr_columns(right))
                 .collect()
         }
         Expr::Like(Like { expr, pattern, .. })
         | Expr::ILike(Like { expr, pattern, .. })
         | Expr::SimilarTo(Like { expr, pattern, .. }) => get_expr_columns(expr)
             .into_iter()
-            .chain(get_expr_columns(pattern).into_iter())
+            .chain(get_expr_columns(pattern))
             .collect(),
         Expr::GetIndexedField { expr, key } => get_expr_columns(expr)
             .into_iter()
-            .chain(get_expr_columns(key).into_iter())
+            .chain(get_expr_columns(key))
             .collect(),
         Expr::Between {
             expr, low, high, ..
         } => get_expr_columns(expr)
             .into_iter()
-            .chain(get_expr_columns(low).into_iter())
-            .chain(get_expr_columns(high).into_iter())
+            .chain(get_expr_columns(low))
+            .chain(get_expr_columns(high))
             .collect(),
         Expr::Case {
             expr,
@@ -447,15 +447,14 @@ pub fn get_expr_columns(expr: &Expr) -> Vec<Column> {
             .chain(when_then_expr.iter().flat_map(|(when, then)| {
                 get_expr_columns(when)
                     .into_iter()
-                    .chain(get_expr_columns(then).into_iter())
+                    .chain(get_expr_columns(then))
                     .collect::<Vec<_>>()
             }))
             .chain(
                 else_expr
                     .as_ref()
                     .map(|else_expr| get_expr_columns(else_expr))
-                    .unwrap_or(vec![])
-                    .into_iter(),
+                    .unwrap_or(vec![]),
             )
             .collect(),
         Expr::ScalarFunction { args, .. }

rust/cubesql/cubesql/src/compile/engine/df/wrapper.rs

@@ -146,7 +146,7 @@ impl SqlQuery {
     }
 
     pub fn extend_values(&mut self, values: impl IntoIterator<Item = Option<String>>) {
-        self.values.extend(values.into_iter());
+        self.values.extend(values);
     }
 
     pub fn replace_sql(&mut self, sql: String) {

rust/cubesql/cubesql/src/compile/plan.rs

@@ -138,15 +138,14 @@ pub async fn get_df_batches(
                         Ok(stream) => {
                             return Ok(stream);
                         }
-                        Err(err) => return Err(CubeError::panic(Box::new(err)).into()),
+                        Err(err) => return Err(CubeError::panic(Box::new(err))),
                     };
                 }
-                Err(err) => return Err(CubeError::panic(err).into()),
+                Err(err) => return Err(CubeError::panic(err)),
             }
         }
         _ => Err(CubeError::user(
             "Only SELECT queries are supported for Cube SQL over HTTP".to_string(),
-        )
-        .into()),
+        )),
     }
 }

rust/cubesql/cubesql/src/compile/rewrite/analysis.rs

@@ -714,12 +714,12 @@ impl LogicalPlanAnalysis {
             }
             LogicalPlanLanguage::CubeScanMembers(params) => {
                 for id in params.iter() {
-                    map.extend(id_to_column_name_to_expr(*id)?.into_iter());
+                    map.extend(id_to_column_name_to_expr(*id)?);
                 }
                 Some(map)
             }
             LogicalPlanLanguage::CubeScan(params) => {
-                map.extend(id_to_column_name_to_expr(params[1])?.into_iter());
+                map.extend(id_to_column_name_to_expr(params[1])?);
                 Some(map)
             }
             _ => None,
@@ -843,7 +843,7 @@ impl LogicalPlanAnalysis {
                 let expr = Expr::Column(col);
                 columns.push(expr);
             } else {
-                columns.extend(referenced_columns(id)?.into_iter());
+                columns.extend(referenced_columns(id)?);
             }
             Some(())
         };

rust/cubesql/cubesql/src/compile/rewrite/converter.rs

@@ -1386,7 +1386,7 @@ impl LanguageToLogicalPlanConverter {
                 LogicalPlan::Join(Join {
                     left,
                     right,
-                    on: left_on.into_iter().zip_eq(right_on.into_iter()).collect(),
+                    on: left_on.into_iter().zip_eq(right_on).collect(),
                     join_type,
                     join_constraint,
                     schema,

rust/cubesql/cubesql/src/compile/rewrite/rules/members.rs

@@ -1416,7 +1416,7 @@ impl MemberRules {
                     if !aliases_to_cube.is_empty() && !projection_aliases.is_empty() {
                         // TODO: We could, more generally, cache referenced_columns(referenced_expr), which calls expr_column_name.
                         let mut columns = HashSet::new();
-                        columns.extend(referenced_columns(referenced_expr).into_iter());
+                        columns.extend(referenced_columns(referenced_expr));
 
                         for alias_to_cube in aliases_to_cube {
                             for projection_alias in &projection_aliases {
@@ -1633,8 +1633,8 @@ impl MemberRules {
             }
 
             let mut columns = HashSet::new();
-            columns.extend(referenced_columns(referenced_group_expr).into_iter());
-            columns.extend(referenced_columns(referenced_aggr_expr).into_iter());
+            columns.extend(referenced_columns(referenced_group_expr));
+            columns.extend(referenced_columns(referenced_aggr_expr));
 
             let new_pushdown_join = referenced_aggr_expr.is_empty();