feat(vortex-bench): support vortex native geo types into SpatialBench, and wire into benchmark orchestrator (#8623)

## Summary

<!--
Why are you proposing this change, and what is its impact? 
Is it part of a long term effort, or a bigger change?

If this PR is related to a tracked effort or an open issue, please link
to the relevant issue.
-->

Wires vortex geo native format into SpatialBench, and wire into the
`vx-bench` / `bench-orchestrator` pipeline so it can be run end-to-end
like the other benchmarks.

Running command:
```
vx-bench run spatialbench -e duckdb -f parquet,vortex,vortex-native --opt scale-factor=1.0 --queries 1,2,3,4,5,6,7,8,9
```

## Limitation
<!--
No need to duplicate information from the previous section, but if
you're touching many
parts of the code base, its worth explicitly noting the important
changes or how they are tested.
-->

- DuckDB-only as before. For now SpatialBench queries use
DuckDB-specific ST_* spatial SQL that DataFusion has no functions for
yet. There is a a single ad-hoc entry in `BENCHMARK_ENGINES = {
SPATIALBENCH: {DUCKDB} }`.
- Queries 10, 11, 12 is timeout simply because DuckDB poorly support on
Spatial index.

## Performance

SF=1.0
```
┏━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┓
┃ Query ┃ duckdb:parquet (base) ┃   duckdb:vortex ┃ duckdb:vortex-native ┃
┡━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━┩
│ 1     │                40.8ms │  13.8ms (0.34x) │       23.2ms (0.57x) │
│ 2     │               181.2ms │  26.3ms (0.14x) │       35.3ms (0.20x) │
│ 3     │                57.8ms │  19.8ms (0.34x) │       30.9ms (0.53x) │
│ 4     │               331.9ms │  61.8ms (0.19x) │      111.0ms (0.33x) │
│ 5     │               356.1ms │ 294.3ms (0.83x) │      299.3ms (0.84x) │
│ 6     │               441.9ms │  86.3ms (0.20x) │      135.1ms (0.31x) │
│ 7     │               157.2ms │  73.7ms (0.47x) │       93.1ms (0.59x) │
│ 8     │               197.8ms │  78.1ms (0.39x) │       91.9ms (0.46x) │
│ 9     │                20.3ms │  18.6ms (0.91x) │       20.7ms (1.02x) │
└───────┴───────────────────────┴─────────────────┴──────────────────────┘
```

SF=3
```
┏━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┓
┃ Query ┃ duckdb:parquet (base) ┃   duckdb:vortex ┃ duckdb:vortex-native ┃
┡━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━┩
│ 1     │                51.5ms │  26.6ms (0.52x) │       61.6ms (1.20x) │
│ 2     │               127.6ms │  56.2ms (0.44x) │       93.1ms (0.73x) │
│ 3     │                69.1ms │  46.3ms (0.67x) │       80.0ms (1.16x) │
│ 4     │               543.4ms │  64.5ms (0.12x) │      119.6ms (0.22x) │
│ 5     │               980.6ms │ 881.6ms (0.90x) │      894.4ms (0.91x) │
│ 6     │               660.9ms │ 133.8ms (0.20x) │      233.2ms (0.35x) │
│ 7     │               255.7ms │ 240.6ms (0.94x) │      264.9ms (1.04x) │
│ 8     │               267.6ms │ 247.4ms (0.92x) │      299.7ms (1.12x) │
│ 9     │                30.1ms │  28.8ms (0.96x) │       30.6ms (1.02x) │
└───────┴───────────────────────┴─────────────────┴──────────────────────┘
```

SF=10
```
┏━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┓
┃ Query ┃ duckdb:parquet (base) ┃   duckdb:vortex ┃ duckdb:vortex-native ┃
┡━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━┩
│ 1     │               160.4ms │ 128.5ms (0.80x) │      214.8ms (1.34x) │
│ 2     │               254.3ms │ 239.8ms (0.94x) │      325.9ms (1.28x) │
│ 3     │               231.0ms │ 198.7ms (0.86x) │      284.4ms (1.23x) │
│ 4     │               188.0ms │ 124.2ms (0.66x) │      147.9ms (0.79x) │
│ 5     │                 3.14s │   3.05s (0.97x) │        2.92s (0.93x) │
│ 6     │               480.5ms │ 361.7ms (0.75x) │      467.7ms (0.97x) │
│ 7     │               992.8ms │   1.02s (1.02x) │      915.2ms (0.92x) │
│ 8     │                 1.07s │ 961.8ms (0.90x) │        1.02s (0.95x) │
│ 9     │                34.2ms │  34.1ms (1.00x) │       43.5ms (1.27x) │
└───────┴───────────────────────┴─────────────────┴──────────────────────┘
```

<!--
Are there any user-facing changes that might require documentation
updates
Is any public API changed?
-->

Takeaways: for now we do not have only pushdown to execute predicate in
vortex kernel, so geo native types pay the tax of converting to
geo-binary (talk to duckdb) but no gains, so in SF=10 vortex-native is
less efficient compared with vortex-wkb.

---------

Signed-off-by: Nemo Yu <zyu379@wisc.edu>

Author: HarukiMoriarty

Cargo.lock

@@ -35,6 +35,7 @@ class Format(Enum):
     PARQUET = "parquet"
     VORTEX = "vortex"
     VORTEX_COMPACT = "vortex-compact"
+    VORTEX_NATIVE = "vortex-geo-native"
     DUCKDB = "duckdb"
     LANCE = "lance"
 
@@ -68,6 +69,7 @@ class Benchmark(Enum):
         Format.PARQUET,
         Format.VORTEX,
         Format.VORTEX_COMPACT,
+        Format.VORTEX_NATIVE,
         Format.DUCKDB,
     ],
     Engine.LANCE: [Format.LANCE],

