fmt

Author: ovr

rust/datafusion/src/sql/planner.rs

@@ -41,9 +41,9 @@ use arrow::datatypes::*;
 
 use crate::prelude::JoinType;
 use sqlparser::ast::{
-    BinaryOperator, DataType as SQLDataType, Expr as SQLExpr, FunctionArg, Join, JoinConstraint,
-    JoinOperator, Query, Select, SelectItem, SetExpr, TableFactor, TableWithJoins,
-    UnaryOperator, Value
+    BinaryOperator, DataType as SQLDataType, Expr as SQLExpr, FunctionArg, Join,
+    JoinConstraint, JoinOperator, Query, Select, SelectItem, SetExpr, TableFactor,
+    TableWithJoins, UnaryOperator, Value,
 };
 use sqlparser::ast::{ColumnDef as SQLColumnDef, ColumnOption};
 use sqlparser::ast::{OrderByExpr, Statement};
@@ -90,7 +90,11 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
     /// Generate a logical plan from an SQL statement
     pub fn sql_statement_to_plan(&self, sql: &Statement) -> Result<LogicalPlan> {
         match sql {
-            Statement::Explain { verbose, statement, analyze: _ } => self.explain_statement_to_plan(*verbose, &statement),
+            Statement::Explain {
+                verbose,
+                statement,
+                analyze: _,
+            } => self.explain_statement_to_plan(*verbose, &statement),
             Statement::Query(query) => self.query_to_plan(&query),
             _ => Err(DataFusionError::NotImplemented(
                 "Only SELECT statements are implemented".to_string(),
@@ -326,7 +330,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
             TableFactor::Derived { subquery, .. } => self.query_to_plan(subquery),
             TableFactor::NestedJoin(table_with_joins) => {
                 self.plan_table_with_joins(table_with_joins)
-            },
+            }
             // @todo Support TableFactory::TableFunction?
             _ => Err(DataFusionError::NotImplemented(format!(
                 "Unsupported ast node {:?} in create_relation",
@@ -618,7 +622,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
             FunctionArg::Unnamed(value) => self.sql_expr_to_logical_expr(value),
         }
     }
-    
+
     fn sql_expr_to_logical_expr(&self, sql: &SQLExpr) -> Result<Expr> {
         match sql {
             SQLExpr::Value(Value::Number(n)) => match n.parse::<i64>() {
@@ -738,7 +742,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                         // not a literal, apply negative operator on expression
                         _ => Ok(Expr::Negative(Box::new(self.sql_expr_to_logical_expr(expr)?))),
                     }
-                },
+                }
                 _ => Err(DataFusionError::NotImplemented(format!(
                     "Unsupported SQL unary operator {:?}",
                     op
@@ -812,7 +816,9 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                             .args
                             .iter()
                             .map(|a| match a {
-                                FunctionArg::Unnamed(SQLExpr::Value(Value::Number(_))) => Ok(lit(1_u8)),
+                                FunctionArg::Unnamed(SQLExpr::Value(Value::Number(
+                                    _,
+                                ))) => Ok(lit(1_u8)),
                                 FunctionArg::Unnamed(SQLExpr::Wildcard) => Ok(lit(1_u8)),
                                 _ => self.sql_fn_arg_to_logical_expr(a),
                             })