Function check_and_compact

crates/store/src/optimize.rs:208–264

(db: &Connection, name: &str, config: &CompactConfig)

}

async fn check_and_compact(db: &Connection, name: &str, config: &CompactConfig) -> CompactResult {
    let started = Instant::now();
    let finalize = |action: CompactAction,
                    small_fragments: usize,
                    max_unindexed_rows: usize,
                    compacted: bool,
                    pruned: bool,
                    index_optimized: bool,
                    error: Option<String>| CompactResult {
        table: name.to_string(),
        small_fragments,
        max_unindexed_rows,
        action,
        elapsed_ms: started.elapsed().as_millis(),
        compacted,
        pruned,
        index_optimized,
        error,
    };

    if !config.enabled {
        return finalize(CompactAction::CompactionDisabled, 0, 0, false, false, false, None);
    }

    let lock_path = local_table_rewrite_lock_path(db.uri(), name);
    let _file_guard =
        match acquire_table_access_file_lock(&lock_path, TableAccessMode::Exclusive).await {
            Ok(guard) => guard,
            Err(err) => {
                return finalize(
                    CompactAction::CompactFailed,
                    0,
                    0,
                    false,
                    false,
                    false,
                    Some(format!("table lock failed: {err}")),
                )
            },
        };

    let table = match db.open_table(name).execute().await {
        Ok(t) => t,
        Err(err) => {
            return finalize(
                CompactAction::OpenFailed,
                0,
                0,
                false,
                false,
                false,
                Some(format!("open failed: {err:#}")),
            )
        },
    };
    check_opened_table_and_compact(&table, config).await
}