chore: specify import style in rustfmt (#460)

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

src/script/src/manager.rs

@@ -88,8 +88,10 @@ mod tests {
 
     use super::*;
     type DefaultEngine = MitoEngine<EngineImpl<LocalFileLogStore>>;
-    use log_store::fs::{config::LogConfig, log::LocalFileLogStore};
-    use storage::{config::EngineConfig as StorageEngineConfig, EngineImpl};
+    use log_store::fs::config::LogConfig;
+    use log_store::fs::log::LocalFileLogStore;
+    use storage::config::EngineConfig as StorageEngineConfig;
+    use storage::EngineImpl;
     use table_engine::engine::MitoEngine;
     use tempdir::TempDir;
 

src/script/src/python/builtins/mod.rs

@@ -12,12 +12,8 @@ use datatypes::arrow::array::ArrayRef;
 use datatypes::arrow::compute::cast::CastOptions;
 use datatypes::arrow::datatypes::DataType;
 use datatypes::vectors::Helper as HelperVec;
-use rustpython_vm::builtins::PyList;
-use rustpython_vm::pymodule;
-use rustpython_vm::{
-    builtins::{PyBaseExceptionRef, PyBool, PyFloat, PyInt, PyStr},
-    AsObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-};
+use rustpython_vm::builtins::{PyBaseExceptionRef, PyBool, PyFloat, PyInt, PyList, PyStr};
+use rustpython_vm::{pymodule, AsObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 
 use crate::python::utils::is_instance;
 use crate::python::PyVector;
@@ -274,45 +270,31 @@ pub(crate) mod greptime_builtin {
     // P.S.: not extract to file because not-inlined proc macro attribute is *unstable*
     use std::sync::Arc;
 
-    use common_function::scalars::{
-        function::FunctionContext, math::PowFunction, Function, FunctionRef, FUNCTION_REGISTRY,
-    };
-    use datafusion::{
-        arrow::{
-            compute::comparison::{gt_eq_scalar, lt_eq_scalar},
-            datatypes::DataType,
-            error::ArrowError,
-            scalar::{PrimitiveScalar, Scalar},
-        },
-        physical_plan::expressions,
-    };
+    use common_function::scalars::function::FunctionContext;
+    use common_function::scalars::math::PowFunction;
+    use common_function::scalars::{Function, FunctionRef, FUNCTION_REGISTRY};
+    use datafusion::arrow::compute::comparison::{gt_eq_scalar, lt_eq_scalar};
+    use datafusion::arrow::datatypes::DataType;
+    use datafusion::arrow::error::ArrowError;
+    use datafusion::arrow::scalar::{PrimitiveScalar, Scalar};
+    use datafusion::physical_plan::expressions;
     use datafusion_expr::ColumnarValue as DFColValue;
     use datafusion_physical_expr::math_expressions;
-    use datatypes::vectors::{ConstantVector, Float64Vector, Helper, Int64Vector};
-    use datatypes::{
-        arrow::{
-            self,
-            array::{ArrayRef, NullArray},
-            compute,
-        },
-        vectors::VectorRef,
-    };
+    use datatypes::arrow::array::{ArrayRef, NullArray};
+    use datatypes::arrow::{self, compute};
+    use datatypes::vectors::{ConstantVector, Float64Vector, Helper, Int64Vector, VectorRef};
     use paste::paste;
-    use rustpython_vm::{
-        builtins::{PyFloat, PyFunction, PyInt, PyStr},
-        function::{FuncArgs, KwArgs, OptionalArg},
-        AsObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    };
+    use rustpython_vm::builtins::{PyFloat, PyFunction, PyInt, PyStr};
+    use rustpython_vm::function::{FuncArgs, KwArgs, OptionalArg};
+    use rustpython_vm::{AsObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
 
     use crate::python::builtins::{
         all_to_f64, eval_aggr_fn, from_df_err, try_into_columnar_value, try_into_py_obj,
         type_cast_error,
     };
-    use crate::python::{
-        utils::{is_instance, py_vec_obj_to_array, PyVectorRef},
-        vector::val_to_pyobj,
-        PyVector,
-    };
+    use crate::python::utils::{is_instance, py_vec_obj_to_array, PyVectorRef};
+    use crate::python::vector::val_to_pyobj;
+    use crate::python::PyVector;
 
     #[pyfunction]
     fn vector(args: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult<PyVector> {

src/script/src/python/builtins/test.rs

@@ -1,25 +1,24 @@
-use std::{collections::HashMap, fs::File, io::Read, path::Path, sync::Arc};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Read;
+use std::path::Path;
+use std::sync::Arc;
 
-use arrow::{
-    array::{Float64Array, Int64Array, PrimitiveArray},
-    compute::cast::CastOptions,
-    datatypes::DataType,
-};
+use arrow::array::{Float64Array, Int64Array, PrimitiveArray};
+use arrow::compute::cast::CastOptions;
+use arrow::datatypes::DataType;
 use datatypes::vectors::VectorRef;
 use ron::from_str as from_ron_string;
+use rustpython_vm::builtins::{PyFloat, PyInt, PyList};
 use rustpython_vm::class::PyClassImpl;
-use rustpython_vm::{
-    builtins::{PyFloat, PyInt, PyList},
-    convert::ToPyObject,
-    scope::Scope,
-    AsObject, PyObjectRef, VirtualMachine,
-};
+use rustpython_vm::convert::ToPyObject;
+use rustpython_vm::scope::Scope;
+use rustpython_vm::{AsObject, PyObjectRef, VirtualMachine};
 use serde::{Deserialize, Serialize};
 
-use super::greptime_builtin;
-use super::*;
-use crate::python::utils::format_py_error;
-use crate::python::{utils::is_instance, PyVector};
+use super::{greptime_builtin, *};
+use crate::python::utils::{format_py_error, is_instance};
+use crate::python::PyVector;
 #[test]
 fn convert_scalar_to_py_obj_and_back() {
     rustpython_vm::Interpreter::with_init(Default::default(), |vm| {

src/script/src/python/coprocessor.rs

@@ -12,11 +12,11 @@ use datatypes::arrow::array::{Array, ArrayRef};
 use datatypes::arrow::compute::cast::CastOptions;
 use datatypes::arrow::datatypes::{DataType, Field, Schema as ArrowSchema};
 use datatypes::schema::Schema;
-use datatypes::vectors::Helper;
-use datatypes::vectors::{BooleanVector, StringVector, Vector, VectorRef};
+use datatypes::vectors::{BooleanVector, Helper, StringVector, Vector, VectorRef};
 use rustpython_bytecode::CodeObject;
 use rustpython_vm as vm;
-use rustpython_vm::{class::PyClassImpl, AsObject};
+use rustpython_vm::class::PyClassImpl;
+use rustpython_vm::AsObject;
 #[cfg(test)]
 use serde::Deserialize;
 use snafu::{OptionExt, ResultExt};
@@ -29,8 +29,8 @@ use crate::python::coprocessor::parse::DecoratorArgs;
 use crate::python::error::{
     ensure, ret_other_error_with, ArrowSnafu, OtherSnafu, Result, TypeCastSnafu,
 };
-use crate::python::utils::{format_py_error, py_vec_obj_to_array};
-use crate::python::{utils::is_instance, PyVector};
+use crate::python::utils::{format_py_error, is_instance, py_vec_obj_to_array};
+use crate::python::PyVector;
 
 #[cfg_attr(test, derive(Deserialize))]
 #[derive(Debug, Clone, PartialEq, Eq)]

src/script/src/python/coprocessor/compile.rs

@@ -2,11 +2,8 @@
 
 use rustpython_bytecode::CodeObject;
 use rustpython_compiler_core::compile as python_compile;
-use rustpython_parser::{
-    ast,
-    ast::{Located, Location},
-    parser,
-};
+use rustpython_parser::ast::{Located, Location};
+use rustpython_parser::{ast, parser};
 use snafu::ResultExt;
 
 use crate::fail_parse_error;

src/script/src/python/coprocessor/parse.rs

@@ -1,18 +1,13 @@
 use std::collections::HashSet;
 
 use datatypes::arrow::datatypes::DataType;
-use rustpython_parser::{
-    ast,
-    ast::{Arguments, Location},
-    parser,
-};
+use rustpython_parser::ast::{Arguments, Location};
+use rustpython_parser::{ast, parser};
 #[cfg(test)]
 use serde::Deserialize;
 use snafu::{OptionExt, ResultExt};
 
-use crate::python::coprocessor::compile;
-use crate::python::coprocessor::AnnotationInfo;
-use crate::python::coprocessor::Coprocessor;
+use crate::python::coprocessor::{compile, AnnotationInfo, Coprocessor};
 use crate::python::error::{ensure, CoprParseSnafu, PyParseSnafu, Result};
 
 #[cfg_attr(test, derive(Deserialize))]

src/script/src/python/engine.rs

@@ -7,10 +7,8 @@ use std::task::{Context, Poll};
 use async_trait::async_trait;
 use common_error::prelude::BoxedError;
 use common_query::Output;
-use common_recordbatch::{
-    error::ExternalSnafu, error::Result as RecordBatchResult, RecordBatch, RecordBatchStream,
-    SendableRecordBatchStream,
-};
+use common_recordbatch::error::{ExternalSnafu, Result as RecordBatchResult};
+use common_recordbatch::{RecordBatch, RecordBatchStream, SendableRecordBatchStream};
 use datatypes::schema::SchemaRef;
 use futures::Stream;
 use query::QueryEngineRef;
@@ -18,11 +16,8 @@ use snafu::{ensure, ResultExt};
 use sql::statements::statement::Statement;
 
 use crate::engine::{CompileContext, EvalContext, Script, ScriptEngine};
-use crate::python::coprocessor::{exec_parsed, parse};
-use crate::python::{
-    coprocessor::CoprocessorRef,
-    error::{self, Result},
-};
+use crate::python::coprocessor::{exec_parsed, parse, CoprocessorRef};
+use crate::python::error::{self, Result};
 
 const PY_ENGINE: &str = "python";
 
@@ -137,10 +132,8 @@ mod tests {
     use catalog::{CatalogList, CatalogProvider, SchemaProvider};
     use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
     use common_recordbatch::util;
-    use datafusion_common::field_util::FieldExt;
-    use datafusion_common::field_util::SchemaExt;
-    use datatypes::arrow::array::Float64Array;
-    use datatypes::arrow::array::Int64Array;
+    use datafusion_common::field_util::{FieldExt, SchemaExt};
+    use datatypes::arrow::array::{Float64Array, Int64Array};
     use query::QueryEngineFactory;
     use table::table::numbers::NumbersTable;
 

src/script/src/python/error.rs

@@ -5,9 +5,11 @@ use datatypes::arrow::error::ArrowError;
 use datatypes::error::Error as DataTypeError;
 use query::error::Error as QueryError;
 use rustpython_compiler_core::error::CompileError as CoreCompileError;
-use rustpython_parser::{ast::Location, error::ParseError};
+use rustpython_parser::ast::Location;
+use rustpython_parser::error::ParseError;
 pub use snafu::ensure;
-use snafu::{prelude::Snafu, Backtrace};
+use snafu::prelude::Snafu;
+use snafu::Backtrace;
 pub type Result<T> = std::result::Result<T, Error>;
 
 pub(crate) fn ret_other_error_with(reason: String) -> OtherSnafu<String> {

src/script/src/python/test.rs

@@ -15,11 +15,10 @@ use rustpython_parser::parser;
 use serde::{Deserialize, Serialize};
 
 use super::error::{get_error_reason_loc, visualize_loc};
-use crate::python::coprocessor::AnnotationInfo;
-use crate::python::error::pretty_print_error_in_src;
-use crate::python::{
-    coprocessor, coprocessor::parse::parse_and_compile_copr, coprocessor::Coprocessor, error::Error,
-};
+use crate::python::coprocessor;
+use crate::python::coprocessor::parse::parse_and_compile_copr;
+use crate::python::coprocessor::{AnnotationInfo, Coprocessor};
+use crate::python::error::{pretty_print_error_in_src, Error};
 
 #[derive(Deserialize, Debug)]
 struct TestCase {

src/script/src/python/utils.rs

@@ -4,16 +4,13 @@ use datafusion::arrow::array::{ArrayRef, BooleanArray, NullArray, PrimitiveArray
 use datafusion_common::ScalarValue;
 use datafusion_expr::ColumnarValue as DFColValue;
 use datatypes::arrow::datatypes::DataType;
-use rustpython_vm::builtins::{PyBool, PyFloat, PyInt, PyList, PyStr};
-use rustpython_vm::{builtins::PyBaseExceptionRef, PyObjectRef, PyPayload, PyRef, VirtualMachine};
-use snafu::OptionExt;
-use snafu::ResultExt;
-use snafu::{Backtrace, GenerateImplicitData};
+use rustpython_vm::builtins::{PyBaseExceptionRef, PyBool, PyFloat, PyInt, PyList, PyStr};
+use rustpython_vm::{PyObjectRef, PyPayload, PyRef, VirtualMachine};
+use snafu::{Backtrace, GenerateImplicitData, OptionExt, ResultExt};
 
 use crate::python::builtins::try_into_columnar_value;
-use crate::python::error;
 use crate::python::error::ret_other_error_with;
-use crate::python::PyVector;
+use crate::python::{error, PyVector};
 
 pub(crate) type PyVectorRef = PyRef<PyVector>;
 

src/script/src/python/vector.rs

@@ -4,40 +4,27 @@ use std::sync::Arc;
 use common_time::date::Date;
 use common_time::datetime::DateTime;
 use common_time::timestamp::Timestamp;
-use datatypes::arrow;
-use datatypes::arrow::array::BooleanArray;
+use datatypes::arrow::array::{Array, ArrayRef, BooleanArray, PrimitiveArray};
 use datatypes::arrow::compute;
+use datatypes::arrow::compute::cast::{self, CastOptions};
+use datatypes::arrow::compute::{arithmetics, comparison};
 use datatypes::arrow::datatypes::DataType;
 use datatypes::arrow::scalar::{PrimitiveScalar, Scalar};
-use datatypes::arrow::{
-    array::{Array, ArrayRef, PrimitiveArray},
-    compute::{
-        arithmetics,
-        cast::{self, CastOptions},
-        comparison,
-    },
-};
 use datatypes::data_type::ConcreteDataType;
 use datatypes::prelude::Value;
 use datatypes::value::OrderedFloat;
-use datatypes::{
-    value,
-    vectors::{Helper, NullVector, VectorBuilder, VectorRef},
-};
-use rustpython_vm::function::{Either, PyComparisonValue};
-use rustpython_vm::types::{Comparable, PyComparisonOp};
+use datatypes::vectors::{Helper, NullVector, VectorBuilder, VectorRef};
+use datatypes::{arrow, value};
+use rustpython_vm::builtins::{PyBaseExceptionRef, PyBool, PyBytes, PyFloat, PyInt, PyNone, PyStr};
+use rustpython_vm::function::{Either, OptionalArg, PyComparisonValue};
+use rustpython_vm::protocol::{PyMappingMethods, PySequenceMethods};
+use rustpython_vm::sliceable::{SaturatedSlice, SequenceIndex, SequenceIndexOp};
+use rustpython_vm::types::{AsMapping, AsSequence, Comparable, PyComparisonOp};
 use rustpython_vm::{
-    builtins::{PyBaseExceptionRef, PyBool, PyBytes, PyFloat, PyInt, PyNone, PyStr},
-    function::OptionalArg,
-    protocol::{PyMappingMethods, PySequenceMethods},
-    pyclass, pyimpl,
-    sliceable::{SaturatedSlice, SequenceIndex, SequenceIndexOp},
-    types::{AsMapping, AsSequence},
-    AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    pyclass, pyimpl, AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
 };
 
-use crate::python::utils::is_instance;
-use crate::python::utils::PyVectorRef;
+use crate::python::utils::{is_instance, PyVectorRef};
 
 #[pyclass(module = false, name = "vector")]
 #[derive(PyPayload, Debug)]
@@ -1033,7 +1020,9 @@ pub mod tests {
     use std::sync::Arc;
 
     use datatypes::vectors::{Float32Vector, Int32Vector, NullVector};
-    use rustpython_vm::{builtins::PyList, class::PyClassImpl, protocol::PySequence};
+    use rustpython_vm::builtins::PyList;
+    use rustpython_vm::class::PyClassImpl;
+    use rustpython_vm::protocol::PySequence;
     use value::Value;
 
     use super::*;

src/script/src/table.rs

@@ -10,8 +10,7 @@ use common_telemetry::logging;
 use common_time::timestamp::Timestamp;
 use common_time::util;
 use datatypes::arrow::array::Utf8Array;
-use datatypes::prelude::ConcreteDataType;
-use datatypes::prelude::ScalarVector;
+use datatypes::prelude::{ConcreteDataType, ScalarVector};
 use datatypes::schema::{ColumnSchema, Schema, SchemaBuilder};
 use datatypes::vectors::{StringVector, TimestampVector, VectorRef};
 use query::QueryEngineRef;