#![allow(deprecated)]
use crate::backend::{
CollectionInfo, CollectionParamsSpec, CollectionSchema, PayloadIndexSpec, SparseVectorSpec,
VectorSpec,
};
use crate::qdrant_grpc::qdrant;
use qql_plan::types::MemoryPlacement;
use qql_plan::{
BinaryQuantization, HnswConfig, MaxOptimizationThreads, OptimizersConfig, ProductQuantization,
QuantizationConfig, ScalarQuantization, TurboQuantization,
};
use super::memory::memory_to_str;
pub(crate) fn collection_info_from_grpc(info: &qdrant::CollectionInfo) -> CollectionInfo {
CollectionInfo {
status: collection_status_to_str(info.status).to_string(),
points_count: info.points_count.unwrap_or(0),
indexed_vectors_count: info.indexed_vectors_count,
segments_count: info.segments_count,
schema: schema_from_grpc_collection(info),
}
}
fn collection_status_to_str(status: i32) -> &'static str {
match qdrant::CollectionStatus::try_from(status) {
Ok(qdrant::CollectionStatus::Green) => "green",
Ok(qdrant::CollectionStatus::Yellow) => "yellow",
Ok(qdrant::CollectionStatus::Grey) => "grey",
Ok(qdrant::CollectionStatus::Red) => "red",
Ok(qdrant::CollectionStatus::UnknownCollectionStatus) | Err(_) => "unknown",
}
}
pub(crate) fn schema_from_grpc_collection(info: &qdrant::CollectionInfo) -> CollectionSchema {
let mut schema = CollectionSchema::default();
if let Some(config) = &info.config {
if let Some(params) = &config.params {
if let Some(vc) = ¶ms.vectors_config {
match &vc.config {
Some(qdrant::vectors_config::Config::Params(p)) => {
schema.vectors.push(vector_params_to_spec(None, p));
schema.dense_vectors.clear();
}
Some(qdrant::vectors_config::Config::ParamsMap(map)) => {
let mut names: Vec<String> = map.map.keys().cloned().collect();
names.sort();
schema.dense_vectors = names.clone();
for name in &names {
if let Some(p) = map.map.get(name) {
schema
.vectors
.push(vector_params_to_spec(Some(name.clone()), p));
}
}
}
None => {}
}
}
if let Some(sparse) = ¶ms.sparse_vectors_config {
let mut specs = Vec::new();
for (name, p) in &sparse.map {
let modifier = p
.modifier
.and_then(|m| qdrant::Modifier::try_from(m).ok())
.map(|m| match m {
qdrant::Modifier::Idf => "idf".to_string(),
qdrant::Modifier::None => "none".to_string(),
});
let index = p.index.as_ref().map(|i| {
let mut map = serde_json::Map::new();
if let Some(v) = i.full_scan_threshold {
map.insert("full_scan_threshold".into(), serde_json::json!(v));
}
if let Some(v) = i.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = i.datatype
&& let Ok(dt) = qdrant::Datatype::try_from(v)
{
let name = match dt {
qdrant::Datatype::Float32 => "float32",
qdrant::Datatype::Uint8 => "uint8",
qdrant::Datatype::Float16 => "float16",
qdrant::Datatype::Turbo4 => "turbo4",
qdrant::Datatype::Default => "default",
};
map.insert("datatype".into(), serde_json::Value::String(name.into()));
}
if let Some(name) = i.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(name.into()));
}
map
});
specs.push(SparseVectorSpec {
name: name.clone(),
index,
modifier,
});
}
specs.sort_by(|a, b| a.name.cmp(&b.name));
schema.sparse_vectors = specs;
}
let sharding_method = params.sharding_method.and_then(|m| {
qdrant::ShardingMethod::try_from(m).ok().map(|sm| match sm {
qdrant::ShardingMethod::Auto => "auto".to_string(),
qdrant::ShardingMethod::Custom => "custom".to_string(),
})
});
schema.params = CollectionParamsSpec {
shard_number: Some(params.shard_number as u64),
sharding_method,
on_disk_payload: Some(params.on_disk_payload),
payload_memory: params
.payload
.as_ref()
.and_then(|p| p.memory)
.and_then(memory_to_str)
.map(str::to_string),
replication_factor: params.replication_factor.map(|n| n as u64),
};
}
if let Some(hnsw) = &config.hnsw_config {
schema.hnsw = Some(hnsw_diff_to_spec(hnsw));
}
if let Some(opt) = &config.optimizer_config {
schema.optimizers = Some(optimizer_config_diff_to_spec(opt));
}
if let Some(quant) = &config.quantization_config {
schema.quantization = quantization_config_to_spec(quant);
}
}
for (field, meta) in &info.payload_schema {
let data_type = qdrant::PayloadSchemaType::try_from(meta.data_type)
.ok()
.map(|t| t.as_str_name().to_ascii_lowercase())
.unwrap_or_else(|| "keyword".into());
let data_type = match data_type.as_str() {
"unknowntype" => "keyword".to_string(),
other => other.to_string(),
};
let (params_map, is_tenant) = payload_index_params_from_proto(meta.params.as_ref());
schema.payload_indexes.push(PayloadIndexSpec {
field: field.clone(),
data_type,
params: params_map,
is_tenant,
});
}
schema.payload_indexes.sort_by(|a, b| a.field.cmp(&b.field));
schema
}
fn vector_params_to_spec(name: Option<String>, p: &qdrant::VectorParams) -> VectorSpec {
let distance = qdrant::Distance::try_from(p.distance)
.ok()
.map(|d| d.as_str_name().to_string())
.unwrap_or_else(|| "Cosine".into());
let hnsw = p.hnsw_config.as_ref().map(hnsw_diff_to_map);
let quantization = p
.quantization_config
.as_ref()
.and_then(quantization_config_to_json);
let multivector = p.multivector_config.as_ref().map(|m| {
let mut map = serde_json::Map::new();
if let Ok(c) = qdrant::MultiVectorComparator::try_from(m.comparator) {
let name = match c {
qdrant::MultiVectorComparator::MaxSim => "max_sim",
};
map.insert("comparator".into(), serde_json::Value::String(name.into()));
}
map
});
let datatype = p
.datatype
.and_then(|v| qdrant::Datatype::try_from(v).ok())
.map(|dt| {
match dt {
qdrant::Datatype::Float32 => "float32",
qdrant::Datatype::Uint8 => "uint8",
qdrant::Datatype::Float16 => "float16",
qdrant::Datatype::Turbo4 => "turbo4",
qdrant::Datatype::Default => "default",
}
.to_string()
});
let memory = p.memory.and_then(memory_to_str).map(str::to_string);
VectorSpec {
name,
size: p.size,
distance,
hnsw,
quantization,
multivector,
on_disk: p.on_disk,
datatype,
memory,
}
}
fn f32_to_f64(value: f32) -> f64 {
value.to_string().parse().unwrap_or(f64::from(value))
}
fn hnsw_diff_to_spec(diff: &qdrant::HnswConfigDiff) -> HnswConfig {
HnswConfig {
m: diff.m,
ef_construct: diff.ef_construct,
full_scan_threshold: diff.full_scan_threshold,
max_indexing_threads: diff.max_indexing_threads,
on_disk: diff.on_disk,
payload_m: diff.payload_m,
inline_storage: diff.inline_storage,
memory: diff
.memory
.and_then(memory_to_str)
.and_then(MemoryPlacement::parse),
}
}
fn optimizer_config_diff_to_spec(diff: &qdrant::OptimizersConfigDiff) -> OptimizersConfig {
OptimizersConfig {
deleted_threshold: diff.deleted_threshold,
vacuum_min_vector_number: diff.vacuum_min_vector_number,
default_segment_number: diff.default_segment_number,
max_segment_size: diff.max_segment_size,
memmap_threshold: diff.memmap_threshold,
indexing_threshold: diff.indexing_threshold,
flush_interval_sec: diff.flush_interval_sec,
max_optimization_threads: diff.max_optimization_threads.as_ref().and_then(|mot| {
mot.variant.as_ref().map(|variant| match variant {
qdrant::max_optimization_threads::Variant::Value(val) => {
MaxOptimizationThreads::Threads(*val)
}
qdrant::max_optimization_threads::Variant::Setting(_) => {
MaxOptimizationThreads::Auto
}
})
}),
prevent_unoptimized: diff.prevent_unoptimized,
}
}
fn quantization_config_to_spec(q: &qdrant::QuantizationConfig) -> Option<QuantizationConfig> {
use qdrant::quantization_config::Quantization;
let memory = |m: Option<i32>| m.and_then(memory_to_str).and_then(MemoryPlacement::parse);
match &q.quantization {
Some(Quantization::Scalar(sq)) => Some(QuantizationConfig::Scalar {
scalar: ScalarQuantization {
qtype: "int8".into(),
quantile: sq.quantile.map(f32_to_f64),
always_ram: sq.always_ram,
memory: memory(sq.memory),
},
}),
Some(Quantization::Product(pq)) => {
let compression = qdrant::CompressionRatio::try_from(pq.compression)
.ok()?
.as_str_name()
.to_string();
Some(QuantizationConfig::Product {
product: ProductQuantization {
compression,
always_ram: pq.always_ram,
memory: memory(pq.memory),
},
})
}
Some(Quantization::Binary(bq)) => {
let encoding = bq
.encoding
.and_then(|enc| qdrant::BinaryQuantizationEncoding::try_from(enc).ok())
.map(|encoding| {
match encoding {
qdrant::BinaryQuantizationEncoding::OneBit => "one_bit",
qdrant::BinaryQuantizationEncoding::TwoBits => "two_bits",
qdrant::BinaryQuantizationEncoding::OneAndHalfBits => "one_and_half_bits",
}
.to_string()
});
let query_encoding = bq
.query_encoding
.as_ref()
.and_then(|qe| match qe.variant {
Some(qdrant::binary_quantization_query_encoding::Variant::Setting(s)) => {
qdrant::binary_quantization_query_encoding::Setting::try_from(s).ok()
}
None => None,
})
.map(|setting| {
match setting {
qdrant::binary_quantization_query_encoding::Setting::Binary => "binary",
qdrant::binary_quantization_query_encoding::Setting::Scalar4Bits => {
"scalar4bits"
}
qdrant::binary_quantization_query_encoding::Setting::Scalar8Bits => {
"scalar8bits"
}
qdrant::binary_quantization_query_encoding::Setting::Default => "default",
}
.to_string()
});
Some(QuantizationConfig::Binary {
binary: BinaryQuantization {
always_ram: bq.always_ram,
encoding,
query_encoding,
memory: memory(bq.memory),
},
})
}
Some(Quantization::Turboquant(tq)) => {
let bits = tq
.bits
.and_then(|bits| qdrant::TurboQuantBitSize::try_from(bits).ok())
.map(|bits| {
match bits {
qdrant::TurboQuantBitSize::Bits1 => "bits1",
qdrant::TurboQuantBitSize::Bits15 => "bits1_5",
qdrant::TurboQuantBitSize::Bits2 => "bits2",
qdrant::TurboQuantBitSize::Bits4 => "bits4",
}
.to_string()
});
Some(QuantizationConfig::Turbo {
turbo: TurboQuantization {
bits,
always_ram: tq.always_ram,
memory: memory(tq.memory),
},
})
}
None => None,
}
}
fn hnsw_diff_to_map(diff: &qdrant::HnswConfigDiff) -> serde_json::Map<String, serde_json::Value> {
let mut map = serde_json::Map::new();
if let Some(v) = diff.m {
map.insert("m".into(), serde_json::Value::from(v));
}
if let Some(v) = diff.ef_construct {
map.insert("ef_construct".into(), serde_json::Value::from(v));
}
if let Some(v) = diff.full_scan_threshold {
map.insert("full_scan_threshold".into(), serde_json::Value::from(v));
}
if let Some(v) = diff.max_indexing_threads {
map.insert("max_indexing_threads".into(), serde_json::Value::from(v));
}
if let Some(v) = diff.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = diff.payload_m {
map.insert("payload_m".into(), serde_json::Value::from(v));
}
if let Some(v) = diff.inline_storage {
map.insert("inline_storage".into(), serde_json::Value::Bool(v));
}
if let Some(name) = diff.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(name.into()));
}
map
}
fn quantization_config_to_json(q: &qdrant::QuantizationConfig) -> Option<serde_json::Value> {
use qdrant::quantization_config::Quantization;
let memory = |map: &mut serde_json::Map<String, serde_json::Value>, value: Option<i32>| {
if let Some(name) = value.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(name.into()));
}
};
match &q.quantization {
Some(Quantization::Scalar(sq)) => {
let mut map = serde_json::Map::new();
map.insert("type".into(), serde_json::json!("int8"));
if let Some(v) = sq.quantile {
map.insert("quantile".into(), serde_json::json!(v));
}
if let Some(v) = sq.always_ram {
map.insert("always_ram".into(), serde_json::Value::Bool(v));
}
memory(&mut map, sq.memory);
Some(serde_json::json!({ "scalar": map }))
}
Some(Quantization::Product(pq)) => {
let mut map = serde_json::Map::new();
if let Ok(c) = qdrant::CompressionRatio::try_from(pq.compression) {
map.insert(
"compression".into(),
serde_json::Value::String(c.as_str_name().to_string()),
);
}
if let Some(v) = pq.always_ram {
map.insert("always_ram".into(), serde_json::Value::Bool(v));
}
memory(&mut map, pq.memory);
Some(serde_json::json!({ "product": map }))
}
Some(Quantization::Binary(bq)) => {
let mut map = serde_json::Map::new();
if let Some(v) = bq.always_ram {
map.insert("always_ram".into(), serde_json::Value::Bool(v));
}
if let Some(enc) = bq.encoding
&& let Ok(e) = qdrant::BinaryQuantizationEncoding::try_from(enc)
{
let qql_enc = match e {
qdrant::BinaryQuantizationEncoding::OneBit => "one_bit",
qdrant::BinaryQuantizationEncoding::TwoBits => "two_bits",
qdrant::BinaryQuantizationEncoding::OneAndHalfBits => "one_and_half_bits",
};
map.insert("encoding".into(), serde_json::Value::String(qql_enc.into()));
}
if let Some(ref qe) = bq.query_encoding
&& let Some(qdrant::binary_quantization_query_encoding::Variant::Setting(s)) =
qe.variant
&& let Ok(setting) =
qdrant::binary_quantization_query_encoding::Setting::try_from(s)
{
let name = match setting {
qdrant::binary_quantization_query_encoding::Setting::Binary => "binary",
qdrant::binary_quantization_query_encoding::Setting::Scalar4Bits => {
"scalar4bits"
}
qdrant::binary_quantization_query_encoding::Setting::Scalar8Bits => {
"scalar8bits"
}
qdrant::binary_quantization_query_encoding::Setting::Default => "default",
};
map.insert(
"query_encoding".into(),
serde_json::Value::String(name.into()),
);
}
memory(&mut map, bq.memory);
Some(serde_json::json!({ "binary": map }))
}
Some(Quantization::Turboquant(tq)) => {
let mut map = serde_json::Map::new();
if let Some(v) = tq.always_ram {
map.insert("always_ram".into(), serde_json::Value::Bool(v));
}
if let Some(bits) = tq.bits
&& let Ok(b) = qdrant::TurboQuantBitSize::try_from(bits)
{
let label = match b {
qdrant::TurboQuantBitSize::Bits1 => "bits1",
qdrant::TurboQuantBitSize::Bits15 => "bits1_5",
qdrant::TurboQuantBitSize::Bits2 => "bits2",
qdrant::TurboQuantBitSize::Bits4 => "bits4",
};
map.insert("bits".into(), serde_json::Value::String(label.into()));
}
memory(&mut map, tq.memory);
Some(serde_json::json!({ "turbo": map }))
}
None => None,
}
}
fn payload_index_params_from_proto(
params: Option<&qdrant::PayloadIndexParams>,
) -> (serde_json::Map<String, serde_json::Value>, Option<bool>) {
let mut map = serde_json::Map::new();
let mut is_tenant = None;
let Some(params) = params else {
return (map, is_tenant);
};
use qdrant::payload_index_params::IndexParams;
match ¶ms.index_params {
Some(IndexParams::KeywordIndexParams(p)) => {
is_tenant = p.is_tenant;
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if p.prefix.is_some() {
map.insert("prefix".into(), serde_json::Value::Bool(true));
}
if let Some(v) = p.is_tenant {
map.insert("is_tenant".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(v.into()));
}
}
Some(IndexParams::UuidIndexParams(p)) => {
is_tenant = p.is_tenant;
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.is_tenant {
map.insert("is_tenant".into(), serde_json::Value::Bool(v));
}
}
Some(IndexParams::TextIndexParams(p)) => {
if let Some(v) = p.lowercase {
map.insert("lowercase".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Ok(tok) = qdrant::TokenizerType::try_from(p.tokenizer) {
let name = tok.as_str_name().to_ascii_lowercase();
if name != "unknowntokenizer" {
map.insert("tokenizer".into(), serde_json::Value::String(name));
}
}
if let Some(v) = p.min_token_len {
map.insert("min_token_len".into(), serde_json::Value::from(v));
}
if let Some(v) = p.max_token_len {
map.insert("max_token_len".into(), serde_json::Value::from(v));
}
}
Some(IndexParams::IntegerIndexParams(p)) => {
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.is_principal {
map.insert("is_principal".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(v.into()));
}
}
Some(IndexParams::FloatIndexParams(p)) => {
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(v.into()));
}
}
Some(IndexParams::DatetimeIndexParams(p)) => {
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(v.into()));
}
}
Some(IndexParams::GeoIndexParams(p)) => {
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(v.into()));
}
}
Some(IndexParams::BoolIndexParams(p)) => {
if let Some(v) = p.on_disk {
map.insert("on_disk".into(), serde_json::Value::Bool(v));
}
if let Some(v) = p.memory.and_then(memory_to_str) {
map.insert("memory".into(), serde_json::Value::String(v.into()));
}
}
None => {}
}
(map, is_tenant)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn collection_status_maps_to_canonical_names() {
assert_eq!(collection_status_to_str(1), "green");
assert_eq!(collection_status_to_str(2), "yellow");
assert_eq!(collection_status_to_str(3), "red");
assert_eq!(collection_status_to_str(4), "grey");
assert_eq!(collection_status_to_str(0), "unknown");
assert_eq!(collection_status_to_str(99), "unknown");
}
#[test]
fn grpc_collection_info_reports_canonical_status() {
let info = qdrant::CollectionInfo {
status: qdrant::CollectionStatus::Yellow as i32,
..Default::default()
};
assert_eq!(collection_info_from_grpc(&info).status, "yellow");
}
#[test]
fn grpc_configs_lower_to_typed_plan_types() {
let hnsw = hnsw_diff_to_spec(&qdrant::HnswConfigDiff {
m: Some(16),
memory: Some(qdrant::Memory::Pinned as i32),
..Default::default()
});
assert_eq!(hnsw.m, Some(16));
assert_eq!(hnsw.memory, Some(MemoryPlacement::Pinned));
let scalar = qdrant::QuantizationConfig {
quantization: Some(qdrant::quantization_config::Quantization::Scalar(
qdrant::ScalarQuantization {
quantile: Some(0.99),
always_ram: Some(true),
..Default::default()
},
)),
};
match quantization_config_to_spec(&scalar).expect("typed scalar") {
QuantizationConfig::Scalar { scalar } => {
assert_eq!(scalar.qtype, "int8");
assert_eq!(
scalar.quantile,
Some(0.99),
"f32 quantile widens through its shortest decimal form"
);
}
other => panic!("expected scalar quantization, got {other:?}"),
}
let quant = qdrant::QuantizationConfig {
quantization: Some(qdrant::quantization_config::Quantization::Turboquant(
qdrant::TurboQuantization {
always_ram: Some(true),
bits: Some(qdrant::TurboQuantBitSize::Bits15 as i32),
memory: None,
},
)),
};
match quantization_config_to_spec(&quant).expect("typed turbo") {
QuantizationConfig::Turbo { turbo } => {
assert_eq!(turbo.bits.as_deref(), Some("bits1_5"));
assert_eq!(turbo.always_ram, Some(true));
}
other => panic!("expected turbo quantization, got {other:?}"),
}
}
#[test]
fn grpc_schema_matches_rest_schema_fixture() {
use std::collections::HashMap;
let rest = serde_json::json!({
"config": {
"params": {
"vectors": {
"body": {
"size": 8,
"distance": "Cosine",
"on_disk": true,
"datatype": "float32",
"memory": "cold",
"hnsw_config": {"m": 16, "inline_storage": true, "memory": "pinned"},
"quantization_config": {
"turbo": {"bits": "bits1_5", "always_ram": true, "memory": "cached"}
},
"multivector_config": {"comparator": "max_sim"},
},
},
"sparse_vectors": {"text": {"modifier": "idf", "index": {"on_disk": true}}},
"shard_number": 3,
"sharding_method": "custom",
"on_disk_payload": true,
"replication_factor": 2,
"payload": {"memory": "cold"},
},
"hnsw_config": {"m": 16, "inline_storage": true, "memory": "pinned"},
"optimizer_config": {
"memmap_threshold": 100000,
"prevent_unoptimized": true,
"max_optimization_threads": "auto",
},
"quantization_config": {
"turbo": {"bits": "bits1_5", "always_ram": true, "memory": "cached"}
},
},
"payload_schema": {
"tenant_id": {"data_type": "keyword", "params": {"is_tenant": true}},
},
});
let quantization = qdrant::QuantizationConfig {
quantization: Some(qdrant::quantization_config::Quantization::Turboquant(
qdrant::TurboQuantization {
always_ram: Some(true),
bits: Some(qdrant::TurboQuantBitSize::Bits15 as i32),
memory: Some(qdrant::Memory::Cached as i32),
},
)),
};
let vector_hnsw = qdrant::HnswConfigDiff {
m: Some(16),
inline_storage: Some(true),
memory: Some(qdrant::Memory::Pinned as i32),
..Default::default()
};
let proto = qdrant::CollectionInfo {
config: Some(qdrant::CollectionConfig {
params: Some(qdrant::CollectionParams {
vectors_config: Some(qdrant::VectorsConfig {
config: Some(qdrant::vectors_config::Config::ParamsMap(
qdrant::VectorParamsMap {
map: HashMap::from([(
"body".to_string(),
qdrant::VectorParams {
size: 8,
distance: qdrant::Distance::Cosine as i32,
hnsw_config: Some(vector_hnsw),
quantization_config: Some(quantization),
on_disk: Some(true),
datatype: Some(qdrant::Datatype::Float32 as i32),
memory: Some(qdrant::Memory::Cold as i32),
multivector_config: Some(qdrant::MultiVectorConfig {
comparator: qdrant::MultiVectorComparator::MaxSim
as i32,
}),
},
)]),
},
)),
}),
sparse_vectors_config: Some(qdrant::SparseVectorConfig {
map: HashMap::from([(
"text".to_string(),
qdrant::SparseVectorParams {
modifier: Some(qdrant::Modifier::Idf as i32),
index: Some(qdrant::SparseIndexConfig {
on_disk: Some(true),
..Default::default()
}),
},
)]),
}),
shard_number: 3,
on_disk_payload: true,
replication_factor: Some(2),
sharding_method: Some(qdrant::ShardingMethod::Custom as i32),
payload: Some(qdrant::PayloadStorageParams {
memory: Some(qdrant::Memory::Cold as i32),
}),
..Default::default()
}),
hnsw_config: Some(qdrant::HnswConfigDiff {
m: Some(16),
inline_storage: Some(true),
memory: Some(qdrant::Memory::Pinned as i32),
..Default::default()
}),
optimizer_config: Some(qdrant::OptimizersConfigDiff {
memmap_threshold: Some(100000),
prevent_unoptimized: Some(true),
max_optimization_threads: Some(qdrant::MaxOptimizationThreads {
variant: Some(qdrant::max_optimization_threads::Variant::Setting(0)),
}),
..Default::default()
}),
quantization_config: Some(quantization),
..Default::default()
}),
payload_schema: HashMap::from([(
"tenant_id".to_string(),
qdrant::PayloadSchemaInfo {
data_type: qdrant::PayloadSchemaType::Keyword as i32,
params: Some(qdrant::PayloadIndexParams {
index_params: Some(
qdrant::payload_index_params::IndexParams::KeywordIndexParams(
qdrant::KeywordIndexParams {
is_tenant: Some(true),
..Default::default()
},
),
),
}),
..Default::default()
},
)]),
..Default::default()
};
let from_rest = serde_json::to_value(crate::backend::schema_from_rest_result(&rest))
.expect("REST schema serializes");
let from_grpc = serde_json::to_value(schema_from_grpc_collection(&proto))
.expect("gRPC schema serializes");
assert_eq!(
from_grpc, from_rest,
"gRPC and REST must report one SHOW COLLECTION shape"
);
assert_eq!(from_rest["quantization"]["turbo"]["bits"], "bits1_5");
assert_eq!(
from_rest["vectors"][0]["quantization"]["turbo"]["bits"],
"bits1_5"
);
assert_eq!(from_rest["hnsw"]["inline_storage"], true);
assert_eq!(from_rest["optimizers"]["memmap_threshold"], 100000);
assert_eq!(from_rest["optimizers"]["prevent_unoptimized"], true);
assert_eq!(from_rest["quantization"]["turbo"]["memory"], "cached",);
}
}