Remove Lance benchmarks

Signed-off-by: Adam Gutglick <[email protected]>

Author: AdamGS

Cargo.lock

@@ -16,13 +16,7 @@ version = { workspace = true }
 [lints]
 workspace = true
 
-[features]
-lance = ["dep:lance", "dep:lance-encoding"]
-
 [dependencies]
-lance = { version = "0.39.0", optional = true }
-lance-encoding = { version = "0.39.0", optional = true }
-
 anyhow = { workspace = true }
 arrow-array = { workspace = true }
 arrow-cast = { workspace = true }

bench-vortex/Cargo.toml

@@ -254,8 +254,6 @@ pub fn benchmark_compress(
                     let compress_fn: CompressFn = match format {
                         Format::OnDiskVortex => compress::benchmark_vortex_compress,
                         Format::Parquet => compress::benchmark_parquet_compress,
-                        #[cfg(feature = "lance")]
-                        Format::Lance => compress::benchmark_lance_compress,
                         _ => unimplemented!("Compress bench not implemented for {format}"),
                     };
 
@@ -272,8 +270,6 @@ pub fn benchmark_compress(
                     let decompress_fn: DecompressFn = match format {
                         Format::OnDiskVortex => compress::benchmark_vortex_decompress,
                         Format::Parquet => compress::benchmark_parquet_decompress,
-                        #[cfg(feature = "lance")]
-                        Format::Lance => compress::benchmark_lance_decompress,
                         _ => unimplemented!("Decompress bench not implemented for {format}"),
                     };
 

bench-vortex/src/bin/compress.rs

@@ -16,8 +16,6 @@ use bench_vortex::display::DisplayFormat;
 use bench_vortex::display::print_measurements_json;
 use bench_vortex::display::render_table;
 use bench_vortex::measurements::TimingMeasurement;
-#[cfg(feature = "lance")]
-use bench_vortex::random_access::take::take_lance;
 use bench_vortex::random_access::take::take_parquet;
 use bench_vortex::random_access::take::take_vortex_tokio;
 use bench_vortex::setup_logging_and_tracing;
@@ -128,8 +126,6 @@ fn random_access(
         let engine = match format {
             Format::OnDiskVortex | Format::VortexCompact => Engine::Vortex,
             Format::Parquet => Engine::Arrow,
-            #[cfg(feature = "lance")]
-            Format::Lance => Engine::Arrow,
             Format::Csv | Format::Arrow | Format::OnDiskDuckDB => unimplemented!(),
         };
         let target = Target::new(engine, format);
@@ -185,22 +181,6 @@ fn random_access(
                     },
                 )
             }
-            #[cfg(feature = "lance")]
-            Format::Lance => {
-                let taxi_lance = runtime.block_on(taxi_data_lance())?;
-
-                create_timing_measurement(
-                    |indices| async { take_lance(&taxi_lance, indices).await },
-                    TimingConfig {
-                        name: "random-access/lance-tokio-local-disk".to_string(),
-                        storage: STORAGE_NVME.to_owned(),
-                        runtime: &runtime,
-                        indices: &indices,
-                        time_limit,
-                        target,
-                    },
-                )
-            }
             Format::Csv | Format::Arrow | Format::OnDiskDuckDB => unimplemented!(),
         };
 

bench-vortex/src/bin/random_access.rs

@@ -123,29 +123,6 @@ impl Benchmark for ClickBenchBenchmark {
                             })?
                         }
                     }
-                    #[cfg(feature = "lance")]
-                    Format::Lance => {
-                        // Lance manages its own partitioning internally, so flavor doesn't matter.
-                        if self.flavor == Flavor::Single {
-                            eprintln!(
-                                "Note: Lance manages its own internal partitioning. There is no \
-                                difference between Single and Partitioned flavors for Lance format."
-                            );
-                        }
-
-                        // Download Parquet files (either Single or Partitioned).
-                        self.flavor.download(&client, basepath.as_path())?;
-
-                        // Then convert to Lance format (idempotent).
-                        if self.data_url.scheme() == "file" {
-                            let file_path = self.data_url.to_file_path().map_err(|_| {
-                                anyhow::anyhow!("invalid file URL: {}", self.data_url)
-                            })?;
-
-                            let rt = Runtime::new()?;
-                            rt.block_on(async { convert_parquet_to_lance(&file_path).await })?
-                        }
-                    }
                     f => {
                         todo!("format {f} unsupported in clickbench")
                     }

bench-vortex/src/clickbench/clickbench_benchmark.rs

@@ -46,8 +46,6 @@ use crate::CompactionStrategy;
 use crate::Format;
 use crate::SESSION;
 use crate::conversions::parquet_to_vortex;
