Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
Remove qdrant and opengauss vector backends (#3872)
Jiahui Zhou1d02a72b2b9f
diff --git a/docs/en/configuration/01-server.md b/docs/en/configuration/01-server.mdindex 702a6bd3c..4ea97164e 100644--- a/docs/en/configuration/01-server.md+++ b/docs/en/configuration/01-server.md@@ -192,7 +192,7 @@ Search and Find requests default to `limit: 10`; override the limit on each API|---|---|---|---|| `workspace` | path | `"./data"` | OpenViking workspace || `agfs.backend` | `local`, `memory`, `s3` | `local` | File and metadata backend |-| `vectordb.backend` | `local`, `cuvs`, `http`, `volcengine`, `vikingdb`, `qdrant`, `opengauss` | `local` | Vector database backend |+| `vectordb.backend` | `local`, `cuvs`, `http`, `volcengine`, `vikingdb` | `local` | Vector database backend || `vectordb.dimension` | integer | follows Embedding | Vector collection dimension || `skip_process_lock` | boolean | `false` | Skip the workspace process lock; use only when accepting concurrent-write risk |diff --git a/docs/en/guides/01-configuration.md b/docs/en/guides/01-configuration.mdindex e15c8c6d2..e95af1337 100644--- a/docs/en/guides/01-configuration.md+++ b/docs/en/guides/01-configuration.md@@ -988,7 +988,7 @@ Grep engine configuration for content pattern search. These settings are server-| `engine` | str | Search engine mode: `"auto"` uses VikingDB BM25 recall when available and falls back to local filesystem search; `"fs"` forces local filesystem search only. | `"auto"` || `switch_to_remote_threshold` | int | L2 record count threshold to switch to VikingDB BM25 recall. When the number of L2 files under the search scope reaches this threshold, VikingDB BM25 is used for phase-1 recall; otherwise local filesystem search is used. Set to `0` to always use VikingDB BM25. Must be ≥ 0. | `10000` |-For VikingDB / Volcengine FullText grep, OpenViking writes a `content` text field for BM25 recall. The source context keeps the full content, while the vector-store write payload truncates this field to **1 MB** at the final adapter boundary to stay within backend payload limits. Only VikingDB-backed backends use `content`; on all other backends (`local`, `cuvs`, `qdrant`, `opengauss`, `http`) the field is not written.+For VikingDB / Volcengine FullText grep, OpenViking writes a `content` text field for BM25 recall. The source context keeps the full content, while the vector-store write payload truncates this field to **1 MB** at the final adapter boundary to stay within backend payload limits. Only VikingDB-backed backends use `content`; on all other backends (`local`, `cuvs`, `http`) the field is not written.### storage@@ -1351,7 +1351,7 @@ Vector database storage configuration| Parameter | Type | Description | Default ||-----------|------|-------------|---------|-| `backend` | str | VectorDB backend type: 'local' (file-based), 'http' (remote service), 'volcengine' (cloud VikingDB), 'vikingdb' (private deployment), 'cuvs' (local storage + GPU dense search), 'qdrant', or 'opengauss' | "local" |+| `backend` | str | VectorDB backend type: 'local' (file-based), 'http' (remote service), 'volcengine' (cloud VikingDB), 'vikingdb' (private deployment), or 'cuvs' (local storage + GPU dense search) | "local" || `name` | str | VectorDB collection name | "context" || `url` | str | Remote service URL for 'http' type (e.g., 'http://localhost:5000') | null || `project_name` | str | Project name (alias project) | "default" |@@ -1361,8 +1361,6 @@ Vector database storage configuration| `volcengine` | object | 'volcengine' type VikingDB configuration | - || `vikingdb` | object | 'vikingdb' type private deployment configuration | - || `cuvs` | object | NVIDIA cuVS configuration for the 'cuvs' backend and the opt-in memory-aware auto mode on 'local'; see the [cuVS guide](./16-cuvs.md) | - |-| `qdrant` | object | 'qdrant' type Qdrant configuration | - |-| `opengauss` | object | 'opengauss' native vector backend configuration | - |Default local mode```@@ -1396,40 +1394,6 @@ Supports cloud-deployed VikingDB on Volcengine```</details>-<details>-<summary><b>openGauss</b></summary>--Requires an openGauss server with native `vector` support and a remote-capable database user.-Install the optional driver with `pip install "openviking[opengauss]"`.-In the official container, the initial `omm` user may be restricted for remote login; create a normal user for OpenViking if needed.--```json-{- "storage": {- "vectordb": {- "name": "context",- "backend": "opengauss",- "project": "default",- "distance_metric": "cosine",- "dimension": 1024,- "opengauss": {- "host": "127.0.0.1",- "port": 5432,- "user": "openviking",- "password": "your-password",- "db_name": "postgres",- "schema": "public",- "mode": "standalone"- }- }- }-}-```--Set `mode` to `"distributed"` for openGauss distributed deployments; OpenViking will attempt to mark metadata tables as reference tables and distribute collection tables by `id`.-</details>--## Config FilesOpenViking uses two config files:diff --git a/docs/zh/configuration/01-server.md b/docs/zh/configuration/01-server.mdindex a90f0a0e9..29c26cd1f 100644--- a/docs/zh/configuration/01-server.md+++ b/docs/zh/configuration/01-server.md@@ -192,7 +192,7 @@ Search 和 Find 请求的默认 `limit` 为 `10`,可以在每次 API 或 SDK|---|---|---|---|| `workspace` | path | `"./data"` | OpenViking 工作目录 || `agfs.backend` | `local`、`memory`、`s3` | `local` | 文件与元数据存储后端 |-| `vectordb.backend` | `local`、`cuvs`、`http`、`volcengine`、`vikingdb`、`qdrant`、`opengauss` | `local` | 向量数据库后端 |+| `vectordb.backend` | `local`、`cuvs`、`http`、`volcengine`、`vikingdb` | `local` | 向量数据库后端 || `vectordb.dimension` | integer | 跟随 Embedding | 向量集合维度 || `skip_process_lock` | boolean | `false` | 是否跳过 workspace 进程锁;仅在明确接受并发写风险时启用 |diff --git a/docs/zh/guides/01-configuration.md b/docs/zh/guides/01-configuration.mdindex 5746dd37c..a0c03a903 100644--- a/docs/zh/guides/01-configuration.md+++ b/docs/zh/guides/01-configuration.md@@ -956,7 +956,7 @@ Grep 引擎配置,用于内容模式搜索。这些设置为服务端配置,| `engine` | str | 搜索引擎模式:`"auto"` 在可用时使用 VikingDB BM25 召回,不可用时回退到本地文件系统搜索;`"fs"` 强制仅使用本地文件系统搜索。 | `"auto"` || `switch_to_remote_threshold` | int | 切换到 VikingDB BM25 召回的 L2 记录数阈值。当搜索范围内的 L2 文件数达到此阈值时,使用 VikingDB BM25 进行第一阶段召回;否则使用本地文件系统搜索。设为 `0` 表示始终使用 VikingDB BM25。必须 ≥ 0。 | `10000` |-对于 VikingDB / Volcengine FullText grep,OpenViking 会写入 `content` text 字段用于 BM25 召回。源上下文中保留完整内容,仅在最终写入向量库 adapter payload 时将该字段截断到 **1 MB**,以满足后端 payload 限制。只有 VikingDB 系后端使用 `content`;其它后端(`local`、`cuvs`、`qdrant`、`opengauss`、`http`)不写入该字段。+对于 VikingDB / Volcengine FullText grep,OpenViking 会写入 `content` text 字段用于 BM25 召回。源上下文中保留完整内容,仅在最终写入向量库 adapter payload 时将该字段截断到 **1 MB**,以满足后端 payload 限制。只有 VikingDB 系后端使用 `content`;其它后端(`local`、`cuvs`、`http`)不写入该字段。### storage@@ -1437,7 +1437,7 @@ Redis Sentinel 分别配置数据节点和 Sentinel 的 ACL:| 参数 | 类型 | 说明 | 默认值 ||------|------|------|--------|-| `backend` | str | VectorDB 后端类型: 'local'(基于文件), 'http'(远程服务), 'volcengine'(云上 VikingDB), 'vikingdb'(私有部署), 'cuvs'(本地存储 + GPU dense search), 'qdrant' 或 'opengauss' | "local" |+| `backend` | str | VectorDB 后端类型: 'local'(基于文件), 'http'(远程服务), 'volcengine'(云上 VikingDB), 'vikingdb'(私有部署)或 'cuvs'(本地存储 + GPU dense search) | "local" || `name` | str | VectorDB 的集合名称 | "context" || `url` | str | 'http' 类型的远程服务 URL(例如 'http://localhost:5000') | null || `project_name` | str | 项目名称(别名 project) | "default" |@@ -1447,8 +1447,6 @@ Redis Sentinel 分别配置数据节点和 Sentinel 的 ACL:| `volcengine` | object | 'volcengine' 类型的 VikingDB 配置 | - || `vikingdb` | object | 'vikingdb' 类型的私有部署配置 | - || `cuvs` | object | NVIDIA cuVS 配置,也用于在 'local' 下显式开启显存感知自动模式,参见 [cuVS 使用指南](./16-cuvs.md) | - |-| `qdrant` | object | 'qdrant' 类型的 Qdrant 配置 | - |-| `opengauss` | object | 'opengauss' 原生向量后端配置 | - |默认使用本地模式```@@ -1482,41 +1480,6 @@ Redis Sentinel 分别配置数据节点和 Sentinel 的 ACL:```</details>-<details>-<summary><b>openGauss</b></summary>--需要 openGauss 服务端支持原生 `vector` 类型,并使用允许远程连接的数据库用户。-可通过 `pip install "openviking[opengauss]"` 安装可选驱动。-官方容器中的初始 `omm` 用户可能限制远程登录,必要时请为 OpenViking 创建普通数据库用户。--```json-{- "storage": {- "vectordb": {- "name": "context",- "backend": "opengauss",- "project": "default",- "distance_metric": "cosine",- "dimension": 1024,- "opengauss": {- "host": "127.0.0.1",- "port": 5432,- "user": "openviking",- "password": "your-password",- "db_name": "postgres",- "schema": "public",- "mode": "standalone"- }- }- }-}-```--分布式 openGauss 部署可将 `mode` 设为 `"distributed"`;OpenViking 会尝试把元数据表标记为 reference table,并按 `id` 分布集合表。-</details>---## 配置文件OpenViking 使用两个配置文件:diff --git a/openviking/storage/vectordb/collection/qdrant_collection.py b/openviking/storage/vectordb/collection/qdrant_collection.pydeleted file mode 100644index 375c40825..000000000--- a/openviking/storage/vectordb/collection/qdrant_collection.py+++ /dev/null@@ -1,1245 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0-"""Qdrant-backed ICollection implementation for OpenViking."""--from __future__ import annotations--import datetime as dt-import uuid-from typing import Any, Dict, List, Optional, Sequence, Tuple--import xxhash--from openviking.storage.vectordb.collection.collection import ICollection-from openviking.storage.vectordb.collection.qdrant_meta_store import QdrantMetaStore-from openviking.storage.vectordb.collection.qdrant_rest import QdrantRestClient, QdrantRestError-from openviking.storage.vectordb.collection.result import (- AggregateResult,- DataItem,- FetchDataInCollectionResult,- SearchItemResult,- SearchResult,-)-from openviking.storage.vectordb.index.index import IIndex-from openviking.storage.vectordb.store.data import DeltaRecord-from openviking_cli.utils import get_logger--logger = get_logger(__name__)--QDRANT_SPARSE_INDEX_MAX = 2**31 - 1-QDRANT_UINT64_MAX = 2**64 - 1-OPENVIKING_QDRANT_ID_NAMESPACE = uuid.UUID("4b6bb5a8-7f1f-5b1a-9d4c-b93f29b1d67c")-ORIGINAL_ID_FIELD = "_openviking_original_id"---def _coerce_iso_datetime(value: Any) -> Any:- if isinstance(value, dt.datetime):- if value.tzinfo is None:- value = value.replace(tzinfo=dt.timezone.utc)- return value.isoformat()- return value---def _normalize_distance(distance: str) -> str:- distance_value = (distance or "cosine").strip().lower()- mapping = {- "cosine": "Cosine",- "ip": "Dot",- "dot": "Dot",- "l2": "Euclid",- "euclid": "Euclid",- "manhattan": "Manhattan",- }- return mapping.get(distance_value, "Cosine")---def _payload_selector(output_fields: Optional[List[str]]) -> bool | Dict[str, List[str]]:- if not output_fields:- return True- include_fields = [field for field in output_fields if field != "id"]- if ORIGINAL_ID_FIELD not in include_fields:- include_fields.append(ORIGINAL_ID_FIELD)- return {"include": include_fields} if include_fields else True---def _parse_point_id(value: Any) -> Any:- if value is None:- return ""- if isinstance(value, int) and not isinstance(value, bool):- return value- return str(value)---def _to_qdrant_point_id(value: Any) -> int | str:- if isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= QDRANT_UINT64_MAX:- return value- value_str = str(value)- try:- return str(uuid.UUID(value_str))- except (ValueError, AttributeError, TypeError):- return str(uuid.uuid5(OPENVIKING_QDRANT_ID_NAMESPACE, value_str))---def _extract_points(response: Dict[str, Any]) -> List[Dict[str, Any]]:- result = response.get("result", response)- if isinstance(result, list):- return result- if isinstance(result, dict):- if isinstance(result.get("points"), list):- return result.get("points", [])- if isinstance(result.get("result"), list):- return result.get("result", [])- return []---def _hash_sparse_term(term: str) -> int:- # Keep sparse indices in the positive signed 32-bit integer range expected- # by Qdrant sparse vectors.- return xxhash.xxh64_intdigest(str(term)) % QDRANT_SPARSE_INDEX_MAX---def _sparse_to_qdrant(sparse_vector: Optional[Dict[str, float]]) -> Optional[Dict[str, List[Any]]]:- if not sparse_vector:- return None- merged: Dict[int, float] = {}- hashed_terms: Dict[int, str] = {}- collisions: List[tuple[str, str, int]] = []- for raw_term, raw_weight in sparse_vector.items():- try:- weight = float(raw_weight)- except (TypeError, ValueError):- continue- idx = _hash_sparse_term(str(raw_term))- previous_term = hashed_terms.get(idx)- if previous_term is not None and previous_term != str(raw_term):- collisions.append((previous_term, str(raw_term), idx))- else:- hashed_terms[idx] = str(raw_term)- merged[idx] = merged.get(idx, 0.0) + weight- if collisions:- sample = ", ".join(f"{left!r}<->{right!r}@{idx}" for left, right, idx in collisions[:3])- logger.warning(- "Qdrant sparse term hash collision detected; colliding terms are merged into the same sparse index bucket. count=%s sample=%s",- len(collisions),- sample,- )- if not merged:- return None- indices = sorted(merged.keys())- values = [merged[idx] for idx in indices]- return {"indices": indices, "values": values}---class QdrantIndex(IIndex):- """Lightweight logical index facade backed by Qdrant payload/vector config."""-- def __init__(- self, collection: "QdrantCollection", index_name: str, meta: Dict[str, Any]- ) -> None:- super().__init__(meta=meta)- self._collection = collection- self._index_name = index_name- self._meta = dict(meta)-- def upsert_data(self, delta_list: List[DeltaRecord]):- raise NotImplementedError("QdrantIndex.upsert_data is managed at collection level")-- def delete_data(self, delta_list: List[DeltaRecord]):- raise NotImplementedError("QdrantIndex.delete_data is managed at collection level")-- def search(- self,- query_vector: Optional[List[float]],- limit: int = 10,- filters: Optional[Dict[str, Any]] = None,- sparse_raw_terms: Optional[List[str]] = None,- sparse_values: Optional[List[float]] = None,- ) -> Tuple[List[int], List[float]]:- raise NotImplementedError("QdrantIndex.search is not exposed via raw index interface")-- def aggregate(self, filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:- raise NotImplementedError("QdrantIndex.aggregate is not exposed via raw index interface")-- def update(- self, scalar_index: Optional[Dict[str, Any]] = None, description: Optional[str] = None- ):- self._collection.update_index(- index_name=self._index_name,- scalar_index=scalar_index,- description=description,- )- self._meta = self._collection.get_index_meta_data(self._index_name) or self._meta-- def get_meta_data(self):- return dict(self._meta)-- def close(self):- return None-- def drop(self):- self._collection.drop_index(self._index_name)---class QdrantCollection(ICollection):- """Qdrant-backed collection implementation."""-- DEFAULT_SCROLL_PAGE_SIZE = 256- DEFAULT_DELETE_BATCH_SIZE = 1_000- DEFAULT_HYBRID_PREFETCH_LIMIT = 32- MAX_HYBRID_PREFETCH_LIMIT = 256- MAX_SCROLL_ITERATIONS = 10_000- CLIENT_SIDE_SCAN_WARNING_THRESHOLD = 10_000- TEXT_INDEX_FIELDS = {"name", "description", "abstract", "tags"}-- def __init__(- self,- *,- url: str,- api_key: str | None,- timeout_seconds: int,- project_name: str,- logical_collection_name: str,- physical_collection_name: str,- dense_vector_name: str,- sparse_vector_name: str,- meta_collection_name: str,- distance_metric: str,- enable_text_index: bool = False,- ) -> None:- super().__init__()- self._client = QdrantRestClient(- url=url,- api_key=api_key,- timeout_seconds=timeout_seconds,- )- self._project_name = project_name- self._logical_collection_name = logical_collection_name- self._physical_collection_name = physical_collection_name- self._dense_vector_name = dense_vector_name- self._sparse_vector_name = sparse_vector_name- self._distance_metric = distance_metric- self._enable_text_index = enable_text_index- self._meta_store = QdrantMetaStore(- client=self._client,- meta_collection_name=meta_collection_name,- )- self._vector_dim = 0- self._path_payload_fields: set[str] = {"parent_uri", "scope_roots"}- self._refresh_vector_dim_from_meta()-- # ---------------------------------------------------------------------- # Helpers- # ---------------------------------------------------------------------- @property- def collection_key(self) -> str:- return self._physical_collection_name-- def collection_exists(self) -> bool:- return self._client.collection_exists(self._physical_collection_name)-- def _apply_meta_schema(self, meta: Dict[str, Any]) -> None:- path_payload_fields = {"parent_uri", "scope_roots"}- for field in meta.get("Fields", []):- if field.get("FieldType") == "path":- field_name = field.get("FieldName")- if field_name:- path_payload_fields.add(str(field_name))- if field.get("FieldType") == "vector":- try:- self._vector_dim = int(field.get("Dim") or 0)- except (TypeError, ValueError):- self._vector_dim = 0- self._path_payload_fields = path_payload_fields-- def _refresh_vector_dim_from_meta(self) -> None:- meta = self._meta_store.get_collection_meta(collection_key=self.collection_key)- if not meta:- return- self._apply_meta_schema(meta)-- @staticmethod- def _decode_path_value(value: Any) -> Any:- if isinstance(value, list):- return [QdrantCollection._decode_path_value(item) for item in value]- if not isinstance(value, str):- return value- stripped = value.strip()- if stripped.startswith("viking://") or not stripped.startswith("/"):- return value- suffix = stripped.strip("/")- return f"viking://{suffix}" if suffix else "viking://"-- def _normalize_payload_for_read(self, payload: Dict[str, Any]) -> Dict[str, Any]:- if not payload:- return {}- normalized = dict(payload)- for field_name in self._path_payload_fields:- if field_name in normalized:- normalized[field_name] = self._decode_path_value(normalized[field_name])- return normalized-- def _build_vector_config(self, meta_data: Dict[str, Any]) -> Dict[str, Any]:- dense_dim = 0- has_sparse = False- for field in meta_data.get("Fields", []):- field_type = field.get("FieldType")- if field_type == "vector":- dense_dim = int(field.get("Dim") or 0)- elif field_type == "sparse_vector":- has_sparse = True-- if dense_dim <= 0:- raise ValueError("Qdrant collection requires a positive dense vector dimension")-- self._vector_dim = dense_dim- body: Dict[str, Any] = {- "vectors": {- self._dense_vector_name: {- "size": dense_dim,- "distance": _normalize_distance(self._distance_metric),- }- }- }- if has_sparse:- body["sparse_vectors"] = {self._sparse_vector_name: {}}- return body-- def create_remote_collection(self, meta_data: Dict[str, Any]) -> None:- body = self._build_vector_config(meta_data)- self._client.request(- "PUT",- f"/collections/{self._physical_collection_name}",- json_body=body,- expected_statuses=(200, 201),- )- try:- self._meta_store.save_collection_meta(- collection_key=self.collection_key,- logical_collection_name=self._logical_collection_name,- project_name=self._project_name,- meta=meta_data,- )- except Exception:- try:- self._client.request(- "DELETE",- f"/collections/{self._physical_collection_name}",- expected_statuses=(200, 202, 404),- )- except Exception as cleanup_error:- logger.warning(- "Failed to rollback Qdrant collection after metadata write failure: collection=%s error=%s",- self._physical_collection_name,- cleanup_error,- )- raise- self._apply_meta_schema(meta_data)-- def _make_point(self, record: Dict[str, Any]) -> Dict[str, Any]:- original_id = record.get("id")- if original_id is None or original_id == "":- raise ValueError("Qdrant point requires id")-- dense_vector = record.get(self._dense_vector_name)- sparse_vector = record.get(self._sparse_vector_name)- payload = {- key: _coerce_iso_datetime(value)- for key, value in record.items()- if key not in {"id", self._dense_vector_name, self._sparse_vector_name}- }- payload[ORIGINAL_ID_FIELD] = _parse_point_id(original_id)-- vector_payload: Dict[str, Any] = {}- if isinstance(dense_vector, list) and dense_vector:- vector_payload[self._dense_vector_name] = dense_vector-- sparse_payload = _sparse_to_qdrant(sparse_vector)- if sparse_payload:- vector_payload[self._sparse_vector_name] = sparse_payload-- if not vector_payload:- raise ValueError("Qdrant point requires at least one dense or sparse vector")-- return {- "id": _to_qdrant_point_id(original_id),- "vector": vector_payload,- "payload": payload,- }-- def _point_payload_for_read(self, point: Dict[str, Any]) -> Tuple[Any, Dict[str, Any]]:- raw_payload = dict(point.get("payload", {}) or {})- original_id = raw_payload.pop(ORIGINAL_ID_FIELD, None)- if original_id is None:- original_id = _parse_point_id(point.get("id"))- return original_id, self._normalize_payload_for_read(raw_payload)-- def _parse_search_result(- self,- response: Dict[str, Any],- *,- offset: int,- limit: int,- ) -> SearchResult:- items: List[SearchItemResult] = []- for point in _extract_points(response):- if not isinstance(point, dict):- continue- original_id, payload = self._point_payload_for_read(point)- score = point.get("score") if isinstance(point, dict) else None- items.append(- SearchItemResult(- id=original_id,- fields=payload,- score=score,- )- )- if offset > 0:- items = items[offset:]- if len(items) > limit:- items = items[:limit]- return SearchResult(data=items)-- def _parse_points_as_search_result(- self,- points: Sequence[Dict[str, Any]],- *,- score: Optional[float] = 1.0,- ) -> SearchResult:- data: List[SearchItemResult] = []- for point in points:- original_id, payload = self._point_payload_for_read(point)- data.append(- SearchItemResult(- id=original_id,- fields=payload,- score=score,- )- )- return SearchResult(data=data)-- def _extract_named_vectors(- self,- point: Dict[str, Any],- ) -> Tuple[Optional[List[float]], Optional[Dict[str, List[Any]]]]:- vectors = point.get("vector")- if not isinstance(vectors, dict):- return None, None-- dense_vector = vectors.get(self._dense_vector_name)- sparse_vector = vectors.get(self._sparse_vector_name)- if not isinstance(dense_vector, list):- dense_vector = None- if not isinstance(sparse_vector, dict):- sparse_vector = None- return dense_vector, sparse_vector-- def _scroll_points(- self,- *,- filters: Optional[Dict[str, Any]] = None,- with_payload: bool | Dict[str, List[str]] = True,- limit: Optional[int] = None,- order_by: Optional[str] = None,- order_desc: bool = False,- ) -> List[Dict[str, Any]]:- points: List[Dict[str, Any]] = []- next_offset: Any = None- seen_offsets: set[str] = set()- iterations = 0-- while iterations < self.MAX_SCROLL_ITERATIONS:- iterations += 1- remaining = None if limit is None else max(limit - len(points), 0)- if remaining == 0:- break-- body: Dict[str, Any] = {- "limit": min(- self.DEFAULT_SCROLL_PAGE_SIZE,- remaining if remaining is not None else self.DEFAULT_SCROLL_PAGE_SIZE,- ),- "with_payload": with_payload,- "with_vector": False,- }- if filters:- body["filter"] = filters- if next_offset is not None:- body["offset"] = next_offset- if order_by:- body["order_by"] = {- "key": order_by,- "direction": "desc" if order_desc else "asc",- }-- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/scroll",- json_body=body,- )- result = response.get("result", {})- page_points = result.get("points", []) if isinstance(result, dict) else []- if not page_points:- break-- points.extend(page_points)- next_offset = result.get("next_page_offset") if isinstance(result, dict) else None- if next_offset is None:- break- offset_key = repr(next_offset)- if offset_key in seen_offsets:- logger.warning(- "Stopping Qdrant scroll early because next_page_offset repeated for collection=%s offset=%s",- self._physical_collection_name,- next_offset,- )- break- seen_offsets.add(offset_key)- else:- logger.warning(- "Stopping Qdrant scroll after reaching MAX_SCROLL_ITERATIONS=%s for collection=%s",- self.MAX_SCROLL_ITERATIONS,- self._physical_collection_name,- )- return points-- def _scan_points_with_warning(- self,- *,- purpose: str,- filters: Optional[Dict[str, Any]],- with_payload: bool | Dict[str, List[str]],- limit: Optional[int] = None,- order_by: Optional[str] = None,- order_desc: bool = False,- ) -> List[Dict[str, Any]]:- if limit is None:- logger.warning(- "Qdrant %s uses client-side full scan/scroll. This may be expensive for large collections.",- purpose,- )- elif limit >= self.CLIENT_SIDE_SCAN_WARNING_THRESHOLD:- logger.warning(- "Qdrant %s will scan up to %s points client-side. This may be expensive for large collections.",- purpose,- limit,- )- return self._scroll_points(- filters=filters,- with_payload=with_payload,- limit=limit,- order_by=order_by,- order_desc=order_desc,- )-- def _delete_field_index(self, field_name: str) -> None:- try:- self._client.request(- "DELETE",- f"/collections/{self._physical_collection_name}/index/{field_name}",- params={"wait": "true"},- expected_statuses=(200, 202),- )- except QdrantRestError as exc:- logger.warning("Failed to delete Qdrant field index %s: %s", field_name, exc)-- def _field_type_map(self) -> Dict[str, str]:- meta = self.get_meta_data() or {}- fields = meta.get("Fields", [])- mapping = {field.get("FieldName"): field.get("FieldType") for field in fields}- mapping.setdefault("parent_uri", "string")- mapping.setdefault("scope_roots", "string")- mapping.setdefault("uri_depth", "int64")- return {str(k): str(v) for k, v in mapping.items() if k}-- def _payload_field_schema(self, field_name: str, field_type: str) -> Optional[str]:- normalized_type = (field_type or "").lower()- if normalized_type in {"string", "path"}:- if self._enable_text_index and field_name in self.TEXT_INDEX_FIELDS:- return "text"- return "keyword"- if normalized_type in {"int64", "int32"}:- return "integer"- if normalized_type in {"float", "double"}:- return "float"- if normalized_type in {"bool", "boolean"}:- return "bool"- if normalized_type == "date_time":- return "datetime"- return None-- def _count_points(self, filters: Optional[Dict[str, Any]] = None) -> int:- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/count",- json_body={- "filter": filters or {},- "exact": True,- },- )- result = response.get("result", {})- try:- return int(result.get("count", 0)) if isinstance(result, dict) else 0- except (TypeError, ValueError):- return 0-- def _delete_points(self, point_ids: Sequence[Any]) -> None:- if not point_ids:- return- self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/delete",- json_body={"points": list(point_ids)},- params={"wait": "true"},- expected_statuses=(200, 202),- )-- # ---------------------------------------------------------------------- # ICollection- # ---------------------------------------------------------------------- def update(self, fields: Optional[Dict[str, Any]] = None, description: Optional[str] = None):- meta = self._meta_store.update_collection_meta(- collection_key=self.collection_key,- logical_collection_name=self._logical_collection_name,- project_name=self._project_name,- fields=fields,- description=description,- )- if isinstance(meta, dict):- self._apply_meta_schema(meta)- return meta-- def get_meta_data(self):- return self._meta_store.get_collection_meta(collection_key=self.collection_key) or {}-- def has_openviking_metadata(self) -> bool:- return bool(self._meta_store.get_collection_meta(collection_key=self.collection_key))-- def close(self):- self._client.close()-- def drop(self):- try:- self._client.request(- "DELETE",- f"/collections/{self._physical_collection_name}",- expected_statuses=(200, 202, 404),- )- finally:- self._meta_store.delete_collection_meta(collection_key=self.collection_key)-- def create_index(self, index_name: str, meta_data: Dict[str, Any]):- field_type_map = self._field_type_map()- scalar_fields = list(meta_data.get("ScalarIndex", []) or [])- for field_name in scalar_fields:- field_schema = self._payload_field_schema(- field_name, field_type_map.get(field_name, "")- )- if not field_schema:- continue- self._client.request(- "PUT",- f"/collections/{self._physical_collection_name}/index",- json_body={- "field_name": field_name,- "field_schema": field_schema,- },- params={"wait": "true"},- expected_statuses=(200, 202),- )- self._meta_store.save_index_meta(- collection_key=self.collection_key,- logical_collection_name=self._logical_collection_name,- index_name=index_name,- meta=meta_data,- )- return QdrantIndex(self, index_name, meta_data)-- def has_index(self, index_name: str) -> bool:- return index_name in self.list_indexes()-- def get_index(self, index_name: str) -> Optional[IIndex]:- meta = self.get_index_meta_data(index_name)- if not meta:- return None- return QdrantIndex(self, index_name, meta)-- def search_by_vector(- self,- index_name: str,- dense_vector: Optional[List[float]] = None,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- sparse_vector: Optional[Dict[str, float]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- if dense_vector is None and sparse_vector is None:- return SearchResult()-- fetch_limit = max(limit + offset, limit)- body: Dict[str, Any] = {- "limit": fetch_limit,- "with_payload": _payload_selector(output_fields),- }- if filters:- body["filter"] = filters-- try:- if dense_vector is not None and sparse_vector:- sparse_payload = _sparse_to_qdrant(sparse_vector)- if not sparse_payload:- sparse_vector = None- else:- hybrid_prefetch_limit = min(- max(fetch_limit * 4, fetch_limit + 8, self.DEFAULT_HYBRID_PREFETCH_LIMIT),- self.MAX_HYBRID_PREFETCH_LIMIT,- )- body.update(- {- "prefetch": [- {- "query": dense_vector,- "using": self._dense_vector_name,- "limit": hybrid_prefetch_limit,- },- {- "query": sparse_payload,- "using": self._sparse_vector_name,- "limit": hybrid_prefetch_limit,- },- ],- "query": {"fusion": "rrf"},- }- )- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/query",- json_body=body,- expected_statuses=(200, 202),- )- return self._parse_search_result(response, offset=offset, limit=limit)-- if sparse_vector and dense_vector is None:- sparse_payload = _sparse_to_qdrant(sparse_vector)- if not sparse_payload:- return SearchResult()- body.update(- {- "query": sparse_payload,- "using": self._sparse_vector_name,- }- )- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/query",- json_body=body,- expected_statuses=(200, 202),- )- return self._parse_search_result(response, offset=offset, limit=limit)-- if dense_vector is None:- return SearchResult()-- body.update(- {- "query": dense_vector,- "using": self._dense_vector_name,- }- )- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/query",- json_body=body,- expected_statuses=(200, 202),- )- return self._parse_search_result(response, offset=offset, limit=limit)- except QdrantRestError as exc:- if dense_vector is None:- raise- logger.warning(- "Falling back to Qdrant /points/search for dense-only query because /points/query failed: %s",- exc,- )- fallback_body: Dict[str, Any] = {- "vector": {- "name": self._dense_vector_name,- "vector": dense_vector,- },- "limit": fetch_limit,- "with_payload": _payload_selector(output_fields),- }- if filters:- fallback_body["filter"] = filters- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/search",- json_body=fallback_body,- expected_statuses=(200, 202),- )- return self._parse_search_result(response, offset=offset, limit=limit)-- def search_by_keywords(- self,- index_name: str,- keywords: Optional[List[str]] = None,- query: Optional[str] = None,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- query_text = query or " ".join(keywords or [])- if not query_text.strip():- return SearchResult()-- text_filter = {- "should": [- {"must": [{"key": field_name, "match": {"text": query_text}}]}- for field_name in sorted(self.TEXT_INDEX_FIELDS)- ]- }- compound_filter = {"must": [filters, text_filter]} if filters else text_filter- points = self._scroll_points(- filters=compound_filter,- with_payload=_payload_selector(output_fields),- limit=limit + offset,- )- if offset > 0:- points = points[offset:]- if len(points) > limit:- points = points[:limit]- return SearchResult(data=self._parse_points_as_search_result(points, score=1.0).data)-- def search_by_id(- self,- index_name: str,- id: Any,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- point_id = _to_qdrant_point_id(id)- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points",- json_body={- "ids": [point_id],- "with_payload": _payload_selector([ORIGINAL_ID_FIELD]),- "with_vector": True,- },- )- points = _extract_points(response)- if not points:- return SearchResult()-- dense_vector, sparse_payload = self._extract_named_vectors(points[0])- if dense_vector is None and sparse_payload is None:- return SearchResult()-- fetch_limit = max(limit + offset + 1, limit + 1)- body: Dict[str, Any] = {- "limit": fetch_limit,- "with_payload": _payload_selector(output_fields),- }- if filters:- body["filter"] = filters-- try:- if dense_vector is not None and sparse_payload is not None:- hybrid_prefetch_limit = min(- max(fetch_limit * 4, fetch_limit + 8, self.DEFAULT_HYBRID_PREFETCH_LIMIT),- self.MAX_HYBRID_PREFETCH_LIMIT,- )- body.update(- {- "prefetch": [- {- "query": dense_vector,- "using": self._dense_vector_name,- "limit": hybrid_prefetch_limit,- },- {- "query": sparse_payload,- "using": self._sparse_vector_name,- "limit": hybrid_prefetch_limit,- },- ],- "query": {"fusion": "rrf"},- }- )- elif sparse_payload is not None:- body.update({"query": sparse_payload, "using": self._sparse_vector_name})- else:- body.update({"query": dense_vector, "using": self._dense_vector_name})-- search_response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/query",- json_body=body,- expected_statuses=(200, 202),- )- except QdrantRestError as exc:- if dense_vector is None:- raise- logger.warning(- "Falling back to Qdrant /points/search for search_by_id because /points/query failed: %s",- exc,- )- fallback_body: Dict[str, Any] = {- "vector": {- "name": self._dense_vector_name,- "vector": dense_vector,- },- "limit": fetch_limit,- "with_payload": _payload_selector(output_fields),- }- if filters:- fallback_body["filter"] = filters- search_response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/search",- json_body=fallback_body,- expected_statuses=(200, 202),- )-- data = []- for item in self._parse_search_result(search_response, offset=0, limit=fetch_limit).data:- if item.id == id or str(item.id) == str(id):- continue- data.append(item)- return SearchResult(data=data[offset : offset + limit])-- def search_by_multimodal(- self,- index_name: str,- text: Optional[str],- image: Optional[Any],- video: Optional[Any],- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- raise NotImplementedError("QdrantCollection.search_by_multimodal is not supported")-- def search_by_random(- self,- index_name: str,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- points = self._scroll_points(- filters=filters,- with_payload=_payload_selector(output_fields),- limit=limit + offset,- )- if offset > 0:- points = points[offset:]- if len(points) > limit:- points = points[:limit]- return SearchResult(data=self._parse_points_as_search_result(points, score=1.0).data)-- def search_by_scalar(- self,- index_name: str,- field: str,- order: Optional[str] = "desc",- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- need_cleanup = False- with_payload = list(output_fields or [])- if field not in with_payload:- with_payload.append(field)- need_cleanup = True-- reverse = (order or "desc").lower() == "desc"- try:- points = self._scan_points_with_warning(- purpose="scalar sort",- filters=filters,- with_payload=_payload_selector(with_payload),- limit=limit + offset,- order_by=field,- order_desc=reverse,- )- except QdrantRestError as exc:- logger.warning(- "Falling back to client-side scalar sort because Qdrant order_by is unavailable for field=%s: %s",- field,- exc,- )- points = self._scan_points_with_warning(- purpose="scalar sort fallback",- filters=filters,- with_payload=_payload_selector(with_payload),- limit=None,- )- points.sort(- key=lambda point: (- point.get("payload", {}).get(field) is None,- point.get("payload", {}).get(field),- ),- reverse=reverse,- )- points = points[offset : offset + limit]- data: List[SearchItemResult] = []- for point in points:- original_id, payload = self._point_payload_for_read(point)- score = payload.get(field)- if need_cleanup:- payload.pop(field, None)- data.append(- SearchItemResult(- id=original_id,- fields=payload,- score=score if isinstance(score, (int, float)) else None,- )- )- return SearchResult(data=data)-- def update_index(- self,- index_name: str,- scalar_index: Optional[Dict[str, Any]] = None,- description: Optional[str] = None,- ):- current_meta = self.get_index_meta_data(index_name) or {"IndexName": index_name}- old_scalar_fields = set(current_meta.get("ScalarIndex", []) or [])-- if scalar_index is not None:- if isinstance(scalar_index, dict):- new_scalar_fields = list(scalar_index.keys())- else:- new_scalar_fields = list(scalar_index)- current_meta["ScalarIndex"] = new_scalar_fields- else:- new_scalar_fields = list(current_meta.get("ScalarIndex", []) or [])-- if description is not None:- current_meta["Description"] = description-- field_type_map = self._field_type_map()- for field_name in new_scalar_fields:- if field_name in old_scalar_fields:- continue- field_schema = self._payload_field_schema(- field_name, field_type_map.get(field_name, "")- )- if not field_schema:- continue- self._client.request(- "PUT",- f"/collections/{self._physical_collection_name}/index",- json_body={- "field_name": field_name,- "field_schema": field_schema,- },- params={"wait": "true"},- expected_statuses=(200, 202),- )-- for field_name in sorted(old_scalar_fields - set(new_scalar_fields)):- self._delete_field_index(field_name)-- self._meta_store.save_index_meta(- collection_key=self.collection_key,- logical_collection_name=self._logical_collection_name,- index_name=index_name,- meta=current_meta,- )- return current_meta-- def get_index_meta_data(self, index_name: str):- return self._meta_store.get_index_meta(- collection_key=self.collection_key, index_name=index_name- )-- def list_indexes(self):- return self._meta_store.list_indexes(collection_key=self.collection_key)-- def drop_index(self, index_name: str):- index_meta = self.get_index_meta_data(index_name) or {}- for field_name in index_meta.get("ScalarIndex", []) or []:- self._delete_field_index(field_name)- self._meta_store.delete_index_meta(- collection_key=self.collection_key, index_name=index_name- )-- def upsert_data(self, data_list: List[Dict[str, Any]], ttl=0):- # Qdrant does not provide a collection-level per-point TTL primitive that- # matches the existing ICollection contract, so ttl is accepted only for- # interface compatibility and intentionally ignored here.- points = [self._make_point(data) for data in data_list]- self._client.request(- "PUT",- f"/collections/{self._physical_collection_name}/points",- json_body={"points": points},- params={"wait": "true"},- expected_statuses=(200, 202),- )- return [data.get("id") for data in data_list]-- def update_data(self, data_list: List[Dict[str, Any]]):- updated_records: List[Dict[str, Any]] = []- updated_ids: List[Any] = []-- for raw_data in data_list:- if "id" not in raw_data or raw_data.get("id") in (None, ""):- raise ValueError("Qdrant update requires id")-- original_id = raw_data.get("id")- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points",- json_body={- "ids": [_to_qdrant_point_id(original_id)],- "with_payload": True,- "with_vector": True,- },- )- points = _extract_points(response)- if not points:- raise ValueError(f"Qdrant point does not exist for update: {original_id}")-- point = points[0]- existing_id, existing_payload = self._point_payload_for_read(point)- dense_vector, sparse_vector = self._extract_named_vectors(point)-- merged_record: Dict[str, Any] = {"id": existing_id, **existing_payload}- if dense_vector is not None:- merged_record[self._dense_vector_name] = dense_vector- if sparse_vector is not None:- merged_record[self._sparse_vector_name] = sparse_vector-- for field_name, field_value in raw_data.items():- merged_record[field_name] = field_value-- updated_records.append(merged_record)- updated_ids.append(existing_id)-- points = [self._make_point(data) for data in updated_records]- self._client.request(- "PUT",- f"/collections/{self._physical_collection_name}/points",- json_body={"points": points},- params={"wait": "true"},- expected_statuses=(200, 202),- )- return updated_ids-- def fetch_data(self, primary_keys: List[Any]):- if not primary_keys:- return FetchDataInCollectionResult()- response = self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points",- json_body={- "ids": [_to_qdrant_point_id(pk) for pk in primary_keys],- "with_payload": True,- "with_vector": False,- },- )- points = _extract_points(response)- items: List[DataItem] = []- found_ids: set[str] = set()- for point in points:- if not isinstance(point, dict):- continue- original_id, payload = self._point_payload_for_read(point)- found_ids.add(str(original_id))- items.append(DataItem(id=original_id, fields=payload))- return FetchDataInCollectionResult(- items=items,- ids_not_exist=[pk for pk in primary_keys if str(pk) not in found_ids],- )-- def delete_data(self, primary_keys: List[Any]):- self._delete_points([_to_qdrant_point_id(pk) for pk in primary_keys])-- def delete_all_data(self):- try:- self._client.request(- "POST",- f"/collections/{self._physical_collection_name}/points/delete",- json_body={"filter": {}},- params={"wait": "true"},- expected_statuses=(200, 202),- )- except QdrantRestError as exc:- logger.warning(- "Falling back to batched delete_all_data for collection=%s because filter delete failed: %s",- self._physical_collection_name,- exc,- )- points = self._scan_points_with_warning(- purpose="delete_all_data fallback",- filters=None,- with_payload=False,- limit=None,- )- batch_ids: List[str] = []- for point in points:- batch_ids.append(_parse_point_id(point.get("id")))- if len(batch_ids) >= self.DEFAULT_DELETE_BATCH_SIZE:- self._delete_points(batch_ids)- batch_ids = []- if batch_ids:- self._delete_points(batch_ids)-- def aggregate_data(- self,- index_name: str,- op: str = "count",- field: Optional[str] = None,- filters: Optional[Dict[str, Any]] = None,- cond: Optional[Dict[str, Any]] = None,- ) -> AggregateResult:- if op != "count":- return AggregateResult(agg={}, op=op, field=field)-- if not field:- return AggregateResult(- agg={"_total": self._count_points(filters)},- op="count",- field=None,- )-- grouped: Dict[Any, int] = {}- points = self._scan_points_with_warning(- purpose=f"aggregate(count by {field})",- filters=filters,- with_payload=_payload_selector([field]),- limit=None,- )- for point in points:- payload = point.get("payload", {})- value = payload.get(field)- if value is None:- continue- if field in self._path_payload_fields:- value = self._decode_path_value(value)- grouped[value] = grouped.get(value, 0) + 1-- if cond:- filtered_grouped: Dict[Any, int] = {}- for key, value in grouped.items():- include = True- if cond.get("gt") is not None:- include = include and value > cond["gt"]- if cond.get("gte") is not None:- include = include and value >= cond["gte"]- if cond.get("lt") is not None:- include = include and value < cond["lt"]- if cond.get("lte") is not None:- include = include and value <= cond["lte"]- if include:- filtered_grouped[key] = value- grouped = filtered_grouped-- return AggregateResult(agg=grouped, op="count", field=field)diff --git a/openviking/storage/vectordb/collection/qdrant_meta_store.py b/openviking/storage/vectordb/collection/qdrant_meta_store.pydeleted file mode 100644index 4d344d6ef..000000000--- a/openviking/storage/vectordb/collection/qdrant_meta_store.py+++ /dev/null@@ -1,291 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0-"""Sidecar metadata persistence for Qdrant-backed OpenViking collections."""--from __future__ import annotations--import datetime as dt-import uuid-from typing import Any, Dict, List, Optional--from .qdrant_rest import QdrantRestClient, QdrantRestError---def _utcnow_iso() -> str:- return dt.datetime.now(dt.timezone.utc).isoformat()---class QdrantMetaStore:- """Store OpenViking collection/index metadata in a dedicated Qdrant collection."""-- COLLECTION_KIND = "collection"- INDEX_KIND = "index"-- def __init__(- self,- *,- client: QdrantRestClient,- meta_collection_name: str,- ) -> None:- self._client = client- self._meta_collection_name = meta_collection_name- self._meta_collection_ensured = False-- @property- def meta_collection_name(self) -> str:- return self._meta_collection_name-- def _ensure_meta_collection(self) -> None:- if self._meta_collection_ensured:- return- if self._client.collection_exists(self._meta_collection_name):- self._meta_collection_ensured = True- return- self._client.request(- "PUT",- f"/collections/{self._meta_collection_name}",- json_body={- # Keep metadata in a tiny dedicated collection. Some Qdrant- # deployments still require vector configuration, so we use a- # 1D dummy vector payload for sidecar metadata documents.- "vectors": {- "size": 1,- "distance": "Cosine",- }- },- expected_statuses=(200, 201),- )- self._meta_collection_ensured = True-- @staticmethod- def _collection_doc_id(collection_key: str) -> str:- return str(uuid.uuid5(uuid.NAMESPACE_URL, f"openviking:qdrant:collection:{collection_key}"))-- @staticmethod- def _index_doc_id(collection_key: str, index_name: str) -> str:- return str(- uuid.uuid5(- uuid.NAMESPACE_URL,- f"openviking:qdrant:index:{collection_key}:{index_name}",- )- )-- def _upsert_meta_doc(self, *, point_id: str, payload: Dict[str, Any]) -> None:- self._ensure_meta_collection()- self._client.request(- "PUT",- f"/collections/{self._meta_collection_name}/points",- json_body={- "points": [- {- "id": point_id,- "vector": [0.0],- "payload": payload,- }- ]- },- params={"wait": "true"},- expected_statuses=(200, 202),- )-- def _get_point(self, point_id: str) -> Optional[Dict[str, Any]]:- if not self._meta_collection_ensured and not self._client.collection_exists(- self._meta_collection_name- ):- return None- self._meta_collection_ensured = True- try:- response = self._client.request(- "POST",- f"/collections/{self._meta_collection_name}/points",- json_body={- "ids": [point_id],- "with_payload": True,- "with_vector": False,- },- )- except QdrantRestError as exc:- if exc.status_code == 404:- return None- raise-- result = response.get("result", {})- if isinstance(result, list):- points = result- elif isinstance(result, dict):- points = result.get("points", [])- else:- points = []- return points[0] if points else None-- def _scroll_index_docs(self, collection_key: str) -> List[Dict[str, Any]]:- if not self._meta_collection_ensured and not self._client.collection_exists(- self._meta_collection_name- ):- return []- self._meta_collection_ensured = True- points: List[Dict[str, Any]] = []- next_offset: Optional[Any] = None-- while True:- request_body: Dict[str, Any] = {- "limit": 128,- "with_payload": True,- "with_vector": False,- "filter": {- "must": [- {"key": "kind", "match": {"value": self.INDEX_KIND}},- {"key": "collection_key", "match": {"value": collection_key}},- ]- },- }- if next_offset is not None:- request_body["offset"] = next_offset-- response = self._client.request(- "POST",- f"/collections/{self._meta_collection_name}/points/scroll",- json_body=request_body,- )- result = response.get("result", {})- if not isinstance(result, dict):- break-- batch = result.get("points", [])- if isinstance(batch, list):- points.extend(batch)-- next_offset = result.get("next_page_offset")- if next_offset is None:- break-- return points-- def save_collection_meta(- self,- *,- collection_key: str,- logical_collection_name: str,- project_name: str,- meta: Dict[str, Any],- ) -> None:- now = _utcnow_iso()- payload = {- "kind": self.COLLECTION_KIND,- "collection_key": collection_key,- "logical_collection_name": logical_collection_name,- "project_name": project_name,- "meta": meta,- "updated_at": now,- }- self._upsert_meta_doc(- point_id=self._collection_doc_id(collection_key),- payload=payload,- )-- def get_collection_meta(self, *, collection_key: str) -> Optional[Dict[str, Any]]:- point = self._get_point(self._collection_doc_id(collection_key))- if not point:- return None- payload = point.get("payload", {})- meta = payload.get("meta")- return meta if isinstance(meta, dict) else None-- def update_collection_meta(- self,- *,- collection_key: str,- logical_collection_name: str,- project_name: str,- fields: Optional[Dict[str, Any]] = None,- description: Optional[str] = None,- ) -> Dict[str, Any]:- meta = self.get_collection_meta(collection_key=collection_key) or {- "CollectionName": logical_collection_name- }- if fields is not None:- meta["Fields"] = fields- if description is not None:- meta["Description"] = description- self.save_collection_meta(- collection_key=collection_key,- logical_collection_name=logical_collection_name,- project_name=project_name,- meta=meta,- )- return meta-- def save_index_meta(- self,- *,- collection_key: str,- logical_collection_name: str,- index_name: str,- meta: Dict[str, Any],- ) -> None:- now = _utcnow_iso()- payload = {- "kind": self.INDEX_KIND,- "collection_key": collection_key,- "logical_collection_name": logical_collection_name,- "index_name": index_name,- "meta": meta,- "updated_at": now,- }- self._upsert_meta_doc(- point_id=self._index_doc_id(collection_key, index_name),- payload=payload,- )-- def get_index_meta(self, *, collection_key: str, index_name: str) -> Optional[Dict[str, Any]]:- point = self._get_point(self._index_doc_id(collection_key, index_name))- if not point:- return None- payload = point.get("payload", {})- meta = payload.get("meta")- return meta if isinstance(meta, dict) else None-- def list_indexes(self, *, collection_key: str) -> List[str]:- docs = self._scroll_index_docs(collection_key)- index_names: List[str] = []- for doc in docs:- payload = doc.get("payload", {})- index_name = payload.get("index_name")- if isinstance(index_name, str):- index_names.append(index_name)- return index_names-- def delete_index_meta(self, *, collection_key: str, index_name: str) -> None:- if not self._meta_collection_ensured and not self._client.collection_exists(- self._meta_collection_name- ):- return- self._meta_collection_ensured = True- self._client.request(- "POST",- f"/collections/{self._meta_collection_name}/points/delete",- json_body={"points": [self._index_doc_id(collection_key, index_name)]},- params={"wait": "true"},- expected_statuses=(200, 202),- )-- def delete_collection_meta(self, *, collection_key: str) -> None:- if not self._meta_collection_ensured and not self._client.collection_exists(- self._meta_collection_name- ):- return- self._meta_collection_ensured = True- point_ids = [self._collection_doc_id(collection_key)]- point_ids.extend(- self._index_doc_id(collection_key, index_name)- for index_name in self.list_indexes(collection_key=collection_key)- )- if not point_ids:- return- self._client.request(- "POST",- f"/collections/{self._meta_collection_name}/points/delete",- json_body={"points": point_ids},- params={"wait": "true"},- expected_statuses=(200, 202),- )diff --git a/openviking/storage/vectordb/collection/qdrant_rest.py b/openviking/storage/vectordb/collection/qdrant_rest.pydeleted file mode 100644index 0dce339f9..000000000--- a/openviking/storage/vectordb/collection/qdrant_rest.py+++ /dev/null@@ -1,239 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0-"""Lightweight Qdrant REST client helpers used by the adapter."""--from __future__ import annotations--import asyncio-import json-from typing import Any, Dict, Optional--import httpx-import requests---class QdrantRestError(RuntimeError):- """Raised when a Qdrant REST request fails."""-- def __init__(- self,- message: str,- *,- status_code: int | None = None,- response_text: str | None = None,- ) -> None:- super().__init__(message)- self.status_code = status_code- self.response_text = response_text---class QdrantRestClient:- """Minimal REST client for Qdrant.-- The implementation intentionally uses REST instead of `qdrant-client` so the- adapter can be developed and unit-tested without introducing a hard runtime- dependency on the Python SDK.-- This client is intentionally synchronous because the current ICollection- contract is synchronous across backends. Async OpenViking code paths must- either:-- 1. use the async backend façade (`_AsyncVectorAdapter`) that wraps adapter- calls with `asyncio.to_thread`, or- 2. use `request_async()` / `collection_exists_async()` directly.- """-- def __init__(- self,- *,- url: str,- api_key: str | None = None,- timeout_seconds: int = 10,- ) -> None:- normalized = url.strip()- if normalized and not normalized.startswith(("http://", "https://")):- normalized = f"http://{normalized}"- self._base_url = normalized.rstrip("/")- self._timeout_seconds = timeout_seconds- self._session = requests.Session()- self._headers: Dict[str, str] = {"Content-Type": "application/json"}- if api_key:- self._headers["api-key"] = api_key-- @property- def base_url(self) -> str:- return self._base_url-- def close(self) -> None:- self._session.close()-- def request(- self,- method: str,- path: str,- *,- json_body: Optional[Dict[str, Any]] = None,- params: Optional[Dict[str, Any]] = None,- expected_statuses: tuple[int, ...] = (200,),- ) -> Dict[str, Any]:- response = self._session.request(- method=method.upper(),- url=f"{self._base_url}{path}",- headers=self._headers,- json=json_body,- params=params,- timeout=self._timeout_seconds,- )- if response.status_code not in expected_statuses:- raise QdrantRestError(- f"Qdrant request failed: {method.upper()} {path} -> {response.status_code}",- status_code=response.status_code,- response_text=response.text,- )-- if not response.text:- return {}-- try:- data = response.json()- except json.JSONDecodeError as exc:- raise QdrantRestError(- f"Qdrant returned non-JSON response for {method.upper()} {path}",- status_code=response.status_code,- response_text=response.text,- ) from exc-- if isinstance(data, dict) and data.get("status") == "error":- raise QdrantRestError(- f"Qdrant reported error for {method.upper()} {path}: {data.get('result') or data}",- status_code=response.status_code,- response_text=response.text,- )- return data if isinstance(data, dict) else {"result": data}-- async def request_async(- self,- method: str,- path: str,- *,- json_body: Optional[Dict[str, Any]] = None,- params: Optional[Dict[str, Any]] = None,- expected_statuses: tuple[int, ...] = (200,),- ) -> Dict[str, Any]:- return await asyncio.to_thread(- self.request,- method,- path,- json_body=json_body,- params=params,- expected_statuses=expected_statuses,- )-- def collection_exists(self, collection_name: str) -> bool:- response = self._session.get(- f"{self._base_url}/collections/{collection_name}",- headers=self._headers,- timeout=self._timeout_seconds,- )- if response.status_code == 404:- return False- if response.status_code != 200:- raise QdrantRestError(- f"Failed to check Qdrant collection existence: {collection_name}",- status_code=response.status_code,- response_text=response.text,- )- return True-- async def collection_exists_async(self, collection_name: str) -> bool:- return await asyncio.to_thread(self.collection_exists, collection_name)---class AsyncQdrantRestClient:- """Async REST client for Qdrant based on httpx.AsyncClient.-- This is provided for async-only call sites that should not rely on- `asyncio.to_thread`. The current Qdrant ICollection implementation remains- synchronous because it follows the shared ICollection interface.- """-- def __init__(- self,- *,- url: str,- api_key: str | None = None,- timeout_seconds: int = 10,- ) -> None:- normalized = url.strip()- if normalized and not normalized.startswith(("http://", "https://")):- normalized = f"http://{normalized}"- self._base_url = normalized.rstrip("/")- headers: Dict[str, str] = {"Content-Type": "application/json"}- if api_key:- headers["api-key"] = api_key- self._client = httpx.AsyncClient(- base_url=self._base_url,- headers=headers,- timeout=timeout_seconds,- )-- @property- def base_url(self) -> str:- return self._base_url-- async def close(self) -> None:- await self._client.aclose()-- async def request(- self,- method: str,- path: str,- *,- json_body: Optional[Dict[str, Any]] = None,- params: Optional[Dict[str, Any]] = None,- expected_statuses: tuple[int, ...] = (200,),- ) -> Dict[str, Any]:- response = await self._client.request(- method=method.upper(),- url=path,- json=json_body,- params=params,- )- if response.status_code not in expected_statuses:- raise QdrantRestError(- f"Qdrant request failed: {method.upper()} {path} -> {response.status_code}",- status_code=response.status_code,- response_text=response.text,- )-- if not response.text:- return {}-- try:- data = response.json()- except json.JSONDecodeError as exc:- raise QdrantRestError(- f"Qdrant returned non-JSON response for {method.upper()} {path}",- status_code=response.status_code,- response_text=response.text,- ) from exc-- if isinstance(data, dict) and data.get("status") == "error":- raise QdrantRestError(- f"Qdrant reported error for {method.upper()} {path}: {data.get('result') or data}",- status_code=response.status_code,- response_text=response.text,- )- return data if isinstance(data, dict) else {"result": data}-- async def collection_exists(self, collection_name: str) -> bool:- response = await self._client.get(f"/collections/{collection_name}")- if response.status_code == 404:- return False- if response.status_code != 200:- raise QdrantRestError(- f"Failed to check Qdrant collection existence: {collection_name}",- status_code=response.status_code,- response_text=response.text,- )- return Truediff --git a/openviking/storage/vectordb_adapters/__init__.py b/openviking/storage/vectordb_adapters/__init__.pyindex bb33a3a36..1d19e1bac 100644--- a/openviking/storage/vectordb_adapters/__init__.py+++ b/openviking/storage/vectordb_adapters/__init__.py@@ -6,8 +6,6 @@ from .base import CollectionAdapterfrom .factory import create_collection_adapterfrom .http_adapter import HttpCollectionAdapterfrom .local_adapter import CuVSCollectionAdapter, LocalCollectionAdapter-from .opengauss_adapter import OpenGaussCollectionAdapter-from .qdrant_adapter import QdrantCollectionAdapterfrom .vikingdb_private_adapter import VikingDBPrivateCollectionAdapterfrom .volcengine_adapter import VolcengineCollectionAdapter@@ -16,8 +14,6 @@ __all__ = ["LocalCollectionAdapter","CuVSCollectionAdapter","HttpCollectionAdapter",- "OpenGaussCollectionAdapter",- "QdrantCollectionAdapter","VolcengineCollectionAdapter","VikingDBPrivateCollectionAdapter","create_collection_adapter",diff --git a/openviking/storage/vectordb_adapters/factory.py b/openviking/storage/vectordb_adapters/factory.pyindex 24e570e6c..b01dc6dec 100644--- a/openviking/storage/vectordb_adapters/factory.py+++ b/openviking/storage/vectordb_adapters/factory.py@@ -9,8 +9,6 @@ import importlibfrom .base import CollectionAdapterfrom .http_adapter import HttpCollectionAdapterfrom .local_adapter import CuVSCollectionAdapter, LocalCollectionAdapter-from .opengauss_adapter import OpenGaussCollectionAdapter-from .qdrant_adapter import QdrantCollectionAdapterfrom .vikingdb_private_adapter import VikingDBPrivateCollectionAdapterfrom .volcengine_adapter import VolcengineCollectionAdapter@@ -18,8 +16,6 @@ _ADAPTER_REGISTRY: dict[str, type[CollectionAdapter]] = {"local": LocalCollectionAdapter,"cuvs": CuVSCollectionAdapter,"http": HttpCollectionAdapter,- "opengauss": OpenGaussCollectionAdapter,- "qdrant": QdrantCollectionAdapter,"volcengine": VolcengineCollectionAdapter,"vikingdb": VikingDBPrivateCollectionAdapter,}diff --git a/openviking/storage/vectordb_adapters/opengauss_adapter.py b/openviking/storage/vectordb_adapters/opengauss_adapter.pydeleted file mode 100644index 21b4913a8..000000000--- a/openviking/storage/vectordb_adapters/opengauss_adapter.py+++ /dev/null@@ -1,1596 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0-"""openGauss-backed vector collection adapter.--The official openGauss container ships a native ``vector`` type and HNSW/IVFFlat-index support. The adapter stores one SQL table per OpenViking collection and-keeps collection/index metadata in small sidecar tables.-"""--from __future__ import annotations--import datetime as dt-import json-import math-import re-import threading-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple--from openviking.storage.expr import (- And,- Contains,- Eq,- FilterExpr,- In,- Or,- PathScope,- Range,- RawDSL,- TimeRange,-)-from openviking.storage.vectordb.collection.collection import Collection, ICollection-from openviking.storage.vectordb.collection.result import (- AggregateResult,- DataItem,- FetchDataInCollectionResult,- SearchItemResult,- SearchResult,-)-from openviking.storage.vectordb.index.index import IIndex-from openviking.storage.vectordb.store.data import DeltaRecord-from openviking.storage.vectordb_adapters.base import CollectionAdapter-from openviking_cli.utils import get_logger--logger = get_logger(__name__)--_COLLECTION_META_TABLE = "__openviking_opengauss_collections"-_INDEX_META_TABLE = "__openviking_opengauss_indexes"-_DEFAULT_SCHEMA = "public"-_IDENT_RE = re.compile(r"[^a-zA-Z0-9_]+")-_MAX_IDENTIFIER_BYTES = 63--_FIELD_TYPE_SQL: Dict[str, str] = {- "string": "TEXT",- "path": "TEXT",- "int64": "BIGINT",- "int32": "INTEGER",- "float": "DOUBLE PRECISION",- "double": "DOUBLE PRECISION",- "bool": "BOOLEAN",- "boolean": "BOOLEAN",- "date_time": "TIMESTAMP WITH TIME ZONE",-}--_VECTOR_OPS: Dict[str, Dict[str, str]] = {- "cosine": {"operator": "<=>", "hnsw": "vector_cosine_ops"},- "ip": {"operator": "<#>", "hnsw": "vector_ip_ops"},- "l2": {"operator": "<->", "hnsw": "vector_l2_ops"},-}---def _import_psycopg2():- try:- import psycopg2 # type: ignore # noqa: PLC0415-- return psycopg2- except ImportError as exc: # pragma: no cover - exercised only without optional driver- raise ImportError(- "The openGauss backend requires a psycopg2-compatible driver. "- 'Install it with `pip install "openviking[opengauss]"`, or install another '- "psycopg2-compatible driver that can connect to openGauss."- ) from exc---def _quote_ident(name: str) -> str:- return '"' + str(name).replace('"', '""') + '"'---def _qualify(schema: str, name: str) -> str:- return f"{_quote_ident(schema)}.{_quote_ident(name)}"---def _safe_identifier(*parts: Any, prefix: str = "ov") -> str:- raw = "_".join(str(part or "") for part in parts)- normalized = _IDENT_RE.sub("_", raw).strip("_").lower() or "default"- name = f"{prefix}_{normalized}"- encoded = name.encode("utf-8")- if len(encoded) <= _MAX_IDENTIFIER_BYTES:- return name- import hashlib-- digest = hashlib.sha1(encoded).hexdigest()[:10]- keep = max(8, _MAX_IDENTIFIER_BYTES - len(prefix) - len(digest) - 3)- return f"{prefix}_{normalized[:keep]}_{digest}"---def _json_default(value: Any) -> Any:- if isinstance(value, (dt.datetime, dt.date)):- return value.isoformat()- return str(value)---def _json_dumps(value: Any) -> str:- return json.dumps(value, ensure_ascii=False, sort_keys=True, default=_json_default)---def _encode_scope_roots(value: Any) -> str:- roots = value if isinstance(value, list) else [value]- normalized = [str(root) for root in roots if root is not None]- return "\n" + "\n".join(normalized) + "\n" if normalized else "\n"---def _vector_literal(vector: Sequence[float]) -> str:- values = []- for item in vector:- number = float(item)- if not math.isfinite(number):- number = 0.0- values.append(format(number, ".12g"))- return "[" + ",".join(values) + "]"---def _normalize_distance(distance: str) -> str:- value = (distance or "cosine").strip().lower()- if value not in _VECTOR_OPS:- raise ValueError(- "openGauss vector backend supports only cosine, l2, and ip distance metrics; "- f"got {distance!r}"- )- return value---def _coerce_sql_value(value: Any, field_type: str | None) -> Any:- if value is None:- return None- normalized_type = (field_type or "").lower()- if normalized_type == "date_time":- if isinstance(value, dt.datetime):- return value- if isinstance(value, dt.date):- return dt.datetime.combine(value, dt.time.min, tzinfo=dt.timezone.utc)- return str(value)- if normalized_type in {"int64", "int32"}:- try:- return int(value)- except (TypeError, ValueError):- return None- if normalized_type in {"float", "double"}:- try:- number = float(value)- except (TypeError, ValueError):- return None- return number if math.isfinite(number) else None- if normalized_type in {"bool", "boolean"}:- if isinstance(value, bool):- return value- if isinstance(value, str):- lowered = value.strip().lower()- if lowered in {"true", "t", "yes", "y", "1", "on"}:- return True- if lowered in {"false", "f", "no", "n", "0", "off"}:- return False- return None- return bool(value)- if isinstance(value, (dict, list, tuple)):- return _json_dumps(value)- return value---def _sparse_dot(left: Optional[Dict[str, float]], right: Optional[Dict[str, float]]) -> float:- if not left or not right:- return 0.0- total = 0.0- for key, raw_value in left.items():- try:- total += float(raw_value) * float(right.get(key, 0.0))- except (TypeError, ValueError):- continue- return total---class OpenGaussIndex(IIndex):- """Metadata-only logical index facade for openGauss."""-- def __init__(- self, collection: "OpenGaussCollection", index_name: str, meta: Dict[str, Any]- ) -> None:- super().__init__(meta=meta)- self._collection = collection- self._index_name = index_name- self._meta = dict(meta)-- def upsert_data(self, delta_list: List[DeltaRecord]):- raise NotImplementedError("OpenGaussIndex.upsert_data is managed at collection level")-- def delete_data(self, delta_list: List[DeltaRecord]):- raise NotImplementedError("OpenGaussIndex.delete_data is managed at collection level")-- def search(- self,- query_vector: Optional[List[float]],- limit: int = 10,- filters: Optional[Dict[str, Any]] = None,- sparse_raw_terms: Optional[List[str]] = None,- sparse_values: Optional[List[float]] = None,- ) -> Tuple[List[int], List[float]]:- raise NotImplementedError("OpenGaussIndex.search is not exposed via raw index interface")-- def aggregate(self, filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:- raise NotImplementedError("OpenGaussIndex.aggregate is not exposed via raw index interface")-- def update(- self, scalar_index: Optional[Dict[str, Any]] = None, description: Optional[str] = None- ):- self._collection.update_index(- index_name=self._index_name,- scalar_index=scalar_index,- description=description,- )- self._meta = self._collection.get_index_meta_data(self._index_name) or self._meta-- def get_meta_data(self):- return dict(self._meta)-- def close(self):- return None-- def drop(self):- self._collection.drop_index(self._index_name)---class OpenGaussCollection(ICollection):- """A single OpenViking collection stored in openGauss."""-- DEFAULT_FETCH_LIMIT = 256- DEFAULT_SPARSE_SCAN_LIMIT = 10_000- INTERNAL_PATH_FIELDS = {- "parent_uri": "TEXT",- "scope_roots": "TEXT",- "uri_depth": "BIGINT",- }-- def __init__(- self,- *,- conn: Any,- schema_name: str,- table_name: str,- logical_collection_name: str,- project_name: str,- dense_vector_name: str,- sparse_vector_name: str,- distance_metric: str,- meta: Optional[Dict[str, Any]] = None,- vector_dim: int = 0,- lock: Optional[threading.RLock] = None,- reconnect: Optional[Any] = None,- ) -> None:- super().__init__()- self._conn = conn- self._lock = lock or threading.RLock()- self._reconnect = reconnect- self._schema_name = (schema_name or _DEFAULT_SCHEMA).strip() or _DEFAULT_SCHEMA- self._table_name = table_name- self._logical_collection_name = logical_collection_name- self._project_name = project_name- self._dense_vector_name = dense_vector_name- self._sparse_vector_name = sparse_vector_name- self._distance_metric = _normalize_distance(distance_metric)- self._meta = dict(meta or {})- self._vector_dim = int(vector_dim or self._extract_vector_dim(self._meta) or 0)- self._field_types = self._build_field_type_map(self._meta)-- @property- def collection_key(self) -> str:- return self._table_name-- @staticmethod- def _extract_vector_dim(meta: Dict[str, Any]) -> int:- for field in meta.get("Fields", []) or []:- if field.get("FieldType") == "vector":- try:- return int(field.get("Dim") or 0)- except (TypeError, ValueError):- return 0- return 0-- @staticmethod- def _build_field_type_map(meta: Dict[str, Any]) -> Dict[str, str]:- mapping: Dict[str, str] = {}- for field in meta.get("Fields", []) or []:- name = field.get("FieldName")- field_type = field.get("FieldType")- if name and field_type:- mapping[str(name)] = str(field_type)- mapping.setdefault("id", "string")- mapping.setdefault("parent_uri", "path")- mapping.setdefault("scope_roots", "string")- mapping.setdefault("uri_depth", "int64")- return mapping-- def _ensure_connection(self) -> Any:- if getattr(self._conn, "closed", 0):- if self._reconnect is None:- raise RuntimeError("openGauss connection is closed")- self._conn = self._reconnect()- return self._conn-- def _safe_rollback(self) -> None:- try:- if not getattr(self._conn, "closed", 1):- self._conn.rollback()- except Exception:- logger.debug("Failed to rollback openGauss connection", exc_info=True)-- def _execute(- self,- sql: str,- params: Optional[Sequence[Any]] = None,- *,- fetch: bool = False,- ) -> List[Tuple[Any, ...]]:- with self._lock:- conn = self._ensure_connection()- cur = conn.cursor()- try:- cur.execute(sql, list(params or []))- rows = cur.fetchall() if fetch else []- conn.commit()- return rows- except Exception:- self._safe_rollback()- raise- finally:- cur.close()-- def _table_exists(self) -> bool:- rows = self._execute(- """- SELECT 1- FROM information_schema.tables- WHERE table_schema = %s AND table_name = %s- LIMIT 1- """,- [self._schema_name, self._table_name],- fetch=True,- )- return bool(rows)-- def create_remote_collection(self, meta_data: Dict[str, Any]) -> None:- self._meta = dict(meta_data)- self._vector_dim = self._extract_vector_dim(self._meta)- self._field_types = self._build_field_type_map(self._meta)- if self._vector_dim <= 0:- raise ValueError("openGauss collection requires a positive dense vector dimension")-- columns = ["id TEXT PRIMARY KEY"]- seen = {"id"}- for field in meta_data.get("Fields", []) or []:- ddl = self._field_to_column_ddl(field)- field_name = field.get("FieldName")- if ddl and field_name not in seen:- columns.append(ddl)- seen.add(str(field_name))- for field_name, sql_type in self.INTERNAL_PATH_FIELDS.items():- if field_name not in seen:- columns.append(f"{_quote_ident(field_name)} {sql_type}")- seen.add(field_name)-- self._execute(f"CREATE TABLE IF NOT EXISTS {self._table_ref()} ({', '.join(columns)})")- self._save_collection_meta(meta_data)-- def _field_to_column_ddl(self, field: Dict[str, Any]) -> Optional[str]:- name = field.get("FieldName")- field_type = str(field.get("FieldType") or "").lower()- if not name or name == "id":- return None- if field_type == "vector":- dim = int(field.get("Dim") or self._vector_dim or 0)- if dim <= 0:- raise ValueError("openGauss vector field requires Dim")- return f"{_quote_ident(name)} vector({dim})"- if field_type == "sparse_vector":- return f"{_quote_ident(name)} TEXT"- return f"{_quote_ident(name)} {_FIELD_TYPE_SQL.get(field_type, 'TEXT')}"-- def _save_collection_meta(self, meta: Dict[str, Any]) -> None:- self._execute(- f"""- MERGE INTO {self._meta_table_ref(_COLLECTION_META_TABLE)} target- USING (- SELECT- %s AS table_name,- %s AS logical_collection_name,- %s AS project_name,- %s AS meta_json- ) source- ON (target.table_name = source.table_name)- WHEN MATCHED THEN UPDATE SET- logical_collection_name = source.logical_collection_name,- project_name = source.project_name,- meta_json = source.meta_json,- updated_at = CURRENT_TIMESTAMP- WHEN NOT MATCHED THEN INSERT- (table_name, logical_collection_name, project_name, meta_json, updated_at)- VALUES (- source.table_name,- source.logical_collection_name,- source.project_name,- source.meta_json,- CURRENT_TIMESTAMP- )- """,- [- self.collection_key,- self._logical_collection_name,- self._project_name,- _json_dumps(meta),- ],- )-- def _save_index_meta(self, index_name: str, meta: Dict[str, Any]) -> None:- self._execute(- f"""- MERGE INTO {self._meta_table_ref(_INDEX_META_TABLE)} target- USING (- SELECT- %s AS table_name,- %s AS index_name,- %s AS meta_json- ) source- ON (- target.table_name = source.table_name- AND target.index_name = source.index_name- )- WHEN MATCHED THEN UPDATE SET- meta_json = source.meta_json,- updated_at = CURRENT_TIMESTAMP- WHEN NOT MATCHED THEN INSERT- (table_name, index_name, meta_json, updated_at)- VALUES (- source.table_name,- source.index_name,- source.meta_json,- CURRENT_TIMESTAMP- )- """,- [self.collection_key, index_name, _json_dumps(meta)],- )-- def _delete_index_meta(self, index_name: str) -> None:- self._execute(- f"DELETE FROM {self._meta_table_ref(_INDEX_META_TABLE)} "- "WHERE table_name = %s AND index_name = %s",- [self.collection_key, index_name],- )-- def _all_columns(self) -> List[str]:- rows = self._execute(- """- SELECT column_name- FROM information_schema.columns- WHERE table_schema = %s AND table_name = %s- ORDER BY ordinal_position- """,- [self._schema_name, self._table_name],- fetch=True,- )- return [str(row[0]) for row in rows]-- def _table_ref(self) -> str:- return _qualify(self._schema_name, self._table_name)-- def _meta_table_ref(self, table_name: str) -> str:- return _qualify(self._schema_name, table_name)-- def _index_ref(self, index_name: str) -> str:- return _qualify(self._schema_name, index_name)-- def _function_table_name(self, table_name: str) -> str:- return f"{_quote_ident(self._schema_name)}.{_quote_ident(table_name)}"-- def _ensure_columns_for_record(self, record: Dict[str, Any]) -> None:- existing = set(self._all_columns())- for field_name in record:- if field_name in existing:- continue- if field_name == "id":- continue- if field_name == self._dense_vector_name:- sql_type = f"vector({self._vector_dim})"- elif field_name == self._sparse_vector_name:- sql_type = "TEXT"- elif field_name in self.INTERNAL_PATH_FIELDS:- sql_type = self.INTERNAL_PATH_FIELDS[field_name]- else:- field_type = self._field_types.get(field_name)- sql_type = _FIELD_TYPE_SQL.get(str(field_type or "").lower(), "TEXT")- self._field_types.setdefault(field_name, field_type or "string")- self._execute(- f"ALTER TABLE {self._table_ref()} ADD COLUMN {_quote_ident(field_name)} {sql_type}"- )- existing.add(field_name)-- def _select_columns(- self,- output_fields: Optional[List[str]],- *,- include_vector: bool = False,- include_sparse: bool = False,- ) -> List[str]:- columns = self._all_columns()- wanted = ["id"]- if output_fields:- for field in output_fields:- if field != "id" and field in columns and field not in wanted:- wanted.append(field)- else:- for field in columns:- if field == "id":- continue- if field == self._dense_vector_name and not include_vector:- continue- if field == self._sparse_vector_name and not include_sparse:- continue- wanted.append(field)- if (- include_vector- and self._dense_vector_name in columns- and self._dense_vector_name not in wanted- ):- wanted.append(self._dense_vector_name)- if (- include_sparse- and self._sparse_vector_name in columns- and self._sparse_vector_name not in wanted- ):- wanted.append(self._sparse_vector_name)- return wanted-- def _row_to_payload(- self, row: Sequence[Any], columns: Sequence[str]- ) -> Tuple[Any, Dict[str, Any]]:- record = dict(zip(columns, row, strict=False))- record_id = record.pop("id", "")- record.pop(self._dense_vector_name, None)- sparse = record.pop(self._sparse_vector_name, None)- if sparse is not None and self._sparse_vector_name in columns:- try:- record[self._sparse_vector_name] = json.loads(sparse)- except (TypeError, ValueError):- record[self._sparse_vector_name] = sparse- return record_id, record-- def _where_sql(self, filters: Optional[Dict[str, Any]]) -> Tuple[str, List[Any]]:- clause, params = self._compile_filter(filters or {})- return (f" WHERE {clause}", params) if clause else ("", [])-- def _compile_filter(self, payload: Any) -> Tuple[str, List[Any]]:- if not payload:- return "", []- if not isinstance(payload, dict):- return "", []- op = str(payload.get("op") or "").lower()- if not op:- clauses = []- params: List[Any] = []- for key, value in payload.items():- clauses.append(f"{_quote_ident(str(key))} = %s")- params.append(value)- return " AND ".join(clauses), params- if op == "and":- return self._join_filter_clauses("AND", payload.get("conds", []) or [])- if op == "or":- return self._join_filter_clauses("OR", payload.get("conds", []) or [])- if op == "must":- field = str(payload.get("field") or "")- values = list(payload.get("conds", []) or [])- if not field or not values:- return "", []- return self._match_sql(field, values, negate=False)- if op == "must_not":- field = str(payload.get("field") or "")- values = list(payload.get("conds", []) or [])- if not field or not values:- return "", []- return self._match_sql(field, values, negate=True)- if op in {"range", "time_range"}:- field = str(payload.get("field") or "")- clauses = []- params = []- for sql_op, key in ((">=", "gte"), (">", "gt"), ("<=", "lte"), ("<", "lt")):- if payload.get(key) is not None:- clauses.append(f"{_quote_ident(field)} {sql_op} %s")- params.append(_coerce_sql_value(payload[key], self._field_types.get(field)))- return " AND ".join(clauses), params- if op == "range_out":- field = str(payload.get("field") or "")- clauses = []- params = []- if payload.get("gte") is not None:- clauses.append(f"{_quote_ident(field)} < %s")- params.append(payload["gte"])- if payload.get("lte") is not None:- clauses.append(f"{_quote_ident(field)} > %s")- params.append(payload["lte"])- return " OR ".join(clauses), params- if op == "contains":- field = str(payload.get("field") or "")- return f"{_quote_ident(field)} LIKE %s", [f"%{payload.get('substring', '')}%"]- if op == "prefix":- field = str(payload.get("field") or "")- return f"{_quote_ident(field)} LIKE %s", [f"{payload.get('prefix', '')}%"]- logger.warning("openGauss vector backend ignoring unsupported filter op=%r", op)- return "", []-- def _join_filter_clauses(self, operator: str, conds: Iterable[Any]) -> Tuple[str, List[Any]]:- clauses = []- params: List[Any] = []- for cond in conds:- clause, cond_params = self._compile_filter(cond)- if clause:- clauses.append(f"({clause})")- params.extend(cond_params)- return f" {operator} ".join(clauses), params-- def _match_sql(self, field: str, values: List[Any], *, negate: bool) -> Tuple[str, List[Any]]:- if field == "scope_roots":- clauses = []- params = []- for value in values:- clauses.append(f"{_quote_ident(field)} LIKE %s")- params.append(f"%\n{str(value)}\n%")- joined = " OR ".join(clauses)- elif len(values) == 1:- joined = f"{_quote_ident(field)} = %s"- params = [values[0]]- else:- joined = f"{_quote_ident(field)} IN ({', '.join(['%s'] * len(values))})"- params = values- return (f"NOT ({joined})" if negate else joined), params-- # ------------------------------------------------------------------- # ICollection lifecycle- # ------------------------------------------------------------------- def update(self, fields: Optional[Dict[str, Any]] = None, description: Optional[str] = None):- meta = dict(self.get_meta_data() or {})- if fields is not None:- meta["Fields"] = fields- if description is not None:- meta["Description"] = description- self._meta = meta- self._field_types = self._build_field_type_map(meta)- self._save_collection_meta(meta)- return meta-- def get_meta_data(self):- rows = self._execute(- f"SELECT meta_json FROM {self._meta_table_ref(_COLLECTION_META_TABLE)} WHERE table_name = %s",- [self.collection_key],- fetch=True,- )- if not rows:- return {}- try:- return json.loads(rows[0][0])- except (TypeError, ValueError):- return {}-- def close(self):- return None-- def drop(self):- self._execute(f"DROP TABLE IF EXISTS {self._table_ref()}")- self._execute(- f"DELETE FROM {self._meta_table_ref(_INDEX_META_TABLE)} WHERE table_name = %s",- [self.collection_key],- )- self._execute(- f"DELETE FROM {self._meta_table_ref(_COLLECTION_META_TABLE)} WHERE table_name = %s",- [self.collection_key],- )-- def create_index(self, index_name: str, meta_data: Dict[str, Any]):- full_meta = dict(meta_data)- full_meta["IndexName"] = index_name- vector_meta = dict(full_meta.get("VectorIndex", {}) or {})- distance = _normalize_distance(vector_meta.get("Distance") or self._distance_metric)- vector_meta["IndexType"] = "hnsw"- full_meta["VectorIndex"] = vector_meta- self._create_vector_index(index_name, distance, full_meta)- for field_name in full_meta.get("ScalarIndex", []) or []:- self._create_scalar_index(index_name, str(field_name))- self._save_index_meta(index_name, full_meta)- return OpenGaussIndex(self, index_name, full_meta)-- def _create_vector_index(- self,- index_name: str,- distance: str,- meta: Dict[str, Any],- ) -> None:- if self._dense_vector_name not in self._all_columns():- return- ops_class = _VECTOR_OPS[distance]["hnsw"]- pg_index_name = _safe_identifier(self._table_name, index_name, "vec", prefix="idx")- try:- hnsw = meta.get("VectorIndex") or {}- m = int(hnsw.get("M") or hnsw.get("m") or 16)- ef = int(hnsw.get("EfConstruction") or hnsw.get("ef_construction") or 64)- self._execute(- f"""- CREATE INDEX IF NOT EXISTS {_quote_ident(pg_index_name)}- ON {self._table_ref()}- USING hnsw ({_quote_ident(self._dense_vector_name)} {ops_class})- WITH (m = {m}, ef_construction = {ef})- """- )- except Exception as exc:- raise RuntimeError(f"Failed to create openGauss vector index {pg_index_name}") from exc-- def _create_scalar_index(self, index_name: str, field_name: str) -> None:- if field_name not in self._all_columns():- return- pg_index_name = _safe_identifier(self._table_name, index_name, field_name, prefix="idx")- try:- self._execute(- f"""- CREATE INDEX IF NOT EXISTS {_quote_ident(pg_index_name)}- ON {self._table_ref()} ({_quote_ident(field_name)})- """- )- except Exception as exc:- logger.warning("Failed to create openGauss scalar index %s: %s", field_name, exc)-- def has_index(self, index_name: str) -> bool:- return index_name in self.list_indexes()-- def get_index(self, index_name: str) -> Optional[IIndex]:- meta = self.get_index_meta_data(index_name)- if not meta:- return None- return OpenGaussIndex(self, index_name, meta)-- def update_index(- self,- index_name: str,- scalar_index: Optional[Dict[str, Any]] = None,- description: Optional[str] = None,- ):- meta = self.get_index_meta_data(index_name) or {"IndexName": index_name}- if scalar_index is not None:- meta["ScalarIndex"] = (- list(scalar_index.keys()) if isinstance(scalar_index, dict) else list(scalar_index)- )- if description is not None:- meta["Description"] = description- for field_name in meta.get("ScalarIndex", []) or []:- self._create_scalar_index(index_name, str(field_name))- self._save_index_meta(index_name, meta)- return meta-- def get_index_meta_data(self, index_name: str):- rows = self._execute(- f"""- SELECT meta_json- FROM {self._meta_table_ref(_INDEX_META_TABLE)}- WHERE table_name = %s AND index_name = %s- """,- [self.collection_key, index_name],- fetch=True,- )- if not rows:- return None- try:- return json.loads(rows[0][0])- except (TypeError, ValueError):- return None-- def list_indexes(self):- rows = self._execute(- f"SELECT index_name FROM {self._meta_table_ref(_INDEX_META_TABLE)} "- "WHERE table_name = %s ORDER BY index_name",- [self.collection_key],- fetch=True,- )- return [str(row[0]) for row in rows]-- def drop_index(self, index_name: str):- meta = self.get_index_meta_data(index_name) or {}- pg_index_name = _safe_identifier(self._table_name, index_name, "vec", prefix="idx")- self._execute(f"DROP INDEX IF EXISTS {self._index_ref(pg_index_name)}")- for field_name in meta.get("ScalarIndex", []) or []:- scalar_index_name = _safe_identifier(- self._table_name, index_name, field_name, prefix="idx"- )- self._execute(f"DROP INDEX IF EXISTS {self._index_ref(scalar_index_name)}")- self._delete_index_meta(index_name)-- # ------------------------------------------------------------------- # Search- # ------------------------------------------------------------------- def search_by_vector(- self,- index_name: str,- dense_vector: Optional[List[float]] = None,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- sparse_vector: Optional[Dict[str, float]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- if limit <= 0:- return SearchResult()- if dense_vector is None and sparse_vector is None:- return SearchResult()- fetch_limit = max(limit + offset, limit)- if dense_vector is None:- return self._search_by_sparse(- sparse_vector, fetch_limit, offset, limit, filters, output_fields- )-- columns = self._select_columns(output_fields, include_sparse=bool(sparse_vector))- where_sql, params = self._where_sql(filters)- operator = _VECTOR_OPS[self._distance_metric]["operator"]- vector_text = _vector_literal(dense_vector)- sql = (- f"SELECT {', '.join(_quote_ident(col) for col in columns)}, "- f"{_quote_ident(self._dense_vector_name)} {operator} %s::vector AS _distance "- f"FROM {self._table_ref()}"- f"{where_sql} "- f"ORDER BY {_quote_ident(self._dense_vector_name)} {operator} %s::vector "- "LIMIT %s OFFSET %s"- )- rows = self._execute(- sql, [vector_text] + params + [vector_text, fetch_limit, 0], fetch=True- )- scored_items: List[SearchItemResult] = []- for row in rows:- record_id, payload = self._row_to_payload(row[:-1], columns)- distance = row[-1]- score = self._distance_to_score(distance, self._distance_metric)- if sparse_vector:- sparse_payload = payload.pop(self._sparse_vector_name, None)- if isinstance(sparse_payload, dict):- score += _sparse_dot(sparse_vector, sparse_payload)- scored_items.append(SearchItemResult(id=record_id, fields=payload, score=score))- if sparse_vector:- scored_items.sort(key=lambda item: item.score or 0.0, reverse=True)- return SearchResult(data=scored_items[offset : offset + limit])-- def _search_by_sparse(- self,- sparse_vector: Optional[Dict[str, float]],- fetch_limit: int,- offset: int,- limit: int,- filters: Optional[Dict[str, Any]],- output_fields: Optional[List[str]],- ) -> SearchResult:- if not sparse_vector:- return SearchResult()- columns = self._select_columns(output_fields, include_sparse=True)- where_sql, params = self._where_sql(filters)- sql = (- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "- f"FROM {self._table_ref()}{where_sql} LIMIT %s"- )- rows = self._execute(- sql, params + [max(fetch_limit, self.DEFAULT_SPARSE_SCAN_LIMIT)], fetch=True- )- items = []- for row in rows:- record_id, payload = self._row_to_payload(row, columns)- sparse_payload = payload.pop(self._sparse_vector_name, None)- score = _sparse_dot(- sparse_vector, sparse_payload if isinstance(sparse_payload, dict) else None- )- if score > 0:- items.append(SearchItemResult(id=record_id, fields=payload, score=score))- items.sort(key=lambda item: item.score or 0.0, reverse=True)- return SearchResult(data=items[offset : offset + limit])-- @staticmethod- def _distance_to_score(distance: Any, distance_metric: str = "cosine") -> float:- try:- value = float(distance)- except (TypeError, ValueError):- return 0.0- if not math.isfinite(value):- return 0.0- if distance_metric == "ip":- return -value- return 1.0 / (1.0 + max(value, 0.0))-- def search_by_keywords(- self,- index_name: str,- keywords: Optional[List[str]] = None,- query: Optional[str] = None,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- query_text = query or " ".join(keywords or [])- if not query_text.strip():- return SearchResult()- text_filter = {- "op": "or",- "conds": [- {"op": "contains", "field": field, "substring": query_text}- for field in ("name", "description", "abstract", "tags")- if field in self._all_columns()- ],- }- filters = {"op": "and", "conds": [filters, text_filter]} if filters else text_filter- return self.search_by_random(index_name, limit, offset, filters, output_fields)-- def search_by_id(- self,- index_name: str,- id: Any,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- columns = self._select_columns(output_fields, include_vector=True, include_sparse=True)- rows = self._execute(- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "- f"FROM {self._table_ref()} WHERE id = %s",- [str(id)],- fetch=True,- )- if not rows:- return SearchResult()- row_payload = dict(zip(columns, rows[0], strict=False))- dense_vector = row_payload.get(self._dense_vector_name)- sparse_raw = row_payload.get(self._sparse_vector_name)- sparse_vector = None- if sparse_raw:- try:- sparse_vector = json.loads(sparse_raw)- except (TypeError, ValueError):- sparse_vector = None- result = self.search_by_vector(- index_name=index_name,- dense_vector=self._parse_vector_value(dense_vector),- sparse_vector=sparse_vector,- limit=limit + offset + 1,- filters=filters,- output_fields=output_fields,- )- data = [item for item in result.data if str(item.id) != str(id)]- return SearchResult(data=data[offset : offset + limit])-- @staticmethod- def _parse_vector_value(value: Any) -> Optional[List[float]]:- if isinstance(value, list):- return [float(item) for item in value]- if not isinstance(value, str):- return None- stripped = value.strip().strip("[]")- if not stripped:- return None- return [float(item.strip()) for item in stripped.split(",")]-- def search_by_multimodal(- self,- index_name: str,- text: Optional[str],- image: Optional[Any],- video: Optional[Any],- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- raise NotImplementedError("OpenGaussCollection.search_by_multimodal is not supported")-- def search_by_random(- self,- index_name: str,- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- columns = self._select_columns(output_fields)- where_sql, params = self._where_sql(filters)- rows = self._execute(- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "- f"FROM {self._table_ref()}{where_sql} LIMIT %s OFFSET %s",- params + [limit, offset],- fetch=True,- )- return SearchResult(- data=[- SearchItemResult(id=record_id, fields=payload, score=1.0)- for record_id, payload in (self._row_to_payload(row, columns) for row in rows)- ]- )-- def search_by_scalar(- self,- index_name: str,- field: str,- order: Optional[str] = "desc",- limit: int = 10,- offset: int = 0,- filters: Optional[Dict[str, Any]] = None,- output_fields: Optional[List[str]] = None,- ) -> SearchResult:- columns = self._select_columns(output_fields)- if field not in columns:- columns.append(field)- where_sql, params = self._where_sql(filters)- direction = "DESC" if (order or "desc").lower() == "desc" else "ASC"- rows = self._execute(- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "- f"FROM {self._table_ref()}{where_sql} "- f"ORDER BY {_quote_ident(field)} {direction} NULLS LAST LIMIT %s OFFSET %s",- params + [limit, offset],- fetch=True,- )- items = []- for row in rows:- record_id, payload = self._row_to_payload(row, columns)- score = (- payload.pop(field, None)- if output_fields and field not in output_fields- else payload.get(field)- )- items.append(- SearchItemResult(- id=record_id,- fields=payload,- score=score if isinstance(score, (int, float)) else None,- )- )- return SearchResult(data=items)-- # ------------------------------------------------------------------- # Data operations- # ------------------------------------------------------------------- def upsert_data(self, data_list: List[Dict[str, Any]], ttl=0):- if not data_list:- return []- ids = []- for record in data_list:- record_id = record.get("id")- if record_id is None or record_id == "":- raise ValueError("openGauss vector record requires id")- self._ensure_columns_for_record(record)- columns = []- values = []- for column in self._all_columns():- if column not in record:- continue- columns.append(column)- if column == self._dense_vector_name:- values.append(_vector_literal(record[column]))- elif column == self._sparse_vector_name:- values.append(_json_dumps(record[column] or {}))- elif column == "scope_roots":- values.append(_encode_scope_roots(record[column]))- else:- values.append(_coerce_sql_value(record[column], self._field_types.get(column)))- if "id" not in columns:- columns.insert(0, "id")- values.insert(0, str(record_id))- self._upsert_row(columns, values)- ids.append(record_id)- return ids-- def _upsert_row(self, columns: List[str], values: List[Any]) -> None:- id_index = columns.index("id")- update_columns = [column for column in columns if column != "id"]- update_values = [- value for column, value in zip(columns, values, strict=False) if column != "id"- ]- set_parts = [- f"{_quote_ident(column)} = {'%s::vector' if column == self._dense_vector_name else '%s'}"- for column in update_columns- ]- insert_placeholders = [- "%s::vector" if column == self._dense_vector_name else "%s" for column in columns- ]-- with self._lock:- conn = self._ensure_connection()- cur = conn.cursor()- try:- if update_columns:- cur.execute(- f"UPDATE {self._table_ref()} SET {', '.join(set_parts)} WHERE id = %s",- update_values + [values[id_index]],- )- if not update_columns or cur.rowcount == 0:- try:- cur.execute(- f"INSERT INTO {self._table_ref()} "- f"({', '.join(_quote_ident(column) for column in columns)}) "- f"VALUES ({', '.join(insert_placeholders)})",- values,- )- except Exception as exc:- if getattr(exc, "pgcode", None) != "23505" or not update_columns:- raise- self._safe_rollback()- cur.close()- conn = self._ensure_connection()- cur = conn.cursor()- cur.execute(- f"UPDATE {self._table_ref()} SET {', '.join(set_parts)} WHERE id = %s",- update_values + [values[id_index]],- )- conn.commit()- except Exception:- self._safe_rollback()- raise- finally:- cur.close()-- def fetch_data(self, primary_keys: List[Any]):- if not primary_keys:- return FetchDataInCollectionResult()- columns = self._select_columns(None)- placeholders = ", ".join(["%s"] * len(primary_keys))- rows = self._execute(- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "- f"FROM {self._table_ref()} WHERE id IN ({placeholders})",- [str(pk) for pk in primary_keys],- fetch=True,- )- items = []- found_ids = set()- for row in rows:- record_id, payload = self._row_to_payload(row, columns)- found_ids.add(str(record_id))- items.append(DataItem(id=record_id, fields=payload))- return FetchDataInCollectionResult(- items=items,- ids_not_exist=[pk for pk in primary_keys if str(pk) not in found_ids],- )-- def delete_data(self, primary_keys: List[Any]):- if not primary_keys:- return None- placeholders = ", ".join(["%s"] * len(primary_keys))- self._execute(- f"DELETE FROM {self._table_ref()} WHERE id IN ({placeholders})",- [str(pk) for pk in primary_keys],- )- return None-- def delete_all_data(self):- self._execute(f"DELETE FROM {self._table_ref()}")-- def aggregate_data(- self,- index_name: str,- op: str = "count",- field: Optional[str] = None,- filters: Optional[Dict[str, Any]] = None,- cond: Optional[Dict[str, Any]] = None,- ) -> AggregateResult:- if op != "count":- return AggregateResult(agg={}, op=op, field=field)- where_sql, params = self._where_sql(filters)- if not field:- rows = self._execute(- f"SELECT COUNT(*) FROM {self._table_ref()}{where_sql}",- params,- fetch=True,- )- return AggregateResult(- agg={"_total": int(rows[0][0]) if rows else 0}, op=op, field=None- )- rows = self._execute(- f"SELECT {_quote_ident(field)}, COUNT(*) FROM {self._table_ref()}"- f"{where_sql} GROUP BY {_quote_ident(field)}",- params,- fetch=True,- )- grouped = {row[0]: int(row[1]) for row in rows if row[0] is not None}- if cond:- grouped = {- key: value- for key, value in grouped.items()- if (cond.get("gt") is None or value > cond["gt"])- and (cond.get("gte") is None or value >= cond["gte"])- and (cond.get("lt") is None or value < cond["lt"])- and (cond.get("lte") is None or value <= cond["lte"])- }- return AggregateResult(agg=grouped, op=op, field=field)---class OpenGaussCollectionAdapter(CollectionAdapter):- """CollectionAdapter backed by openGauss native vector tables."""-- mode = "opengauss"- INTERNAL_PATH_FIELDS = ["parent_uri", "scope_roots", "uri_depth"]-- def __init__(- self,- *,- host: str,- port: int,- user: str,- password: str,- db_name: str,- schema_name: str,- project_name: str,- collection_name: str,- index_name: str,- distance_metric: str,- dense_vector_name: str,- sparse_vector_name: str,- connect_timeout: int,- mode: str,- shard_count: int,- ) -> None:- super().__init__(collection_name=collection_name, index_name=index_name)- self._host = host- self._port = int(port)- self._user = user- self._password = password- self._db_name = db_name- self._schema_name = (schema_name or _DEFAULT_SCHEMA).strip() or _DEFAULT_SCHEMA- self._project_name = project_name- self._distance_metric = _normalize_distance(distance_metric)- self._dense_vector_name = dense_vector_name- self._sparse_vector_name = sparse_vector_name- self._connect_timeout = int(connect_timeout)- self._deployment_mode = mode- self._shard_count = int(shard_count)- self._conn = None- self._lock = threading.RLock()-- @classmethod- def from_config(cls, config: Any):- cfg = getattr(config, "opengauss", None)- params = dict(getattr(config, "custom_params", {}) or {})- if cfg is None:- raise ValueError("openGauss backend requires opengauss config")- return cls(- host=str(getattr(cfg, "host", None) or params.get("host") or "127.0.0.1"),- port=int(getattr(cfg, "port", None) or params.get("port") or 5432),- user=str(getattr(cfg, "user", None) or params.get("user") or "omm"),- password=str(getattr(cfg, "password", None) or params.get("password") or ""),- db_name=str(getattr(cfg, "db_name", None) or params.get("db_name") or "postgres"),- schema_name=str(- getattr(cfg, "schema_name", None)- or getattr(cfg, "schema", None)- or params.get("schema")- or _DEFAULT_SCHEMA- ),- project_name=config.project_name or "default",- collection_name=config.name or "context",- index_name=config.index_name or "default",- distance_metric=config.distance_metric or "cosine",- dense_vector_name=str(- getattr(cfg, "dense_vector_name", None)- or params.get("dense_vector_name")- or "vector"- ),- sparse_vector_name=str(- getattr(cfg, "sparse_vector_name", None)- or params.get("sparse_vector_name")- or "sparse_vector"- ),- connect_timeout=int(- getattr(cfg, "connect_timeout", None) or params.get("connect_timeout") or 10- ),- mode=str(getattr(cfg, "mode", None) or params.get("mode") or "standalone"),- shard_count=int(getattr(cfg, "shard_count", None) or params.get("shard_count") or 32),- )-- @property- def physical_table_name(self) -> str:- return _safe_identifier(self._project_name, self._collection_name, prefix="ov")-- def _connect(self):- if self._conn is not None and not getattr(self._conn, "closed", 0):- return self._conn- if self._conn is not None:- try:- self._conn.close()- except Exception:- logger.debug("Failed to close stale openGauss connection", exc_info=True)- psycopg2 = _import_psycopg2()- self._conn = psycopg2.connect(- host=self._host,- port=self._port,- user=self._user,- password=self._password,- dbname=self._db_name,- connect_timeout=self._connect_timeout,- )- self._ensure_meta_tables()- return self._conn-- def _ensure_meta_tables(self) -> None:- conn = self._conn- if conn is None:- return- cur = conn.cursor()- try:- cur.execute(f"CREATE SCHEMA IF NOT EXISTS {_quote_ident(self._schema_name)}")- cur.execute(- f"""- CREATE TABLE IF NOT EXISTS {_qualify(self._schema_name, _COLLECTION_META_TABLE)} (- table_name TEXT PRIMARY KEY,- logical_collection_name TEXT NOT NULL,- project_name TEXT NOT NULL,- meta_json TEXT NOT NULL,- updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP- )- """- )- cur.execute(- f"""- CREATE TABLE IF NOT EXISTS {_qualify(self._schema_name, _INDEX_META_TABLE)} (- table_name TEXT NOT NULL,- index_name TEXT NOT NULL,- meta_json TEXT NOT NULL,- updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,- PRIMARY KEY (table_name, index_name)- )- """- )- conn.commit()- except Exception:- conn.rollback()- raise- finally:- cur.close()- if self._deployment_mode == "distributed":- self._try_make_reference_table(_COLLECTION_META_TABLE)- self._try_make_reference_table(_INDEX_META_TABLE)-- def _try_make_reference_table(self, table_name: str) -> None:- conn = self._conn- if conn is None:- return- cur = conn.cursor()- try:- cur.execute(- "SELECT create_reference_table(%s)", [self._function_table_name(table_name)]- )- conn.commit()- except Exception as exc:- conn.rollback()- logger.warning(- "Failed to mark openGauss metadata table %s as reference table: %s",- self._function_table_name(table_name),- exc,- )- finally:- cur.close()-- def _new_collection(self, meta: Optional[Dict[str, Any]] = None) -> OpenGaussCollection:- return OpenGaussCollection(- conn=self._connect(),- schema_name=self._schema_name,- table_name=self.physical_table_name,- logical_collection_name=self._collection_name,- project_name=self._project_name,- dense_vector_name=self._dense_vector_name,- sparse_vector_name=self._sparse_vector_name,- distance_metric=self._distance_metric,- meta=meta,- lock=self._lock,- reconnect=self._connect,- )-- def _load_existing_collection_if_needed(self) -> None:- if self._collection is not None:- return- conn = self._connect()- raw_collection = self._new_collection()- if not raw_collection._table_exists():- return- meta = raw_collection.get_meta_data()- if not meta:- raise RuntimeError(- "openGauss collection table exists but OpenViking metadata is missing: "- f"{self.physical_table_name}. Use a different project/name, restore metadata, "- "or drop the stale table."- )- self._collection = Collection(- OpenGaussCollection(- conn=conn,- schema_name=self._schema_name,- table_name=self.physical_table_name,- logical_collection_name=self._collection_name,- project_name=self._project_name,- dense_vector_name=self._dense_vector_name,- sparse_vector_name=self._sparse_vector_name,- distance_metric=self._distance_metric,- meta=meta,- lock=self._lock,- reconnect=self._connect,- )- )-- def _create_backend_collection(self, meta: Dict[str, Any]) -> Collection:- raw_collection = self._new_collection(meta)- raw_collection.create_remote_collection(meta)- if self._deployment_mode == "distributed":- self._try_make_distributed_table(self.physical_table_name)- return Collection(raw_collection)-- def _try_make_distributed_table(self, table_name: str) -> None:- conn = self._conn- if conn is None:- return- cur = conn.cursor()- try:- cur.execute(- "SELECT create_distributed_table(%s, 'id', 'hash', %s)",- [self._function_table_name(table_name), self._shard_count],- )- conn.commit()- except Exception as exc:- conn.rollback()- logger.warning(- "Failed to distribute openGauss table %s with shard_count=%s: %s",- table_name,- self._shard_count,- exc,- )- finally:- cur.close()-- def close(self) -> None:- super().close()- if self._conn is not None:- self._conn.close()- self._conn = None-- def _sanitize_scalar_index_fields(- self,- scalar_index_fields: list[str],- fields_meta: list[dict[str, Any]],- ) -> list[str]:- del fields_meta- return list(dict.fromkeys(list(scalar_index_fields) + self.INTERNAL_PATH_FIELDS))-- def _build_default_index_meta(- self,- *,- index_name: str,- distance: str,- use_sparse: bool,- sparse_weight: float,- scalar_index_fields: list[str],- ) -> Dict[str, Any]:- index_meta = super()._build_default_index_meta(- index_name=index_name,- distance=distance,- use_sparse=use_sparse,- sparse_weight=sparse_weight,- scalar_index_fields=scalar_index_fields,- )- index_meta["VectorIndex"]["IndexType"] = "hnsw_hybrid" if use_sparse else "hnsw"- return index_meta-- @staticmethod- def _normalize_path(path: str) -> str:- stripped = (path or "").strip()- if not stripped:- return "/"- if not stripped.startswith("/"):- stripped = f"/{stripped}"- if len(stripped) > 1:- stripped = stripped.rstrip("/")- return stripped or "/"-- @classmethod- def _compute_parent_uri(cls, uri: str) -> str:- normalized = cls._normalize_path(uri)- if normalized == "/":- return "/"- parts = normalized.strip("/").split("/")- if len(parts) <= 1:- return "/"- return "/" + "/".join(parts[:-1])-- @classmethod- def _compute_scope_roots(cls, uri: str) -> List[str]:- normalized = cls._normalize_path(uri)- if normalized == "/":- return ["/"]- parts = normalized.strip("/").split("/")- roots = ["/"]- current_parts: List[str] = []- for part in parts[:-1]:- current_parts.append(part)- roots.append("/" + "/".join(current_parts))- return roots-- def _normalize_record_for_write(self, record: Dict[str, Any]) -> Dict[str, Any]:- normalized = dict(super()._normalize_record_for_write(record))- raw_uri = normalized.get("uri")- if isinstance(raw_uri, str):- normalized_uri = self._normalize_path(raw_uri)- normalized["uri"] = normalized_uri- normalized["parent_uri"] = self._compute_parent_uri(normalized_uri)- normalized["scope_roots"] = self._compute_scope_roots(normalized_uri)- normalized["uri_depth"] = len(- [part for part in normalized_uri.strip("/").split("/") if part]- )- return normalized-- def _normalize_record_for_read(self, record: Dict[str, Any]) -> Dict[str, Any]:- normalized = super()._normalize_record_for_read(record)- for field_name in self.INTERNAL_PATH_FIELDS:- normalized.pop(field_name, None)- return normalized-- def _coerce_datetime_value(self, value: Any) -> Any:- if isinstance(value, dt.datetime):- if value.tzinfo is None:- value = value.replace(tzinfo=dt.timezone.utc)- return value.isoformat()- return value-- def _compile_filter(self, expr: FilterExpr | Dict[str, Any] | None) -> Dict[str, Any]:- if expr is None:- return {}- if isinstance(expr, dict):- return self._normalize_filter_payload_for_write(expr)- if isinstance(expr, RawDSL):- return self._normalize_filter_payload_for_write(expr.payload)- if isinstance(expr, And):- conds = [self._compile_filter(cond) for cond in expr.conds if cond]- return {"op": "and", "conds": [cond for cond in conds if cond]}- if isinstance(expr, Or):- conds = [self._compile_filter(cond) for cond in expr.conds if cond]- return {"op": "or", "conds": [cond for cond in conds if cond]}- if isinstance(expr, Eq):- value = expr.value- if expr.field in self._URI_FIELD_NAMES:- value = self._normalize_path(self._encode_uri_field_value(value))- return {"op": "must", "field": expr.field, "conds": [value]}- if isinstance(expr, In):- values = list(expr.values)- if expr.field in self._URI_FIELD_NAMES:- values = [- self._normalize_path(self._encode_uri_field_value(value)) for value in values- ]- return {"op": "must", "field": expr.field, "conds": values}- if isinstance(expr, Range):- payload: Dict[str, Any] = {"op": "range", "field": expr.field}- for key in ("gte", "gt", "lte", "lt"):- value = getattr(expr, key)- if value is not None:- payload[key] = value- return payload- if isinstance(expr, TimeRange):- payload: Dict[str, Any] = {"op": "range", "field": expr.field}- if expr.start is not None:- payload["gte"] = self._coerce_datetime_value(expr.start)- if expr.end is not None:- payload["lt"] = self._coerce_datetime_value(expr.end)- return payload- if isinstance(expr, Contains):- return {"op": "contains", "field": expr.field, "substring": expr.substring}- if isinstance(expr, PathScope):- encoded_path = (- self._normalize_path(self._encode_uri_field_value(expr.path))- if expr.field in self._URI_FIELD_NAMES- else expr.path- )- if expr.depth == 0:- return {"op": "must", "field": expr.field, "conds": [encoded_path]}- if expr.depth == 1:- return {"op": "must", "field": "parent_uri", "conds": [encoded_path]}- if expr.depth == -1:- return {"op": "must", "field": "scope_roots", "conds": [encoded_path]}- raise ValueError(- f"OpenGauss adapter only supports PathScope depth 0/1/-1, got {expr.depth}"- )- raise TypeError(f"Unsupported filter expr type: {type(expr)!r}")diff --git a/openviking/storage/vectordb_adapters/qdrant_adapter.py b/openviking/storage/vectordb_adapters/qdrant_adapter.pydeleted file mode 100644index 743d7f06f..000000000--- a/openviking/storage/vectordb_adapters/qdrant_adapter.py+++ /dev/null@@ -1,396 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0-"""Qdrant backend collection adapter."""--from __future__ import annotations--from datetime import datetime, timezone-from typing import Any, Dict, List--from openviking.storage.expr import (- And,- Contains,- Eq,- FilterExpr,- In,- Or,- PathScope,- Range,- RawDSL,- TimeRange,-)-from openviking.storage.vectordb.collection.collection import Collection-from openviking.storage.vectordb.collection.qdrant_collection import QdrantCollection--from .base import CollectionAdapter---class QdrantCollectionAdapter(CollectionAdapter):- """Adapter for Qdrant-backed vector collections."""-- INTERNAL_PATH_FIELDS = ["parent_uri", "scope_roots", "uri_depth"]- DEFAULT_TEXT_INDEX_FIELDS = ["name", "description", "abstract", "tags"]-- def __init__(- self,- *,- url: str,- api_key: str | None,- timeout_seconds: int,- project_name: str,- collection_name: str,- index_name: str,- distance_metric: str,- dense_vector_name: str,- sparse_vector_name: str,- meta_collection_name: str,- enable_text_index: bool,- ) -> None:- super().__init__(collection_name=collection_name, index_name=index_name)- self.mode = "qdrant"- self._url = url- self._api_key = api_key- self._timeout_seconds = timeout_seconds- self._project_name = project_name- self._distance_metric = distance_metric- self._dense_vector_name = dense_vector_name- self._sparse_vector_name = sparse_vector_name- self._meta_collection_name = meta_collection_name- self._enable_text_index = enable_text_index-- @classmethod- def from_config(cls, config: Any):- cfg = getattr(config, "qdrant", None)- params = dict(getattr(config, "custom_params", {}) or {})- url = getattr(cfg, "url", None) or getattr(config, "url", None) or params.get("url")- if not url:- raise ValueError("Qdrant backend requires qdrant.url or url")- return cls(- url=str(url).strip().rstrip("/"),- api_key=getattr(cfg, "api_key", None) or params.get("api_key"),- timeout_seconds=int(- getattr(cfg, "timeout_seconds", None) or params.get("timeout_seconds") or 10- ),- project_name=config.project_name or "default",- collection_name=config.name or "context",- index_name=config.index_name or "default",- distance_metric=config.distance_metric or "cosine",- dense_vector_name=getattr(cfg, "dense_vector_name", "vector"),- sparse_vector_name=getattr(cfg, "sparse_vector_name", "sparse_vector"),- meta_collection_name=getattr(cfg, "meta_collection_name", "__openviking_meta"),- enable_text_index=bool(getattr(cfg, "enable_text_index", True)),- )-- @property- def physical_collection_name(self) -> str:- return f"{self._project_name}__{self._collection_name}"-- def _new_qdrant_collection(self) -> QdrantCollection:- return QdrantCollection(- url=self._url,- api_key=self._api_key,- timeout_seconds=self._timeout_seconds,- project_name=self._project_name,- logical_collection_name=self._collection_name,- physical_collection_name=self.physical_collection_name,- dense_vector_name=self._dense_vector_name,- sparse_vector_name=self._sparse_vector_name,- meta_collection_name=self._meta_collection_name,- distance_metric=self._distance_metric,- enable_text_index=self._enable_text_index,- )-- def _load_existing_collection_if_needed(self) -> None:- if self._collection is not None:- return- candidate = self._new_qdrant_collection()- try:- if not candidate.collection_exists():- return- if not candidate.has_openviking_metadata():- raise RuntimeError(- "Qdrant collection exists but OpenViking metadata is missing: "- f"{self.physical_collection_name}. "- "Use a different project/name, restore metadata, or drop the stale Qdrant collection."- )- self._collection = Collection(candidate)- candidate = None- finally:- if candidate is not None:- candidate.close()-- def _create_backend_collection(self, meta: Dict[str, Any]) -> Collection:- raw_collection = self._new_qdrant_collection()- raw_collection.create_remote_collection(meta)- return Collection(raw_collection)-- def _sanitize_scalar_index_fields(- self,- scalar_index_fields: list[str],- fields_meta: list[dict[str, Any]],- ) -> list[str]:- text_fields = self.DEFAULT_TEXT_INDEX_FIELDS if self._enable_text_index else []- merged = list(- dict.fromkeys(list(scalar_index_fields) + self.INTERNAL_PATH_FIELDS + text_fields)- )- return merged-- def _build_default_index_meta(- self,- *,- index_name: str,- distance: str,- use_sparse: bool,- sparse_weight: float,- scalar_index_fields: list[str],- ) -> Dict[str, Any]:- index_type = "hnsw_hybrid" if use_sparse else "hnsw"- index_meta: Dict[str, Any] = {- "IndexName": index_name,- "VectorIndex": {- "IndexType": index_type,- "Distance": distance,- "Quant": "int8",- },- "ScalarIndex": scalar_index_fields,- }- if use_sparse:- index_meta["VectorIndex"]["EnableSparse"] = True- index_meta["VectorIndex"]["SearchWithSparseLogitAlpha"] = sparse_weight- return index_meta-- @staticmethod- def _normalize_path(path: str) -> str:- stripped = (path or "").strip()- if not stripped:- return "/"- if not stripped.startswith("/"):- stripped = f"/{stripped}"- if len(stripped) > 1:- stripped = stripped.rstrip("/")- return stripped or "/"-- @classmethod- def _compute_parent_uri(cls, uri: str) -> str:- normalized = cls._normalize_path(uri)- if normalized == "/":- return "/"- parts = normalized.strip("/").split("/")- if len(parts) <= 1:- return "/"- return "/" + "/".join(parts[:-1])-- @classmethod- def _compute_scope_roots(cls, uri: str) -> List[str]:- normalized = cls._normalize_path(uri)- if normalized == "/":- return ["/"]- parts = normalized.strip("/").split("/")- roots = ["/"]- current_parts: List[str] = []- for part in parts[:-1]:- current_parts.append(part)- roots.append("/" + "/".join(current_parts))- return roots-- def _normalize_record_for_write(self, record: Dict[str, Any]) -> Dict[str, Any]:- normalized = dict(super()._normalize_record_for_write(record))- raw_uri = normalized.get("uri")- if isinstance(raw_uri, str):- normalized_uri = self._normalize_path(raw_uri)- normalized["uri"] = normalized_uri- normalized["parent_uri"] = self._compute_parent_uri(normalized_uri)- normalized["scope_roots"] = self._compute_scope_roots(normalized_uri)- normalized["uri_depth"] = len(- [part for part in normalized_uri.strip("/").split("/") if part]- )- return normalized-- def _normalize_record_for_read(self, record: Dict[str, Any]) -> Dict[str, Any]:- normalized = super()._normalize_record_for_read(record)- for field_name in self.INTERNAL_PATH_FIELDS:- normalized.pop(field_name, None)- return normalized-- def _coerce_datetime_value(self, value: Any) -> Any:- if isinstance(value, datetime):- if value.tzinfo is None:- value = value.replace(tzinfo=timezone.utc)- return value.isoformat()- return value-- def _must_clause(self, *conds: Dict[str, Any]) -> Dict[str, Any]:- items = [cond for cond in conds if cond]- if not items:- return {}- if len(items) == 1 and set(items[0].keys()) in ({"must"}, {"should"}, {"must_not"}):- return items[0]- flattened: List[Dict[str, Any]] = []- for item in items:- if set(item.keys()) == {"must"}:- flattened.extend(item.get("must", []))- else:- flattened.append(item)- return {"must": flattened}-- def _should_clause(self, *conds: Dict[str, Any]) -> Dict[str, Any]:- items = [cond for cond in conds if cond]- if not items:- return {}- flattened: List[Dict[str, Any]] = []- for item in items:- if set(item.keys()) == {"should"}:- flattened.extend(item.get("should", []))- else:- flattened.append(item)- return {"should": flattened}-- @staticmethod- def _match_condition(field: str, value: Any) -> Dict[str, Any]:- return {"key": field, "match": {"value": value}}-- @staticmethod- def _match_any_condition(field: str, values: List[Any]) -> Dict[str, Any]:- return {"key": field, "match": {"any": values}}-- @staticmethod- def _range_condition(field: str, payload: Dict[str, Any]) -> Dict[str, Any]:- return {"key": field, "range": payload}-- @staticmethod- def _text_condition(field: str, text: str) -> Dict[str, Any]:- return {"key": field, "match": {"text": text}}-- def _compile_legacy_dict_filter(self, payload: Dict[str, Any]) -> Dict[str, Any]:- op = str(payload.get("op") or "").lower()- if not op:- return self._normalize_filter_payload_for_write(payload)-- if op == "and":- return self._must_clause(- *(- self._compile_legacy_dict_filter(cond)- for cond in payload.get("conds", [])- if cond- )- )- if op == "or":- return self._should_clause(- *(- self._compile_legacy_dict_filter(cond)- for cond in payload.get("conds", [])- if cond- )- )- if op == "must":- field = payload.get("field")- values = payload.get("conds", []) or []- if field in self._URI_FIELD_NAMES:- values = [- self._normalize_path(self._encode_uri_field_value(value)) for value in values- ]- if len(values) <= 1:- value = values[0] if values else None- return {"must": [self._match_condition(field, value)]} if value is not None else {}- return {"must": [self._match_any_condition(field, list(values))]}- if op == "must_not":- field = payload.get("field")- values = payload.get("conds", []) or []- if field in self._URI_FIELD_NAMES:- values = [- self._normalize_path(self._encode_uri_field_value(value)) for value in values- ]- condition = (- self._match_any_condition(field, list(values))- if len(values) > 1- else self._match_condition(field, values[0] if values else None)- )- return {"must_not": [condition]} if condition else {}- if op in {"range", "time_range"}:- range_payload: Dict[str, Any] = {}- for key in ("gte", "gt", "lte", "lt"):- if payload.get(key) is not None:- range_payload[key] = self._coerce_datetime_value(payload[key])- return {"must": [self._range_condition(payload.get("field"), range_payload)]}- if op == "range_out":- field = payload.get("field")- branches: List[Dict[str, Any]] = []- if payload.get("gte") is not None:- branches.append({"must": [self._range_condition(field, {"lt": payload["gte"]})]})- if payload.get("lte") is not None:- branches.append({"must": [self._range_condition(field, {"gt": payload["lte"]})]})- return self._should_clause(*branches)- if op == "contains":- return {- "must": [self._text_condition(payload.get("field"), payload.get("substring", ""))]- }- if op == "prefix":- field = payload.get("field")- prefix = payload.get("prefix", "")- if field in self._URI_FIELD_NAMES:- return self._compile_filter(PathScope(field, prefix, depth=-1))- return {"must": [self._text_condition(field, prefix)]}- return self._normalize_filter_payload_for_write(payload)-- def _compile_filter(self, expr: FilterExpr | Dict[str, Any] | None) -> Dict[str, Any]:- if expr is None:- return {}- if isinstance(expr, dict):- if "op" in expr:- return self._compile_legacy_dict_filter(expr)- return self._normalize_filter_payload_for_write(expr)- if isinstance(expr, RawDSL):- payload = expr.payload- if isinstance(payload, dict) and "op" in payload:- return self._compile_legacy_dict_filter(payload)- return self._normalize_filter_payload_for_write(payload)- if isinstance(expr, And):- return self._must_clause(*(self._compile_filter(cond) for cond in expr.conds if cond))- if isinstance(expr, Or):- return self._should_clause(*(self._compile_filter(cond) for cond in expr.conds if cond))- if isinstance(expr, Eq):- value = expr.value- if expr.field in self._URI_FIELD_NAMES:- value = self._normalize_path(self._encode_uri_field_value(value))- return {"must": [self._match_condition(expr.field, value)]}- if isinstance(expr, In):- values = list(expr.values)- if expr.field in self._URI_FIELD_NAMES:- values = [- self._normalize_path(self._encode_uri_field_value(value)) for value in values- ]- if len(values) == 1:- return {"must": [self._match_condition(expr.field, values[0])]}- return {"must": [self._match_any_condition(expr.field, values)]}- if isinstance(expr, Range):- numeric_range_payload: Dict[str, Any] = {}- for key in ("gte", "gt", "lte", "lt"):- value = getattr(expr, key)- if value is not None:- numeric_range_payload[key] = value- return {"must": [self._range_condition(expr.field, numeric_range_payload)]}- if isinstance(expr, TimeRange):- time_range_payload: Dict[str, Any] = {}- if expr.start is not None:- time_range_payload["gte"] = self._coerce_datetime_value(expr.start)- if expr.end is not None:- time_range_payload["lt"] = self._coerce_datetime_value(expr.end)- return {"must": [self._range_condition(expr.field, time_range_payload)]}- if isinstance(expr, Contains):- return {"must": [self._text_condition(expr.field, expr.substring)]}- if isinstance(expr, PathScope):- encoded_path = (- self._normalize_path(self._encode_uri_field_value(expr.path))- if expr.field in self._URI_FIELD_NAMES- else expr.path- )- if expr.depth == 0:- return {"must": [self._match_condition(expr.field, encoded_path)]}- if expr.depth == 1:- return {"must": [self._match_condition("parent_uri", encoded_path)]}- if expr.depth == -1:- return {"must": [self._match_condition("scope_roots", encoded_path)]}- raise ValueError(- f"Qdrant adapter only supports PathScope depth 0/1/-1, got {expr.depth}"- )- raise TypeError(f"Unsupported filter expr type: {type(expr)!r}")diff --git a/openviking_cli/utils/config/vectordb_config.py b/openviking_cli/utils/config/vectordb_config.pyindex ef8593e04..bccc25cde 100644--- a/openviking_cli/utils/config/vectordb_config.py+++ b/openviking_cli/utils/config/vectordb_config.py@@ -50,32 +50,6 @@ class VikingDBConfig(BaseModel):model_config = {"extra": "forbid"}-class QdrantConfig(BaseModel):- """Configuration for Qdrant backend."""-- url: Optional[str] = Field(default=None, description="Qdrant service URL")- api_key: Optional[str] = Field(default=None, description="Optional Qdrant API key")- timeout_seconds: int = Field(default=10, description="HTTP timeout for Qdrant requests")- dense_vector_name: str = Field(- default="vector",- description="Named dense vector field in Qdrant collection.",- )- sparse_vector_name: str = Field(- default="sparse_vector",- description="Named sparse vector field in Qdrant collection.",- )- meta_collection_name: str = Field(- default="__openviking_meta",- description="Sidecar collection name for OpenViking metadata in Qdrant.",- )- enable_text_index: bool = Field(- default=True,- description="Whether to create text payload indexes for supported text fields.",- )-- model_config = {"extra": "forbid"}--class CuVSConfig(BaseModel):"""Configuration for GPU dense-vector search through NVIDIA cuVS."""@@ -214,56 +188,6 @@ class CuVSConfig(BaseModel):return self-_OPENGAUSS_MODES = {"standalone", "distributed"}---class OpenGaussConfig(BaseModel):- """Configuration for openGauss native vector backend."""-- host: Optional[str] = Field(- default="127.0.0.1",- description="openGauss host address. Use the CN address when mode=distributed.",- )- port: int = Field(default=5432, description="openGauss port")- user: str = Field(default="omm", description="Database user")- password: str = Field(default="", description="Database password")- db_name: str = Field(default="postgres", description="Database name")- schema_name: str = Field(- default="public",- alias="schema",- description="Database schema for OpenViking tables",- )- mode: str = Field(- default="standalone",- description="openGauss deployment mode: 'standalone' or 'distributed'",- )- shard_count: int = Field(- default=32,- description="Shard count for create_distributed_table when mode=distributed",- )- connect_timeout: int = Field(default=10, description="Database connection timeout in seconds")- dense_vector_name: str = Field(default="vector", description="Dense vector column name")- sparse_vector_name: str = Field(- default="sparse_vector", description="Sparse vector JSON column name"- )-- model_config = {"extra": "forbid", "populate_by_name": True}-- @model_validator(mode="after")- def validate_mode(self):- self.schema_name = (self.schema_name or "public").strip()- if not self.schema_name:- raise ValueError("openGauss schema must not be empty")- self.mode = (self.mode or "standalone").strip().lower()- if self.mode not in _OPENGAUSS_MODES:- raise ValueError(- f"Invalid openGauss mode: '{self.mode}'. Must be one of: {sorted(_OPENGAUSS_MODES)}"- )- self.dense_vector_name = (self.dense_vector_name or "vector").strip()- self.sparse_vector_name = (self.sparse_vector_name or "sparse_vector").strip()- return self--class VectorDBBackendConfig(BaseModel):"""Configuration for VectorDB backend.@@ -277,7 +201,7 @@ class VectorDBBackendConfig(BaseModel):description=("VectorDB backend type: 'local', 'cuvs', 'http', ""'volcengine' (AK/SK signed or API key data-plane only), "- "'vikingdb' (private deployment), 'qdrant', or 'opengauss'"+ "or 'vikingdb' (private deployment)"),)@@ -331,21 +255,11 @@ class VectorDBBackendConfig(BaseModel):description="VikingDB private deployment configuration for 'vikingdb' type",)- qdrant: Optional[QdrantConfig] = Field(- default_factory=QdrantConfig,- description="Qdrant configuration for 'qdrant' type",- )-cuvs: Optional[CuVSConfig] = Field(default_factory=CuVSConfig,description="NVIDIA cuVS dense-vector search configuration for the 'cuvs' backend",)- opengauss: Optional[OpenGaussConfig] = Field(- default_factory=OpenGaussConfig,- description="openGauss configuration for 'opengauss' type",- )-custom_params: Dict[str, Any] = Field(default_factory=dict,description="Custom parameters for custom backend adapters",@@ -362,8 +276,6 @@ class VectorDBBackendConfig(BaseModel):"http","volcengine","vikingdb",- "qdrant",- "opengauss",]# Allow custom backend classes (containing dot) without standard validation@@ -413,25 +325,4 @@ class VectorDBBackendConfig(BaseModel):if not self.vikingdb or not self.vikingdb.host:raise ValueError("VectorDB vikingdb backend requires 'host' to be set")- elif self.backend == "qdrant":- qdrant_url = (- (self.qdrant.url if self.qdrant else None)- or self.url- or self.custom_params.get("url")- )- if not qdrant_url:- raise ValueError("VectorDB qdrant backend requires 'qdrant.url' or 'url' to be set")- if self.qdrant is None:- self.qdrant = QdrantConfig()- self.qdrant.url = str(qdrant_url).strip().rstrip("/")- if self.url:- self.url = self.url.strip().rstrip("/")-- elif self.backend == "opengauss":- if self.opengauss is None:- self.opengauss = OpenGaussConfig()- if not self.opengauss.host:- raise ValueError("VectorDB opengauss backend requires 'opengauss.host' to be set")- self.opengauss.host = self.opengauss.host.strip()-return selfdiff --git a/pyproject.toml b/pyproject.tomlindex cf42fcb27..defbab250 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -110,9 +110,6 @@ auth = ["httpx>=0.25.0","python-ldap>=3.4.0",]-opengauss = [- "psycopg2-binary>=2.9",-]dev = ["mypy>=1.0.0","ruff>=0.1.0",diff --git a/tests/integration/conftest.py b/tests/integration/conftest.pyindex 8f98d3d92..87572a28d 100644--- a/tests/integration/conftest.py+++ b/tests/integration/conftest.py@@ -14,7 +14,6 @@ import shutilimport socketimport threadingimport time-from functools import lru_cachefrom pathlib import Pathimport httpx@@ -51,40 +50,6 @@ requires_volcengine_kms = pytest.mark.skipif(reason="VOLCENGINE_ACCESS_KEY, VOLCENGINE_SECRET_KEY, or VOLCENGINE_KMS_KEY_ID not set",)-# ── Qdrant integration test helpers ─────────────────────────────────────────-QDRANT_URL = os.environ.get("QDRANT_URL", "http://127.0.0.1:6333").rstrip("/")-QDRANT_API_KEY = os.environ.get("QDRANT_API_KEY", "")---@lru_cache(maxsize=1)-def _qdrant_available() -> bool:- try:- headers = {"api-key": QDRANT_API_KEY} if QDRANT_API_KEY else None- response = httpx.get(- f"{QDRANT_URL}/collections",- headers=headers,- timeout=2.0,- )- return response.status_code == 200- except Exception:- return False---requires_qdrant = pytest.mark.qdrant---def pytest_configure(config):- config.addinivalue_line("markers", "qdrant: requires a reachable Qdrant instance")--[email protected](autouse=True)-def _skip_when_qdrant_unavailable(request):- if request.node.get_closest_marker("qdrant") is None:- return- if not _qdrant_available():- pytest.skip(f"Qdrant not available at {QDRANT_URL}")--# (model_name, default_dimension, token_limit)GEMINI_MODELS = [("gemini-embedding-2-preview", 3072, 8192),diff --git a/tests/integration/test_qdrant_integration.py b/tests/integration/test_qdrant_integration.pydeleted file mode 100644index 8a23836f3..000000000--- a/tests/integration/test_qdrant_integration.py+++ /dev/null@@ -1,342 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0-"""Integration tests for the Qdrant vectordb adapter.--Usage:-- QDRANT_URL=http://127.0.0.1:6333 pytest tests/integration/test_qdrant_integration.py -v -s-"""--from __future__ import annotations--import uuid--import pytest--from openviking.storage.expr import Contains, Eq, PathScope-from openviking.storage.vectordb_adapters.factory import create_collection_adapter-from openviking_cli.utils.config.vectordb_config import VectorDBBackendConfig-from tests.integration.conftest import QDRANT_API_KEY, QDRANT_URL, requires_qdrant--pytestmark = [pytest.mark.integration, requires_qdrant]---def _build_qdrant_config(collection_name: str) -> VectorDBBackendConfig:- return VectorDBBackendConfig.model_validate(- {- "backend": "qdrant",- "project": "it",- "name": collection_name,- "index_name": "default",- "distance_metric": "cosine",- "qdrant": {- "url": QDRANT_URL,- "api_key": QDRANT_API_KEY or None,- "timeout_seconds": 10,- "dense_vector_name": "vector",- "sparse_vector_name": "sparse_vector",- "meta_collection_name": "__openviking_meta",- "enable_text_index": True,- },- }- )---def _build_schema(collection_name: str) -> dict:- return {- "CollectionName": collection_name,- "Description": "Qdrant integration test collection",- "Fields": [- {"FieldName": "id", "FieldType": "string", "IsPrimaryKey": True},- {"FieldName": "uri", "FieldType": "path"},- {"FieldName": "vector", "FieldType": "vector", "Dim": 4},- {"FieldName": "sparse_vector", "FieldType": "sparse_vector"},- {"FieldName": "created_at", "FieldType": "date_time"},- {"FieldName": "updated_at", "FieldType": "date_time"},- {"FieldName": "active_count", "FieldType": "int64"},- {"FieldName": "level", "FieldType": "int64"},- {"FieldName": "abstract", "FieldType": "string"},- {"FieldName": "account_id", "FieldType": "string"},- ],- "ScalarIndex": [- "uri",- "updated_at",- "active_count",- "level",- "account_id",- "abstract",- ],- }---def qdrant_adapter():- collection_name = f"qdrant_it_{uuid.uuid4().hex[:8]}"- adapter = create_collection_adapter(_build_qdrant_config(collection_name))- try:- yield adapter, collection_name- finally:- try:- if adapter.collection_exists():- adapter.drop_collection()- finally:- adapter.close()---def test_qdrant_adapter_end_to_end(qdrant_adapter):- adapter, collection_name = qdrant_adapter- schema = _build_schema(collection_name)-- created = adapter.create_collection(- collection_name,- schema,- distance="cosine",- sparse_weight=0.0,- index_name="default",- )- assert created is True- assert adapter.physical_collection_name == f"it__{collection_name}"- assert adapter.get_collection().list_indexes() == ["default"]-- records = [- {- "id": "doc_1",- "uri": "viking://resources/acme/docs/a.md",- "vector": [1.0, 0.0, 0.0, 0.0],- "created_at": "2026-05-29T12:00:00Z",- "updated_at": "2026-05-29T12:00:00Z",- "active_count": 5,- "level": 2,- "abstract": "alpha quarterly report",- "account_id": "acme",- },- {- "id": "doc_2",- "uri": "viking://resources/acme/docs/b.md",- "vector": [0.9, 0.1, 0.0, 0.0],- "created_at": "2026-05-29T12:01:00Z",- "updated_at": "2026-05-29T12:01:00Z",- "active_count": 3,- "level": 2,- "abstract": "beta design note",- "account_id": "acme",- },- {- "id": "doc_3",- "uri": "viking://resources/beta/notes/c.md",- "vector": [0.0, 1.0, 0.0, 0.0],- "created_at": "2026-05-29T12:02:00Z",- "updated_at": "2026-05-29T12:02:00Z",- "active_count": 1,- "level": 2,- "abstract": "gamma meeting note",- "account_id": "beta",- },- ]-- ids = adapter.upsert(records)- assert len(ids) == 3-- fetched = adapter.get(ids[:2])- assert len(fetched) == 2- assert fetched[0]["uri"].startswith("viking://resources/")- assert "parent_uri" not in fetched[0]- assert "scope_roots" not in fetched[0]-- assert adapter.count() == 3- assert adapter.count(Eq("account_id", "acme")) == 2- assert adapter.count({"op": "must", "field": "account_id", "conds": ["beta"]}) == 1-- vector_hits = adapter.query(- query_vector=[1.0, 0.0, 0.0, 0.0],- filter=Eq("account_id", "acme"),- limit=2,- output_fields=["uri", "account_id", "active_count"],- )- assert len(vector_hits) >= 1- assert all(item["account_id"] == "acme" for item in vector_hits)- assert vector_hits[0]["uri"] == "viking://resources/acme/docs/a.md"-- id_hits = adapter.get_collection().search_by_id(- index_name="default",- id="doc_1",- limit=2,- output_fields=["uri", "account_id"],- )- assert id_hits.data[0].id == "doc_2"- assert id_hits.data[0].fields["uri"] == "viking://resources/acme/docs/b.md"-- path_hits = adapter.query(- filter=PathScope("uri", "viking://resources/acme/docs", depth=-1),- limit=10,- output_fields=["uri", "account_id"],- )- assert len(path_hits) == 2- assert {item["uri"] for item in path_hits} == {- "viking://resources/acme/docs/a.md",- "viking://resources/acme/docs/b.md",- }-- parent_hits = adapter.query(- filter=PathScope("uri", "viking://resources/acme/docs", depth=1),- limit=10,- output_fields=["uri"],- )- assert len(parent_hits) == 2-- ordered = adapter.query(- filter=Eq("account_id", "acme"),- limit=10,- order_by="active_count",- order_desc=True,- output_fields=["uri", "active_count"],- )- assert [item["active_count"] for item in ordered][:2] == [5, 3]-- meta = adapter.get_collection_info()- assert meta["CollectionName"] == collection_name- assert meta["Description"] == "Qdrant integration test collection"- assert len(meta["Fields"]) == 10-- deleted = adapter.delete(filter=Eq("account_id", "beta"))- assert deleted == 1- assert adapter.count() == 2---def test_qdrant_hybrid_dense_sparse_query(qdrant_adapter):- adapter, collection_name = qdrant_adapter- schema = _build_schema(collection_name)-- created = adapter.create_collection(- collection_name,- schema,- distance="cosine",- sparse_weight=0.5,- index_name="default",- )- assert created is True-- records = [- {- "id": str(uuid.uuid4()),- "uri": "viking://resources/acme/hybrid/doc1.md",- "vector": [1.0, 0.0, 0.0, 0.0],- "sparse_vector": {"alpha": 1.0, "beta": 0.5},- "created_at": "2026-05-29T12:10:00Z",- "updated_at": "2026-05-29T12:10:00Z",- "active_count": 10,- "level": 2,- "abstract": "alpha beta anchor",- "account_id": "acme",- },- {- "id": str(uuid.uuid4()),- "uri": "viking://resources/acme/hybrid/doc2.md",- "vector": [0.98, 0.02, 0.0, 0.0],- "sparse_vector": {"gamma": 1.0},- "created_at": "2026-05-29T12:11:00Z",- "updated_at": "2026-05-29T12:11:00Z",- "active_count": 8,- "level": 2,- "abstract": "dense only neighbor",- "account_id": "acme",- },- {- "id": str(uuid.uuid4()),- "uri": "viking://resources/acme/hybrid/doc3.md",- "vector": [0.0, 1.0, 0.0, 0.0],- "sparse_vector": {"alpha": 1.0},- "created_at": "2026-05-29T12:12:00Z",- "updated_at": "2026-05-29T12:12:00Z",- "active_count": 6,- "level": 2,- "abstract": "sparse only booster",- "account_id": "acme",- },- ]- adapter.upsert(records)-- dense_only = adapter.query(- query_vector=[1.0, 0.0, 0.0, 0.0],- filter=Eq("account_id", "acme"),- limit=2,- output_fields=["uri"],- )- dense_uris = [item["uri"] for item in dense_only]- assert dense_uris == [- "viking://resources/acme/hybrid/doc1.md",- "viking://resources/acme/hybrid/doc2.md",- ]-- hybrid_hits = adapter.query(- query_vector=[1.0, 0.0, 0.0, 0.0],- sparse_query_vector={"alpha": 1.0},- filter=Eq("account_id", "acme"),- limit=2,- output_fields=["uri"],- )- hybrid_uris = [item["uri"] for item in hybrid_hits]-- # doc1 should remain top because it is strong on both dense and sparse.- assert hybrid_uris[0] == "viking://resources/acme/hybrid/doc1.md"- # doc3 should be pulled up by sparse matching into top2.- assert "viking://resources/acme/hybrid/doc3.md" in hybrid_uris---def test_qdrant_contains_and_keywords_search(qdrant_adapter):- adapter, collection_name = qdrant_adapter- schema = _build_schema(collection_name)-- created = adapter.create_collection(- collection_name,- schema,- distance="cosine",- sparse_weight=0.0,- index_name="default",- )- assert created is True-- records = [- {- "id": str(uuid.uuid4()),- "uri": "viking://resources/acme/text/report.md",- "vector": [1.0, 0.0, 0.0, 0.0],- "created_at": "2026-05-29T12:20:00Z",- "updated_at": "2026-05-29T12:20:00Z",- "active_count": 2,- "level": 2,- "abstract": "quarterly report for product alpha",- "account_id": "acme",- },- {- "id": str(uuid.uuid4()),- "uri": "viking://resources/acme/text/design.md",- "vector": [0.8, 0.2, 0.0, 0.0],- "created_at": "2026-05-29T12:21:00Z",- "updated_at": "2026-05-29T12:21:00Z",- "active_count": 1,- "level": 2,- "abstract": "design draft for project beta",- "account_id": "acme",- },- ]- ids = adapter.upsert(records)- assert len(ids) == 2-- contains_hits = adapter.query(- filter=Contains("abstract", "quarterly"),- limit=10,- output_fields=["uri", "abstract"],- )- assert len(contains_hits) == 1- assert contains_hits[0]["uri"] == "viking://resources/acme/text/report.md"-- collection = adapter.get_collection()- keyword_hits = collection.search_by_keywords(- index_name="default",- keywords=["quarterly"],- limit=10,- output_fields=["uri", "abstract"],- )- assert len(keyword_hits.data) >= 1- assert keyword_hits.data[0].fields["uri"] == "viking://resources/acme/text/report.md"diff --git a/tests/misc/test_config_validation.py b/tests/misc/test_config_validation.pyindex d5bffa0f3..cd685f80f 100644--- a/tests/misc/test_config_validation.py+++ b/tests/misc/test_config_validation.py@@ -878,6 +878,18 @@ def test_removed_volcengine_api_key_backend_name_is_rejected():assert "volcengine_api_key" in str(e)[email protected]("backend", ["qdrant", "opengauss"])+def test_removed_third_party_vectordb_backends_are_rejected(backend):+ with pytest.raises(ValueError) as exc_info:+ VectorDBBackendConfig(backend=backend)++ message = str(exc_info.value)+ assert backend in message+ assert "local" in message+ assert "volcengine" in message+ assert "vikingdb" in message++def test_vectordb_volcengine_api_key_auth_requires_host_or_region():try:VectorDBBackendConfig(diff --git a/tests/storage/test_collection_schemas.py b/tests/storage/test_collection_schemas.pyindex 56e897e82..647e05b2a 100644--- a/tests/storage/test_collection_schemas.py+++ b/tests/storage/test_collection_schemas.py@@ -40,7 +40,6 @@ from openviking.storage.viking_vector_index_backend import (_SingleAccountBackend,)from openviking_cli.utils.config.vectordb_config import (- QdrantConfig,VectorDBBackendConfig,VolcengineConfig,)@@ -1960,136 +1959,6 @@ def test_storage_upsert_signatures_use_options_instead_of_partial_update():assert "partial_update" not in signature.parameters-async def test_qdrant_backend_upsert_partial_update_reads_then_upserts_existing_record():- calls = []-- class _Collection:- def get_meta_data(self):- return {- "Fields": [- {"FieldName": "id", "FieldType": "string"},- {"FieldName": "uri", "FieldType": "path"},- {"FieldName": "abstract", "FieldType": "string"},- {"FieldName": "account_id", "FieldType": "string"},- ]- }-- class _Adapter:- mode = "qdrant"- USE_CONTENT_FIELD = False-- def get(self, ids):- calls.append(("get", ids))- return [- {- "id": "doc-1",- "uri": "viking://resources/qdrant",- "abstract": "before",- "account_id": "acc1",- }- ]-- def upsert(self, data):- calls.append(("upsert", data))- return ["doc-1"]-- backend = _SingleAccountBackend(- config=VectorDBBackendConfig(- backend="qdrant",- name="context",- dimension=2,- qdrant=QdrantConfig(url="http://qdrant:6333"),- ),- bound_account_id="acc1",- shared_adapter=_Adapter(),- )-- result = await backend.upsert(- {"id": "doc-1", "uri": "viking://resources/qdrant", "abstract": "patched"},- options=UpsertOptions(partial_update=True),- )-- assert result == "doc-1"- assert calls == [- (- "get",- ["doc-1"],- ),- (- "upsert",- {- "id": "doc-1",- "uri": "viking://resources/qdrant",- "abstract": "patched",- "account_id": "acc1",- },- ),- ]---async def test_qdrant_backend_upsert_partial_update_creates_when_record_does_not_exist():- calls = []-- class _Collection:- def get_meta_data(self):- return {- "Fields": [- {"FieldName": "id", "FieldType": "string"},- {"FieldName": "uri", "FieldType": "path"},- {"FieldName": "abstract", "FieldType": "string"},- {"FieldName": "vector", "FieldType": "vector", "Dim": 2},- {"FieldName": "sparse_vector", "FieldType": "sparse_vector"},- {"FieldName": "active_count", "FieldType": "int64"},- {"FieldName": "account_id", "FieldType": "string"},- ]- }-- class _Adapter:- mode = "qdrant"- USE_CONTENT_FIELD = False-- def get(self, ids):- calls.append(("get", ids))- return []-- def upsert(self, data):- calls.append(("upsert", data))- return ["doc-404"]-- backend = _SingleAccountBackend(- config=VectorDBBackendConfig(- backend="qdrant",- name="context",- dimension=2,- qdrant=QdrantConfig(url="http://qdrant:6333"),- ),- bound_account_id="acc1",- shared_adapter=_Adapter(),- )-- result = await backend.upsert(- {"id": "doc-404", "uri": "viking://resources/qdrant/new", "abstract": "created"},- options=UpsertOptions(partial_update=True),- )-- assert result == "doc-404"- assert calls[0] == (- "get",- ["doc-404"],- )- assert calls[1] == (- "upsert",- {- "id": "doc-404",- "uri": "viking://resources/qdrant/new",- "abstract": "created",- "account_id": "acc1",- },- )--@pytest.mark.asyncioasync def test_volcengine_backend_upsert_partial_update_reads_then_upserts_existing_record():calls = []diff --git a/tests/storage/test_opengauss_adapter.py b/tests/storage/test_opengauss_adapter.pydeleted file mode 100644index 1f4d140a8..000000000--- a/tests/storage/test_opengauss_adapter.py+++ /dev/null@@ -1,345 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0--from __future__ import annotations--import os-import uuid--import pytest--from openviking.storage.vectordb.collection.result import SearchResult-from openviking.storage.vectordb_adapters.factory import create_collection_adapter-from openviking.storage.vectordb_adapters.opengauss_adapter import (- OpenGaussCollection,- OpenGaussCollectionAdapter,- _coerce_sql_value,- _encode_scope_roots,- _normalize_distance,- _safe_identifier,- _vector_literal,-)-from openviking_cli.utils.config.vectordb_config import VectorDBBackendConfig---def _build_config() -> VectorDBBackendConfig:- return VectorDBBackendConfig.model_validate(- {- "backend": "opengauss",- "project": "default",- "name": "context",- "index_name": "default",- "distance_metric": "cosine",- "opengauss": {- "host": "127.0.0.1",- "port": 8888,- "user": "omm",- "password": "OpenGauss@123",- "db_name": "postgres",- "schema": "public",- "mode": "standalone",- "dense_vector_name": "vector",- "sparse_vector_name": "sparse_vector",- },- }- )---def test_opengauss_backend_config_validation():- config = _build_config()-- assert config.backend == "opengauss"- assert config.opengauss is not None- assert config.opengauss.host == "127.0.0.1"- assert config.opengauss.port == 8888- assert config.opengauss.db_name == "postgres"- assert config.opengauss.schema_name == "public"---def test_factory_creates_opengauss_adapter_without_connecting():- adapter = create_collection_adapter(_build_config())-- assert isinstance(adapter, OpenGaussCollectionAdapter)- assert adapter.mode == "opengauss"- assert adapter.collection_name == "context"- assert adapter.index_name == "default"- assert adapter.physical_table_name == "ov_default_context"---def test_collection_filter_to_sql_for_path_scope():- collection = object.__new__(OpenGaussCollection)- collection._field_types = {"updated_at": "date_time"}-- clause, params = collection._compile_filter(- {- "op": "and",- "conds": [- {"op": "must", "field": "scope_roots", "conds": ["/resources/acme/docs"]},- {- "op": "range",- "field": "updated_at",- "gte": "2026-05-01T00:00:00+00:00",- "lt": "2026-06-01T00:00:00+00:00",- },- ],- }- )-- assert '"scope_roots" LIKE %s' in clause- assert '"updated_at" >= %s' in clause- assert '"updated_at" < %s' in clause- assert params == [- "%\n/resources/acme/docs\n%",- "2026-05-01T00:00:00+00:00",- "2026-06-01T00:00:00+00:00",- ]---def test_vector_literal_and_identifier_safety():- assert _vector_literal([1, 2.5, float("nan")]) == "[1,2.5,0]"-- name = _safe_identifier("Project/With Space", "Context.Table", prefix="ov")- assert name.startswith("ov_project_with_space_context_table")- assert len(name.encode("utf-8")) <= 63---def test_opengauss_distance_validation_accepts_ip_and_rejects_dot():- assert _normalize_distance("cosine") == "cosine"- assert _normalize_distance("l2") == "l2"- assert _normalize_distance("ip") == "ip"-- with pytest.raises(ValueError, match="supports only cosine, l2, and ip"):- _normalize_distance("dot")-- with pytest.raises(ValueError, match="supports only cosine, l2, and ip"):- _normalize_distance("euclid")---def test_distance_to_score_handles_inner_product_distance():- assert OpenGaussCollection._distance_to_score(-0.75, "ip") == 0.75- assert OpenGaussCollection._distance_to_score(0.25, "l2") == 0.8---def test_scope_roots_encoding_is_token_safe():- encoded = _encode_scope_roots(["/a", "/a/b"])-- assert encoded == "\n/a\n/a/b\n"- assert "\n/a\n" in encoded- assert "\n/a/b\n" in encoded- assert "\n/a/c\n" not in encoded---def test_bool_coercion_parses_string_values():- assert _coerce_sql_value(True, "bool") is True- assert _coerce_sql_value(False, "bool") is False- assert _coerce_sql_value("true", "bool") is True- assert _coerce_sql_value("1", "bool") is True- assert _coerce_sql_value("false", "bool") is False- assert _coerce_sql_value("0", "bool") is False- assert _coerce_sql_value("unknown", "bool") is None---def test_drop_index_removes_vector_and_scalar_indexes():- collection = object.__new__(OpenGaussCollection)- collection._schema_name = "public"- collection._table_name = "ov_test"- statements = []-- collection.get_index_meta_data = lambda index_name: {- "IndexName": index_name,- "ScalarIndex": ["uri", "account_id"],- }- collection._delete_index_meta = lambda index_name: statements.append(- ("delete_meta", index_name)- )- collection._execute = lambda sql, params=None, fetch=False: statements.append(sql)-- collection.drop_index("default")-- assert 'DROP INDEX IF EXISTS "public"."idx_ov_test_default_vec"' in statements- assert 'DROP INDEX IF EXISTS "public"."idx_ov_test_default_uri"' in statements- assert 'DROP INDEX IF EXISTS "public"."idx_ov_test_default_account_id"' in statements- assert ("delete_meta", "default") in statements---def test_vector_index_creation_uses_hnsw_only():- collection = object.__new__(OpenGaussCollection)- collection._schema_name = "public"- collection._table_name = "ov_test"- collection._dense_vector_name = "vector"- statements = []-- collection._table_ref = lambda: '"public"."ov_test"'- collection._all_columns = lambda: ["id", "vector"]- collection._execute = lambda sql, params=None, fetch=False: statements.append(sql)-- collection._create_vector_index(- "default",- "cosine",- {"VectorIndex": {"IndexType": "flat", "Distance": "cosine"}},- )-- sql = "\n".join(statements).lower()- assert "using hnsw" in sql- assert "vector_cosine_ops" in sql---def test_create_index_normalizes_metadata_to_hnsw():- collection = object.__new__(OpenGaussCollection)- saved = {}-- collection._create_vector_index = lambda index_name, distance, meta: saved.setdefault(- "vector_meta", meta- )- collection._create_scalar_index = lambda index_name, field_name: None- collection._save_index_meta = lambda index_name, meta: saved.setdefault("saved_meta", meta)-- collection.create_index(- "default",- {- "IndexName": "default",- "VectorIndex": {"IndexType": "flat", "Distance": "cosine"},- "ScalarIndex": ["uri"],- },- )-- assert saved["vector_meta"]["VectorIndex"]["IndexType"] == "hnsw"- assert saved["saved_meta"]["VectorIndex"]["IndexType"] == "hnsw"---def test_create_index_does_not_save_metadata_when_vector_index_fails():- collection = object.__new__(OpenGaussCollection)- saved = {}-- def fail_vector_index(index_name, distance, meta):- raise RuntimeError("boom")-- collection._create_vector_index = fail_vector_index- collection._create_scalar_index = lambda index_name, field_name: saved.setdefault(- "scalar", field_name- )- collection._save_index_meta = lambda index_name, meta: saved.setdefault("saved_meta", meta)-- with pytest.raises(RuntimeError, match="boom"):- collection.create_index(- "default",- {- "IndexName": "default",- "VectorIndex": {"IndexType": "flat", "Distance": "cosine"},- "ScalarIndex": ["uri"],- },- )-- assert saved == {}---def test_vector_search_binds_vector_before_filter_params():- collection = object.__new__(OpenGaussCollection)- collection._dense_vector_name = "vector"- collection._distance_metric = "cosine"- collection._select_columns = lambda output_fields, include_sparse=False: ["id"]- collection._where_sql = lambda filters: (' WHERE "scope_roots" LIKE %s', ["%\n/a\n%"])- collection._table_ref = lambda: '"public"."ov_test"'- captured = {}-- def execute(sql, params=None, *, fetch=False):- captured["sql"] = sql- captured["params"] = params- captured["fetch"] = fetch- return []-- collection._execute = execute-- collection.search_by_vector(- "default",- dense_vector=[0.1, 0.2],- filters={"op": "must", "field": "scope_roots", "conds": ["/a"]},- )-- assert captured["fetch"] is True- assert captured["params"] == ["[0.1,0.2]", "%\n/a\n%", "[0.1,0.2]", 10, 0]--- not os.getenv("OPENVIKING_OPENGAUSS_HOST"),- reason="set OPENVIKING_OPENGAUSS_HOST to run openGauss integration smoke test",-)-def test_opengauss_adapter_integration_smoke():- suffix = uuid.uuid4().hex[:8]- adapter = OpenGaussCollectionAdapter(- host=os.environ["OPENVIKING_OPENGAUSS_HOST"],- port=int(os.getenv("OPENVIKING_OPENGAUSS_PORT", "5432")),- user=os.getenv("OPENVIKING_OPENGAUSS_USER", "omm"),- password=os.getenv("OPENVIKING_OPENGAUSS_PASSWORD", ""),- db_name=os.getenv("OPENVIKING_OPENGAUSS_DB", "postgres"),- schema_name=os.getenv("OPENVIKING_OPENGAUSS_SCHEMA", "public"),- project_name=f"pytest_{suffix}",- collection_name="context",- index_name="default",- distance_metric="cosine",- dense_vector_name="vector",- sparse_vector_name="sparse_vector",- connect_timeout=10,- mode=os.getenv("OPENVIKING_OPENGAUSS_MODE", "standalone"),- shard_count=4,- )- meta = {- "CollectionName": "context",- "Fields": [- {"FieldName": "id", "FieldType": "string", "IsPrimaryKey": True},- {"FieldName": "uri", "FieldType": "path"},- {"FieldName": "vector", "FieldType": "vector", "Dim": 2},- {"FieldName": "sparse_vector", "FieldType": "sparse_vector"},- {"FieldName": "abstract", "FieldType": "string"},- ],- }-- collection = adapter._new_collection(meta)- try:- collection.create_remote_collection(meta)- collection.create_index(- "default",- {- "IndexName": "default",- "VectorIndex": {"IndexType": "hnsw", "Distance": "cosine"},- "ScalarIndex": ["uri", "parent_uri", "scope_roots"],- },- )- collection.upsert_data(- [- adapter._normalize_record_for_write(- {- "id": "doc-1",- "uri": "viking://resources/acme/docs/a.md",- "vector": [0.1, 0.2],- "sparse_vector": {"quarter": 1.0},- "abstract": "quarterly report",- }- ),- adapter._normalize_record_for_write(- {- "id": "doc-2",- "uri": "viking://resources/acme/notes/b.md",- "vector": [0.2, 0.1],- "sparse_vector": {"notes": 1.0},- "abstract": "meeting notes",- }- ),- ]- )-- result = collection.search_by_vector(- "default",- dense_vector=[0.1, 0.2],- sparse_vector={"quarter": 1.0},- limit=1,- filters={"op": "must", "field": "scope_roots", "conds": ["/resources/acme/docs"]},- )- count = collection.aggregate_data("default")-- assert isinstance(result, SearchResult)- assert [item.id for item in result.data] == ["doc-1"]- assert count.agg["_total"] == 2- finally:- collection.drop()- adapter.close()diff --git a/tests/storage/test_qdrant_adapter.py b/tests/storage/test_qdrant_adapter.pydeleted file mode 100644index 0ee35af03..000000000--- a/tests/storage/test_qdrant_adapter.py+++ /dev/null@@ -1,70 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0---import pytest--from openviking.storage.vectordb_adapters.factory import create_collection_adapter-from openviking.storage.vectordb_adapters.qdrant_adapter import QdrantCollectionAdapter-from openviking_cli.utils.config.vectordb_config import VectorDBBackendConfig---def _build_config() -> VectorDBBackendConfig:- return VectorDBBackendConfig.model_validate(- {- "backend": "qdrant",- "project": "default",- "name": "context",- "index_name": "default",- "distance_metric": "cosine",- "qdrant": {- "url": "http://qdrant:6333/",- "api_key": "test-key",- "timeout_seconds": 7,- "dense_vector_name": "vector",- "sparse_vector_name": "sparse_vector",- "meta_collection_name": "__openviking_meta",- "enable_text_index": True,- },- }- )---def test_qdrant_backend_config_validation():- config = _build_config()- assert config.backend == "qdrant"- assert config.qdrant is not None- assert config.qdrant.url == "http://qdrant:6333"---def test_factory_creates_qdrant_adapter():- adapter = create_collection_adapter(_build_config())- assert isinstance(adapter, QdrantCollectionAdapter)- assert adapter.mode == "qdrant"- assert adapter.collection_name == "context"- assert adapter.index_name == "default"- assert adapter.physical_collection_name == "default__context"---def test_existing_physical_collection_without_metadata_is_rejected_and_closed(monkeypatch):- class FakeQdrantCollection:- def __init__(self) -> None:- self.closed = False-- def collection_exists(self) -> bool:- return True-- def has_openviking_metadata(self) -> bool:- return False-- def close(self) -> None:- self.closed = True-- candidate = FakeQdrantCollection()- adapter = QdrantCollectionAdapter.from_config(_build_config())- monkeypatch.setattr(adapter, "_new_qdrant_collection", lambda: candidate)-- with pytest.raises(RuntimeError, match="OpenViking metadata is missing"):- adapter.collection_exists()-- assert candidate.closed is Truediff --git a/tests/storage/test_qdrant_collection.py b/tests/storage/test_qdrant_collection.pydeleted file mode 100644index 69a156eed..000000000--- a/tests/storage/test_qdrant_collection.py+++ /dev/null@@ -1,306 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0--from __future__ import annotations--from typing import Any, Dict, List--import pytest--import openviking.storage.vectordb.collection.qdrant_collection as qdrant_collection_module-from openviking.storage.vectordb.collection.qdrant_collection import (- ORIGINAL_ID_FIELD,- QdrantCollection,- _sparse_to_qdrant,- _to_qdrant_point_id,-)-from openviking.storage.vectordb.collection.qdrant_rest import QdrantRestError---class _StubClient:- def __init__(self, responses: List[Any]) -> None:- self._responses = list(responses)- self.calls: List[Dict[str, Any]] = []-- def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:- self.calls.append({"method": method, "path": path, **kwargs})- if not self._responses:- raise AssertionError("No more stubbed Qdrant responses available")- response = self._responses.pop(0)- if isinstance(response, Exception):- raise response- return response---def _build_collection_stub(client: _StubClient) -> QdrantCollection:- collection = object.__new__(QdrantCollection)- collection._client = client- collection._physical_collection_name = "proj__context"- collection._dense_vector_name = "vector"- collection._sparse_vector_name = "sparse_vector"- collection._vector_dim = 3- collection._path_payload_fields = {"parent_uri", "scope_roots"}- return collection---class _FailingMetaStore:- def save_collection_meta(self, **_: Any) -> None:- raise RuntimeError("metadata write failed")---class _RecordingMetaStore:- def __init__(self) -> None:- self.deleted_keys: List[str] = []-- def delete_collection_meta(self, *, collection_key: str) -> None:- self.deleted_keys.append(collection_key)---def test_sparse_to_qdrant_warns_on_hash_collision(monkeypatch, caplog):- monkeypatch.setattr(- qdrant_collection_module,- "_hash_sparse_term",- lambda term: 7 if term in {"alpha", "beta"} else 9,- )-- payload = _sparse_to_qdrant({"alpha": 1.0, "beta": 2.5, "gamma": 4.0})-- assert payload == {"indices": [7, 9], "values": [3.5, 4.0]}- assert "hash collision detected" in caplog.text---def test_scroll_points_stops_on_repeated_next_page_offset(caplog):- client = _StubClient(- [- {"result": {"points": [{"id": "p1"}], "next_page_offset": "repeat-me"}},- {"result": {"points": [{"id": "p2"}], "next_page_offset": "repeat-me"}},- ]- )- collection = _build_collection_stub(client)-- points = collection._scroll_points(limit=None)-- assert [point["id"] for point in points] == ["p1", "p2"]- assert "next_page_offset repeated" in caplog.text---def test_delete_all_data_prefers_filter_delete():- client = _StubClient([{"status": "ok", "result": {}}])- collection = _build_collection_stub(client)- collection._scan_points_with_warning = lambda **_: (_ for _ in ()).throw(- AssertionError("fallback scan should not be used")- )- collection._delete_points = lambda _: (_ for _ in ()).throw(- AssertionError("batched delete should not be used")- )-- collection.delete_all_data()-- assert len(client.calls) == 1- call = client.calls[0]- assert call["method"] == "POST"- assert call["path"] == "/collections/proj__context/points/delete"- assert call["json_body"] == {"filter": {}}- assert call["params"] == {"wait": "true"}---def test_delete_all_data_falls_back_to_batched_delete(caplog):- client = _StubClient([QdrantRestError("delete failed")])- collection = _build_collection_stub(client)- collection._scan_points_with_warning = lambda **_: [- {"id": str(i)} for i in range(QdrantCollection.DEFAULT_DELETE_BATCH_SIZE * 2 + 5)- ]-- deleted_batches: List[List[str]] = []- collection._delete_points = lambda ids: deleted_batches.append(list(ids))-- collection.delete_all_data()-- assert [len(batch) for batch in deleted_batches] == [- QdrantCollection.DEFAULT_DELETE_BATCH_SIZE,- QdrantCollection.DEFAULT_DELETE_BATCH_SIZE,- 5,- ]- assert "Falling back to batched delete_all_data" in caplog.text---def test_make_point_accepts_zero_id():- collection = _build_collection_stub(_StubClient([]))-- point = collection._make_point({"id": 0, "vector": [0.1, 0.2, 0.3], "name": "zero"})-- assert point["id"] == 0- assert point["vector"]["vector"] == [0.1, 0.2, 0.3]- assert point["payload"]["name"] == "zero"- assert point["payload"][ORIGINAL_ID_FIELD] == 0---def test_make_point_maps_arbitrary_string_id_and_preserves_original_id():- collection = _build_collection_stub(_StubClient([]))-- point = collection._make_point({"id": "doc_1", "vector": [0.1, 0.2, 0.3]})-- assert point["id"] == _to_qdrant_point_id("doc_1")- assert point["id"] != "doc_1"- assert point["payload"][ORIGINAL_ID_FIELD] == "doc_1"---def test_make_point_rejects_missing_vector():- collection = _build_collection_stub(_StubClient([]))-- with pytest.raises(ValueError, match="requires at least one dense or sparse vector"):- collection._make_point({"id": "doc_1", "name": "missing vector"})---def test_create_remote_collection_rolls_back_when_metadata_write_fails():- client = _StubClient([{"status": "ok"}, {"status": "ok"}])- collection = _build_collection_stub(client)- collection._logical_collection_name = "context"- collection._project_name = "proj"- collection._distance_metric = "cosine"- collection._meta_store = _FailingMetaStore()-- with pytest.raises(RuntimeError, match="metadata write failed"):- collection.create_remote_collection(- {- "Fields": [- {"FieldName": "id", "FieldType": "string"},- {"FieldName": "vector", "FieldType": "vector", "Dim": 3},- ]- }- )-- assert client.calls[0]["method"] == "PUT"- assert client.calls[0]["path"] == "/collections/proj__context"- assert client.calls[1]["method"] == "DELETE"- assert client.calls[1]["path"] == "/collections/proj__context"- assert client.calls[1]["expected_statuses"] == (200, 202, 404)---def test_drop_tolerates_missing_physical_collection_and_deletes_metadata():- client = _StubClient([{"status": "ok"}])- collection = _build_collection_stub(client)- meta_store = _RecordingMetaStore()- collection._meta_store = meta_store-- collection.drop()-- assert client.calls[0]["method"] == "DELETE"- assert client.calls[0]["expected_statuses"] == (200, 202, 404)- assert meta_store.deleted_keys == ["proj__context"]---def test_fetch_data_maps_ids_and_returns_original_ids():- point_id = _to_qdrant_point_id("doc_1")- client = _StubClient(- [- {- "result": [- {- "id": point_id,- "payload": {ORIGINAL_ID_FIELD: "doc_1", "name": "Document"},- }- ]- }- ]- )- collection = _build_collection_stub(client)-- result = collection.fetch_data(["doc_1", "doc_2"])-- assert client.calls[0]["json_body"]["ids"] == [point_id, _to_qdrant_point_id("doc_2")]- assert result.items[0].id == "doc_1"- assert result.items[0].fields == {"name": "Document"}- assert result.ids_not_exist == ["doc_2"]---def test_update_data_preserves_omitted_fields_and_overwrites_explicit_fields():- point_id = _to_qdrant_point_id("doc_1")- client = _StubClient(- [- {- "result": [- {- "id": point_id,- "payload": {- ORIGINAL_ID_FIELD: "doc_1",- "name": "Before",- "status": "active",- },- "vector": {"vector": [0.1, 0.2, 0.3]},- }- ]- },- {"status": "ok"},- ]- )- collection = _build_collection_stub(client)-- updated_ids = collection.update_data([{"id": "doc_1", "name": "After"}])-- assert updated_ids == ["doc_1"]- assert client.calls[0]["method"] == "POST"- assert client.calls[0]["path"] == "/collections/proj__context/points"- assert client.calls[0]["json_body"]["ids"] == [point_id]- assert client.calls[0]["json_body"]["with_vector"] is True-- assert client.calls[1]["method"] == "PUT"- assert client.calls[1]["path"] == "/collections/proj__context/points"- point = client.calls[1]["json_body"]["points"][0]- assert point["id"] == point_id- assert point["vector"]["vector"] == [0.1, 0.2, 0.3]- assert point["payload"] == {- ORIGINAL_ID_FIELD: "doc_1",- "name": "After",- "status": "active",- }---def test_update_data_requires_existing_record():- client = _StubClient([{"result": []}])- collection = _build_collection_stub(client)-- with pytest.raises(ValueError, match="Qdrant point does not exist for update: doc_404"):- collection.update_data([{"id": "doc_404", "name": "After"}])---def test_search_by_id_uses_stored_vector_for_similarity_query():- point_id = _to_qdrant_point_id("doc_1")- client = _StubClient(- [- {- "result": [- {- "id": point_id,- "payload": {ORIGINAL_ID_FIELD: "doc_1"},- "vector": {"vector": [0.1, 0.2, 0.3]},- }- ]- },- {- "result": {- "points": [- {- "id": point_id,- "payload": {ORIGINAL_ID_FIELD: "doc_1"},- "score": 1.0,- },- {- "id": _to_qdrant_point_id("doc_2"),- "payload": {ORIGINAL_ID_FIELD: "doc_2", "name": "Document 2"},- "score": 0.9,- },- ]- }- },- ]- )- collection = _build_collection_stub(client)-- result = collection.search_by_id("default", "doc_1", limit=10)-- assert client.calls[0]["json_body"]["with_vector"] is True- assert client.calls[1]["path"] == "/collections/proj__context/points/query"- assert client.calls[1]["json_body"]["query"] == [0.1, 0.2, 0.3]- assert result.data[0].id == "doc_2"- assert result.data[0].fields == {"name": "Document 2"}diff --git a/tests/storage/test_qdrant_meta_store.py b/tests/storage/test_qdrant_meta_store.pydeleted file mode 100644index 4b00bbf6e..000000000--- a/tests/storage/test_qdrant_meta_store.py+++ /dev/null@@ -1,62 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0--from __future__ import annotations--from typing import Any, Dict, List--from openviking.storage.vectordb.collection.qdrant_meta_store import QdrantMetaStore-from openviking.storage.vectordb.collection.qdrant_rest import QdrantRestError---class _StubClient:- def __init__(self, responses: List[Any]) -> None:- self._responses = list(responses)- self.calls: List[Dict[str, Any]] = []-- def collection_exists(self, name: str) -> bool:- self.calls.append({"method": "COLLECTION_EXISTS", "name": name})- return True-- def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:- self.calls.append({"method": method, "path": path, **kwargs})- if not self._responses:- raise AssertionError("No more stubbed Qdrant responses available")- response = self._responses.pop(0)- if isinstance(response, Exception):- raise response- return response---def test_scroll_index_docs_paginates_until_exhausted():- client = _StubClient(- [- {"result": {"points": [{"id": "idx-1"}], "next_page_offset": "page-2"}},- {"result": {"points": [{"id": "idx-2"}], "next_page_offset": None}},- ]- )- store = QdrantMetaStore(client=client, meta_collection_name="__meta")-- docs = store._scroll_index_docs("proj__context")-- assert [doc["id"] for doc in docs] == ["idx-1", "idx-2"]- assert client.calls[2]["json_body"]["offset"] == "page-2"---def test_get_point_returns_none_for_missing_meta_collection():- client = _StubClient([QdrantRestError("missing", status_code=404)])- store = QdrantMetaStore(client=client, meta_collection_name="__meta")-- assert store._get_point("missing") is None---def test_get_point_reraises_non_missing_qdrant_errors():- client = _StubClient([QdrantRestError("auth failed", status_code=401)])- store = QdrantMetaStore(client=client, meta_collection_name="__meta")-- try:- store._get_point("meta-id")- except QdrantRestError as exc:- assert exc.status_code == 401- else:- raise AssertionError("Expected QdrantRestError to be reraised")diff --git a/uv.lock b/uv.lockindex e1f10739d..3cfb2dba9 100644--- a/uv.lock+++ b/uv.lock@@ -1636,6 +1636,7 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/38/3f/9859f655d11901e7b2996c6e3d33e0caa9a1d4572c3bc61ed0faa64b2f4c/greenlet-3.3.2-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9bc885b89709d901859cf95179ec9f6bb67a3d2bb1f0e88456461bd4b7f8fd0d", size = 277747, upload-time = "2026-02-20T20:16:21.325Z" },{ url = "https://files.pythonhosted.org/packages/fb/07/cb284a8b5c6498dbd7cba35d31380bb123d7dceaa7907f606c8ff5993cbf/greenlet-3.3.2-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b568183cf65b94919be4438dc28416b234b678c608cafac8874dfeeb2a9bbe13", size = 579202, upload-time = "2026-02-20T20:47:28.955Z" },{ url = "https://files.pythonhosted.org/packages/ed/45/67922992b3a152f726163b19f890a85129a992f39607a2a53155de3448b8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:527fec58dc9f90efd594b9b700662ed3fb2493c2122067ac9c740d98080a620e", size = 590620, upload-time = "2026-02-20T20:55:55.581Z" },+ { url = "https://files.pythonhosted.org/packages/03/5f/6e2a7d80c353587751ef3d44bb947f0565ec008a2e0927821c007e96d3a7/greenlet-3.3.2-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:508c7f01f1791fbc8e011bd508f6794cb95397fdb198a46cb6635eb5b78d85a7", size = 602132, upload-time = "2026-02-20T21:02:43.261Z" },{ url = "https://files.pythonhosted.org/packages/ad/55/9f1ebb5a825215fadcc0f7d5073f6e79e3007e3282b14b22d6aba7ca6cb8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ad0c8917dd42a819fe77e6bdfcb84e3379c0de956469301d9fd36427a1ca501f", size = 591729, upload-time = "2026-02-20T20:20:58.395Z" },{ url = "https://files.pythonhosted.org/packages/24/b4/21f5455773d37f94b866eb3cf5caed88d6cea6dd2c6e1f9c34f463cba3ec/greenlet-3.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:97245cc10e5515dbc8c3104b2928f7f02b6813002770cfaffaf9a6e0fc2b94ef", size = 1551946, upload-time = "2026-02-20T20:49:31.102Z" },{ url = "https://files.pythonhosted.org/packages/00/68/91f061a926abead128fe1a87f0b453ccf07368666bd59ffa46016627a930/greenlet-3.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8c1fdd7d1b309ff0da81d60a9688a8bd044ac4e18b250320a96fc68d31c209ca", size = 1618494, upload-time = "2026-02-20T20:21:06.541Z" },@@ -1643,6 +1644,7 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/f3/47/16400cb42d18d7a6bb46f0626852c1718612e35dcb0dffa16bbaffdf5dd2/greenlet-3.3.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:c56692189a7d1c7606cb794be0a8381470d95c57ce5be03fb3d0ef57c7853b86", size = 278890, upload-time = "2026-02-20T20:19:39.263Z" },{ url = "https://files.pythonhosted.org/packages/a3/90/42762b77a5b6aa96cd8c0e80612663d39211e8ae8a6cd47c7f1249a66262/greenlet-3.3.2-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ebd458fa8285960f382841da585e02201b53a5ec2bac6b156fc623b5ce4499f", size = 581120, upload-time = "2026-02-20T20:47:30.161Z" },{ url = "https://files.pythonhosted.org/packages/bf/6f/f3d64f4fa0a9c7b5c5b3c810ff1df614540d5aa7d519261b53fba55d4df9/greenlet-3.3.2-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a443358b33c4ec7b05b79a7c8b466f5d275025e750298be7340f8fc63dff2a55", size = 594363, upload-time = "2026-02-20T20:55:56.965Z" },+ { url = "https://files.pythonhosted.org/packages/9c/8b/1430a04657735a3f23116c2e0d5eb10220928846e4537a938a41b350bed6/greenlet-3.3.2-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4375a58e49522698d3e70cc0b801c19433021b5c37686f7ce9c65b0d5c8677d2", size = 605046, upload-time = "2026-02-20T21:02:45.234Z" },{ url = "https://files.pythonhosted.org/packages/72/83/3e06a52aca8128bdd4dcd67e932b809e76a96ab8c232a8b025b2850264c5/greenlet-3.3.2-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e2cd90d413acbf5e77ae41e5d3c9b3ac1d011a756d7284d7f3f2b806bbd6358", size = 594156, upload-time = "2026-02-20T20:20:59.955Z" },{ url = "https://files.pythonhosted.org/packages/70/79/0de5e62b873e08fe3cef7dbe84e5c4bc0e8ed0c7ff131bccb8405cd107c8/greenlet-3.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:442b6057453c8cb29b4fb36a2ac689382fc71112273726e2423f7f17dc73bf99", size = 1554649, upload-time = "2026-02-20T20:49:32.293Z" },{ url = "https://files.pythonhosted.org/packages/5a/00/32d30dee8389dc36d42170a9c66217757289e2afb0de59a3565260f38373/greenlet-3.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:45abe8eb6339518180d5a7fa47fa01945414d7cca5ecb745346fc6a87d2750be", size = 1619472, upload-time = "2026-02-20T20:21:07.966Z" },@@ -1651,6 +1653,7 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:ac8d61d4343b799d1e526db579833d72f23759c71e07181c2d2944e429eb09cd", size = 280358, upload-time = "2026-02-20T20:17:43.971Z" },{ url = "https://files.pythonhosted.org/packages/a5/23/0eae412a4ade4e6623ff7626e38998cb9b11e9ff1ebacaa021e4e108ec15/greenlet-3.3.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ceec72030dae6ac0c8ed7591b96b70410a8be370b6a477b1dbc072856ad02bd", size = 601217, upload-time = "2026-02-20T20:47:31.462Z" },{ url = "https://files.pythonhosted.org/packages/f8/16/5b1678a9c07098ecb9ab2dd159fafaf12e963293e61ee8d10ecb55273e5e/greenlet-3.3.2-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2a5be83a45ce6188c045bcc44b0ee037d6a518978de9a5d97438548b953a1ac", size = 611792, upload-time = "2026-02-20T20:55:58.423Z" },+ { url = "https://files.pythonhosted.org/packages/5c/c5/cc09412a29e43406eba18d61c70baa936e299bc27e074e2be3806ed29098/greenlet-3.3.2-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ae9e21c84035c490506c17002f5c8ab25f980205c3e61ddb3a2a2a2e6c411fcb", size = 626250, upload-time = "2026-02-20T21:02:46.596Z" },{ url = "https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e99d1749147ac21dde49b99c9abffcbc1e2d55c67501465ef0930d6e78e070", size = 613875, upload-time = "2026-02-20T20:21:01.102Z" },{ url = "https://files.pythonhosted.org/packages/fc/dd/845f249c3fcd69e32df80cdab059b4be8b766ef5830a3d0aa9d6cad55beb/greenlet-3.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4c956a19350e2c37f2c48b336a3afb4bff120b36076d9d7fb68cb44e05d95b79", size = 1571467, upload-time = "2026-02-20T20:49:33.495Z" },{ url = "https://files.pythonhosted.org/packages/2a/50/2649fe21fcc2b56659a452868e695634722a6655ba245d9f77f5656010bf/greenlet-3.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c6f8ba97d17a1e7d664151284cb3315fc5f8353e75221ed4324f84eb162b395", size = 1640001, upload-time = "2026-02-20T20:21:09.154Z" },@@ -1659,6 +1662,7 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ac/48/f8b875fa7dea7dd9b33245e37f065af59df6a25af2f9561efa8d822fde51/greenlet-3.3.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:aa6ac98bdfd716a749b84d4034486863fd81c3abde9aa3cf8eff9127981a4ae4", size = 279120, upload-time = "2026-02-20T20:19:01.9Z" },{ url = "https://files.pythonhosted.org/packages/49/8d/9771d03e7a8b1ee456511961e1b97a6d77ae1dea4a34a5b98eee706689d3/greenlet-3.3.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab0c7e7901a00bc0a7284907273dc165b32e0d109a6713babd04471327ff7986", size = 603238, upload-time = "2026-02-20T20:47:32.873Z" },{ url = "https://files.pythonhosted.org/packages/59/0e/4223c2bbb63cd5c97f28ffb2a8aee71bdfb30b323c35d409450f51b91e3e/greenlet-3.3.2-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d248d8c23c67d2291ffd47af766e2a3aa9fa1c6703155c099feb11f526c63a92", size = 614219, upload-time = "2026-02-20T20:55:59.817Z" },+ { url = "https://files.pythonhosted.org/packages/94/2b/4d012a69759ac9d77210b8bfb128bc621125f5b20fc398bce3940d036b1c/greenlet-3.3.2-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ccd21bb86944ca9be6d967cf7691e658e43417782bce90b5d2faeda0ff78a7dd", size = 628268, upload-time = "2026-02-20T21:02:48.024Z" },{ url = "https://files.pythonhosted.org/packages/7a/34/259b28ea7a2a0c904b11cd36c79b8cef8019b26ee5dbe24e73b469dea347/greenlet-3.3.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6997d360a4e6a4e936c0f9625b1c20416b8a0ea18a8e19cabbefc712e7397ab", size = 616774, upload-time = "2026-02-20T20:21:02.454Z" },{ url = "https://files.pythonhosted.org/packages/0a/03/996c2d1689d486a6e199cb0f1cf9e4aa940c500e01bdf201299d7d61fa69/greenlet-3.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64970c33a50551c7c50491671265d8954046cb6e8e2999aacdd60e439b70418a", size = 1571277, upload-time = "2026-02-20T20:49:34.795Z" },{ url = "https://files.pythonhosted.org/packages/d9/c4/2570fc07f34a39f2caf0bf9f24b0a1a0a47bc2e8e465b2c2424821389dfc/greenlet-3.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1a9172f5bf6bd88e6ba5a84e0a68afeac9dc7b6b412b245dd64f52d83c81e55b", size = 1640455, upload-time = "2026-02-20T20:21:10.261Z" },@@ -1667,6 +1671,7 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/3f/ae/8bffcbd373b57a5992cd077cbe8858fff39110480a9d50697091faea6f39/greenlet-3.3.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:8d1658d7291f9859beed69a776c10822a0a799bc4bfe1bd4272bb60e62507dab", size = 279650, upload-time = "2026-02-20T20:18:00.783Z" },{ url = "https://files.pythonhosted.org/packages/d1/c0/45f93f348fa49abf32ac8439938726c480bd96b2a3c6f4d949ec0124b69f/greenlet-3.3.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18cb1b7337bca281915b3c5d5ae19f4e76d35e1df80f4ad3c1a7be91fadf1082", size = 650295, upload-time = "2026-02-20T20:47:34.036Z" },{ url = "https://files.pythonhosted.org/packages/b3/de/dd7589b3f2b8372069ab3e4763ea5329940fc7ad9dcd3e272a37516d7c9b/greenlet-3.3.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2e47408e8ce1c6f1ceea0dffcdf6ebb85cc09e55c7af407c99f1112016e45e9", size = 662163, upload-time = "2026-02-20T20:56:01.295Z" },+ { url = "https://files.pythonhosted.org/packages/cd/ac/85804f74f1ccea31ba518dcc8ee6f14c79f73fe36fa1beba38930806df09/greenlet-3.3.2-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e3cb43ce200f59483eb82949bf1835a99cf43d7571e900d7c8d5c62cdf25d2f9", size = 675371, upload-time = "2026-02-20T21:02:49.664Z" },{ url = "https://files.pythonhosted.org/packages/d2/d8/09bfa816572a4d83bccd6750df1926f79158b1c36c5f73786e26dbe4ee38/greenlet-3.3.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63d10328839d1973e5ba35e98cccbca71b232b14051fd957b6f8b6e8e80d0506", size = 664160, upload-time = "2026-02-20T20:21:04.015Z" },{ url = "https://files.pythonhosted.org/packages/48/cf/56832f0c8255d27f6c35d41b5ec91168d74ec721d85f01a12131eec6b93c/greenlet-3.3.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e4ab3cfb02993c8cc248ea73d7dae6cec0253e9afa311c9b37e603ca9fad2ce", size = 1619181, upload-time = "2026-02-20T20:49:36.052Z" },{ url = "https://files.pythonhosted.org/packages/0a/23/b90b60a4aabb4cec0796e55f25ffbfb579a907c3898cd2905c8918acaa16/greenlet-3.3.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94ad81f0fd3c0c0681a018a976e5c2bd2ca2d9d94895f23e7bb1af4e8af4e2d5", size = 1687713, upload-time = "2026-02-20T20:21:11.684Z" },@@ -1675,6 +1680,7 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/98/6d/8f2ef704e614bcf58ed43cfb8d87afa1c285e98194ab2cfad351bf04f81e/greenlet-3.3.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:e26e72bec7ab387ac80caa7496e0f908ff954f31065b0ffc1f8ecb1338b11b54", size = 286617, upload-time = "2026-02-20T20:19:29.856Z" },{ url = "https://files.pythonhosted.org/packages/5e/0d/93894161d307c6ea237a43988f27eba0947b360b99ac5239ad3fe09f0b47/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b466dff7a4ffda6ca975979bab80bdadde979e29fc947ac3be4451428d8b0e4", size = 655189, upload-time = "2026-02-20T20:47:35.742Z" },{ url = "https://files.pythonhosted.org/packages/f5/2c/d2d506ebd8abcb57386ec4f7ba20f4030cbe56eae541bc6fd6ef399c0b41/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8bddc5b73c9720bea487b3bffdb1840fe4e3656fba3bd40aa1489e9f37877ff", size = 658225, upload-time = "2026-02-20T20:56:02.527Z" },+ { url = "https://files.pythonhosted.org/packages/d1/67/8197b7e7e602150938049d8e7f30de1660cfb87e4c8ee349b42b67bdb2e1/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:59b3e2c40f6706b05a9cd299c836c6aa2378cabe25d021acd80f13abf81181cf", size = 666581, upload-time = "2026-02-20T21:02:51.526Z" },{ url = "https://files.pythonhosted.org/packages/8e/30/3a09155fbf728673a1dea713572d2d31159f824a37c22da82127056c44e4/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b26b0f4428b871a751968285a1ac9648944cea09807177ac639b030bddebcea4", size = 657907, upload-time = "2026-02-20T20:21:05.259Z" },{ url = "https://files.pythonhosted.org/packages/f3/fd/d05a4b7acd0154ed758797f0a43b4c0962a843bedfe980115e842c5b2d08/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1fb39a11ee2e4d94be9a76671482be9398560955c9e568550de0224e41104727", size = 1618857, upload-time = "2026-02-20T20:49:37.309Z" },{ url = "https://files.pythonhosted.org/packages/6f/e1/50ee92a5db521de8f35075b5eff060dd43d39ebd46c2181a2042f7070385/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:20154044d9085151bc309e7689d6f7ba10027f8f5a8c0676ad398b951913d89e", size = 1680010, upload-time = "2026-02-20T20:21:13.427Z" },@@ -3784,9 +3790,6 @@ local-embed = [ocr = [{ name = "pytesseract" },]-opengauss = [- { name = "psycopg2-binary" },-]test = [{ name = "boto3" },{ name = "datasets" },@@ -3875,7 +3878,6 @@ requires-dist = [{ name = "pdfplumber", specifier = ">=0.10.0" },{ name = "prompt-toolkit", marker = "extra == 'bot'", specifier = ">=3.0.0" },{ name = "protobuf", specifier = ">=6.33.5" },- { name = "psycopg2-binary", marker = "extra == 'opengauss'", specifier = ">=2.9" },{ name = "py-machineid", marker = "extra == 'bot'", specifier = ">=1.0.0" },{ name = "pydantic", specifier = ">=2.0.0" },{ name = "pydantic-settings", marker = "extra == 'bot'", specifier = ">=2.0.0" },@@ -3939,7 +3941,7 @@ requires-dist = [{ name = "xlrd", specifier = ">=2.0.1" },{ name = "xxhash", specifier = ">=3.0.0" },]-provides-extras = ["test", "auth", "opengauss", "dev", "doc", "eval", "gemini", "gemini-async", "ocr", "build", "bot", "benchmark", "langchain", "langgraph", "local-embed"]+provides-extras = ["test", "auth", "dev", "doc", "eval", "gemini", "gemini-async", "ocr", "build", "bot", "benchmark", "langchain", "langgraph", "local-embed"][package.metadata.requires-dev]dev = [{ name = "pytest", specifier = ">=9.0.2" }]@@ -4587,69 +4589,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/57/bf/2086963c69bdac3d7cff1cc7ff79b8ce5ea0bec6797a017e1be338a46248/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02", size = 170687, upload-time = "2026-01-29T21:51:32.557Z" },]-[[package]]-name = "psycopg2-binary"-version = "2.9.12"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/2a/60/a3624f79acea344c16fbef3a94d28b89a8042ddfb8f3e4ca83f538671409/psycopg2_binary-2.9.12.tar.gz", hash = "sha256:5ac9444edc768c02a6b6a591f070b8aae28ff3a99be57560ac996001580f294c", size = 379686, upload-time = "2026-04-21T09:40:34.304Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/78/80/49bacf9e51617d8309f6f0123e29edc793f6f5f6700c7d1f1b20782fbb37/psycopg2_binary-2.9.12-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9b818ceff717f98851a64bffd4c5eb5b3059ae280276dcecc52ac658dcf006a4", size = 3712314, upload-time = "2026-04-20T23:33:31.363Z" },- { url = "https://files.pythonhosted.org/packages/d3/f2/98eeac7d60c43df9338287834edf9b3e69be68a2db78a57b1b81d705e735/psycopg2_binary-2.9.12-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d2fa0d7caca8635c56e373055094eeda3208d901d55dd0ff5abc1d4e47f82b56", size = 3822389, upload-time = "2026-04-20T23:33:34.178Z" },- { url = "https://files.pythonhosted.org/packages/9f/7c/30575e75f14d5351a56a1971bb43fe7f8bf7edf1b654fb1bec65c42a8812/psycopg2_binary-2.9.12-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:864c261b3690e1207d14bbfe0a61e27567981b80c47a778561e49f676f7ce433", size = 4578448, upload-time = "2026-04-20T23:33:37.073Z" },- { url = "https://files.pythonhosted.org/packages/65/9b/4df366d89f28c527dc39d0b6c98a5ca74e30d37ac097b73f3352147568ae/psycopg2_binary-2.9.12-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c5ee5213445dd45312459029b8c4c0a695461eb517b753d2582315bd07995f5e", size = 4273705, upload-time = "2026-04-20T23:33:39.291Z" },- { url = "https://files.pythonhosted.org/packages/4e/8a/c566803818eb03161ba869b6ba612bf7ad56816d98b9e5121e0a22ad6b0b/psycopg2_binary-2.9.12-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6f9cae1f848779b5b01f417e762c40d026ea93eb0648249a604728cda991dde3", size = 5893784, upload-time = "2026-04-20T23:33:41.658Z" },- { url = "https://files.pythonhosted.org/packages/63/fe/0dfa5797e0b229e0567bc378695224caf14d547f73b05be0c80549089772/psycopg2_binary-2.9.12-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:63a3ebbd543d3d1eda088ac99164e8c5bac15293ee91f20281fd17d050aee1c4", size = 4109306, upload-time = "2026-04-20T23:33:43.953Z" },- { url = "https://files.pythonhosted.org/packages/3c/89/28063adf17a4ba501eedd9890feab0c649ee4d8bd0a97df0ff1e9584feab/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d6fcbba8c9fed08a73b8ac61ea79e4821e45b1e92bb466230c5e746bbf3d5256", size = 3654400, upload-time = "2026-04-20T23:33:46.115Z" },- { url = "https://files.pythonhosted.org/packages/84/94/5a01de0aa4ead0b8d8d1aa4ec18cec0bd36d03fa714eaa5bb8a0b1b50020/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:36512911ebb2b60a0c3e44d0bb5048c1980aced91235d133b7874f3d1d93487c", size = 3299215, upload-time = "2026-04-20T23:33:48.202Z" },- { url = "https://files.pythonhosted.org/packages/7a/85/723bb085a61c6ac2dc0a0043f375f2fe7365363e27b073bad56ca5bda979/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:8ffdb59fe88f99589e34354a130217aa1fd2d615612402d6edc8b3dbc7a44463", size = 3047724, upload-time = "2026-04-20T23:33:50.74Z" },- { url = "https://files.pythonhosted.org/packages/b4/67/4d8b1e0d2fc4166677380eac0edf9cdff91013aca2546e8ef7bc04b56158/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a46fe069b65255df410f856d842bc235f90e22ffdf532dda625fd4213d3fd9b1", size = 3349183, upload-time = "2026-04-20T23:33:59.635Z" },- { url = "https://files.pythonhosted.org/packages/73/99/21af7a5498637ea4dc91a17c281a53bc1d632fbafe00f6689fbfb32a9fed/psycopg2_binary-2.9.12-cp310-cp310-win_amd64.whl", hash = "sha256:ab29414b25dcb698bf26bf213e3348abdcd07bbd5de032a5bec15bd75b298b03", size = 2757036, upload-time = "2026-04-20T23:34:01.606Z" },- { url = "https://files.pythonhosted.org/packages/d5/19/d4ce60954f3bb9d8e3bc5e5c4d1f2487de2d3851bf2391d54954c9df12a6/psycopg2_binary-2.9.12-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5c8ce6c61bd1b1f6b9c24ee32211599f6166af2c55abb19456090a21fd16554b", size = 3712338, upload-time = "2026-04-20T23:34:03.961Z" },- { url = "https://files.pythonhosted.org/packages/53/71/c85409ee0d78890f0660eff262e815e7dd2bb741a17611d82e9e8cd9dc5e/psycopg2_binary-2.9.12-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b4a9eaa6e7f4ff91bec10aa3fb296878e75187bced5cc4bafe17dc40915e1326", size = 3822407, upload-time = "2026-04-20T23:34:05.977Z" },- { url = "https://files.pythonhosted.org/packages/3c/ed/60486c2c7f0d4d1ede2bfb1ed27e2498477ce646bc7f6b2759906303117e/psycopg2_binary-2.9.12-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c6528cefc8e50fcc6f4a107e27a672058b36cc5736d665476aeb413ba88dbb06", size = 4578425, upload-time = "2026-04-20T23:34:08.246Z" },- { url = "https://files.pythonhosted.org/packages/0b/b9/656cb03fad9f4f49f2145c334b1126ee75189929ca4e6187d485a2d59951/psycopg2_binary-2.9.12-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e4e184b1fb6072bf05388aa41c697e1b2d01b3473f107e7ec44f186a32cfd0b8", size = 4273709, upload-time = "2026-04-20T23:34:10.974Z" },- { url = "https://files.pythonhosted.org/packages/99/66/08cf0da0e25cc6fb142c89be45fc8418792858f0c4cbff5e24530ff02cd6/psycopg2_binary-2.9.12-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4766ab678563054d3f1d064a4db19cc4b5f9e3a8d9018592a8285cf200c248f3", size = 5893779, upload-time = "2026-04-20T23:34:13.905Z" },- { url = "https://files.pythonhosted.org/packages/17/d7/eecd9ce8e146d3721115d82d3836efdbb712187e4590325df549989d18f4/psycopg2_binary-2.9.12-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5a0253224780c978746cb9be55a946bcdaf40fe3519c0f622924cdabdafe2c39", size = 4109308, upload-time = "2026-04-20T23:34:16.761Z" },- { url = "https://files.pythonhosted.org/packages/b6/2e/b1dc289b362cc8d45697b57eefbd673186f49a4ea0906928988e3affcc98/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0dc9228d47c46bda253d2ecd6bb93b56a9f2d7ad33b684a1fa3622bf74ffe30c", size = 3654405, upload-time = "2026-04-20T23:34:19.303Z" },- { url = "https://files.pythonhosted.org/packages/eb/e4/4c4aea6473214dbdbd0fbba11aa4691e76dc01722c55724c5951719865ff/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f921f3cd87035ef7df233383011d7a53ea1d346224752c1385f1edfd790ceb6a", size = 3299187, upload-time = "2026-04-20T23:34:21.206Z" },- { url = "https://files.pythonhosted.org/packages/ba/5d/b03b99986446a4f57b170ed9a2579fb7ff9783ca0fa5226b19db99737fee/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3d999bd982a723113c1a45b55a7a6a90d64d0ed2278020ed625c490ff7bef96c", size = 3047716, upload-time = "2026-04-20T23:34:23.077Z" },- { url = "https://files.pythonhosted.org/packages/14/86/382ee4afbd1d97500c9d2862b20c2fdeddf4b7335e984df3fb4309f64108/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29d4d134bd0ab46ffb04e94aa3c5fa3ef582e9026609165e2f758ff76fc3a3be", size = 3349237, upload-time = "2026-04-20T23:34:25.211Z" },- { url = "https://files.pythonhosted.org/packages/a8/16/9a57c75ba1eda7165c017342f526810d5f5a12647dde749c99ae9a7141d7/psycopg2_binary-2.9.12-cp311-cp311-win_amd64.whl", hash = "sha256:cb4a1dacdd48077150dc762a9e5ddbf32c256d66cb46f80839391aa458774936", size = 2757036, upload-time = "2026-04-20T23:34:27.77Z" },- { url = "https://files.pythonhosted.org/packages/e2/9f/ef4ef3c8e15083df90ca35265cfd1a081a2f0cc07bb229c6314c6af817f4/psycopg2_binary-2.9.12-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5cdc05117180c5fa9c40eea8ea559ce64d73824c39d928b7da9fb5f6a9392433", size = 3712459, upload-time = "2026-04-20T23:34:30.549Z" },- { url = "https://files.pythonhosted.org/packages/b5/01/3dd14e46ba48c1e1a6ec58ee599fa1b5efa00c246d5046cd903d0eeb1af1/psycopg2_binary-2.9.12-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3227a3bc228c10d21011a99245edca923e4e8bf461857e869a507d9a41fe9f6", size = 3822936, upload-time = "2026-04-20T23:34:32.77Z" },- { url = "https://files.pythonhosted.org/packages/a6/f7/0640e4901119d8a9f7a1784b927f494e2198e213ceb593753d1f2c8b1b30/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:995ce929eede89db6254b50827e2b7fd61e50d11f0b116b29fffe4a2e53c4580", size = 4578676, upload-time = "2026-04-20T23:34:35.18Z" },- { url = "https://files.pythonhosted.org/packages/b0/55/44df3965b5f297c50cc0b1b594a31c67d6127a9d133045b8a66611b14dfb/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9fe06d93e72f1c048e731a2e3e7854a5bfaa58fc736068df90b352cefe66f03f", size = 4274917, upload-time = "2026-04-20T23:34:37.982Z" },- { url = "https://files.pythonhosted.org/packages/b0/4b/74535248b1eac0c9336862e8617c765ac94dac76f9e25d7c4a79588c8907/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40e7b28b63aaf737cb3a1edc3a9bbc9a9f4ad3dcb7152e8c1130e4050eddcb7d", size = 5894843, upload-time = "2026-04-20T23:34:40.856Z" },- { url = "https://files.pythonhosted.org/packages/f2/ba/f1bf8d2ae71868ad800b661099086ee52bc0f8d9f05be1acd8ebb06757cc/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:89d19a9f7899e8eb0656a2b3a08e0da04c720a06db6e0033eab5928aabe60fa9", size = 4110556, upload-time = "2026-04-20T23:34:44.016Z" },- { url = "https://files.pythonhosted.org/packages/45/46/c15706c338403b7c420bcc0c2905aad116cc064545686d8bf85f1999ea00/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:612b965daee295ae2da8f8218ce1d274645dc76ef3f1abf6a0a94fd57eff876d", size = 3655714, upload-time = "2026-04-20T23:34:46.233Z" },- { url = "https://files.pythonhosted.org/packages/b3/7c/a2d5dc09b64a4564db242a0fe418fde7d33f6f8259dd2c5b9d7def00fb5a/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b9a339b79d37c1b45f3235265f07cdeb0cb5ad7acd2ac7720a5920989c17c24e", size = 3301154, upload-time = "2026-04-20T23:34:49.528Z" },- { url = "https://files.pythonhosted.org/packages/c0/e8/cc8c9a4ce71461f9ec548d38cadc41dc184b34c73e6455450775a9334ccd/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:3471336e1acfd9c7fe507b8bad5af9317b6a89294f9eb37bd9a030bb7bebcdc6", size = 3048882, upload-time = "2026-04-20T23:34:51.86Z" },- { url = "https://files.pythonhosted.org/packages/19/6a/31e2296bc0787c5ab75d3d118e40b239db8151b5192b90b77c72bc9256e9/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7af18183109e23502c8b2ae7f6926c0882766f35b5175a4cd737ad825e4d7a1b", size = 3351298, upload-time = "2026-04-20T23:34:54.124Z" },- { url = "https://files.pythonhosted.org/packages/5f/a8/75f4e3e11203b590150abed2cf7794b9c9c9f7eceddae955191138b44dde/psycopg2_binary-2.9.12-cp312-cp312-win_amd64.whl", hash = "sha256:398fcd4db988c7d7d3713e2b8e18939776fd3fb447052daae4f24fa39daede4c", size = 2757230, upload-time = "2026-04-20T23:34:56.242Z" },- { url = "https://files.pythonhosted.org/packages/91/bb/4608c96f970f6e0c56572e87027ef4404f709382a3503e9934526d7ba051/psycopg2_binary-2.9.12-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7c729a73c7b1b84de3582f73cdd27d905121dc2c531f3d9a3c32a3011033b965", size = 3712419, upload-time = "2026-04-20T23:34:58.754Z" },- { url = "https://files.pythonhosted.org/packages/5e/af/48f76af9d50d61cf390f8cd657b503168b089e2e9298e48465d029fcc713/psycopg2_binary-2.9.12-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4413d0caef93c5cf50b96863df4c2efe8c269bf2267df353225595e7e15e8df7", size = 3822990, upload-time = "2026-04-20T23:35:00.821Z" },- { url = "https://files.pythonhosted.org/packages/7a/df/aba0f99397cd811d32e06fc0cc781f1f3ce98bc0e729cb423925085d781a/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4dfcf8e45ebb0c663be34a3442f65e17311f3367089cd4e5e3a3e8e62c978777", size = 4578696, upload-time = "2026-04-20T23:35:03.409Z" },- { url = "https://files.pythonhosted.org/packages/95/9c/eaa74021ac4e4d5c2f83d82fc6615a63f4fe6c94dc4e94c3990427053f67/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c41321a14dd74aceb6a9a643b9253a334521babfa763fa873e33d89cfa122fb5", size = 4274982, upload-time = "2026-04-20T23:35:05.583Z" },- { url = "https://files.pythonhosted.org/packages/35/ed/c25deff98bd26187ba48b3b250a3ffc3037c46c5b89362534a15d200e0db/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83946ba43979ebfdc99a3cd0ee775c89f221df026984ba19d46133d8d75d3cd9", size = 5894867, upload-time = "2026-04-20T23:35:07.902Z" },- { url = "https://files.pythonhosted.org/packages/9a/81/8d0e21ca77373c6c9589e5c4528f6e8f0c08c62cafc76fb0bddb7a2cee22/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:411e85815652d13560fbe731878daa5d92378c4995a22302071890ec3397d019", size = 4110578, upload-time = "2026-04-20T23:35:10.149Z" },- { url = "https://files.pythonhosted.org/packages/00/fc/f481e2435bd8f742d0123309174aae4165160ad3ef17c1b99c3622c241d2/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c8ad4c08e00f7679559eaed7aff1edfffc60c086b976f93972f686384a95e2c", size = 3655816, upload-time = "2026-04-20T23:35:12.56Z" },- { url = "https://files.pythonhosted.org/packages/53/79/b9f46466bdbe9f239c96cde8be33c1aace4842f06013b47b730dc9759187/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:00814e40fa23c2b37ef0a1e3c749d89982c73a9cb5046137f0752a22d432e82f", size = 3301307, upload-time = "2026-04-20T23:35:15.029Z" },- { url = "https://files.pythonhosted.org/packages/3f/19/7dc003b32fe35024df89b658104f7c8538a8b2dcbde7a4e746ce929742e7/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:98062447aebc20ed20add1f547a364fd0ef8933640d5372ff1873f8deb9b61be", size = 3048968, upload-time = "2026-04-20T23:35:16.757Z" },- { url = "https://files.pythonhosted.org/packages/91/58/2dbd7db5c604d45f4950d988506aae672a14126ec22998ced5021cbb76bb/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:66a7685d7e548f10fb4ce32fb01a7b7f4aa702134de92a292c7bd9e0d3dbd290", size = 3351369, upload-time = "2026-04-20T23:35:18.933Z" },- { url = "https://files.pythonhosted.org/packages/42/ee/dee8dcaad07f735824de3d6563bc67119fa6c28257b17977a8d624f02fab/psycopg2_binary-2.9.12-cp313-cp313-win_amd64.whl", hash = "sha256:b6937f5fe4e180aeee87de907a2fa982ded6f7f15d7218f78a083e4e1d68f2a0", size = 2757347, upload-time = "2026-04-20T23:35:21.283Z" },- { url = "https://files.pythonhosted.org/packages/13/1b/708c0dca874acfad6d65314271859899a79007686f3a1f74e82a2ed4b645/psycopg2_binary-2.9.12-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6f3b3de8a74ef8db215f22edffb19e32dc6fa41340456de7ec99efdc8a7b3ec2", size = 3712428, upload-time = "2026-04-20T23:35:23.453Z" },- { url = "https://files.pythonhosted.org/packages/d6/39/ddbea9d4b4de6aca9431b6ed253f530f8a02d3b8f9bcfd0dbfe2b3de6fe4/psycopg2_binary-2.9.12-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1006fb62f0f0bc5ce256a832356c6262e91be43f5e4eb15b5eaf38079464caf2", size = 3823184, upload-time = "2026-04-20T23:35:25.92Z" },- { url = "https://files.pythonhosted.org/packages/bf/a0/bc2fef74b106fa345567122a0659e6d94512ed7dc0131ec44c9e5aba3725/psycopg2_binary-2.9.12-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:840066105706cd2eb29b9a1c2329620056582a4bf3e8169dec5c447042d0869f", size = 4579157, upload-time = "2026-04-20T23:35:28.542Z" },- { url = "https://files.pythonhosted.org/packages/57/d7/d4e3b2005d3de607ca4fbb0e8742e248056e52184a6b94ebda3c1c2c329b/psycopg2_binary-2.9.12-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:863f5d12241ebe1c76a72a04c2113b6dc905f90b9cef0e9be0efd994affd9354", size = 4274970, upload-time = "2026-04-20T23:35:30.418Z" },- { url = "https://files.pythonhosted.org/packages/2e/42/c9853f8db3967fe08bcde11f53d53b85d351750cae726ce001cb68afa9c1/psycopg2_binary-2.9.12-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a99eaab34a9010f1a086b126de467466620a750634d114d20455f3a824aae033", size = 5895175, upload-time = "2026-04-20T23:35:33.584Z" },- { url = "https://files.pythonhosted.org/packages/eb/fd/b82b5601a97630308bef079f545ffec481bbbc795c2ba5ec416a01d03f60/psycopg2_binary-2.9.12-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ffdd7dc5463ccd61845ac37b7012d0f35a1548df9febe14f8dd549be4a0bc81e", size = 4110658, upload-time = "2026-04-20T23:35:35.638Z" },- { url = "https://files.pythonhosted.org/packages/62/8c/32ca69b0389ef25dd22937bf9e8fbe2ce27aea20b05ded48c4ce4cb42475/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:54a0dfecab1b48731f934e06139dfe11e24219fb6d0ceb32177cf0375f14c7b5", size = 3656251, upload-time = "2026-04-20T23:35:37.854Z" },- { url = "https://files.pythonhosted.org/packages/c4/29/96992a2b59e3b9d730fcf9612d0a387305025dc867a9fc490a9e496e074e/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:96937c9c5d891f772430f418a7a8b4691a90c3e6b93cf72b5bd7cad8cbca32a5", size = 3301810, upload-time = "2026-04-20T23:35:39.927Z" },- { url = "https://files.pythonhosted.org/packages/56/ad/44b06659949b243ae10112cd3b20a197f9bf3e81d5651379b9eb889bfaad/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:77b348775efd4cdab410ec6609d81ccecd1139c90265fa583a7255c8064bc03d", size = 3048977, upload-time = "2026-04-20T23:35:41.806Z" },- { url = "https://files.pythonhosted.org/packages/1d/f2/10a1bcebadb6aa55e280e1f58975c36a7b560ea525184c7aa4064c466633/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:527e6342b3e44c2f0544f6b8e927d60de7f163f5723b8f1dfa7d2a84298738cd", size = 3351466, upload-time = "2026-04-20T23:35:43.993Z" },- { url = "https://files.pythonhosted.org/packages/20/be/b732c8418ffa5bcfda002890f5dc4c869fc17db66ff11f53b17cfe44afc0/psycopg2_binary-2.9.12-cp314-cp314-win_amd64.whl", hash = "sha256:f12ae41fcafadb39b2785e64a40f9db05d6de2ac114077457e0e7c597f3af980", size = 2848762, upload-time = "2026-04-20T23:35:46.421Z" },-]-[[package]]name = "py"version = "1.11.0"