Function check_opened_table_and_compact

crates/store/src/optimize.rs:266–412

(
    table: &Table,
    config: &CompactConfig,
)

}

pub async fn check_opened_table_and_compact(
    table: &Table,
    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: 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 small = match count_small_fragments(table).await {
        Ok(count) => count,
        Err(err) => {
            return finalize(
                CompactAction::StatsFailed,
                0,
                0,
                false,
                false,
                false,
                Some(format!("fragment scan failed: {err}")),
            )
        },
    };
    let max_unindexed_rows = match max_unindexed_rows(table).await {
        Ok(count) => count,
        Err(err) => {
            return finalize(
                CompactAction::StatsFailed,
                small,
                0,
                false,
                false,
                false,
                Some(format!("index scan failed: {err}")),
            )
        },
    };
    if small < config.fragment_threshold {
        // Even when compaction is skipped, old versions should still be pruned
        // and lagging indices repaired through the same maintenance entrypoint.