build: bump rust edition to 2024 (#6920)

* bump edition

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

* format

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

* gen keyword

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

* lifetime and env var

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

* one more gen fix

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

* lifetime of temporaries in tail expressions

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

* format again

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

* clippy nested if

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

* clippy let and return

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

---------

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

tests-fuzz/src/context.rs

@@ -17,7 +17,7 @@ use std::sync::Arc;
 use common_query::AddColumnLocation;
 use datatypes::types::cast;
 use rand::Rng;
-use snafu::{ensure, OptionExt};
+use snafu::{OptionExt, ensure};
 
 use crate::error::{self, Result};
 use crate::generator::Random;
@@ -175,9 +175,9 @@ impl TableContext {
         rng: &mut R,
         generator: &dyn Random<Ident, R>,
     ) -> Ident {
-        let mut name = generator.gen(rng);
+        let mut name = generator.generate(rng);
         while self.columns.iter().any(|col| col.name.value == name.value) {
-            name = generator.gen(rng);
+            name = generator.generate(rng);
         }
         name
     }
@@ -187,9 +187,9 @@ impl TableContext {
         rng: &mut R,
         generator: &dyn Random<Ident, R>,
     ) -> Ident {
-        let mut name = generator.gen(rng);
+        let mut name = generator.generate(rng);
         while self.name.value == name.value {
-            name = generator.gen(rng);
+            name = generator.generate(rng);
         }
         name
     }

tests-fuzz/src/fake.rs

@@ -16,9 +16,9 @@ use std::collections::HashSet;
 use std::marker::PhantomData;
 
 use lazy_static::lazy_static;
+use rand::Rng;
 use rand::prelude::IndexedRandom;
 use rand::seq::{IteratorRandom, SliceRandom};
-use rand::Rng;
 
 use crate::generator::Random;
 use crate::impl_random;

tests-fuzz/src/generator.rs

@@ -51,7 +51,7 @@ pub trait Generator<T, R: Rng> {
 
 pub trait Random<T, R: Rng> {
     /// Generates a random element.
-    fn gen(&self, rng: &mut R) -> T {
+    fn generate(&self, rng: &mut R) -> T {
         self.choose(rng, 1).remove(0)
     }
 

tests-fuzz/src/generator/alter_expr.rs

@@ -29,8 +29,8 @@ use crate::generator::{ColumnOptionGenerator, ConcreteDataTypeGenerator, Generat
 use crate::ir::alter_expr::{AlterTableExpr, AlterTableOperation, AlterTableOption, Ttl};
 use crate::ir::create_expr::ColumnOption;
 use crate::ir::{
-    droppable_columns, generate_columns, generate_random_value, modifiable_columns, Column,
-    ColumnTypeGenerator, Ident,
+    Column, ColumnTypeGenerator, Ident, droppable_columns, generate_columns, generate_random_value,
+    modifiable_columns,
 };
 
 fn add_column_options_generator<R: Rng>(
@@ -175,9 +175,9 @@ impl<R: Rng> Generator<AlterTableExpr, R> for AlterExprModifyDataTypeGenerator<R
     fn generate(&self, rng: &mut R) -> Result<AlterTableExpr> {
         let modifiable = modifiable_columns(&self.table_ctx.columns);
         let changed = modifiable[rng.random_range(0..modifiable.len())].clone();
-        let mut to_type = self.column_type_generator.gen(rng);
+        let mut to_type = self.column_type_generator.generate(rng);
         while !changed.column_type.can_arrow_type_cast_to(&to_type) {
-            to_type = self.column_type_generator.gen(rng);
+            to_type = self.column_type_generator.generate(rng);
         }
 
         Ok(AlterTableExpr {
@@ -292,8 +292,8 @@ mod tests {
 
     use super::*;
     use crate::context::TableContext;
-    use crate::generator::create_expr::CreateTableExprGeneratorBuilder;
     use crate::generator::Generator;
+    use crate::generator::create_expr::CreateTableExprGeneratorBuilder;
 
     #[test]
     fn test_alter_table_expr_generator_deterministic() {

tests-fuzz/src/generator/create_expr.rs

@@ -18,23 +18,23 @@ use datatypes::data_type::ConcreteDataType;
 use datatypes::value::Value;
 use derive_builder::Builder;
 use partition::expr::{Operand, PartitionExpr, RestrictedOp};
-use rand::seq::SliceRandom;
 use rand::Rng;
-use snafu::{ensure, ResultExt};
+use rand::seq::SliceRandom;
+use snafu::{ResultExt, ensure};
 
 use super::Generator;
 use crate::context::TableContextRef;
 use crate::error::{self, Error, Result};
-use crate::fake::{random_capitalize_map, MappedGenerator, WordGenerator};
+use crate::fake::{MappedGenerator, WordGenerator, random_capitalize_map};
 use crate::generator::{ColumnOptionGenerator, ConcreteDataTypeGenerator, Random};
 use crate::ir::create_expr::{
     ColumnOption, CreateDatabaseExprBuilder, CreateTableExprBuilder, PartitionDef,
 };
 use crate::ir::{
-    column_options_generator, generate_columns, generate_partition_bounds,
-    partible_column_options_generator, primary_key_options_generator, ts_column_options_generator,
     Column, ColumnTypeGenerator, CreateDatabaseExpr, CreateTableExpr, Ident,
     PartibleColumnTypeGenerator, StringColumnTypeGenerator, TsColumnTypeGenerator,
+    column_options_generator, generate_columns, generate_partition_bounds,
+    partible_column_options_generator, primary_key_options_generator, ts_column_options_generator,
 };
 
 #[derive(Builder)]
@@ -163,7 +163,7 @@ impl<R: Rng + 'static> Generator<CreateTableExpr, R> for CreateTableExprGenerato
         builder.engine(self.engine.to_string());
         builder.if_not_exists(self.if_not_exists);
         if self.name.is_empty() {
-            builder.table_name(self.name_generator.gen(rng));
+            builder.table_name(self.name_generator.generate(rng));
         } else {
             builder.table_name(self.name.clone());
         }
@@ -243,7 +243,7 @@ impl<R: Rng + 'static> Generator<CreateTableExpr, R> for CreatePhysicalTableExpr
         }
 
         Ok(CreateTableExpr {
-            table_name: self.name_generator.gen(rng),
+            table_name: self.name_generator.generate(rng),
             columns: vec![
                 Column {
                     name: Ident::new("ts"),
@@ -355,7 +355,7 @@ impl<R: Rng + 'static> Generator<CreateDatabaseExpr, R> for CreateDatabaseExprGe
         let mut builder = CreateDatabaseExprBuilder::default();
         builder.if_not_exists(self.if_not_exists);
         if self.database_name.is_empty() {
-            builder.database_name(self.name_generator.gen(rng));
+            builder.database_name(self.name_generator.generate(rng));
         } else {
             builder.database_name(self.database_name.to_string());
         }
@@ -477,16 +477,13 @@ mod tests {
         assert_eq!(logical_table_expr.engine, "metric");
         assert_eq!(logical_table_expr.columns.len(), 7);
         assert_eq!(logical_ts_name, physical_ts_name);
-        assert!(logical_table_expr
-            .columns
-            .iter()
-            .all(
-                |column| column.column_type != ConcreteDataType::string_datatype()
-                    || column
-                        .options
-                        .iter()
-                        .any(|option| option == &ColumnOption::PrimaryKey)
-            ));
+        assert!(logical_table_expr.columns.iter().all(|column| {
+            column.column_type != ConcreteDataType::string_datatype()
+                || column
+                    .options
+                    .iter()
+                    .any(|option| option == &ColumnOption::PrimaryKey)
+        }));
     }
 
     #[test]

tests-fuzz/src/generator/insert_expr.rs

@@ -16,8 +16,8 @@ use std::marker::PhantomData;
 
 use datatypes::value::Value;
 use derive_builder::Builder;
-use rand::seq::{IndexedRandom, SliceRandom};
 use rand::Rng;
+use rand::seq::{IndexedRandom, SliceRandom};
 
 use super::TsValueGenerator;
 use crate::context::TableContextRef;
@@ -25,7 +25,7 @@ use crate::error::{Error, Result};
 use crate::fake::WordGenerator;
 use crate::generator::{Generator, Random, ValueGenerator};
 use crate::ir::insert_expr::{InsertIntoExpr, RowValue};
-use crate::ir::{generate_random_timestamp, generate_random_value, Ident};
+use crate::ir::{Ident, generate_random_timestamp, generate_random_value};
 
 /// Generates [InsertIntoExpr].
 #[derive(Builder)]

tests-fuzz/src/generator/select_expr.rs

@@ -15,8 +15,8 @@
 use std::marker::PhantomData;
 
 use derive_builder::Builder;
-use rand::seq::{IndexedRandom, SliceRandom};
 use rand::Rng;
+use rand::seq::{IndexedRandom, SliceRandom};
 
 use crate::context::TableContextRef;
 use crate::error::{Error, Result};

tests-fuzz/src/ir.rs

@@ -34,8 +34,8 @@ use datatypes::value::Value;
 use derive_builder::Builder;
 pub use insert_expr::InsertIntoExpr;
 use lazy_static::lazy_static;
-use rand::seq::{IndexedRandom, SliceRandom};
 use rand::Rng;
+use rand::seq::{IndexedRandom, SliceRandom};
 use serde::{Deserialize, Serialize};
 
 use self::insert_expr::{RowValue, RowValues};
@@ -153,7 +153,7 @@ pub fn generate_random_value<R: Rng>(
         ConcreteDataType::Float32(_) => Value::from(rng.random::<f32>()),
         ConcreteDataType::Float64(_) => Value::from(rng.random::<f64>()),
         ConcreteDataType::String(_) => match random_str {
-            Some(random) => Value::from(random.gen(rng).value),
+            Some(random) => Value::from(random.generate(rng).value),
             None => Value::from(rng.random::<char>().to_string()),
         },
         ConcreteDataType::Date(_) => generate_random_date(rng),
@@ -483,7 +483,7 @@ pub fn generate_columns<R: Rng + 'static>(
     names
         .into_iter()
         .map(|name| {
-            let column_type = types.gen(rng);
+            let column_type = types.generate(rng);
             let options = options(rng, &column_type);
             Column {
                 name,

tests-fuzz/src/ir/alter_expr.rs

@@ -172,8 +172,7 @@ mod tests {
 
     #[test]
     fn test_parse_kv_pairs() {
-        let option_string =
-            "compaction.twcs.max_output_file_size = '1M', compaction.type = 'twcs', ttl = 'forever'";
+        let option_string = "compaction.twcs.max_output_file_size = '1M', compaction.type = 'twcs', ttl = 'forever'";
         let options = AlterTableOption::parse_kv_pairs(option_string).unwrap();
         assert_eq!(options.len(), 2);
         assert_eq!(

tests-fuzz/src/test_utils.rs

@@ -15,8 +15,8 @@
 use datatypes::data_type::ConcreteDataType;
 
 use crate::context::TableContext;
-use crate::ir::create_expr::ColumnOption;
 use crate::ir::Column;
+use crate::ir::create_expr::ColumnOption;
 
 pub fn new_test_ctx() -> TableContext {
     TableContext {

tests-fuzz/src/translator/mysql/alter_expr.rs

@@ -22,8 +22,8 @@ use crate::error::{Error, Result};
 use crate::ir::alter_expr::AlterTableOperation;
 use crate::ir::create_expr::ColumnOption;
 use crate::ir::{AlterTableExpr, Column};
-use crate::translator::common::CommonAlterTableTranslator;
 use crate::translator::DslTranslator;
+use crate::translator::common::CommonAlterTableTranslator;
 
 pub struct AlterTableExprTranslator;
 

tests-fuzz/src/translator/mysql/insert_expr.rs

@@ -74,8 +74,8 @@ mod tests {
     use rand::{Rng, SeedableRng};
 
     use super::*;
-    use crate::generator::insert_expr::InsertExprGeneratorBuilder;
     use crate::generator::Generator;
+    use crate::generator::insert_expr::InsertExprGeneratorBuilder;
     use crate::test_utils;
     use crate::translator::DslTranslator;
 

tests-fuzz/src/translator/mysql/select_expr.rs

@@ -52,8 +52,8 @@ mod tests {
     use rand::SeedableRng;
 
     use super::SelectExprTranslator;
-    use crate::generator::select_expr::SelectExprGeneratorBuilder;
     use crate::generator::Generator;
+    use crate::generator::select_expr::SelectExprGeneratorBuilder;
     use crate::test_utils;
     use crate::translator::DslTranslator;
 

tests-fuzz/src/translator/postgres/alter_expr.rs

@@ -21,9 +21,9 @@ use crate::error::{Error, Result};
 use crate::ir::alter_expr::AlterTableOperation;
 use crate::ir::create_expr::ColumnOption;
 use crate::ir::{AlterTableExpr, Column};
+use crate::translator::DslTranslator;
 use crate::translator::common::CommonAlterTableTranslator;
 use crate::translator::postgres::sql_data_type_to_postgres_data_type;
-use crate::translator::DslTranslator;
 
 pub struct AlterTableExprTranslator;
 

tests-fuzz/src/translator/postgres/create_expr.rs

@@ -18,8 +18,8 @@ use sql::statements::concrete_data_type_to_sql_data_type;
 use crate::error::{Error, Result};
 use crate::ir::create_expr::ColumnOption;
 use crate::ir::{Column, CreateTableExpr};
-use crate::translator::postgres::sql_data_type_to_postgres_data_type;
 use crate::translator::DslTranslator;
+use crate::translator::postgres::sql_data_type_to_postgres_data_type;
 
 pub struct CreateTableExprTranslator;
 

tests-fuzz/src/utils/process.rs

@@ -22,7 +22,7 @@ use common_telemetry::{info, warn};
 use nix::sys::signal::Signal;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaChaRng;
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use tokio::fs::OpenOptions;
 use tokio::process::Child;
 

tests-fuzz/src/validator/column.rs

@@ -14,7 +14,7 @@
 
 use common_telemetry::debug;
 use datatypes::data_type::DataType;
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::MySqlPool;
 
 use crate::error::{self, Result, UnexpectedSnafu};

tests-fuzz/src/validator/row.rs

@@ -13,10 +13,10 @@
 // limitations under the License.
 
 use chrono::{DateTime as ChronoDateTime, NaiveDate, NaiveDateTime, Utc};
-use common_time::date::Date;
 use common_time::Timestamp;
+use common_time::date::Date;
 use datatypes::value::Value;
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::mysql::MySqlRow;
 use sqlx::{Column, ColumnIndex, Database, MySqlPool, Row, TypeInfo, ValueRef};
 

tests-fuzz/src/validator/table.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::{MySqlPool, Row};
 
 use crate::error::{self, Result, UnexpectedSnafu};
@@ -74,8 +74,8 @@ mod tests {
     use common_time::Duration;
 
     use super::*;
-    use crate::ir::alter_expr::Ttl;
     use crate::ir::AlterTableOption;
+    use crate::ir::alter_expr::Ttl;
 
     #[test]
     fn test_parse_show_create() {

tests-fuzz/targets/ddl/fuzz_alter_logical_table.rs

@@ -28,23 +28,23 @@ use sqlx::{MySql, Pool};
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::alter_expr::AlterExprAddColumnGeneratorBuilder;
 use tests_fuzz::generator::create_expr::{
     CreateLogicalTableExprGeneratorBuilder, CreatePhysicalTableExprGeneratorBuilder,
 };
-use tests_fuzz::generator::Generator;
 use tests_fuzz::ir::{
-    primary_key_and_not_null_column_options_generator, primary_key_options_generator, Column,
-    CreateTableExpr, StringColumnTypeGenerator,
+    Column, CreateTableExpr, StringColumnTypeGenerator,
+    primary_key_and_not_null_column_options_generator, primary_key_options_generator,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::alter_expr::AlterTableExprTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
-use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::utils::{
-    get_gt_fuzz_input_max_alter_actions, init_greptime_connections_via_env, Connections,
+    Connections, get_gt_fuzz_input_max_alter_actions, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 

tests-fuzz/targets/ddl/fuzz_alter_table.rs

@@ -29,24 +29,24 @@ use strum::{EnumIter, IntoEnumIterator};
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result, UnexpectedSnafu};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::alter_expr::{
     AlterExprAddColumnGeneratorBuilder, AlterExprDropColumnGeneratorBuilder,
     AlterExprModifyDataTypeGeneratorBuilder, AlterExprRenameGeneratorBuilder,
     AlterExprSetTableOptionsGeneratorBuilder, AlterExprUnsetTableOptionsGeneratorBuilder,
 };
 use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
-use tests_fuzz::generator::Generator;
 use tests_fuzz::ir::{
-    droppable_columns, modifiable_columns, AlterTableExpr, AlterTableOption, CreateTableExpr,
+    AlterTableExpr, AlterTableOption, CreateTableExpr, droppable_columns, modifiable_columns,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::alter_expr::AlterTableExprTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
-use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::utils::{
-    get_gt_fuzz_input_max_columns, init_greptime_connections_via_env, Connections,
+    Connections, get_gt_fuzz_input_max_columns, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 struct FuzzContext {

tests-fuzz/targets/ddl/fuzz_create_database.rs

@@ -23,15 +23,15 @@ use snafu::ResultExt;
 use sqlx::{MySql, Pool};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
-use tests_fuzz::generator::create_expr::CreateDatabaseExprGeneratorBuilder;
 use tests_fuzz::generator::Generator;
+use tests_fuzz::generator::create_expr::CreateDatabaseExprGeneratorBuilder;
 use tests_fuzz::ir::CreateDatabaseExpr;
-use tests_fuzz::translator::mysql::create_expr::CreateDatabaseExprTranslator;
 use tests_fuzz::translator::DslTranslator;
-use tests_fuzz::utils::{init_greptime_connections_via_env, Connections};
+use tests_fuzz::translator::mysql::create_expr::CreateDatabaseExprTranslator;
+use tests_fuzz::utils::{Connections, init_greptime_connections_via_env};
 
 struct FuzzContext {
     greptime: Pool<MySql>,

tests-fuzz/targets/ddl/fuzz_create_logical_table.rs

@@ -28,17 +28,17 @@ use sqlx::{MySql, Pool};
 use tests_fuzz::context::TableContext;
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::create_expr::{
     CreateLogicalTableExprGeneratorBuilder, CreatePhysicalTableExprGeneratorBuilder,
 };
-use tests_fuzz::generator::Generator;
-use tests_fuzz::ir::{primary_key_and_not_null_column_options_generator, Column};
-use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
+use tests_fuzz::ir::{Column, primary_key_and_not_null_column_options_generator};
 use tests_fuzz::translator::DslTranslator;
-use tests_fuzz::utils::{init_greptime_connections_via_env, Connections};
+use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
+use tests_fuzz::utils::{Connections, init_greptime_connections_via_env};
 use tests_fuzz::validator;
 
 struct FuzzContext {

tests-fuzz/targets/ddl/fuzz_create_table.rs

@@ -25,16 +25,16 @@ use snafu::ResultExt;
 use sqlx::{MySql, Pool};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
-use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
 use tests_fuzz::generator::Generator;
+use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
 use tests_fuzz::ir::CreateTableExpr;
-use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::DslTranslator;
+use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::utils::{
-    get_gt_fuzz_input_max_columns, init_greptime_connections_via_env, Connections,
+    Connections, get_gt_fuzz_input_max_columns, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 

tests-fuzz/targets/failover/fuzz_failover_metric_regions.rs

@@ -24,34 +24,33 @@ use common_telemetry::info;
 use libfuzzer_sys::fuzz_target;
 use rand::{Rng, SeedableRng};
 use rand_chacha::{ChaCha20Rng, ChaChaRng};
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::{Executor, MySql, Pool};
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::create_expr::{
     CreateLogicalTableExprGeneratorBuilder, CreatePhysicalTableExprGeneratorBuilder,
 };
 use tests_fuzz::generator::insert_expr::InsertExprGeneratorBuilder;
-use tests_fuzz::generator::Generator;
 use tests_fuzz::ir::{
-    generate_random_timestamp_for_mysql, generate_random_value, CreateTableExpr, InsertIntoExpr,
+    CreateTableExpr, InsertIntoExpr, generate_random_timestamp_for_mysql, generate_random_value,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
-use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::utils::cluster_info::wait_for_all_datanode_online;
 use tests_fuzz::utils::partition::{
     fetch_partitions, region_distribution, wait_for_all_regions_evicted,
 };
 use tests_fuzz::utils::pod_failure::{inject_datanode_pod_failure, recover_pod_failure};
 use tests_fuzz::utils::{
-    compact_table, flush_memtable, get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables,
-    init_greptime_connections_via_env, Connections, GT_FUZZ_CLUSTER_NAME,
-    GT_FUZZ_CLUSTER_NAMESPACE,
+    Connections, GT_FUZZ_CLUSTER_NAME, GT_FUZZ_CLUSTER_NAMESPACE, compact_table, flush_memtable,
+    get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator::row::count_values;
 

tests-fuzz/targets/failover/fuzz_failover_mito_regions.rs

@@ -27,35 +27,34 @@ use libfuzzer_sys::fuzz_target;
 use rand::seq::IndexedRandom;
 use rand::{Rng, SeedableRng};
 use rand_chacha::{ChaCha20Rng, ChaChaRng};
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::{Executor, MySql, Pool};
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
 use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
 use tests_fuzz::generator::insert_expr::InsertExprGeneratorBuilder;
 use tests_fuzz::generator::{Generator, Random};
 use tests_fuzz::ir::{
-    generate_random_value, generate_unique_timestamp_for_mysql, CreateTableExpr, Ident,
-    InsertIntoExpr, MySQLTsColumnTypeGenerator,
+    CreateTableExpr, Ident, InsertIntoExpr, MySQLTsColumnTypeGenerator, generate_random_value,
+    generate_unique_timestamp_for_mysql,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
-use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::utils::cluster_info::wait_for_all_datanode_online;
 use tests_fuzz::utils::partition::{
-    fetch_partitions, pretty_print_region_distribution, region_distribution,
-    wait_for_all_regions_evicted, Partition,
+    Partition, fetch_partitions, pretty_print_region_distribution, region_distribution,
+    wait_for_all_regions_evicted,
 };
 use tests_fuzz::utils::pod_failure::{inject_datanode_pod_failure, recover_pod_failure};
 use tests_fuzz::utils::{
-    compact_table, flush_memtable, get_gt_fuzz_input_max_columns,
-    get_gt_fuzz_input_max_insert_actions, get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables,
-    init_greptime_connections_via_env, Connections, GT_FUZZ_CLUSTER_NAME,
-    GT_FUZZ_CLUSTER_NAMESPACE,
+    Connections, GT_FUZZ_CLUSTER_NAME, GT_FUZZ_CLUSTER_NAMESPACE, compact_table, flush_memtable,
+    get_gt_fuzz_input_max_columns, get_gt_fuzz_input_max_insert_actions,
+    get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator::row::count_values;
 use tokio::sync::Semaphore;
@@ -114,7 +113,7 @@ fn generate_create_exprs<R: Rng + 'static>(
         merge_two_word_map_fn(random_capitalize_map, uppercase_and_keyword_backtick_map),
     );
 
-    let base_table_name = name_generator.gen(rng);
+    let base_table_name = name_generator.generate(rng);
     let min_column = columns / 2;
     let columns = rng.random_range(min_column..columns);
     let mut exprs = Vec::with_capacity(tables);

tests-fuzz/targets/fuzz_insert.rs

@@ -23,27 +23,27 @@ use libfuzzer_sys::arbitrary::{Arbitrary, Unstructured};
 use libfuzzer_sys::fuzz_target;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaChaRng;
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::{Executor, MySql, Pool};
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
 use tests_fuzz::generator::insert_expr::InsertExprGeneratorBuilder;
-use tests_fuzz::generator::Generator;
 use tests_fuzz::ir::{
-    generate_random_value, generate_unique_timestamp_for_mysql, replace_default,
-    sort_by_primary_keys, CreateTableExpr, InsertIntoExpr, MySQLTsColumnTypeGenerator,
+    CreateTableExpr, InsertIntoExpr, MySQLTsColumnTypeGenerator, generate_random_value,
+    generate_unique_timestamp_for_mysql, replace_default, sort_by_primary_keys,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
-use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::utils::{
-    flush_memtable, get_gt_fuzz_input_max_columns, get_gt_fuzz_input_max_rows,
-    init_greptime_connections_via_env, Connections,
+    Connections, flush_memtable, get_gt_fuzz_input_max_columns, get_gt_fuzz_input_max_rows,
+    init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 

tests-fuzz/targets/fuzz_insert_logical_table.rs

@@ -23,29 +23,29 @@ use libfuzzer_sys::arbitrary::{Arbitrary, Unstructured};
 use libfuzzer_sys::fuzz_target;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaChaRng;
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::{Executor, MySql, Pool};
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::create_expr::{
     CreateLogicalTableExprGeneratorBuilder, CreatePhysicalTableExprGeneratorBuilder,
 };
 use tests_fuzz::generator::insert_expr::InsertExprGeneratorBuilder;
-use tests_fuzz::generator::Generator;
 use tests_fuzz::ir::{
-    generate_random_value, generate_unique_timestamp_for_mysql, replace_default,
-    sort_by_primary_keys, CreateTableExpr, InsertIntoExpr,
+    CreateTableExpr, InsertIntoExpr, generate_random_value, generate_unique_timestamp_for_mysql,
+    replace_default, sort_by_primary_keys,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
-use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::utils::{
-    compact_table, flush_memtable, get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables,
-    init_greptime_connections_via_env, Connections,
+    Connections, compact_table, flush_memtable, get_gt_fuzz_input_max_rows,
+    get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 struct FuzzContext {

tests-fuzz/targets/migration/fuzz_migrate_metric_regions.rs

@@ -24,35 +24,35 @@ use common_telemetry::info;
 use libfuzzer_sys::fuzz_target;
 use rand::{Rng, SeedableRng};
 use rand_chacha::{ChaCha20Rng, ChaChaRng};
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::{Executor, MySql, Pool};
 use store_api::storage::RegionId;
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::create_expr::{
     CreateLogicalTableExprGeneratorBuilder, CreatePhysicalTableExprGeneratorBuilder,
 };
 use tests_fuzz::generator::insert_expr::InsertExprGeneratorBuilder;
-use tests_fuzz::generator::Generator;
 use tests_fuzz::ir::{
-    generate_random_timestamp_for_mysql, generate_random_value, CreateTableExpr, Ident,
-    InsertIntoExpr,
+    CreateTableExpr, Ident, InsertIntoExpr, generate_random_timestamp_for_mysql,
+    generate_random_value,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
-use tests_fuzz::translator::DslTranslator;
-use tests_fuzz::utils::cluster_info::{fetch_nodes, PEER_TYPE_DATANODE};
+use tests_fuzz::utils::cluster_info::{PEER_TYPE_DATANODE, fetch_nodes};
 use tests_fuzz::utils::migration::migrate_region;
 use tests_fuzz::utils::partition::{fetch_partition, fetch_partitions, region_distribution};
 use tests_fuzz::utils::procedure::procedure_state;
 use tests_fuzz::utils::wait::wait_condition_fn;
 use tests_fuzz::utils::{
-    compact_table, flush_memtable, get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables,
-    init_greptime_connections_via_env, Connections,
+    Connections, compact_table, flush_memtable, get_gt_fuzz_input_max_rows,
+    get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator::row::count_values;
 
@@ -264,7 +264,9 @@ async fn migrate_regions(ctx: &FuzzContext, migrations: &[Migration]) -> Result<
     {
         let procedure_id =
             migrate_region(&ctx.greptime, region_id.as_u64(), *from_peer, *to_peer, 120).await;
-        info!("Migrating region: {region_id} from {from_peer} to {to_peer}, procedure: {procedure_id}");
+        info!(
+            "Migrating region: {region_id} from {from_peer} to {to_peer}, procedure: {procedure_id}"
+        );
         procedure_ids.push(procedure_id);
     }
     for (migration, procedure_id) in migrations.iter().zip(procedure_ids) {

tests-fuzz/targets/migration/fuzz_migrate_mito_regions.rs

@@ -24,32 +24,33 @@ use common_telemetry::info;
 use libfuzzer_sys::fuzz_target;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaChaRng;
-use snafu::{ensure, ResultExt};
+use snafu::{ResultExt, ensure};
 use sqlx::{Executor, MySql, Pool};
 use store_api::storage::RegionId;
 use tests_fuzz::context::{TableContext, TableContextRef};
 use tests_fuzz::error::{self, Result};
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
+use tests_fuzz::generator::Generator;
 use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
 use tests_fuzz::generator::insert_expr::InsertExprGeneratorBuilder;
-use tests_fuzz::generator::Generator;
 use tests_fuzz::ir::{
-    format_columns, generate_random_value, generate_unique_timestamp_for_mysql, replace_default,
-    sort_by_primary_keys, CreateTableExpr, InsertIntoExpr, MySQLTsColumnTypeGenerator,
+    CreateTableExpr, InsertIntoExpr, MySQLTsColumnTypeGenerator, format_columns,
+    generate_random_value, generate_unique_timestamp_for_mysql, replace_default,
+    sort_by_primary_keys,
 };
+use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
-use tests_fuzz::translator::DslTranslator;
-use tests_fuzz::utils::cluster_info::{fetch_nodes, PEER_TYPE_DATANODE};
+use tests_fuzz::utils::cluster_info::{PEER_TYPE_DATANODE, fetch_nodes};
 use tests_fuzz::utils::migration::migrate_region;
 use tests_fuzz::utils::partition::{fetch_partition, fetch_partitions, region_distribution};
 use tests_fuzz::utils::procedure::procedure_state;
 use tests_fuzz::utils::wait::wait_condition_fn;
 use tests_fuzz::utils::{
-    compact_table, flush_memtable, init_greptime_connections_via_env, Connections,
+    Connections, compact_table, flush_memtable, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 
@@ -233,7 +234,9 @@ async fn migrate_regions(ctx: &FuzzContext, migrations: &[Migration]) -> Result<
     {
         let procedure_id =
             migrate_region(&ctx.greptime, region_id.as_u64(), *from_peer, *to_peer, 240).await;
-        info!("Migrating region: {region_id} from {from_peer} to {to_peer}, procedure: {procedure_id}");
+        info!(
+            "Migrating region: {region_id} from {from_peer} to {to_peer}, procedure: {procedure_id}"
+        );
         procedure_ids.push(procedure_id);
     }
 

tests-fuzz/targets/unstable/fuzz_create_table_standalone.rs

@@ -16,8 +16,8 @@
 
 use std::collections::HashMap;
 use std::fs::create_dir_all;
-use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 use std::time::Duration;
 
 use common_telemetry::info;
@@ -33,14 +33,14 @@ use sqlx::{MySql, Pool};
 use tests_fuzz::context::TableContext;
 use tests_fuzz::error::Result;
 use tests_fuzz::fake::{
-    merge_two_word_map_fn, random_capitalize_map, uppercase_and_keyword_backtick_map,
-    MappedGenerator, WordGenerator,
+    MappedGenerator, WordGenerator, merge_two_word_map_fn, random_capitalize_map,
+    uppercase_and_keyword_backtick_map,
 };
-use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
 use tests_fuzz::generator::Generator;
+use tests_fuzz::generator::create_expr::CreateTableExprGeneratorBuilder;
 use tests_fuzz::ir::CreateTableExpr;
-use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::DslTranslator;
+use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::utils::config::{get_conf_path, write_config_file};
 use tests_fuzz::utils::health::HttpHealthChecker;
 use tests_fuzz::utils::process::{ProcessManager, ProcessState, UnstableProcessController};