-#[cfg(feature = "lance")]
-use crate::utils;
 use crate::utils::file_utils::idempotent;
 use crate::utils::file_utils::idempotent_async;
 
@@ -238,26 +236,6 @@ pub async fn convert_parquet_to_vortex(
     Ok(())
 }
 
-/// Convert Parquet files to Lance format for ClickBench.
-/// Lance manages its own internal partitioning, so we convert all Parquet files
-/// (whether Single or Partitioned flavor) into a single Lance dataset.
-#[cfg(feature = "lance")]
-pub async fn convert_parquet_to_lance(input_path: &Path) -> anyhow::Result<()> {
-    let lance_dir = input_path.join(Format::Lance.name());
-    let parquet_dir = input_path.join(Format::Parquet.name());
-
-    // Use the generic converter with no prefix filter (accepts all parquet files)
-    // ClickBench also uses Utf8View columns that need conversion for Lance
-    utils::convert_parquet_to_lance(
-        &parquet_dir,
-        &lance_dir,
-        "hits", // ClickBench uses "hits" as the dataset name
-        None,   // No file prefix filter
-        true,   // Convert Utf8View to Utf8 for Lance compatibility
-    )
-    .await
-}
-
 pub async fn register_vortex_files(
     session: SessionContext,
     table_name: &str,

bench-vortex/src/clickbench/clickbench_data.rs

@@ -17,19 +17,6 @@ use tokio::runtime::Runtime;
 use vortex::array::Array;
 use vortex::array::arrays::ChunkedVTable;
 use vortex::utils::aliases::hash_map::HashMap;
-#[cfg(feature = "lance")]
-#[rustfmt::skip]
-use {
-    super::lance::*,
-    crate::bench_run::run_with_setup,
-    crate::utils::convert_utf8view_batch,
-    crate::utils::convert_utf8view_schema,
-    arrow_array::RecordBatch,
-    parking_lot::Mutex,
-    std::fs,
-    std::path::PathBuf,
-    std::sync::Arc,
-};
 
 use crate::Format;
 use crate::bench_run::run;
@@ -229,125 +216,6 @@ pub fn benchmark_parquet_decompress(
     Ok((time, timing))
 }
 
-#[cfg(feature = "lance")]
-pub fn benchmark_lance_compress(
-    runtime: &Runtime,
-    uncompressed: &dyn Array,
-    iterations: usize,
-    bench_name: &str,
-) -> Result<(
-    Duration,
-    u64,
-    Vec<CustomUnitMeasurement>,
-    CompressionTimingMeasurement,
-)> {
-    // NOTE: Lance requires filesystem access unlike Parquet/Vortex which use in-memory buffers.
-    // To make the benchmark fairer, we exclude directory creation and size calculation from timing
-    // (which is included in timing in the other benchmarks).
-
-    let chunked = uncompressed.as_::<ChunkedVTable>().clone();
-    let (batches, schema) = chunked_to_vec_record_batch(chunked);
-
-    // Convert Utf8View to Utf8 (Lance doesn't support Utf8View).
-    let converted_batches: Vec<RecordBatch> = batches
-        .into_iter()
-        .map(convert_utf8view_batch)
-        .collect::<Result<Vec<_>, _>>()?;
-    let converted_schema = convert_utf8view_schema(&schema);
-
-    let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
-    let iteration_paths: Arc<Mutex<Vec<PathBuf>>> = Arc::new(Mutex::new(Vec::new()));
-    let iteration_counter = AtomicU64::new(0);
-
-    // Run the benchmark and measure time.
-    let time = run_with_setup(
-        runtime,
-        iterations,
-        || {
-            // Create a unique subdirectory for each iteration (not timed).
-            let iteration_id = iteration_counter.fetch_add(1, Ordering::Relaxed);
-            let iteration_dir = temp_dir.path().join(format!("iter_{}", iteration_id));
-            fs::create_dir_all(&iteration_dir).expect("Failed to create iteration directory");
-
-            (
-                iteration_dir,
-                converted_batches.clone(),
-                converted_schema.clone(),
-                iteration_paths.clone(),
-            )
-        },
-        |(iteration_dir, batches, schema, paths)| async move {
-            lance_compress_write_only(batches, schema, &iteration_dir)
-                .await
-                .expect("Failed to compress with lance");
-
-            // Since there should be low contention, this won't block and will be fast.
-            paths.lock().push(iteration_dir);
-        },
-    );
-
-    // Calculate size from the last iteration.
-    let paths = iteration_paths.lock();
-    let lance_compressed_size_val = if let Some(last_path) = paths.last() {
-        calculate_lance_size(last_path).expect("Failed to calculate Lance size")
-    } else {
-        0
-    };
-    let ratios = vec![CustomUnitMeasurement {
-        name: format!("lance size/{bench_name}"),
-        // Unlike timings, ratios have a single column vortex.
-        format: Format::OnDiskVortex,
-        unit: Cow::from("bytes"),
-        value: lance_compressed_size_val as f64,
-    }];
-
-    let timing = CompressionTimingMeasurement {
-        name: format!("compress time/{bench_name}"),
-        time,
-        format: Format::Lance,
-    };
-
-    Ok((time, lance_compressed_size_val, ratios, timing))
-}
-
-#[cfg(feature = "lance")]
-pub fn benchmark_lance_decompress(
-    runtime: &Runtime,
-    uncompressed: &dyn Array,
-    iterations: usize,
-    bench_name: &str,
-) -> Result<(Duration, CompressionTimingMeasurement)> {
-    // NOTE: Lance requires filesystem access unlike Parquet/Vortex which use in-memory buffers.
-    let chunked = uncompressed.as_::<ChunkedVTable>().clone();
-    let (batches, schema) = chunked_to_vec_record_batch(chunked);
-    let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
-
-    // Write the Lance dataset once for all iterations.
-    let dataset_path = runtime.block_on(async {
-        lance_compress_write(batches, schema, &temp_dir)
-            .await
-            .expect("Failed to compress with lance for decompression test")
-    });
-
-    // Keep temp_dir alive to prevent deletion.
-    let temp_path = (dataset_path, temp_dir);
-
-    // Run the benchmark and measure time.
-    let time = run(runtime, iterations, || async {
-        lance_decompress_read(&temp_path.0)
-            .await
-            .expect("Failed to decompress with lance");
-    });
-
-    let timing = CompressionTimingMeasurement {
-        name: format!("decompress time/{bench_name}"),
-        time,
-        format: Format::Lance,
-    };
-
-    Ok((time, timing))
-}
-
 // Helper function to calculate ratios between formats.
 pub fn calculate_ratios(
     measurements: &HashMap<(Format, CompressOp), Duration>,
@@ -356,9 +224,6 @@ pub fn calculate_ratios(
     ratios: &mut Vec<CustomUnitMeasurement>,
 ) {
     calculate_vortex_parquet_ratios(measurements, compressed_sizes, bench_name, ratios);
-
-    #[cfg(feature = "lance")]
-    calculate_vortex_lance_ratios(measurements, compressed_sizes, bench_name, ratios);
 }
 
 fn calculate_vortex_parquet_ratios(
@@ -406,50 +271,3 @@ fn calculate_vortex_parquet_ratios(
         });
     }
 }
