Function optimize_compaction_with_fallback

crates/store/src/optimize.rs:419–458

(table: &Table)

}

async fn optimize_compaction_with_fallback(table: &Table) -> Result<OptimizePath, String> {
    let options = maintenance_compaction_options(table).await?;
    match table
        .optimize(OptimizeAction::Compact {
            options: options.clone(),
            remap_options: None,
        })
        .await
    {
        Ok(_) => Ok(OptimizePath::Maintenance),
        Err(err) => {
            if !is_offset_overflow_error(&err) {
                return Err(format!("compact failed: {err:#}"));
            }

            let options = CompactionOptions {
                num_threads: Some(MAINTENANCE_COMPACTION_THREADS),
                batch_size: Some(SAFE_COMPACTION_BATCH_SIZE),
                max_rows_per_group: SAFE_COMPACTION_MAX_ROWS_PER_GROUP,
                max_bytes_per_file: Some(SAFE_COMPACTION_MAX_BYTES_PER_FILE),
                defer_index_remap: options.defer_index_remap,
                ..CompactionOptions::default()
            };

            if let Err(fallback_err) = table
                .optimize(OptimizeAction::Compact {
                    options,
                    remap_options: None,
                })
                .await
            {
                return Err(format!(
                    "compact failed: {err:#}; safe compact fallback failed: {fallback_err:#}"
                ));
            }

            Ok(OptimizePath::SafeFallback)
        },
    }
}

fn is_offset_overflow_error(err: &dyn std::error::Error) -> bool {
    err.to_string().contains("Offset overflow error")