qail-qdrant 0.14.10

//! gRPC-based Qdrant driver with zero-copy encoding.
//!
//! This driver uses the proto_encoder for direct protobuf encoding
//! and grpc_transport for HTTP/2 communication, achieving performance
//! that matches or exceeds the official qdrant-client.

use bytes::BytesMut;
use qail_core::ast::Qail;

use crate::error::{QdrantError, QdrantResult};
use crate::grpc_transport::GrpcClient;
use crate::point::{Point, ScoredPoint};
use crate::proto_decoder;
use crate::proto_encoder;

/// High-performance gRPC driver for Qdrant.
///
/// Unlike `QdrantDriver` (REST), this driver:
/// - Uses gRPC/HTTP2 for lower latency
/// - Encodes protobuf directly with pre-computed headers
/// - Reuses buffers to minimize allocations
/// - Uses memcpy for vector data (no per-element loop)
///
/// # Example
/// ```ignore
/// use qail_qdrant::GrpcDriver;
/// use qail_core::prelude::*;
///
/// let driver = GrpcDriver::connect("localhost", 6334).await?;
///
/// let results = driver.search(
///     "products",
///     &embedding,
///     10,
///     Some(0.5),
/// ).await?;
/// ```
pub struct GrpcDriver {
    /// gRPC client for HTTP/2 transport
    client: GrpcClient,
    /// Reusable encoding buffer
    buffer: BytesMut,
}

impl GrpcDriver {
    /// Connect to Qdrant gRPC endpoint (default port 6334).
    pub async fn connect(host: &str, port: u16) -> QdrantResult<Self> {
        let client = GrpcClient::connect(host, port).await?;
        Ok(Self {
            client,
            buffer: BytesMut::with_capacity(8192),
        })
    }

    /// Connect with address string.
    pub async fn connect_addr(addr: &str) -> QdrantResult<Self> {
        let parts: Vec<&str> = addr.split(':').collect();
        if parts.len() != 2 {
            return Err(QdrantError::Connection(
                "Invalid address format, expected host:port".to_string(),
            ));
        }
        let port: u16 = parts[1]
            .parse()
            .map_err(|_| QdrantError::Connection("Invalid port".to_string()))?;
        Self::connect(parts[0], port).await
    }

    /// Vector similarity search with zero-copy encoding.
    ///
    /// # Arguments
    /// * `collection` - Collection name
    /// * `vector` - Query vector
    /// * `limit` - Max results
    /// * `score_threshold` - Optional minimum score
    ///
    /// # Performance
    /// Vector is encoded via memcpy (no per-element serialization).
    pub async fn search(
        &mut self,
        collection: &str,
        vector: &[f32],
        limit: u64,
        score_threshold: Option<f32>,
    ) -> QdrantResult<Vec<ScoredPoint>> {
        // Encode request using zero-copy encoder
        proto_encoder::encode_search_proto(
            &mut self.buffer,
            collection,
            vector,
            limit,
            score_threshold,
            None,
        );

        // Send via gRPC
        let response = self.client.search(self.buffer.clone().freeze()).await?;

        // Decode response using zero-copy decoder
        proto_decoder::decode_search_response(&response)
    }

    /// Search using QAIL AST.
    ///
    /// Extracts vector, collection, limit from the Qail command.
    pub async fn search_ast(&mut self, cmd: &Qail) -> QdrantResult<Vec<ScoredPoint>> {
        let collection = if cmd.table.is_empty() {
            return Err(QdrantError::Encode("Collection name required".to_string()));
        } else {
            &cmd.table
        };

        let vector = cmd.vector.as_ref().ok_or_else(|| {
            QdrantError::Encode("Vector required for search".to_string())
        })?;

        // Extract limit from cages (default 10)
        let mut limit = 10u64;
        for cage in &cmd.cages {
            if let qail_core::ast::CageKind::Limit(n) = cage.kind {
                limit = n as u64;
            }
        }

        let score_threshold = cmd.score_threshold;

        self.search(collection, vector, limit, score_threshold).await
    }

    /// Upsert points with zero-copy encoding.
    pub async fn upsert(
        &mut self,
        collection: &str,
        points: &[Point],
        wait: bool,
    ) -> QdrantResult<()> {
        // Encode request using zero-copy encoder
        proto_encoder::encode_upsert_proto(&mut self.buffer, collection, points, wait);

        // Send via gRPC
        let _response = self.client.upsert(self.buffer.clone().freeze()).await?;

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_grpc_driver_struct() {
        // Verify struct is constructible
        let buffer = BytesMut::with_capacity(1024);
        assert!(buffer.capacity() >= 1024);
    }
}