-
-#[cfg(feature = "lance")]
-fn calculate_vortex_lance_ratios(
-    measurements: &HashMap<(Format, CompressOp), Duration>,
-    compressed_sizes: &HashMap<Format, u64>,
-    bench_name: &str,
-    ratios: &mut Vec<CustomUnitMeasurement>,
-) {
-    // Size ratio: vortex vs lance.
-    if let (Some(vortex_size), Some(lance_size)) = (
-        compressed_sizes.get(&Format::OnDiskVortex),
-        compressed_sizes.get(&Format::Lance),
-    ) {
-        ratios.push(CustomUnitMeasurement {
-            name: format!("vortex:lance size/{bench_name}"),
-            format: Format::OnDiskVortex,
-            unit: Cow::from("ratio"),
-            value: *vortex_size as f64 / *lance_size as f64,
-        });
-    }
-
-    // Compress time ratio: vortex vs lance.
-    if let (Some(vortex_time), Some(lance_time)) = (
-        measurements.get(&(Format::OnDiskVortex, CompressOp::Compress)),
-        measurements.get(&(Format::Lance, CompressOp::Compress)),
-    ) {
-        ratios.push(CustomUnitMeasurement {
-            name: format!("vortex:lance ratio compress time/{bench_name}"),
-            format: Format::OnDiskVortex,
-            unit: Cow::from("ratio"),
-            value: vortex_time.as_nanos() as f64 / lance_time.as_nanos() as f64,
-        });
-    }
-
-    // Decompress time ratio: vortex vs lance.
-    if let (Some(vortex_time), Some(lance_time)) = (
-        measurements.get(&(Format::OnDiskVortex, CompressOp::Decompress)),
-        measurements.get(&(Format::Lance, CompressOp::Decompress)),
-    ) {
-        ratios.push(CustomUnitMeasurement {
-            name: format!("vortex:lance ratio decompress time/{bench_name}"),
-            format: Format::OnDiskVortex,
-            unit: Cow::from("ratio"),
-            value: vortex_time.as_nanos() as f64 / lance_time.as_nanos() as f64,
-        });
-    }
-}