25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(vector): preserve fields by response origin
Guoyu Su5d5e9e8cc1aa
diff --git a/crates/dbx-drivers/src/db/vector_driver.rs b/crates/dbx-drivers/src/db/vector_driver.rsindex 35f3efef55..11a38fef35 100644--- a/crates/dbx-drivers/src/db/vector_driver.rs+++ b/crates/dbx-drivers/src/db/vector_driver.rs@@ -592,15 +592,13 @@ fn chroma_get_response_to_rows(body: &Value) -> Vec<Value> {if let Some(doc) = documents.get(i) {row.insert("document".to_string(), doc.clone());}- if let Some(Value::Object(meta_obj)) = metadatas.get(i) {- for (k, v) in meta_obj {- row.insert(k.clone(), v.clone());- }- }if let Some(dist) = distances.get(i) {row.insert("distance".to_string(), dist.clone());}- Value::Object(row)+ if let Some(metadata) = metadatas.get(i) {+ row.insert("metadata".to_string(), metadata.clone());+ }+ Value::Object(flatten_wrapper_once(row, "metadata"))}).collect()}@@ -613,16 +611,11 @@ fn weaviate_graphql_to_rows(body: &Value) -> Option<Vec<Value>> {items.iter().map(|item| {- let mut obj = match item {+ let obj = match item {Value::Object(m) => m.clone(),_ => return item.clone(),};- if let Some(Value::Object(additional)) = obj.remove("_additional") {- for (k, v) in additional {- obj.entry(k).or_insert(v);- }- }- Value::Object(obj)+ Value::Object(flatten_wrapper_once(obj, "_additional"))}).collect(),)@@ -749,13 +742,65 @@ pub async fn find_documents(pub async fn execute_rest_query(client: &VectorClient, input: &str) -> Result<QueryResult, String> {let start = Instant::now();let request = parse_rest_query(client, input)?;+ let origin = request+ .try_clone()+ .and_then(|request| request.build().ok())+ .map(|request| response_origin(client, &request))+ .unwrap_or(ResponseOrigin::Generic);let resp = request.send().await.map_err(|e| format!("{} request failed: {e}", client.kind.label()))?;let status = resp.status().as_u16();let body = resp.json::<Value>().await.unwrap_or(Value::Null);- rest_query_result(client.kind, status, body, start)+ rest_query_result(client.kind, origin, status, body, start)+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum ResponseOrigin {+ Generic,+ QdrantPointsObject,+ QdrantPointsList,+ WeaviateRestObjects,+ WeaviateGraphqlGet,+ ChromaRecords,}-fn rest_query_result(kind: VectorDbKind, status: u16, body: Value, start: Instant) -> Result<QueryResult, String> {+fn response_origin(client: &VectorClient, request: &reqwest::Request) -> ResponseOrigin {+ let Some(base_url) = reqwest::Url::parse(&client.base_url).ok() else {+ return ResponseOrigin::Generic;+ };+ let base_path = base_url.path().trim_end_matches('/');+ let Some(endpoint_path) = request.url().path().strip_prefix(base_path).filter(|path| path.starts_with('/')) else {+ return ResponseOrigin::Generic;+ };+ let segments: Vec<_> = endpoint_path.split('/').filter(|segment| !segment.is_empty()).collect();+ if request.method() != reqwest::Method::POST && request.method() != reqwest::Method::GET {+ return ResponseOrigin::Generic;+ }+ match (client.kind, request.method().as_str(), segments.as_slice()) {+ (VectorDbKind::Qdrant, "POST", ["collections", _, "points", "scroll" | "query"]) => {+ ResponseOrigin::QdrantPointsObject+ }+ (VectorDbKind::Qdrant, "POST", ["collections", _, "points"])+ | (VectorDbKind::Qdrant, "POST", ["collections", _, "points", "search" | "recommend" | "discover"]) => {+ ResponseOrigin::QdrantPointsList+ }+ (VectorDbKind::Weaviate, "GET", ["v1", "objects"]) => ResponseOrigin::WeaviateRestObjects,+ (VectorDbKind::Weaviate, "POST", ["v1", "graphql"]) => ResponseOrigin::WeaviateGraphqlGet,+ (+ VectorDbKind::ChromaDb,+ "POST",+ ["api", "v2", "tenants", _, "databases", _, "collections", _, "get" | "query"],+ ) => ResponseOrigin::ChromaRecords,+ _ => ResponseOrigin::Generic,+ }+}++fn rest_query_result(+ kind: VectorDbKind,+ origin: ResponseOrigin,+ status: u16,+ body: Value,+ start: Instant,+) -> Result<QueryResult, String> {if !(200..300).contains(&status) {let detail = serde_json::to_string_pretty(&body).unwrap_or_else(|_| body.to_string());return Err(format!("{} error ({status}): {detail}", kind.label()));@@ -765,7 +810,7 @@ fn rest_query_result(kind: VectorDbKind, status: u16, body: Value, start: Instanreturn Err(error);}}- Ok(json_to_query_result(status, body, start))+ Ok(json_to_query_result(kind, origin, status, body, start))}// Milvus REST uses HTTP-style code 200 for success, while some responses use gRPC-style code 0.@@ -889,25 +934,45 @@ async fn ensure_success(label: &str, resp: reqwest::Response) -> Result<reqwest:Err(format!("{label} error ({status}): {body}"))}-fn json_to_query_result(status: u16, body: Value, start: Instant) -> QueryResult {- let rows_value =- body.pointer("/result/points").or_else(|| body.get("result")).or_else(|| body.get("data")).cloned();- if let Some(Value::Array(items)) = rows_value {- return values_to_query_result(items, start);- }- if let Some(Value::Array(items)) = body.get("objects").cloned() {- return values_to_query_result(items, start);- }- if let Some(Value::Array(items)) = body.pointer("/result/collections").cloned() {+fn json_to_query_result(+ kind: VectorDbKind,+ origin: ResponseOrigin,+ status: u16,+ body: Value,+ start: Instant,+) -> QueryResult {+ let rows = match (kind, origin) {+ (VectorDbKind::Qdrant, ResponseOrigin::QdrantPointsObject) => {+ body.pointer("/result/points").and_then(Value::as_array).cloned().map(|items| adapt_rows(items, "payload"))+ }+ (VectorDbKind::Qdrant, ResponseOrigin::QdrantPointsList) => {+ body.get("result").and_then(Value::as_array).cloned().map(|items| adapt_rows(items, "payload"))+ }+ (VectorDbKind::Weaviate, ResponseOrigin::WeaviateRestObjects) => {+ body.get("objects").and_then(Value::as_array).cloned().map(|items| adapt_rows(items, "properties"))+ }+ (VectorDbKind::Weaviate, ResponseOrigin::WeaviateGraphqlGet) => weaviate_graphql_to_rows(&body),+ (VectorDbKind::ChromaDb, ResponseOrigin::ChromaRecords)+ if body.get("ids").and_then(Value::as_array).is_some()+ && body.get("documents").and_then(Value::as_array).is_some() =>+ {+ Some(chroma_get_response_to_rows(&body))+ }+ _ => None,+ };+ if let Some(items) = rows {return values_to_query_result(items, start);}- if body.get("ids").and_then(Value::as_array).is_some() && body.get("documents").and_then(Value::as_array).is_some()- {- let rows = chroma_get_response_to_rows(&body);- return values_to_query_result(rows, start);- }- // Weaviate GraphQL search response- if let Some(items) = weaviate_graphql_to_rows(&body) {+ // Unknown and management responses may still contain a generic array of rows.+ let generic_rows = body+ .pointer("/result/points")+ .or_else(|| body.pointer("/result/collections"))+ .or_else(|| body.get("result"))+ .or_else(|| body.get("data"))+ .or_else(|| body.get("objects"))+ .and_then(Value::as_array)+ .cloned();+ if let Some(items) = generic_rows {return values_to_query_result(items, start);}QueryResult {@@ -970,19 +1035,7 @@ fn values_to_query_result(items: Vec<Value>, start: Instant) -> QueryResult {fn normalize_row_object(value: Value) -> Map<String, Value> {match value {- Value::Object(mut object) => {- if let Some(Value::Object(payload)) = object.remove("payload") {- for (key, value) in payload {- object.entry(key).or_insert(value);- }- }- if let Some(Value::Object(properties)) = object.remove("properties") {- for (key, value) in properties {- object.entry(key).or_insert(value);- }- }- object- }+ Value::Object(object) => object,other => {let mut object = Map::new();object.insert("value".to_string(), other);@@ -991,6 +1044,28 @@ fn normalize_row_object(value: Value) -> Map<String, Value> {}}+fn adapt_rows(items: Vec<Value>, wrapper: &str) -> Vec<Value> {+ items+ .into_iter()+ .map(|item| match item {+ Value::Object(row) => Value::Object(flatten_wrapper_once(row, wrapper)),+ other => other,+ })+ .collect()+}++fn flatten_wrapper_once(mut row: Map<String, Value>, wrapper: &str) -> Map<String, Value> {+ let Some(Value::Object(fields)) = row.get(wrapper) else {+ return row;+ };+ if fields.keys().any(|key| row.contains_key(key)) {+ return row;+ }+ let Some(Value::Object(fields)) = row.remove(wrapper) else { unreachable!("wrapper type checked above") };+ row.extend(fields);+ row+}+fn format_reqwest_error(err: &reqwest::Error) -> String {let mut parts = vec![err.to_string()];let mut source = err.source();@@ -1007,16 +1082,349 @@ fn format_reqwest_error(err: &reqwest::Error) -> String {#[cfg(test)]mod tests {use super::{- chroma_get_response_to_rows, default_collection_query, milvus_collection_schema, milvus_database_names,- rename_collection, rest_query_result, starts_with_http_method, test_connection, test_connection_request,- values_to_query_result, vector_auth, weaviate_collection_names_from_schema,- weaviate_vector_dimension_from_graphql, CollectionInfo, VectorAuth, VectorClient, VectorDbKind,+ chroma_get_response_to_rows, default_collection_query, execute_rest_query, find_documents,+ json_to_query_result, milvus_collection_schema, milvus_database_names, parse_rest_query, rename_collection,+ response_origin, rest_query_result, starts_with_http_method, test_connection, test_connection_request,+ vector_auth, weaviate_collection_names_from_schema, weaviate_vector_dimension_from_graphql, CollectionInfo,+ ResponseOrigin, VectorAuth, VectorClient, VectorDbKind,};use serde_json::{json, Value};use std::time::{Duration, Instant};use tokio::io::{AsyncReadExt, AsyncWriteExt};use tokio::net::TcpListener;+ fn first_row(result: &crate::types::QueryResult) -> serde_json::Map<String, Value> {+ result.columns.iter().cloned().zip(result.rows[0].iter().cloned()).collect()+ }++ #[test]+ fn graphql_business_properties_and_additional_collision_survive() {+ let result = rest_query_result(+ VectorDbKind::Weaviate,+ ResponseOrigin::WeaviateGraphqlGet,+ 200,+ json!({"data":{"Get":{"Article":[{"properties":{"x":2},"id":"business","_additional":{"id":"system"}}]}}}),+ Instant::now(),+ )+ .unwrap();+ assert_eq!(+ first_row(&result),+ json!({"properties":{"x":2},"id":"business","_additional":{"id":"system"}}).as_object().unwrap().clone()+ );+ }++ #[test]+ fn chroma_metadata_collision_survives() {+ let rows = chroma_get_response_to_rows(&json!({+ "ids":["system"],"documents":["body"],"metadatas":[{"id":"business","payload":{"x":1}}]+ }));+ assert_eq!(rows, vec![json!({"id":"system","document":"body","metadata":{"id":"business","payload":{"x":1}}})]);+ }++ #[test]+ fn wrapper_conflicts_and_non_objects_keep_exact_values() {+ for (kind, origin, body, expected) in [+ (+ VectorDbKind::Qdrant,+ ResponseOrigin::QdrantPointsList,+ json!({"result":[{"id":1,"score":0.5,"payload":{"id":9,"title":"a"}}]}),+ json!({"id":1,"score":0.5,"payload":{"id":9,"title":"a"}}),+ ),+ (+ VectorDbKind::Qdrant,+ ResponseOrigin::QdrantPointsList,+ json!({"result":[{"id":1,"payload":{"payload":{"x":1}}}]}),+ json!({"id":1,"payload":{"payload":{"x":1}}}),+ ),+ (+ VectorDbKind::Weaviate,+ ResponseOrigin::WeaviateRestObjects,+ json!({"objects":[{"id":"a","properties":{"id":"b","title":"c"}}]}),+ json!({"id":"a","properties":{"id":"b","title":"c"}}),+ ),+ (+ VectorDbKind::Qdrant,+ ResponseOrigin::QdrantPointsList,+ json!({"result":[{"id":1,"payload":null}]}),+ json!({"id":1,"payload":null}),+ ),+ (+ VectorDbKind::Weaviate,+ ResponseOrigin::WeaviateRestObjects,+ json!({"objects":[{"id":"a","properties":[1,2]}]}),+ json!({"id":"a","properties":[1,2]}),+ ),+ ] {+ let result = json_to_query_result(kind, origin, 200, body, Instant::now());+ assert_eq!(first_row(&result), expected.as_object().unwrap().clone());+ }+ }++ #[test]+ fn generic_and_wrong_engine_envelopes_do_not_flatten_business_names() {+ for (kind, origin, body) in [+ (VectorDbKind::Qdrant, ResponseOrigin::Generic, json!({"result":[{"id":1,"payload":{"x":2}}]})),+ (VectorDbKind::Milvus, ResponseOrigin::QdrantPointsList, json!({"result":[{"id":1,"payload":{"x":2}}]})),+ (VectorDbKind::Weaviate, ResponseOrigin::Generic, json!({"objects":[{"id":1,"properties":{"x":2}}]})),+ ] {+ let result = json_to_query_result(kind, origin, 200, body, Instant::now());+ assert!(first_row(&result).contains_key(if kind == VectorDbKind::Weaviate {+ "properties"+ } else {+ "payload"+ }));+ }+ let management = json_to_query_result(+ VectorDbKind::Qdrant,+ ResponseOrigin::Generic,+ 200,+ json!({"result":{"collections":[{"name":"c","payload":{"x":1}}]}}),+ Instant::now(),+ );+ assert_eq!(first_row(&management), json!({"name":"c","payload":{"x":1}}).as_object().unwrap().clone());+ }++ #[test]+ fn graphql_additional_flattens_once_and_keeps_non_object() {+ for (additional, expected) in [+ (json!({"id":"system"}), json!({"properties":{"x":2},"id":"system"})),+ (json!(null), json!({"properties":{"x":2},"_additional":null})),+ (json!({"_additional":{"x":1}}), json!({"properties":{"x":2},"_additional":{"_additional":{"x":1}}})),+ ] {+ let body = json!({"data":{"Get":{"Article":[{"properties":{"x":2},"_additional":additional}]}}});+ let result = json_to_query_result(+ VectorDbKind::Weaviate,+ ResponseOrigin::WeaviateGraphqlGet,+ 200,+ body,+ Instant::now(),+ );+ assert_eq!(first_row(&result), expected.as_object().unwrap().clone());+ }+ }++ #[test]+ fn empty_mixed_and_scalar_rows_keep_table_contract() {+ let empty = json_to_query_result(+ VectorDbKind::Qdrant,+ ResponseOrigin::QdrantPointsObject,+ 200,+ json!({"result":{"points":[]}}),+ Instant::now(),+ );+ assert_eq!(empty.columns, vec!["value"]);+ assert!(empty.rows.is_empty());++ let mixed = json_to_query_result(+ VectorDbKind::Qdrant,+ ResponseOrigin::QdrantPointsList,+ 200,+ json!({"result":[{"id":1,"payload":{}},{"id":2,"payload":{"title":"x"}},7]}),+ Instant::now(),+ );+ assert_eq!(mixed.affected_rows, 3);+ assert_eq!(mixed.columns, vec!["id", "title", "value"]);+ assert_eq!(mixed.rows[0], vec![json!(1), Value::Null, Value::Null]);+ assert_eq!(mixed.rows[1], vec![json!(2), json!("x"), Value::Null]);+ assert_eq!(mixed.rows[2], vec![Value::Null, Value::Null, json!(7)]);+ }++ #[test]+ fn source_routes_match_complete_segments_after_query_and_trailing_slash() {+ let qdrant =+ VectorClient::new(VectorDbKind::Qdrant, "http://localhost:6333", None, None, false, Duration::from_secs(1));+ for (query, expected) in [+ ("POST /collections/name%2Fpart/points/scroll/?limit=1", ResponseOrigin::QdrantPointsObject),+ ("POST /collections/name/points/search/?limit=1", ResponseOrigin::QdrantPointsList),+ ("GET /collections/name/points/search", ResponseOrigin::Generic),+ ("POST /collections/name/points/search/batch", ResponseOrigin::Generic),+ ] {+ let request = parse_rest_query(&qdrant, query).unwrap().build().unwrap();+ assert_eq!(response_origin(&qdrant, &request), expected);+ }+ }++ #[test]+ fn response_origin_matches_endpoints_below_configured_proxy_path() {+ for (kind, query, expected) in [+ (VectorDbKind::Qdrant, "POST /collections/docs/points/scroll", ResponseOrigin::QdrantPointsObject),+ (VectorDbKind::Weaviate, "GET /v1/objects?class=Article", ResponseOrigin::WeaviateRestObjects),+ (VectorDbKind::Weaviate, "POST /v1/graphql", ResponseOrigin::WeaviateGraphqlGet),+ (+ VectorDbKind::ChromaDb,+ "POST /api/v2/tenants/default_tenant/databases/default_database/collections/docs/get",+ ResponseOrigin::ChromaRecords,+ ),+ ] {+ let client = VectorClient::new(+ kind,+ "http://localhost:6333/proxy/vector/",+ None,+ None,+ false,+ Duration::from_secs(1),+ );+ let request = parse_rest_query(&client, query).unwrap().build().unwrap();+ assert!(request.url().path().starts_with("/proxy/vector/"));+ assert_eq!(response_origin(&client, &request), expected);+ }+ }++ #[tokio::test]+ async fn prefixed_qdrant_request_flattens_confirmed_point_payload() {+ let (url, request_rx, server) = spawn_recording_json_response_server(json!({+ "result":{"points":[{"id":1,"payload":{"title":"proxied"}}]}+ }))+ .await;+ let client =+ VectorClient::new(VectorDbKind::Qdrant, &format!("{url}/proxy"), None, None, false, Duration::from_secs(1));+ let result = execute_rest_query(&client, "docs").await.unwrap();+ assert_eq!(first_row(&result), json!({"id":1,"title":"proxied"}).as_object().unwrap().clone());+ assert!(request_rx.await.unwrap().starts_with("POST /proxy/collections/docs/points/scroll HTTP/1.1\r\n"));+ server.await.unwrap();+ }++ #[test]+ fn chroma_metadata_preserves_reserved_names_and_missing_values() {+ let rows = chroma_get_response_to_rows(&json!({+ "ids":["a","b","c","d"],"documents":["one","two","three","four"],+ "distances":[0.1,0.2,0.3,0.4],+ "metadatas":[{"document":"business","distance":9},null,{"metadata":{"x":1}}]+ }));+ assert_eq!(+ rows[0],+ json!({"id":"a","document":"one","distance":0.1,"metadata":{"document":"business","distance":9}})+ );+ assert_eq!(rows[1], json!({"id":"b","document":"two","distance":0.2,"metadata":null}));+ assert_eq!(rows[2], json!({"id":"c","document":"three","distance":0.3,"metadata":{"metadata":{"x":1}}}));+ assert_eq!(rows[3], json!({"id":"d","document":"four","distance":0.4}));+ }++ #[tokio::test]+ async fn qdrant_request_routes_select_only_their_point_envelopes() {+ for (query, body, expected_path, flattened) in [+ (+ "docs",+ json!({"result":{"points":[{"id":1,"payload":{"x":2}}]}}),+ "/collections/docs/points/scroll",+ true,+ ),+ (+ "POST /collections/docs/points/query\n{\"query\":[0.1]}",+ json!({"result":{"points":[{"id":1,"payload":{"x":2}}]}}),+ "/collections/docs/points/query",+ true,+ ),+ (+ "POST /collections/docs/points\n{\"ids\":[1]}",+ json!({"result":[{"id":1,"payload":{"x":2}}]}),+ "/collections/docs/points",+ true,+ ),+ (+ "POST /collections/docs/points/search\n{\"vector\":[0.1]}",+ json!({"result":[{"id":1,"payload":{"x":2}}]}),+ "/collections/docs/points/search",+ true,+ ),+ (+ "POST /collections/docs/points/recommend\n{\"positive\":[1]}",+ json!({"result":[{"id":1,"payload":{"x":2}}]}),+ "/collections/docs/points/recommend",+ true,+ ),+ (+ "POST /collections/docs/points/discover\n{\"target\":1}",+ json!({"result":[{"id":1,"payload":{"x":2}}]}),+ "/collections/docs/points/discover",+ true,+ ),+ (+ "POST /collections/docs/points/custom\n{}",+ json!({"result":[{"id":1,"payload":{"x":2}}]}),+ "/collections/docs/points/custom",+ false,+ ),+ ] {+ let (url, request_rx, server) = spawn_recording_json_response_server(body).await;+ let client = VectorClient::new(VectorDbKind::Qdrant, &url, None, None, false, Duration::from_secs(1));+ let result = execute_rest_query(&client, query).await.unwrap();+ let request = request_rx.await.unwrap();+ assert!(request.starts_with(&format!("POST {expected_path} HTTP/1.1\r\n")));+ let row = first_row(&result);+ assert_eq!(row.contains_key("x"), flattened);+ assert_eq!(row.contains_key("payload"), !flattened);+ server.await.unwrap();+ }+ }++ #[tokio::test]+ async fn weaviate_rest_and_graphql_same_named_properties_remain_distinct() {+ let (url, request_rx, server) = spawn_recording_json_response_server(json!({+ "objects":[{"id":"a","properties":{"title":"REST"}}]+ }))+ .await;+ let client = VectorClient::new(VectorDbKind::Weaviate, &url, None, None, false, Duration::from_secs(1));+ let rest = execute_rest_query(&client, "GET /v1/objects?class=Article&limit=1").await.unwrap();+ assert_eq!(first_row(&rest), json!({"id":"a","title":"REST"}).as_object().unwrap().clone());+ assert!(request_rx.await.unwrap().starts_with("GET /v1/objects?class=Article&limit=1 HTTP/1.1\r\n"));+ server.await.unwrap();++ let (url, request_rx, server) = spawn_recording_json_response_server(json!({+ "data":{"Get":{"Article":[{"properties":{"title":"business"},"_additional":{"id":"system"}}]}}+ }))+ .await;+ let client = VectorClient::new(VectorDbKind::Weaviate, &url, None, None, false, Duration::from_secs(1));+ let graphql = execute_rest_query(+ &client,+ "POST /v1/graphql\n{\"query\":\"{ Get { Article { properties _additional { id } } } }\"}",+ )+ .await+ .unwrap();+ assert_eq!(+ first_row(&graphql),+ json!({"properties":{"title":"business"},"id":"system"}).as_object().unwrap().clone()+ );+ let request = request_rx.await.unwrap();+ assert!(request.starts_with("POST /v1/graphql HTTP/1.1\r\n"));+ assert_eq!(+ serde_json::from_str::<Value>(request.split("\r\n\r\n").nth(1).unwrap()).unwrap(),+ json!({"query":"{ Get { Article { properties _additional { id } } } }"})+ );+ server.await.unwrap();+ }++ #[tokio::test]+ async fn chroma_query_and_direct_documents_preserve_metadata_conflicts() {+ let body = json!({"ids":["a"],"documents":["body"],"metadatas":[{"id":"business","payload":{"x":1}}]});+ let (url, request_rx, server) = spawn_recording_json_response_server(body.clone()).await;+ let client = VectorClient::new(VectorDbKind::ChromaDb, &url, None, None, false, Duration::from_secs(1));+ let result = execute_rest_query(&client, "docs").await.unwrap();+ assert_eq!(+ first_row(&result),+ json!({"id":"a","document":"body","metadata":{"id":"business","payload":{"x":1}}})+ .as_object()+ .unwrap()+ .clone()+ );+ assert!(request_rx.await.unwrap().starts_with(+ "POST /api/v2/tenants/default_tenant/databases/default_database/collections/docs/get HTTP/1.1\r\n"+ ));+ server.await.unwrap();++ let (url, request_rx, server) = spawn_recording_json_response_server(body).await;+ let client = VectorClient::new(VectorDbKind::ChromaDb, &url, None, None, false, Duration::from_secs(1));+ let docs = find_documents(&client, "", "docs", 0, 10).await.unwrap();+ assert_eq!(+ docs.documents,+ vec![json!({"id":"a","document":"body","metadata":{"id":"business","payload":{"x":1}}})]+ );+ assert!(request_rx.await.unwrap().starts_with(+ "POST /api/v2/tenants/default_tenant/databases/default_database/collections/docs/get HTTP/1.1\r\n"+ ));+ server.await.unwrap();+ }+async fn spawn_json_response_server(body: Value) -> (String, tokio::task::JoinHandle<()>) {let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();let address = listener.local_addr().unwrap();@@ -1093,6 +1501,7 @@ mod tests {assert_eq!(rest_query_result(VectorDbKind::Milvus,+ ResponseOrigin::Generic,200,json!({ "code": 1100, "message": "field kind does not exist" }),Instant::now()@@ -1100,15 +1509,74 @@ mod tests {.unwrap_err(),"Milvus error (code 1100): field kind does not exist");- assert!(rest_query_result(VectorDbKind::Milvus, 200, json!({ "code": 0 }), Instant::now()).is_ok());assert!(rest_query_result(VectorDbKind::Milvus,+ ResponseOrigin::Generic,+ 200,+ json!({ "code": 0 }),+ Instant::now()+ )+ .is_ok());+ assert!(rest_query_result(+ VectorDbKind::Milvus,+ ResponseOrigin::Generic,200,json!({ "code": 200, "data": ["kb_vectors"] }),Instant::now()).is_ok());- assert!(rest_query_result(VectorDbKind::Milvus, 200, json!({ "data": [] }), Instant::now()).is_ok());+ assert!(rest_query_result(+ VectorDbKind::Milvus,+ ResponseOrigin::Generic,+ 200,+ json!({ "data": [] }),+ Instant::now()+ )+ .is_ok());+ }++ #[test]+ fn retains_json_encoded_milvus_payload_from_successful_rest_response() {+ let payload = r#"{"kind":"order", "count":2}"#;+ let result = rest_query_result(+ VectorDbKind::Milvus,+ ResponseOrigin::Generic,+ 200,+ json!({ "code": 200, "data": [{ "id": 42, "payload": payload }] }),+ Instant::now(),+ )+ .unwrap();++ let payload_column =+ result.columns.iter().position(|column| column == "payload").expect("Milvus payload column");+ assert_eq!(result.rows[0][payload_column], json!(payload));+ }++ #[test]+ fn retains_milvus_payload_values_and_properties_without_flattening() {+ for payload in [json!({ "nested": { "value": 7 } }), Value::Null, json!([1, "two"]), json!(3), json!(true)] {+ let properties = json!({ "title": "schema field" });+ let result = rest_query_result(+ VectorDbKind::Milvus,+ ResponseOrigin::Generic,+ 200,+ json!({+ "code": 200,+ "data": [{ "id": 42, "payload": payload, "properties": properties }]+ }),+ Instant::now(),+ )+ .unwrap();++ let payload_column =+ result.columns.iter().position(|column| column == "payload").expect("Milvus payload column");+ let properties_column =+ result.columns.iter().position(|column| column == "properties").expect("Milvus properties column");+ assert_eq!(result.rows[0][payload_column], payload);+ assert_eq!(result.rows[0][properties_column], properties);+ assert!(!result.columns.contains(&"nested".to_string()));+ assert!(!result.columns.contains(&"title".to_string()));+ }}#[tokio::test]@@ -1186,11 +1654,17 @@ mod tests {#[test]fn flattens_qdrant_payload_columns() {- let result =- values_to_query_result(vec![json!({"id": 1, "score": 0.9, "payload": {"title": "hello"}})], Instant::now());+ let result = json_to_query_result(+ VectorDbKind::Qdrant,+ ResponseOrigin::QdrantPointsObject,+ 200,+ json!({"result":{"points":[{"id": 1, "score": 0.9, "payload": {"title": "hello"}}]}}),+ Instant::now(),+ );assert!(result.columns.contains(&"id".to_string()));assert!(result.columns.contains(&"score".to_string()));assert!(result.columns.contains(&"title".to_string()));+ assert!(!result.columns.contains(&"payload".to_string()));}#[test]@@ -1308,13 +1782,38 @@ mod tests {#[test]fn flattens_weaviate_properties_columns() {- let result = values_to_query_result(- vec![json!({"id": "abc", "class": "Article", "properties": {"title": "hello"}})],+ let result = json_to_query_result(+ VectorDbKind::Weaviate,+ ResponseOrigin::WeaviateRestObjects,+ 200,+ json!({"objects":[{"id": "abc", "class": "Article", "properties": {"title": "hello"}}]}),Instant::now(),);assert!(result.columns.contains(&"id".to_string()));assert!(result.columns.contains(&"class".to_string()));assert!(result.columns.contains(&"title".to_string()));+ assert!(!result.columns.contains(&"properties".to_string()));+ }++ #[test]+ fn only_confirmed_wrappers_flatten_once() {+ let qdrant = json_to_query_result(+ VectorDbKind::Qdrant,+ ResponseOrigin::QdrantPointsList,+ 200,+ json!({"result":[{"id":1,"payload":{"properties":{"x":2}}}]}),+ Instant::now(),+ );+ assert_eq!(first_row(&qdrant), json!({"id":1,"properties":{"x":2}}).as_object().unwrap().clone());++ let weaviate = json_to_query_result(+ VectorDbKind::Weaviate,+ ResponseOrigin::WeaviateRestObjects,+ 200,+ json!({"objects":[{"id":"a","properties":{"payload":{"x":2}}}]}),+ Instant::now(),+ );+ assert_eq!(first_row(&weaviate), json!({"id":"a","payload":{"x":2}}).as_object().unwrap().clone());}#[test]