bench-orchestrator/bench_orchestrator/config.py

@@ -26,6 +26,23 @@ def test_parse_formats_json_accepts_ci_format_arrays() -> None:
     assert formats == [Format.PARQUET, Format.VORTEX, Format.DUCKDB]
 
 
+def test_parse_formats_json_accepts_vortex_native() -> None:
+    formats = parse_formats_json('["parquet","vortex","vortex-geo-native"]')
+
+    assert formats == [Format.PARQUET, Format.VORTEX, Format.VORTEX_NATIVE]
+
+
+def test_resolve_axis_targets_offers_vortex_native_on_duckdb_only() -> None:
+    # vortex-geo-native is a DuckDB-only lane; the DataFusion axis is dropped as unsupported.
+    targets, warnings = resolve_axis_targets(
+        [Engine.DATAFUSION, Engine.DUCKDB],
+        [Format.VORTEX_NATIVE],
+    )
+
+    assert targets == [BenchmarkTarget(engine=Engine.DUCKDB, format=Format.VORTEX_NATIVE)]
+    assert warnings == ["Format vortex-geo-native is not supported by engine datafusion"]
+
+
 def test_resolve_axis_targets_filters_unsupported_combinations() -> None:
     targets, warnings = resolve_axis_targets(
         [Engine.DATAFUSION, Engine.DUCKDB],
@@ -55,6 +72,23 @@ def test_resolve_axis_targets_skips_engines_a_benchmark_cannot_run() -> None:
     assert warnings == ["Benchmark spatialbench does not support engine datafusion"]
 
 
+def test_resolve_axis_targets_expands_spatialbench_three_lanes() -> None:
+    # The single-command three-lane comparison: parquet, WKB vortex, and native-geometry vortex, all
+    # on DuckDB.
+    targets, warnings = resolve_axis_targets(
+        [Engine.DUCKDB],
+        [Format.PARQUET, Format.VORTEX, Format.VORTEX_NATIVE],
+        Benchmark.SPATIALBENCH,
+    )
+
+    assert targets == [
+        BenchmarkTarget(engine=Engine.DUCKDB, format=Format.PARQUET),
+        BenchmarkTarget(engine=Engine.DUCKDB, format=Format.VORTEX),
+        BenchmarkTarget(engine=Engine.DUCKDB, format=Format.VORTEX_NATIVE),
+    ]
+    assert warnings == []
+
+
 def test_validate_targets_rejects_engine_a_benchmark_cannot_run() -> None:
     errors = validate_targets(
         [BenchmarkTarget(engine=Engine.DATAFUSION, format=Format.PARQUET)],

bench-orchestrator/tests/test_config.py

@@ -33,6 +33,19 @@ def test_build_command_adds_duckdb_cleanup_flag() -> None:
     assert "scale-factor=1.0" in cmd
 
 
+def test_build_command_serializes_vortex_native_format() -> None:
+    executor = BenchmarkExecutor(Path("/tmp/duckdb-bench"), Engine.DUCKDB)
+
+    cmd = executor.build_command(
+        benchmark=Benchmark.SPATIALBENCH,
+        formats=[Format.PARQUET, Format.VORTEX, Format.VORTEX_NATIVE],
+        iterations=1,
+        options={"scale-factor": "1.0"},
+    )
+
+    assert "parquet,vortex,vortex-geo-native" in cmd
+
+
 def test_build_command_omits_formats_for_lance_backend() -> None:
     executor = BenchmarkExecutor(Path("/tmp/lance-bench"), Engine.LANCE)
 

bench-orchestrator/tests/test_executor.py

@@ -111,10 +111,9 @@ pub fn format_to_df_format(format: Format) -> Arc<dyn FileFormat> {
         Format::Csv => Arc::new(CsvFormat::default()) as _,
         Format::Arrow => Arc::new(ArrowFormat),
         Format::Parquet => Arc::new(ParquetFormat::new()),
-        Format::OnDiskVortex | Format::VortexCompact => Arc::new(VortexFormat::new_with_options(
-            SESSION.clone(),
-            vortex_table_options(),
-        )),
+        Format::OnDiskVortex | Format::VortexCompact | Format::VortexNative => Arc::new(
+            VortexFormat::new_with_options(SESSION.clone(), vortex_table_options()),
+        ),
         Format::OnDiskDuckDB | Format::Lance => {
             unimplemented!("Format {format} cannot be turned into a DataFusion `FileFormat`")
         }

benchmarks/datafusion-bench/src/lib.rs

@@ -169,7 +169,10 @@ impl DuckClient {
         file_format: Format,
     ) -> Result<()> {
         let object_type = match file_format {
-            Format::Parquet | Format::OnDiskVortex | Format::VortexCompact => "VIEW",
+            Format::Parquet
+            | Format::OnDiskVortex
+            | Format::VortexCompact
+            | Format::VortexNative => "VIEW",
             Format::OnDiskDuckDB => "TABLE",
             Format::Lance => {
                 anyhow::bail!(

benchmarks/duckdb-bench/src/lib.rs

@@ -142,6 +142,7 @@ fn main() -> anyhow::Result<()> {
                     // OnDiskDuckDB tables are created during register_tables by loading from Parquet
                     _ => {}
                 }
+                benchmark.prepare_format(format, &base_path).await?;
             }
 
             anyhow::Ok(())

benchmarks/duckdb-bench/src/main.rs

@@ -34,6 +34,8 @@ async-trait = { workspace = true }
 bzip2 = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 futures = { workspace = true }
+geoarrow = { workspace = true }
+geoarrow-cast = { workspace = true }
 get_dir = { workspace = true }
 glob = { workspace = true }
 humansize = { workspace = true }

vortex-bench/Cargo.toml

@@ -3,6 +3,8 @@
 
 //! Core benchmark trait and types.
 
+use std::path::Path;
+
 use arrow_schema::Schema;
 use glob::Pattern;
 use url::Url;
@@ -47,6 +49,13 @@ pub trait Benchmark: Send + Sync {
     /// call this method to ensure base data exists, then perform their own format conversion.
     async fn generate_base_data(&self) -> anyhow::Result<()>;
 
+    /// Prepare benchmark- and format-specific data beyond the Parquet base that
+    /// [`Benchmark::generate_base_data`] produced. Called once per requested format, after the base
+    /// data exists. Default: nothing.
+    async fn prepare_format(&self, _format: Format, _base_path: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+
     /// Get expected row counts for validation (optional)
     /// If None, no validation will be performed
     fn expected_row_counts(&self) -> Option<Vec<usize>> {

vortex-bench/src/benchmark.rs

@@ -76,8 +76,11 @@ use vortex::session::VortexSession;
 #[global_allocator]
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
-pub static SESSION: LazyLock<VortexSession> =
-    LazyLock::new(|| VortexSession::default().with_tokio());
+pub static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    let session = VortexSession::default().with_tokio();
+    vortex_geo::initialize(&session);
+    session
+});
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Target {
@@ -146,6 +149,9 @@ pub enum Format {
     #[clap(name = "vortex-compact")]
     #[serde(rename = "vortex-compact")]
     VortexCompact,
+    #[clap(name = "vortex-geo-native")]
+    #[serde(rename = "vortex-geo-native")]
+    VortexNative,
     #[clap(name = "duckdb")]
     #[serde(rename = "duckdb")]
     OnDiskDuckDB,
@@ -185,6 +191,7 @@ impl Format {
             Format::Parquet => "parquet",
             Format::OnDiskVortex => "vortex-file-compressed",
             Format::VortexCompact => "vortex-compact",
+            Format::VortexNative => "vortex-geo-native",
             Format::OnDiskDuckDB => "duckdb",
             Format::Lance => "lance",
         }
@@ -197,6 +204,7 @@ impl Format {
             Format::Parquet => "parquet",
             Format::OnDiskVortex => "vortex",
             Format::VortexCompact => "vortex",
+            Format::VortexNative => "vortex",
             Format::OnDiskDuckDB => "duckdb",
             Format::Lance => "lance",
         }