correctly propagate version instead of editions

Author: myrrc

vortex-duckdb/build.rs

@@ -627,6 +627,32 @@ fn cbindgen_rust2c(crate_dir: &Path) {
     }
 }
 
+fn git(crate_dir: &Path, args: &[&str]) -> Option<String> {
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(crate_dir)
+        .args(args)
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let stdout = String::from_utf8(output.stdout).ok()?;
+    let stdout = stdout.trim();
+    (!stdout.is_empty()).then(|| stdout.to_owned())
+}
+
+fn vortex_version(crate_dir: &Path) {
+    println!("cargo:rerun-if-env-changed=VORTEX_VERSION");
+    let version = env::var("VORTEX_VERSION")
+        .ok()
+        .filter(|version| !version.is_empty())
+        .or_else(|| git(crate_dir, &["describe", "--tags", "--exact-match", "HEAD"]))
+        .or_else(|| git(crate_dir, &["rev-parse", "HEAD"]))
+        .unwrap_or_else(|| "unknown".to_owned());
+    println!("cargo:rustc-env=VORTEX_VERSION={version}");
+}
+
 fn main() {
     println!("cargo:rerun-if-changed=cpp/include");
     println!("cargo:rerun-if-changed=patches");
@@ -653,6 +679,7 @@ fn main() {
     // in vortex's CI.
 
     let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    vortex_version(&crate_dir);
     if let Some(source_dir) = env::var_os("DUCKDB_SOURCE_DIR") {
         let source_dir = PathBuf::from(source_dir);
         let duckdb_include_dir = source_dir.join("src").join("include");

vortex-duckdb/cpp/include/table_function.h

@@ -76,10 +76,7 @@ typedef struct {
 } duckdb_vx_written_column_statistics;
 
 duckdb_state duckdb_vx_register_table_functions(duckdb_database ffi_db);
-
-duckdb_state duckdb_vx_register_version_function(duckdb_database ffi_db,
-                                                 const char *const *editions,
-                                                 size_t editions_count);
+duckdb_state duckdb_vx_register_version_function(duckdb_database ffi_db, const char *version);
 
 typedef struct duckdb_vx_agg_input_ *duckdb_vx_agg_input;
 idx_t duckdb_vx_aggregate_len(duckdb_vx_agg_input ffi);

vortex-duckdb/cpp/table_function.cpp

@@ -222,22 +222,13 @@ duckdb_state register_table_function(DatabaseInstance &db, LogicalType parameter
     return DuckDBSuccess;
 }
 
-extern "C" duckdb_state duckdb_vx_register_version_function(duckdb_database ffi_db,
-                                                            const char *const *editions,
-                                                            size_t editions_count) {
+extern "C" duckdb_state duckdb_vx_register_version_function(duckdb_database ffi_db, const char *version) {
     D_ASSERT(ffi_db);
-    D_ASSERT(editions || editions_count == 0);
+    D_ASSERT(version);
     const DatabaseWrapper &wrapper = *reinterpret_cast<DatabaseWrapper *>(ffi_db);
     DatabaseInstance &db = *wrapper.database->instance;
 
-    string sql = "SELECT unnest([";
-    for (size_t i = 0; i < editions_count; i++) {
-        if (i > 0) {
-            sql += ", ";
-        }
-        sql += KeywordHelper::WriteQuoted(editions[i]);
-    }
-    sql += "]) AS edition";
+    const string sql = "SELECT " + KeywordHelper::WriteQuoted(version) + " AS version";
 
     const DefaultTableMacro macro {DEFAULT_SCHEMA,
                                    "vortex_version",

vortex-duckdb/src/duckdb/database.rs

@@ -62,26 +62,11 @@ impl DatabaseRef {
         Ok(())
     }
 
-    pub fn register_version_function(&self, editions: &[String]) -> VortexResult<()> {
-        let editions = editions
-            .iter()
-            .map(|edition| {
-                CString::new(edition.as_str())
-                    .map_err(|_| vortex_err!("Invalid edition: string contains null bytes"))
-            })
-            .collect::<VortexResult<Vec<_>>>()?;
-        let pointers = editions
-            .iter()
-            .map(|edition| edition.as_ptr())
-            .collect::<Vec<_>>();
+    pub fn register_version_function(&self, version: &str) -> VortexResult<()> {
+        let version = CString::new(version)
+            .map_err(|_| vortex_err!("Invalid version: string contains null bytes"))?;
         duckdb_try!(
-            unsafe {
-                cpp::duckdb_vx_register_version_function(
-                    self.as_ptr(),
-                    pointers.as_ptr(),
-                    pointers.len(),
-                )
-            },
+            unsafe { cpp::duckdb_vx_register_version_function(self.as_ptr(), version.as_ptr()) },
             "Failed to register vortex_version function"
         );
         Ok(())

vortex-duckdb/src/e2e_test/vortex_scan_test.rs

@@ -204,19 +204,13 @@ fn test_scan_function_registration() {
 #[test]
 fn test_vortex_version() -> Result<()> {
     let conn = database_connection();
-    let result = conn.query("SELECT edition FROM vortex_version()")?;
-    let mut chunk = result.into_iter().next().unwrap();
-    let len: usize = chunk.len().as_();
-
-    let editions = unsafe { chunk.get_vector_mut(0).as_slice_mut::<duckdb_string_t>(len) }
-        .iter_mut()
-        .map(String::from_duckdb_value)
-        .collect::<Vec<_>>();
-
-    assert_eq!(
-        editions,
-        ["core2026.08.3", "json2026.08.0", "spatial2026.08.0"]
+    let query = format!(
+        "SELECT count(*) FROM vortex_version() WHERE version = '{}'",
+        env!("VORTEX_VERSION")
     );
+    let result = conn.query(&query)?;
+    let chunk = result.into_iter().next().unwrap();
+    assert_eq!(chunk.get_vector(0).as_slice_with_len::<i64>(1), [1]);
     Ok(())
 }
 

vortex-duckdb/src/lib.rs

@@ -78,22 +78,11 @@ fn init_tracing() {
 /// separately (e.g., before creating connections), call `register_extension_options` first.
 pub fn initialize(db: &DatabaseRef) -> VortexResult<()> {
     db.register_table_functions()?;
-    db.register_version_function(&enabled_editions())?;
+    db.register_version_function(env!("VORTEX_VERSION"))?;
     db.register_optimizer_extension()?;
     db.register_copy_function()
 }
 
-fn enabled_editions() -> Vec<String> {
-    let mut editions = SESSION
-        .enabled_editions()
-        .editions()
-        .iter()
-        .map(|edition| edition.to_string())
-        .collect::<Vec<_>>();
-    editions.sort_unstable();
-    editions
-}
-
 /// Initialize the DuckDB extension from a raw DuckDB database pointer.
 pub unsafe fn initialize_extension_from_raw(db: *mut c_void) {
     init_tracing();