rust/greptimedb
1
0
Fork 0
mirror of https://github.com/GreptimeTeam/greptimedb.git synced 2026-01-07 05:42:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: upgrade some dependencies (#5777)

Browse Source 
* chore: upgrade some dependencies

* chore: upgrade some dependencies

* fix: cr

* fix: ci

* fix: test

* fix: cargo fmt
This commit is contained in:
fys
2025-03-27 10:48:44 +08:00
committed by GitHub
parent e107bd5529
commit 2b2ea5bf72
55 changed files with 665 additions and 555 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
tests-fuzz/targets/ddl/fuzz_alter_logical_table.rs
View File

@@ -69,16 +69,16 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_actions = get_gt_fuzz_input_max_alter_actions();
let actions = rng.gen_range(1..max_actions);
let actions = rng.random_range(1..max_actions);
Ok(FuzzInput { seed, actions })
}
}
fn generate_create_physical_table_expr<R: Rng + 'static>(rng: &mut R) -> Result<CreateTableExpr> {
let physical_table_if_not_exists = rng.gen_bool(0.5);
let physical_table_if_not_exists = rng.random_bool(0.5);
let mut with_clause = HashMap::new();
if rng.gen_bool(0.5) {
if rng.random_bool(0.5) {
with_clause.insert("append_mode".to_string(), "true".to_string());
}
let create_physical_table_expr = CreatePhysicalTableExprGeneratorBuilder::default()
@@ -97,8 +97,8 @@ fn generate_create_logical_table_expr<R: Rng + 'static>(
physical_table_ctx: TableContextRef,
rng: &mut R,
) -> Result<CreateTableExpr> {
let labels = rng.gen_range(1..=5);
let logical_table_if_not_exists = rng.gen_bool(0.5);
let labels = rng.random_range(1..=5);
let logical_table_if_not_exists = rng.random_bool(0.5);
let create_logical_table_expr = CreateLogicalTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(

10
tests-fuzz/targets/ddl/fuzz_alter_table.rs
View File

@@ -76,9 +76,9 @@ enum AlterTableKind {
fn generate_create_table_expr<R: Rng + 'static>(rng: &mut R) -> Result<CreateTableExpr> {
let max_columns = get_gt_fuzz_input_max_columns();
let columns = rng.gen_range(2..max_columns);
let columns = rng.random_range(2..max_columns);
let mut with_clause = HashMap::new();
if rng.gen_bool(0.5) {
if rng.random_bool(0.5) {
with_clause.insert("append_mode".to_string(), "true".to_string());
}
let create_table_generator = CreateTableExprGeneratorBuilder::default()
@@ -99,7 +99,7 @@ fn generate_alter_table_expr<R: Rng + 'static>(
rng: &mut R,
) -> Result<AlterTableExpr> {
let kinds = AlterTableKind::iter().collect::<Vec<_>>();
match kinds[rng.gen_range(0..kinds.len())] {
match kinds[rng.random_range(0..kinds.len())] {
AlterTableKind::DropColumn if !droppable_columns(&table_ctx.columns).is_empty() => {
AlterExprDropColumnGeneratorBuilder::default()
.table_ctx(table_ctx)
@@ -138,7 +138,7 @@ fn generate_alter_table_expr<R: Rng + 'static>(
expr_generator.generate(rng)
}
_ => {
let location = rng.gen_bool(0.5);
let location = rng.random_bool(0.5);
let expr_generator = AlterExprAddColumnGeneratorBuilder::default()
.table_ctx(table_ctx)
.location(location)
@@ -153,7 +153,7 @@ impl Arbitrary<'_> for FuzzInput {
fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let actions = rng.gen_range(1..256);
let actions = rng.random_range(1..256);
Ok(FuzzInput { seed, actions })
}

2
tests-fuzz/targets/ddl/fuzz_create_database.rs
View File

@@ -57,7 +57,7 @@ impl Arbitrary<'_> for FuzzInput {
fn generate_expr(input: FuzzInput) -> Result<CreateDatabaseExpr> {
let mut rng = ChaChaRng::seed_from_u64(input.seed);
let if_not_exists = rng.gen_bool(0.5);
let if_not_exists = rng.random_bool(0.5);
let create_database_generator = CreateDatabaseExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(
WordGenerator,

8
tests-fuzz/targets/ddl/fuzz_create_logical_table.rs
View File

@@ -68,9 +68,9 @@ async fn execute_create_logic_table(ctx: FuzzContext, input: FuzzInput) -> Resul
let mut rng = ChaChaRng::seed_from_u64(input.seed);
// Create physical table
let physical_table_if_not_exists = rng.gen_bool(0.5);
let physical_table_if_not_exists = rng.random_bool(0.5);
let mut with_clause = HashMap::new();
if rng.gen_bool(0.5) {
if rng.random_bool(0.5) {
with_clause.insert("append_mode".to_string(), "true".to_string());
}
let create_physical_table_expr = CreatePhysicalTableExprGeneratorBuilder::default()
@@ -113,8 +113,8 @@ async fn execute_create_logic_table(ctx: FuzzContext, input: FuzzInput) -> Resul
// Create logical table
let physical_table_ctx = Arc::new(TableContext::from(&create_physical_table_expr));
let labels = rng.gen_range(1..=5);
let logical_table_if_not_exists = rng.gen_bool(0.5);
let labels = rng.random_range(1..=5);
let logical_table_if_not_exists = rng.random_bool(0.5);
let create_logical_table_expr = CreateLogicalTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(

6
tests-fuzz/targets/ddl/fuzz_create_table.rs
View File

@@ -59,16 +59,16 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_columns = get_gt_fuzz_input_max_columns();
let columns = rng.gen_range(2..max_columns);
let columns = rng.random_range(2..max_columns);
Ok(FuzzInput { columns, seed })
}
}
fn generate_expr(input: FuzzInput) -> Result<CreateTableExpr> {
let mut rng = ChaChaRng::seed_from_u64(input.seed);
let if_not_exists = rng.gen_bool(0.5);
let if_not_exists = rng.random_bool(0.5);
let mut with_clause = HashMap::new();
if rng.gen_bool(0.5) {
if rng.random_bool(0.5) {
with_clause.insert("append_mode".to_string(), "true".to_string());
}

14
tests-fuzz/targets/failover/fuzz_failover_metric_regions.rs
View File

@@ -80,15 +80,15 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_rows = get_gt_fuzz_input_max_rows();
let rows = rng.gen_range(2..max_rows);
let rows = rng.random_range(2..max_rows);
let max_tables = get_gt_fuzz_input_max_tables();
let tables = rng.gen_range(1..max_tables);
let tables = rng.random_range(1..max_tables);
Ok(FuzzInput { rows, seed, tables })
}
}
fn generate_create_physical_table_expr<R: Rng + 'static>(rng: &mut R) -> Result<CreateTableExpr> {
let physical_table_if_not_exists = rng.gen_bool(0.5);
let physical_table_if_not_exists = rng.random_bool(0.5);
let create_physical_table_expr = CreatePhysicalTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(
WordGenerator,
@@ -121,8 +121,8 @@ fn generate_create_logical_table_expr<R: Rng + 'static>(
physical_table_ctx: TableContextRef,
rng: &mut R,
) -> Result<CreateTableExpr> {
let labels = rng.gen_range(1..=5);
let logical_table_if_not_exists = rng.gen_bool(0.5);
let labels = rng.random_range(1..=5);
let logical_table_if_not_exists = rng.random_bool(0.5);
let create_logical_table_expr = CreateLogicalTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(
@@ -208,10 +208,10 @@ async fn execute_failover(ctx: FuzzContext, input: FuzzInput) -> Result<()> {
let insert_expr =
insert_values(input.rows, &ctx, &mut rng, logical_table_ctx.clone()).await?;
if rng.gen_bool(0.1) {
if rng.random_bool(0.1) {
flush_memtable(&ctx.greptime, &physical_table_ctx.name).await?;
}
if rng.gen_bool(0.1) {
if rng.random_bool(0.1) {
compact_table(&ctx.greptime, &physical_table_ctx.name).await?;
}

28
tests-fuzz/targets/failover/fuzz_failover_mito_regions.rs
View File

@@ -24,7 +24,7 @@ use common_telemetry::info;
use common_time::util::current_time_millis;
use futures::future::try_join_all;
use libfuzzer_sys::fuzz_target;
use rand::seq::SliceRandom;
use rand::seq::IndexedRandom;
use rand::{Rng, SeedableRng};
use rand_chacha::{ChaCha20Rng, ChaChaRng};
use snafu::{ensure, ResultExt};
@@ -87,13 +87,13 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_columns = get_gt_fuzz_input_max_columns();
let columns = rng.gen_range(2..max_columns);
let columns = rng.random_range(2..max_columns);
let max_rows = get_gt_fuzz_input_max_rows();
let rows = rng.gen_range(2..max_rows);
let rows = rng.random_range(2..max_rows);
let max_tables = get_gt_fuzz_input_max_tables();
let tables = rng.gen_range(2..max_tables);
let tables = rng.random_range(2..max_tables);
let max_inserts = get_gt_fuzz_input_max_insert_actions();
let inserts = rng.gen_range(2..max_inserts);
let inserts = rng.random_range(2..max_inserts);
Ok(FuzzInput {
columns,
rows,
@@ -116,7 +116,7 @@ fn generate_create_exprs<R: Rng + 'static>(
let base_table_name = name_generator.gen(rng);
let min_column = columns / 2;
let columns = rng.gen_range(min_column..columns);
let columns = rng.random_range(min_column..columns);
let mut exprs = Vec::with_capacity(tables);
for i in 0..tables {
let table_name = Ident {
@@ -174,11 +174,11 @@ fn generate_insert_exprs<R: Rng + 'static>(
) -> Result<Vec<Vec<InsertIntoExpr>>> {
let mut exprs = Vec::with_capacity(tables.len());
for table_ctx in tables {
let omit_column_list = rng.gen_bool(0.2);
let omit_column_list = rng.random_bool(0.2);
let min_rows = rows / 2;
let rows = rng.gen_range(min_rows..rows);
let rows = rng.random_range(min_rows..rows);
let min_inserts = inserts / 2;
let inserts = rng.gen_range(min_inserts..inserts);
let inserts = rng.random_range(min_inserts..inserts);
let insert_generator = InsertExprGeneratorBuilder::default()
.table_ctx(table_ctx.clone())
@@ -207,9 +207,9 @@ async fn execute_insert_exprs<R: Rng + 'static>(
let semaphore = Arc::new(Semaphore::new(parallelism));
let tasks = inserts.into_iter().map(|inserts| {
let flush_probability = rng.gen_range(0.0..1.0);
let compact_probability = rng.gen_range(0.0..1.0);
let seed: u64 = rng.gen();
let flush_probability = rng.random_range(0.0..1.0);
let compact_probability = rng.random_range(0.0..1.0);
let seed: u64 = rng.random();
let semaphore = semaphore.clone();
let greptime = ctx.greptime.clone();
@@ -235,10 +235,10 @@ async fn execute_insert_exprs<R: Rng + 'static>(
)
}
);
if rng.gen_bool(flush_probability) {
if rng.random_bool(flush_probability) {
flush_memtable(&greptime, &insert_expr.table_name).await?;
}
if rng.gen_bool(compact_probability) {
if rng.random_bool(compact_probability) {
compact_table(&greptime, &insert_expr.table_name).await?;
}
total_affected += result.rows_affected();

10
tests-fuzz/targets/fuzz_insert.rs
View File

@@ -69,9 +69,9 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_columns = get_gt_fuzz_input_max_columns();
let columns = rng.gen_range(2..max_columns);
let columns = rng.random_range(2..max_columns);
let max_row = get_gt_fuzz_input_max_rows();
let rows = rng.gen_range(1..max_row);
let rows = rng.random_range(1..max_row);
Ok(FuzzInput {
columns,
rows,
@@ -85,7 +85,7 @@ fn generate_create_expr<R: Rng + 'static>(
rng: &mut R,
) -> Result<CreateTableExpr> {
let mut with_clause = HashMap::new();
if rng.gen_bool(0.5) {
if rng.random_bool(0.5) {
with_clause.insert("append_mode".to_string(), "true".to_string());
}
@@ -108,7 +108,7 @@ fn generate_insert_expr<R: Rng + 'static>(
rng: &mut R,
table_ctx: TableContextRef,
) -> Result<InsertIntoExpr> {
let omit_column_list = rng.gen_bool(0.2);
let omit_column_list = rng.random_bool(0.2);
let insert_generator = InsertExprGeneratorBuilder::default()
.table_ctx(table_ctx)
@@ -155,7 +155,7 @@ async fn execute_insert(ctx: FuzzContext, input: FuzzInput) -> Result<()> {
}
);
if rng.gen_bool(0.5) {
if rng.random_bool(0.5) {
flush_memtable(&ctx.greptime, &create_expr.table_name).await?;
}

16
tests-fuzz/targets/fuzz_insert_logical_table.rs
View File

@@ -70,17 +70,17 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_tables = get_gt_fuzz_input_max_tables();
let tables = rng.gen_range(1..max_tables);
let tables = rng.random_range(1..max_tables);
let max_row = get_gt_fuzz_input_max_rows();
let rows = rng.gen_range(1..max_row);
let rows = rng.random_range(1..max_row);
Ok(FuzzInput { tables, seed, rows })
}
}
fn generate_create_physical_table_expr<R: Rng + 'static>(rng: &mut R) -> Result<CreateTableExpr> {
let physical_table_if_not_exists = rng.gen_bool(0.5);
let physical_table_if_not_exists = rng.random_bool(0.5);
let mut with_clause = HashMap::new();
if rng.gen_bool(0.5) {
if rng.random_bool(0.5) {
with_clause.insert("append_mode".to_string(), "true".to_string());
}
let create_physical_table_expr = CreatePhysicalTableExprGeneratorBuilder::default()
@@ -99,8 +99,8 @@ fn generate_create_logical_table_expr<R: Rng + 'static>(
physical_table_ctx: TableContextRef,
rng: &mut R,
) -> Result<CreateTableExpr> {
let labels = rng.gen_range(1..=5);
let logical_table_if_not_exists = rng.gen_bool(0.5);
let labels = rng.random_range(1..=5);
let logical_table_if_not_exists = rng.random_bool(0.5);
let create_logical_table_expr = CreateLogicalTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(
@@ -259,11 +259,11 @@ async fn execute_insert(ctx: FuzzContext, input: FuzzInput) -> Result<()> {
insert_values(input.rows, &ctx, &mut rng, logical_table_ctx.clone()).await?;
validate_values(&ctx, logical_table_ctx.clone(), &insert_expr).await?;
tables.insert(logical_table_ctx.name.clone(), logical_table_ctx.clone());
if rng.gen_bool(0.1) {
if rng.random_bool(0.1) {
flush_memtable(&ctx.greptime, &physical_table_ctx.name).await?;
validate_values(&ctx, logical_table_ctx.clone(), &insert_expr).await?;
}
if rng.gen_bool(0.1) {
if rng.random_bool(0.1) {
compact_table(&ctx.greptime, &physical_table_ctx.name).await?;
validate_values(&ctx, logical_table_ctx.clone(), &insert_expr).await?;
}

16
tests-fuzz/targets/migration/fuzz_migrate_metric_regions.rs
View File

@@ -78,16 +78,16 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_rows = get_gt_fuzz_input_max_rows();
let rows = rng.gen_range(2..max_rows);
let rows = rng.random_range(2..max_rows);
let max_tables = get_gt_fuzz_input_max_tables();
let tables = rng.gen_range(1..max_tables);
let tables = rng.random_range(1..max_tables);
Ok(FuzzInput { rows, seed, tables })
}
}
fn generate_create_physical_table_expr<R: Rng + 'static>(rng: &mut R) -> Result<CreateTableExpr> {
let physical_table_if_not_exists = rng.gen_bool(0.5);
let physical_table_if_not_exists = rng.random_bool(0.5);
let create_physical_table_expr = CreatePhysicalTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(
WordGenerator,
@@ -120,8 +120,8 @@ fn generate_create_logical_table_expr<R: Rng + 'static>(
physical_table_ctx: TableContextRef,
rng: &mut R,
) -> Result<CreateTableExpr> {
let labels = rng.gen_range(1..=5);
let logical_table_if_not_exists = rng.gen_bool(0.5);
let labels = rng.random_range(1..=5);
let logical_table_if_not_exists = rng.random_bool(0.5);
let create_logical_table_expr = CreateLogicalTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(
@@ -214,10 +214,10 @@ async fn create_logical_table_and_insert_values(
let logical_table_ctx = Arc::new(TableContext::from(&create_logical_table_expr));
let insert_expr = insert_values(input.rows, ctx, rng, logical_table_ctx.clone()).await?;
if rng.gen_bool(0.1) {
if rng.random_bool(0.1) {
flush_memtable(&ctx.greptime, &physical_table_ctx.name).await?;
}
if rng.gen_bool(0.1) {
if rng.random_bool(0.1) {
compact_table(&ctx.greptime, &physical_table_ctx.name).await?;
}
@@ -338,7 +338,7 @@ async fn execute_migration(ctx: FuzzContext, input: FuzzInput) -> Result<()> {
let mut migrations = Vec::with_capacity(num_partitions);
let mut new_distribution: BTreeMap<u64, HashSet<_>> = BTreeMap::new();
for (datanode_id, regions) in region_distribution {
let step = rng.gen_range(1..datanodes.len());
let step = rng.random_range(1..datanodes.len());
for region in regions {
let to_peer = (datanode_id + step as u64) % datanodes.len() as u64;
new_distribution.entry(to_peer).or_default().insert(region);

16
tests-fuzz/targets/migration/fuzz_migrate_mito_regions.rs
View File

@@ -76,10 +76,10 @@ impl Arbitrary<'_> for FuzzInput {
fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let partitions = rng.gen_range(3..32);
let columns = rng.gen_range(2..30);
let rows = rng.gen_range(128..1024);
let inserts = rng.gen_range(2..8);
let partitions = rng.random_range(3..32);
let columns = rng.random_range(2..30);
let rows = rng.random_range(128..1024);
let inserts = rng.random_range(2..8);
Ok(FuzzInput {
seed,
columns,
@@ -113,7 +113,7 @@ fn generate_insert_exprs<R: Rng + 'static>(
rng: &mut R,
table_ctx: TableContextRef,
) -> Result<Vec<InsertIntoExpr>> {
let omit_column_list = rng.gen_bool(0.2);
let omit_column_list = rng.random_bool(0.2);
let insert_generator = InsertExprGeneratorBuilder::default()
.table_ctx(table_ctx.clone())
.omit_column_list(omit_column_list)
@@ -161,10 +161,10 @@ async fn insert_values<R: Rng + 'static>(
)
}
);
if rng.gen_bool(0.2) {
if rng.random_bool(0.2) {
flush_memtable(&ctx.greptime, &table_ctx.name).await?;
}
if rng.gen_bool(0.1) {
if rng.random_bool(0.1) {
compact_table(&ctx.greptime, &table_ctx.name).await?;
}
}
@@ -309,7 +309,7 @@ async fn execute_region_migration(ctx: FuzzContext, input: FuzzInput) -> Result<
let mut migrations = Vec::with_capacity(num_partitions);
let mut new_distribution: BTreeMap<u64, HashSet<_>> = BTreeMap::new();
for (datanode_id, regions) in region_distribution {
let step = rng.gen_range(1..datanodes.len());
let step = rng.random_range(1..datanodes.len());
for region in regions {
let to_peer = (datanode_id + step as u64) % datanodes.len() as u64;
new_distribution.entry(to_peer).or_default().insert(region);

4
tests-fuzz/targets/unstable/fuzz_create_table_standalone.rs
View File

@@ -69,7 +69,7 @@ impl Arbitrary<'_> for FuzzInput {
let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
let mut rng = ChaChaRng::seed_from_u64(seed);
let max_tables = get_gt_fuzz_input_max_tables();
let tables = rng.gen_range(1..max_tables);
let tables = rng.random_range(1..max_tables);
Ok(FuzzInput { seed, tables })
}
}
@@ -81,7 +81,7 @@ const DEFAULT_MYSQL_URL: &str = "127.0.0.1:4002";
const DEFAULT_HTTP_HEALTH_URL: &str = "http://127.0.0.1:4000/health";
fn generate_create_table_expr<R: Rng + 'static>(rng: &mut R) -> CreateTableExpr {
let columns = rng.gen_range(2..30);
let columns = rng.random_range(2..30);
let create_table_generator = CreateTableExprGeneratorBuilder::default()
.name_generator(Box::new(MappedGenerator::new(
WordGenerator,