fix: use f64 precision for UDTF query vectors, add UDTF tests

Parse query vectors as f64 to match the optimizer path's precision,
avoiding silent accuracy loss for F64-quantized indexes.

Add 5 tests for vector_search_vector: basic happy path, projection
pushdown, bad table ref error, registry miss error, k > dataset size.

Author: anoop-narang

src/udtf.rs

@@ -69,7 +69,7 @@ impl TableFunctionImpl for VectorSearchVectorUDTF {
 
         let table_ref = extract_string_literal(&exprs[0])?;
         let column = extract_string_literal(&exprs[1])?;
-        let query_vec = extract_f32_vec(&exprs[2])?;
+        let query_vec = extract_f64_vec(&exprs[2])?;
         let k = extract_usize_literal(&exprs[3])?;
 
         // Build the registry key: "conn::schema::table::column"
@@ -97,7 +97,7 @@ impl TableFunctionImpl for VectorSearchVectorUDTF {
 /// fetches full rows via the lookup provider, and appends `_distance`.
 struct VectorSearchVectorProvider {
     registered: Arc<RegisteredTable>,
-    query_vec: Vec<f32>,
+    query_vec: Vec<f64>,
     k: usize,
 }
 
@@ -130,10 +130,9 @@ impl TableProvider for VectorSearchVectorProvider {
         _limit: Option<usize>,
     ) -> Result<Arc<dyn ExecutionPlan>> {
         // 1. HNSW search
-        let query_f64: Vec<f64> = self.query_vec.iter().map(|&v| v as f64).collect();
         let matches = usearch_search(
             &self.registered.index,
-            &query_f64,
+            &self.query_vec,
             self.k,
             self.registered.scalar_kind,
         )?;
@@ -311,7 +310,7 @@ fn extract_usize_literal(expr: &Expr) -> Result<usize> {
     }
 }
 
-fn extract_f32_vec(expr: &Expr) -> Result<Vec<f32>> {
+fn extract_f64_vec(expr: &Expr) -> Result<Vec<f64>> {
     use arrow_array::{Float32Array, Float64Array};
 
     match expr {
@@ -320,11 +319,11 @@ fn extract_f32_vec(expr: &Expr) -> Result<Vec<f32>> {
                 return Err(DataFusionError::Execution("Empty query vector".into()));
             }
             let inner = arr.value(0);
-            if let Some(f32a) = inner.as_any().downcast_ref::<Float32Array>() {
-                return Ok(f32a.values().to_vec());
-            }
             if let Some(f64a) = inner.as_any().downcast_ref::<Float64Array>() {
-                return Ok(f64a.values().iter().map(|&v| v as f32).collect());
+                return Ok(f64a.values().to_vec());
+            }
+            if let Some(f32a) = inner.as_any().downcast_ref::<Float32Array>() {
+                return Ok(f32a.values().iter().map(|&v| v as f64).collect());
             }
             Err(DataFusionError::Execution(
                 "FixedSizeList inner is not Float32/Float64".into(),
@@ -335,11 +334,11 @@ fn extract_f32_vec(expr: &Expr) -> Result<Vec<f32>> {
                 return Err(DataFusionError::Execution("Empty query vector".into()));
             }
             let inner = arr.value(0);
-            if let Some(f32a) = inner.as_any().downcast_ref::<Float32Array>() {
-                return Ok(f32a.values().to_vec());
-            }
             if let Some(f64a) = inner.as_any().downcast_ref::<Float64Array>() {
-                return Ok(f64a.values().iter().map(|&v| v as f32).collect());
+                return Ok(f64a.values().to_vec());
+            }
+            if let Some(f32a) = inner.as_any().downcast_ref::<Float32Array>() {
+                return Ok(f32a.values().iter().map(|&v| v as f64).collect());
             }
             Err(DataFusionError::Execution(
                 "List scalar inner is not Float32/Float64".into(),
@@ -349,10 +348,10 @@ fn extract_f32_vec(expr: &Expr) -> Result<Vec<f32>> {
             let mut result = Vec::with_capacity(sf.args.len());
             for arg in &sf.args {
                 match arg {
-                    Expr::Literal(ScalarValue::Float64(Some(v)), _) => result.push(*v as f32),
-                    Expr::Literal(ScalarValue::Float32(Some(v)), _) => result.push(*v),
-                    Expr::Literal(ScalarValue::Int64(Some(v)), _) => result.push(*v as f32),
-                    Expr::Literal(ScalarValue::Int32(Some(v)), _) => result.push(*v as f32),
+                    Expr::Literal(ScalarValue::Float64(Some(v)), _) => result.push(*v),
+                    Expr::Literal(ScalarValue::Float32(Some(v)), _) => result.push(*v as f64),
+                    Expr::Literal(ScalarValue::Int64(Some(v)), _) => result.push(*v as f64),
+                    Expr::Literal(ScalarValue::Int32(Some(v)), _) => result.push(*v as f64),
                     other => {
                         return Err(DataFusionError::Execution(format!(
                             "Non-literal in ARRAY[...]: {other:?}"
@@ -363,7 +362,7 @@ fn extract_f32_vec(expr: &Expr) -> Result<Vec<f32>> {
             Ok(result)
         }
         other => Err(DataFusionError::Execution(format!(
-            "Cannot extract f32 vector from: {other:?}"
+            "Cannot extract f64 vector from: {other:?}"
         ))),
     }
 }

tests/execution.rs

@@ -937,3 +937,93 @@ async fn udf_dimension_mismatch_select_star() {
         "expected dimension mismatch error, got: {msg}"
     );
 }
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// vector_search_vector UDTF tests
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// Basic happy path: returns correct rows with _distance column.
+#[tokio::test]
+async fn udtf_vector_search_vector_basic() {
+    let ctx = make_exec_ctx("conn::schema::items::vector").await;
+    let sql = "SELECT id, label, _distance FROM vector_search_vector('conn.schema.items', 'vector', ARRAY[1.0::float, 0.0::float, 0.0::float, 0.0::float], 3) ORDER BY _distance ASC";
+    let df = ctx.sql(sql).await.expect("sql");
+    let batches = df.collect().await.expect("collect");
+
+    let total: usize = batches.iter().map(|b| b.num_rows()).sum();
+    assert_eq!(total, 3, "expected 3 results");
+
+    // First result should be row 1 (exact match, distance 0)
+    let ids = batches[0]
+        .column(0)
+        .as_any()
+        .downcast_ref::<UInt64Array>()
+        .expect("id col");
+    assert_eq!(ids.value(0), 1, "closest must be row 1");
+
+    let dists = batches[0]
+        .column(2)
+        .as_any()
+        .downcast_ref::<Float32Array>()
+        .expect("_distance col");
+    assert!(
+        (dists.value(0) - 0.0).abs() < 1e-6,
+        "row 1 distance must be 0.0, got {}",
+        dists.value(0)
+    );
+}
+
+/// Projection pushdown: only requested columns are returned.
+#[tokio::test]
+async fn udtf_vector_search_vector_projection() {
+    let ctx = make_exec_ctx("conn::schema::items::vector").await;
+    let sql = "SELECT id, _distance FROM vector_search_vector('conn.schema.items', 'vector', ARRAY[1.0::float, 0.0::float, 0.0::float, 0.0::float], 2)";
+    let df = ctx.sql(sql).await.expect("sql");
+    let batches = df.collect().await.expect("collect");
+    assert_eq!(
+        batches[0].num_columns(),
+        2,
+        "expected 2 columns (id, _distance), got {}",
+        batches[0].num_columns()
+    );
+    let schema = batches[0].schema();
+    let col_names: Vec<&str> = schema.fields().iter().map(|f| f.name().as_str()).collect();
+    assert_eq!(col_names, vec!["id", "_distance"]);
+}
+
+/// parse_dot_table_ref error: fewer than 3 parts.
+#[tokio::test]
+async fn udtf_vector_search_vector_bad_table_ref() {
+    let ctx = make_exec_ctx("conn::schema::items::vector").await;
+    let sql = "SELECT * FROM vector_search_vector('items', 'vector', ARRAY[1.0::float, 0.0::float, 0.0::float, 0.0::float], 3)";
+    let err = ctx.sql(sql).await.unwrap_err();
+    let msg = err.to_string();
+    assert!(
+        msg.contains("connection.schema.table"),
+        "expected table ref format error, got: {msg}"
+    );
+}
+
+/// Registry miss: column not in registry returns clear error.
+#[tokio::test]
+async fn udtf_vector_search_vector_registry_miss() {
+    let ctx = make_exec_ctx("conn::schema::items::vector").await;
+    let sql = "SELECT * FROM vector_search_vector('conn.schema.items', 'nonexistent', ARRAY[1.0::float, 0.0::float, 0.0::float, 0.0::float], 3)";
+    let err = ctx.sql(sql).await.unwrap_err();
+    let msg = err.to_string();
+    assert!(
+        msg.contains("no loaded vector index"),
+        "expected registry miss error, got: {msg}"
+    );
+}
+
+/// Empty result: search with k larger than dataset returns all rows.
+#[tokio::test]
+async fn udtf_vector_search_vector_k_larger_than_dataset() {
+    let ctx = make_exec_ctx("conn::schema::items::vector").await;
+    let sql = "SELECT id, _distance FROM vector_search_vector('conn.schema.items', 'vector', ARRAY[1.0::float, 0.0::float, 0.0::float, 0.0::float], 100)";
+    let df = ctx.sql(sql).await.expect("sql");
+    let batches = df.collect().await.expect("collect");
+    let total: usize = batches.iter().map(|b| b.num_rows()).sum();
+    assert_eq!(total, 4, "expected all 4 rows when k > dataset size");
+}