qdrant-haystack 10.5.0__tar.gz → 11.0.0__tar.gz

{qdrant_haystack-10.5.0 → qdrant_haystack-11.0.0}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [integrations/qdrant-v10.6.0] - 2026-09-01
+
+### 🐛 Bug Fixes
+
+- Standardize license files (#3771)
+- `QdrantDocumentStore` removing duplicated tests already covered by haystack Mixin tests + fixing dedup + adding missing Async test (#3785)
+
+
+## [integrations/qdrant-v10.5.0] - 2026-08-03
+
+### 🚀 Features
+
+- *(qdrant)* Expose RRF k and weights parameters in QdrantHybridRetriever (#3702)
+
+### 🐛 Bug Fixes
+
+- `Qdrant` normalisation of .meta usage in `get_metadata_field_unique_values()` (#3642)
+- `Qdrant` adding offset based pagination to `get_metadata_field_unique_values()` (#3697)
+
+
 ## [integrations/qdrant-v10.4.0] - 2026-07-27
 
 ### 🚀 Features
@@ -67,7 +87,7 @@
 
 - Feat: `QdrantDocumentStore` return number deleted docs on `delete_by_filter` (#2807)
 
-## [integrations/qdrant-v9.6.0] - 2026-02-02
+## [integrations/qdrant-v10.1.0] - 2026-02-02
 
 ### 🚀 Features
 
@@ -75,11 +95,15 @@
 
 ### 🧹 Chores
 
-- Make fmt command more forgiving (#2671)
-- [**breaking**] Qdrant - drop Python 3.9 and use X|Y typing (#2726)
 - Disabling progress bar in `QdrantDocumentStore` tests (#2797)
 
-### 🌀 Miscellaneous
+
+## [integrations/qdrant-v10.0.0] - 2026-01-13
+
+### 🧹 Chores
+
+- Make fmt command more forgiving (#2671)
+- [**breaking**] Qdrant - drop Python 3.9 and use X|Y typing (#2726)
 
 
 ## [integrations/qdrant-v9.5.0] - 2026-01-07
@@ -139,6 +163,8 @@
 - Align core-integrations Hatch scripts (#1898)
 - Update md files for new hatch scripts (#1911)
 
+## [integrations/qdrant-v9.1.3] - 2025-05-28
+
 ### 🌀 Miscellaneous
 
 - Add pins for Qdrant (#1853)
@@ -362,6 +388,18 @@
 - *(Qdrant)* Allow payload indexing + on disk vectors (#553)
 - Qdrant datetime filtering support (#570)
 
+### 📚 Documentation
+
+- Disable-class-def (#556)
+
+### 🌀 Miscellaneous
+
+- Make tests show coverage (#566)
+- Remove references to Python 3.7 (#601)
+- Make Document Stores initially skip `SparseEmbedding` (#606)
+
+## [integrations/qdrant-v3.1.0] - 2024-03-06
+
 ### 🐛 Bug Fixes
 
 - Fix: fix linter errors (#282)
@@ -376,18 +414,11 @@
 
 - Update category slug (#442)
 - Small consistency improvements (#536)
-- Disable-class-def (#556)
 
 ### ⚙️ CI
 
 - Generate API docs for Qdrant (#361)
 
-### 🌀 Miscellaneous
-
-- Make tests show coverage (#566)
-- Remove references to Python 3.7 (#601)
-- Make Document Stores initially skip `SparseEmbedding` (#606)
-
 ## [integrations/qdrant-v3.0.0] - 2024-01-22
 
 ### 🌀 Miscellaneous
@@ -396,20 +427,22 @@
 
 ## [integrations/qdrant-v2.0.1] - 2024-01-18
 
-### 🚀 Features
-
-- Add Qdrant integration (#98)
-
 ### 🐛 Bug Fixes
 
 - Fix import paths for beta5 (#237)
 
-### 🚜 Refactor
-
-- Use `hatch_vcs` to manage integrations versioning (#103)
-
 ### 🌀 Miscellaneous
 
 - Renamed QdrntRetriever to QdrntEmbeddingRetriever (#174)
 
+## [integrations/qdrant-v2.0.0] - 2023-12-18
+
+### 🚀 Features
+
+- Add Qdrant integration (#98)
+
+### 🚜 Refactor
+
+- Use `hatch_vcs` to manage integrations versioning (#103)
+
 <!-- generated by git-cliff -->

{qdrant_haystack-10.5.0 → qdrant_haystack-11.0.0}/LICENSE.txt

@@ -58,7 +58,7 @@ APPENDIX: How to apply the Apache License to your work.
 
 To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
 
-Copyright [yyyy] [name of copyright owner]
+Copyright 2023-present deepset GmbH
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

{qdrant_haystack-10.5.0 → qdrant_haystack-11.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: qdrant-haystack
-Version: 10.5.0
+Version: 11.0.0
 Summary: An integration of Qdrant ANN vector database backend with Haystack
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/qdrant/README.md

{qdrant_haystack-10.5.0 → qdrant_haystack-11.0.0}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -15,7 +15,6 @@ from haystack.utils import Secret, deserialize_secrets_inplace
 from haystack.utils.misc import _normalize_metadata_field_name
 from numpy import exp
 from qdrant_client.http import models as rest
-from qdrant_client.http.exceptions import UnexpectedResponse
 from tqdm import tqdm
 
 from .converters import (
@@ -338,6 +337,9 @@ class QdrantDocumentStore:
     def count_documents(self) -> int:
         """
         Returns the number of documents present in the Document Store.
+
+        :returns: The number of documents in the collection.
+        :raises QdrantStoreError: Counting documents fails.
         """
         self._initialize_client()
         assert self._client is not None
@@ -346,15 +348,16 @@ class QdrantDocumentStore:
                 collection_name=self.index,
             )
             return response.count
-        except (UnexpectedResponse, ValueError):
-            # Qdrant local raises ValueError if the collection is not found, but
-            # with the remote server UnexpectedResponse is raised. Until that's unified,
-            # we need to catch both.
-            return 0
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.count_documents(): {e}"
+            raise QdrantStoreError(msg) from e
 
     async def count_documents_async(self) -> int:
         """
-        Asynchronously returns the number of documents present in the document dtore.
+        Asynchronously returns the number of documents present in the document store.
+
+        :returns: The number of documents in the collection.
+        :raises QdrantStoreError: Counting documents fails.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
@@ -363,11 +366,9 @@ class QdrantDocumentStore:
                 collection_name=self.index,
             )
             return response.count
-        except (UnexpectedResponse, ValueError):
-            # Qdrant local raises ValueError if the collection is not found, but
-            # with the remote server UnexpectedResponse is raised. Until that's unified,
-            # we need to catch both.
-            return 0
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.count_documents_async(): {e}"
+            raise QdrantStoreError(msg) from e
 
     def filter_documents(
         self,
@@ -716,7 +717,7 @@ class QdrantDocumentStore:
 
     @staticmethod
     def _process_records_count_unique(
-        records: list[Any], metadata_fields: list[str], unique_values_by_field: dict[str, set[Any]]
+        records: list[Any], metadata_fields: list[str], unique_values_by_field: dict[str, set[tuple[type, Any]]]
     ) -> None:
         """
         Update unique_values_by_field from a batch of Qdrant records.
@@ -730,10 +731,11 @@ class QdrantDocumentStore:
                     if field in meta:
                         value = meta[field]
                         if value is not None:
-                            if isinstance(value, (list, dict)):
-                                unique_values_by_field[field].add(str(value))
-                            else:
-                                unique_values_by_field[field].add(value)
+                            # Values of different types can be equal in Python (`1 == True`, `1 == 1.0`), so
+                            # a plain set would silently merge them. Dedupe by (type, value) instead - lists
+                            # and dicts aren't hashable, so they're keyed by their str() form.
+                            hashable_value = str(value) if isinstance(value, (list, dict)) else value
+                            unique_values_by_field[field].add((type(value), hashable_value))
 
     @staticmethod
     def _process_records_unique_values(
@@ -752,9 +754,13 @@ class QdrantDocumentStore:
                     if value is not None:
                         if search_term is not None and search_term.lower() not in str(value).lower():
                             continue
+                        # Values of different types can be equal in Python (`1 == True`, `1 == 1.0`), so
+                        # a plain set would silently merge them. Dedupe by (type, value) instead - lists
+                        # and dicts aren't hashable, so they're keyed by their str() form.
                         hashable_value = str(value) if isinstance(value, (list, dict)) else value
-                        if hashable_value not in unique_values_set:
-                            unique_values_set.add(hashable_value)
+                        dedup_key = (type(value), hashable_value)
+                        if dedup_key not in unique_values_set:
+                            unique_values_set.add(dedup_key)
                             unique_values.append(value)
 
     @staticmethod
@@ -916,38 +922,39 @@ class QdrantDocumentStore:
         Deletes all documents from the document store.
 
         :param recreate_index: Whether to recreate the index after deleting all documents.
+        :raises QdrantStoreError: Deleting documents or recreating the collection fails.
         """
 
         self._initialize_client()
         assert self._client is not None
 
-        if recreate_index:
-            # get current collection config as json
-            collection_info = self._client.get_collection(collection_name=self.index)
-            info_json = collection_info.model_dump()
+        try:
+            if recreate_index:
+                # get current collection config as json
+                collection_info = self._client.get_collection(collection_name=self.index)
+                info_json = collection_info.model_dump()
 
-            # deal with the Optional use_sparse_embeddings
-            sparse_vectors = info_json["config"]["params"]["sparse_vectors"]
-            use_sparse_embeddings = True if sparse_vectors else False
+                # deal with the Optional use_sparse_embeddings
+                sparse_vectors = info_json["config"]["params"]["sparse_vectors"]
+                use_sparse_embeddings = True if sparse_vectors else False
 
-            # deal with the Optional sparse_idf
-            hnsw_config = info_json["config"]["params"]["vectors"].get("config", {}).get("hnsw_config", None)
-            sparse_idf = True if use_sparse_embeddings and hnsw_config else False
+                # deal with the Optional sparse_idf
+                hnsw_config = info_json["config"]["params"]["vectors"].get("config", {}).get("hnsw_config", None)
+                sparse_idf = True if use_sparse_embeddings and hnsw_config else False
 
-            # recreate collection
-            self._set_up_collection(
-                collection_name=self.index,
-                embedding_dim=info_json["config"]["params"]["vectors"]["size"],
-                recreate_collection=True,
-                similarity=info_json["config"]["params"]["vectors"]["distance"].lower(),
-                use_sparse_embeddings=use_sparse_embeddings,
-                sparse_idf=sparse_idf,
-                on_disk=info_json["config"]["hnsw_config"]["on_disk"],
-                payload_fields_to_index=info_json["payload_schema"],
-            )
+                # recreate collection
+                self._set_up_collection(
+                    collection_name=self.index,
+                    embedding_dim=info_json["config"]["params"]["vectors"]["size"],
+                    recreate_collection=True,
+                    similarity=info_json["config"]["params"]["vectors"]["distance"].lower(),
+                    use_sparse_embeddings=use_sparse_embeddings,
+                    sparse_idf=sparse_idf,
+                    on_disk=info_json["config"]["hnsw_config"]["on_disk"],
+                    payload_fields_to_index=info_json["payload_schema"],
+                )
 
-        else:
-            try:
+            else:
                 self._client.delete(
                     collection_name=self.index,
                     points_selector=rest.FilterSelector(
@@ -957,48 +964,48 @@ class QdrantDocumentStore:
                     ),
                     wait=self.wait_result_from_api,
                 )
-            except Exception as e:
-                logger.warning(
-                    f"Error {e} when calling QdrantDocumentStore.delete_all_documents()",
-                )
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.delete_all_documents(): {e}"
+            raise QdrantStoreError(msg) from e
 
     async def delete_all_documents_async(self, recreate_index: bool = False) -> None:
         """
         Asynchronously deletes all documents from the document store.
 
         :param recreate_index: Whether to recreate the index after deleting all documents.
+        :raises QdrantStoreError: Deleting documents or recreating the collection fails.
         """
 
         await self._initialize_async_client()
         assert self._async_client is not None
 
-        if recreate_index:
-            # get current collection config as json
-            collection_info = await self._async_client.get_collection(collection_name=self.index)
-            info_json = collection_info.model_dump()
+        try:
+            if recreate_index:
+                # get current collection config as json
+                collection_info = await self._async_client.get_collection(collection_name=self.index)
+                info_json = collection_info.model_dump()
 
-            # deal with the Optional use_sparse_embeddings
-            sparse_vectors = info_json["config"]["params"]["sparse_vectors"]
-            use_sparse_embeddings = True if sparse_vectors else False
+                # deal with the Optional use_sparse_embeddings
+                sparse_vectors = info_json["config"]["params"]["sparse_vectors"]
+                use_sparse_embeddings = True if sparse_vectors else False
 
-            # deal with the Optional sparse_idf
-            hnsw_config = info_json["config"]["params"]["vectors"].get("config", {}).get("hnsw_config", None)
-            sparse_idf = True if use_sparse_embeddings and hnsw_config else False
+                # deal with the Optional sparse_idf
+                hnsw_config = info_json["config"]["params"]["vectors"].get("config", {}).get("hnsw_config", None)
+                sparse_idf = True if use_sparse_embeddings and hnsw_config else False
 
-            # recreate collection
-            await self._set_up_collection_async(
-                collection_name=self.index,
-                embedding_dim=info_json["config"]["params"]["vectors"]["size"],
-                recreate_collection=True,
-                similarity=info_json["config"]["params"]["vectors"]["distance"].lower(),
-                use_sparse_embeddings=use_sparse_embeddings,
-                sparse_idf=sparse_idf,
-                on_disk=info_json["config"]["hnsw_config"]["on_disk"],
-                payload_fields_to_index=info_json["payload_schema"],
-            )
+                # recreate collection
+                await self._set_up_collection_async(
+                    collection_name=self.index,
+                    embedding_dim=info_json["config"]["params"]["vectors"]["size"],
+                    recreate_collection=True,
+                    similarity=info_json["config"]["params"]["vectors"]["distance"].lower(),
+                    use_sparse_embeddings=use_sparse_embeddings,
+                    sparse_idf=sparse_idf,
+                    on_disk=info_json["config"]["hnsw_config"]["on_disk"],
+                    payload_fields_to_index=info_json["payload_schema"],
+                )
 
-        else:
-            try:
+            else:
                 await self._async_client.delete(
                     collection_name=self.index,
                     points_selector=rest.FilterSelector(
@@ -1008,10 +1015,9 @@ class QdrantDocumentStore:
                     ),
                     wait=self.wait_result_from_api,
                 )
-            except Exception as e:
-                logger.warning(
-                    f"Error {e} when calling QdrantDocumentStore.delete_all_documents_async()",
-                )
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.delete_all_documents_async(): {e}"
+            raise QdrantStoreError(msg) from e
 
     def count_documents_by_filter(self, filters: dict[str, Any]) -> int:
         """
@@ -1021,6 +1027,7 @@ class QdrantDocumentStore:
             For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
 
         :returns: The number of documents that match the filters.
+        :raises QdrantStoreError: Counting documents matching the filters fails.
         """
         self._initialize_client()
         assert self._client is not None
@@ -1032,9 +1039,9 @@ class QdrantDocumentStore:
                 count_filter=qdrant_filter,
             )
             return response.count
-        except (UnexpectedResponse, ValueError) as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.count_documents_by_filter()")
-            return 0
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.count_documents_by_filter(): {e}"
+            raise QdrantStoreError(msg) from e
 
     async def count_documents_by_filter_async(self, filters: dict[str, Any]) -> int:
         """
@@ -1045,6 +1052,7 @@ class QdrantDocumentStore:
 
         :returns:
             The number of documents that match the filters.
+        :raises QdrantStoreError: Counting documents matching the filters fails.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
@@ -1056,9 +1064,9 @@ class QdrantDocumentStore:
                 count_filter=qdrant_filter,
             )
             return response.count
-        except (UnexpectedResponse, ValueError) as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.count_documents_by_filter_async()")
-            return 0
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.count_documents_by_filter_async(): {e}"
+            raise QdrantStoreError(msg) from e
 
     def get_metadata_fields_info(self) -> dict[str, dict[str, str]]:
         """
@@ -1073,6 +1081,7 @@ class QdrantDocumentStore:
             ```python
             {"category": {"type": "keyword"}, "priority": {"type": "long"}}
             ```
+        :raises QdrantStoreError: Retrieving or processing metadata field information fails.
         """
         self._initialize_client()
         assert self._client is not None
@@ -1098,9 +1107,9 @@ class QdrantDocumentStore:
                         break
 
             return fields_info
-        except (UnexpectedResponse, ValueError) as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_fields_info()")
-            return {}
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.get_metadata_fields_info(): {e}"
+            raise QdrantStoreError(msg) from e
 
     async def get_metadata_fields_info_async(self) -> dict[str, dict[str, str]]:
         """
@@ -1115,6 +1124,7 @@ class QdrantDocumentStore:
             ```python
             {"category": {"type": "keyword"}, "priority": {"type": "long"}}
             ```
+        :raises QdrantStoreError: Retrieving or processing metadata field information fails.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
@@ -1140,9 +1150,9 @@ class QdrantDocumentStore:
                         break
 
             return fields_info
-        except (UnexpectedResponse, ValueError) as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_fields_info_async()")
-            return {}
+        except Exception as e:
+            msg = f"Error when calling QdrantDocumentStore.get_metadata_fields_info_async(): {e}"
+            raise QdrantStoreError(msg) from e
 
     def get_metadata_field_min_max(self, metadata_field: str) -> dict[str, Any]:
         """
@@ -1153,6 +1163,7 @@ class QdrantDocumentStore:
         :returns: A dictionary with the keys "min" and "max", where each value is the minimum or maximum value of the
                   metadata field across all documents. Returns ``{"min": None, "max": None}`` if no documents have
                   the field.
+        :raises QdrantStoreError: Retrieving or computing the metadata bounds fails.
         """
         self._initialize_client()
         assert self._client is not None
@@ -1178,8 +1189,8 @@ class QdrantDocumentStore:
 
             return {"min": min_value, "max": max_value}
         except Exception as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_min_max()")
-            return {}
+            msg = f"Error when calling QdrantDocumentStore.get_metadata_field_min_max(): {e}"
+            raise QdrantStoreError(msg) from e
 
     async def get_metadata_field_min_max_async(self, metadata_field: str) -> dict[str, Any]:
         """
@@ -1190,6 +1201,7 @@ class QdrantDocumentStore:
         :returns: A dictionary with the keys "min" and "max", where each value is the minimum or maximum value of the
                   metadata field across all documents. Returns ``{"min": None, "max": None}`` if no documents have
                   the field.
+        :raises QdrantStoreError: Retrieving or computing the metadata bounds fails.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
@@ -1215,8 +1227,8 @@ class QdrantDocumentStore:
 
             return {"min": min_value, "max": max_value}
         except Exception as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_min_max_async()")
-            return {}
+            msg = f"Error when calling QdrantDocumentStore.get_metadata_field_min_max_async(): {e}"
+            raise QdrantStoreError(msg) from e
 
     def count_unique_metadata_by_filter(self, filters: dict[str, Any], metadata_fields: list[str]) -> dict[str, int]:
         """
@@ -1228,12 +1240,13 @@ class QdrantDocumentStore:
 
         :returns: A dictionary mapping each metadata field name to the count of its unique values among the filtered
                   documents.
+        :raises QdrantStoreError: Retrieving or counting unique metadata values fails.
         """
         self._initialize_client()
         assert self._client is not None
 
         qdrant_filter = convert_filters_to_qdrant(filters) if filters else None
-        unique_values_by_field: dict[str, set[Any]] = {field: set() for field in metadata_fields}
+        unique_values_by_field: dict[str, set[tuple[type, Any]]] = {field: set() for field in metadata_fields}
 
         try:
             next_offset = None
@@ -1252,8 +1265,8 @@ class QdrantDocumentStore:
 
             return {field: len(unique_values_by_field[field]) for field in metadata_fields}
         except Exception as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.count_unique_metadata_by_filter()")
-            return dict.fromkeys(metadata_fields, 0)
+            msg = f"Error when calling QdrantDocumentStore.count_unique_metadata_by_filter(): {e}"
+            raise QdrantStoreError(msg) from e
 
     async def count_unique_metadata_by_filter_async(
         self, filters: dict[str, Any], metadata_fields: list[str]
@@ -1269,12 +1282,13 @@ class QdrantDocumentStore:
 
         :returns: A dictionary mapping each metadata field name to the count of its unique values among the filtered
                   documents.
+        :raises QdrantStoreError: Retrieving or counting unique metadata values fails.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
 
         qdrant_filter = convert_filters_to_qdrant(filters) if filters else None
-        unique_values_by_field: dict[str, set[Any]] = {field: set() for field in metadata_fields}
+        unique_values_by_field: dict[str, set[tuple[type, Any]]] = {field: set() for field in metadata_fields}
 
         try:
             next_offset = None
@@ -1293,8 +1307,8 @@ class QdrantDocumentStore:
 
             return {field: len(unique_values_by_field[field]) for field in metadata_fields}
         except Exception as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.count_unique_metadata_by_filter_async()")
-            return dict.fromkeys(metadata_fields, 0)
+            msg = f"Error when calling QdrantDocumentStore.count_unique_metadata_by_filter_async(): {e}"
+            raise QdrantStoreError(msg) from e
 
     def get_metadata_field_unique_values(
         self,
@@ -1307,7 +1321,7 @@ class QdrantDocumentStore:
         """
         Returns unique values for a metadata field, with optional filters, search term and pagination.
 
-        Unique values are ordered by first occurrence during scroll.
+        Unique values are sorted by string representation, then by type name, before pagination is applied.
 
         **Note**: This operation can be expensive for metadata fields with many unique values, since all
         matching documents must be scrolled through to compute the total count.
@@ -1320,6 +1334,7 @@ class QdrantDocumentStore:
             For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
 
         :returns: A tuple containing (list of unique values, total count of unique matching values).
+        :raises QdrantStoreError: Retrieving or processing unique metadata values fails.
         """
         self._initialize_client()
         assert self._client is not None
@@ -1344,11 +1359,12 @@ class QdrantDocumentStore:
                 if self._check_stop_scrolling(next_offset):
                     break
 
+            unique_values.sort(key=lambda v: (str(v), type(v).__name__))
             total_count = len(unique_values)
             return unique_values[from_ : from_ + size], total_count
         except Exception as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_unique_values()")
-            return [], 0
+            msg = f"Error when calling QdrantDocumentStore.get_metadata_field_unique_values(): {e}"
+            raise QdrantStoreError(msg) from e
 
     async def get_metadata_field_unique_values_async(
         self,
@@ -1361,7 +1377,7 @@ class QdrantDocumentStore:
         """
         Asynchronously returns unique values for a metadata field, with optional filters, search term and pagination.
 
-        Unique values are ordered by first occurrence during scroll.
+        Unique values are sorted by string representation, then by type name, before pagination is applied.
 
         **Note**: This operation can be expensive for metadata fields with many unique values, since all
         matching documents must be scrolled through to compute the total count.
@@ -1374,6 +1390,7 @@ class QdrantDocumentStore:
             For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
 
         :returns: A tuple containing (list of unique values, total count of unique matching values).
+        :raises QdrantStoreError: Retrieving or processing unique metadata values fails.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
@@ -1398,11 +1415,12 @@ class QdrantDocumentStore:
                 if self._check_stop_scrolling(next_offset):
                     break
 
+            unique_values.sort(key=lambda v: (str(v), type(v).__name__))
             total_count = len(unique_values)
             return unique_values[from_ : from_ + size], total_count
         except Exception as e:
-            logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_unique_values_async()")
-            return [], 0
+            msg = f"Error when calling QdrantDocumentStore.get_metadata_field_unique_values_async(): {e}"
+            raise QdrantStoreError(msg) from e
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "QdrantDocumentStore":

{qdrant_haystack-10.5.0 → qdrant_haystack-11.0.0}/tests/test_document_store.py

@@ -267,8 +267,19 @@ class TestQdrantDocumentStoreUnit:
         ]
         unique: dict = {"category": set(), "tags": set()}
         QdrantDocumentStore._process_records_count_unique(records, ["category", "tags"], unique)
-        assert unique["category"] == {"A", "B"}
-        assert unique["tags"] == {"['x']", "['y']"}
+        assert len(unique["category"]) == 2
+        assert len(unique["tags"]) == 2
+
+    def test_process_records_count_unique_does_not_merge_different_types(self):
+        """Values that are `==` across types (`1 == True`, `1 == 1.0`) must still count as distinct."""
+        records = [
+            SimpleNamespace(payload={"meta": {"value": 1}}),
+            SimpleNamespace(payload={"meta": {"value": True}}),
+            SimpleNamespace(payload={"meta": {"value": 1.0}}),
+        ]
+        unique: dict = {"value": set()}
+        QdrantDocumentStore._process_records_count_unique(records, ["value"], unique)
+        assert len(unique["value"]) == 3
 
     def test_process_records_unique_values_collects_all(self):
         records = [SimpleNamespace(payload={"meta": {"v": i}}) for i in range(10)]
@@ -366,17 +377,19 @@ class TestQdrantDocumentStoreUnit:
             document_store._query_by_sparse(query_sparse_embedding=sparse_embedding)
 
     @pytest.mark.parametrize(
-        ("method_name", "args", "expected"),
+        ("method_name", "args"),
         [
-            ("count_documents", (), 0),
-            ("count_documents_by_filter", ({},), 0),
-            ("get_metadata_fields_info", (), {}),
-            ("get_metadata_field_min_max", ("score",), {}),
-            ("count_unique_metadata_by_filter", ({}, ["category"]), {"category": 0}),
-            ("get_metadata_field_unique_values", ("category",), ([], 0)),
+            ("count_documents", ()),
+            ("delete_all_documents", (False,)),
+            ("delete_all_documents", (True,)),
+            ("count_documents_by_filter", ({},)),
+            ("get_metadata_fields_info", ()),
+            ("get_metadata_field_min_max", ("score",)),
+            ("count_unique_metadata_by_filter", ({}, ["category"])),
+            ("get_metadata_field_unique_values", ("category",)),
         ],
     )
-    def test_metadata_methods_swallow_client_errors(self, method_name, args, expected):
+    def test_operations_raise_on_client_errors(self, method_name, args):
         document_store = QdrantDocumentStore(location=":memory:")
         document_store._initialize_client()
         err = ValueError("boom")
@@ -384,8 +397,11 @@ class TestQdrantDocumentStoreUnit:
             patch.object(document_store._client, "count", side_effect=err),
             patch.object(document_store._client, "scroll", side_effect=err),
             patch.object(document_store._client, "get_collection", side_effect=err),
+            patch.object(document_store._client, "delete", side_effect=err),
         ):
-            assert getattr(document_store, method_name)(*args) == expected
+            with pytest.raises(QdrantStoreError) as exc_info:
+                getattr(document_store, method_name)(*args)
+            assert exc_info.value.__cause__ is err
 
     def test_close(self):
         document_store = QdrantDocumentStore(location=":memory:")
@@ -611,65 +627,3 @@ class TestQdrantDocumentStore(
         assert len(updated_docs) == 1
         assert updated_docs[0].embedding is not None
         assert len(updated_docs[0].embedding) == 768
-
-    def test_get_metadata_field_unique_values_pagination(self, document_store: QdrantDocumentStore):
-        """Test getting unique metadata field values with pagination, total reflects the full unpaginated count."""
-        docs = [Document(content=f"Doc {i}", meta={"value": i % 5}) for i in range(10)]
-        document_store.write_documents(docs)
-
-        # Get first 2 unique values
-        values_page_1, total_1 = document_store.get_metadata_field_unique_values("value", from_=0, size=2)
-        assert len(values_page_1) == 2
-        assert total_1 == 5
-
-        # Get next 2 unique values
-        values_page_2, total_2 = document_store.get_metadata_field_unique_values("value", from_=2, size=2)
-        assert len(values_page_2) == 2
-        assert total_2 == 5
-
-        # Values should not overlap
-        assert set(values_page_1) != set(values_page_2)
-
-    def test_get_metadata_field_unique_values_with_filter(self, document_store: QdrantDocumentStore):
-        """Test getting unique metadata field values with filtering."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "status": "active"}),
-            Document(content="Doc 2", meta={"category": "B", "status": "active"}),
-            Document(content="Doc 3", meta={"category": "A", "status": "inactive"}),
-        ]
-        document_store.write_documents(docs)
-
-        values, total = document_store.get_metadata_field_unique_values(
-            "category", filters={"field": "meta.status", "operator": "==", "value": "active"}
-        )
-        assert set(values) == {"A", "B"}
-        assert total == 2
-
-    def test_get_metadata_field_unique_values_with_meta_prefix(self, document_store: QdrantDocumentStore):
-        """Test that a 'meta.'-prefixed field name is normalized before lookup."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A"}),
-            Document(content="Doc 2", meta={"category": "B"}),
-        ]
-        document_store.write_documents(docs)
-
-        values, total = document_store.get_metadata_field_unique_values("meta.category")
-        assert set(values) == {"A", "B"}
-        assert total == 2
-
-    def test_get_metadata_field_unique_values_with_search_term(self, document_store: QdrantDocumentStore):
-        """Test that search_term filters unique values by a case-insensitive substring match on the field value."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "Apple"}),
-            Document(content="Doc 2", meta={"category": "Banana"}),
-            Document(content="Doc 3", meta={"category": "Apricot"}),
-        ]
-        document_store.write_documents(docs)
-
-        values, total = document_store.get_metadata_field_unique_values("category", search_term="ap")
-        assert set(values) == {"Apple", "Apricot"}
-        assert total == 2
-
-        values, total = document_store.get_metadata_field_unique_values("category", search_term="nonexistent")
-        assert values == []
-        assert total == 0

{qdrant_haystack-10.5.0 → qdrant_haystack-11.0.0}/tests/test_document_store_async.py

@@ -141,17 +141,19 @@ class TestQdrantDocumentStoreAsyncUnit:
             await document_store.delete_documents_async(["doc-1"])
 
     @pytest.mark.parametrize(
-        ("method_name", "args", "expected"),
+        ("method_name", "args"),
         [
-            ("count_documents_async", (), 0),
-            ("count_documents_by_filter_async", ({},), 0),
-            ("get_metadata_fields_info_async", (), {}),
-            ("get_metadata_field_min_max_async", ("score",), {}),
-            ("count_unique_metadata_by_filter_async", ({}, ["category"]), {"category": 0}),
-            ("get_metadata_field_unique_values_async", ("category",), ([], 0)),
+            ("count_documents_async", ()),
+            ("delete_all_documents_async", (False,)),
+            ("delete_all_documents_async", (True,)),
+            ("count_documents_by_filter_async", ({},)),
+            ("get_metadata_fields_info_async", ()),
+            ("get_metadata_field_min_max_async", ("score",)),
+            ("count_unique_metadata_by_filter_async", ({}, ["category"])),
+            ("get_metadata_field_unique_values_async", ("category",)),
         ],
     )
-    async def test_metadata_methods_async_absorb_client_errors(self, method_name, args, expected):
+    async def test_operations_async_raise_on_client_errors(self, method_name, args):
         document_store = QdrantDocumentStore(location=":memory:")
         await document_store._initialize_async_client()
         err = ValueError("boom")
@@ -159,8 +161,11 @@ class TestQdrantDocumentStoreAsyncUnit:
             patch.object(document_store._async_client, "count", side_effect=err),
             patch.object(document_store._async_client, "scroll", side_effect=err),
             patch.object(document_store._async_client, "get_collection", side_effect=err),
+            patch.object(document_store._async_client, "delete", side_effect=err),
         ):
-            assert await getattr(document_store, method_name)(*args) == expected
+            with pytest.raises(QdrantStoreError) as exc_info:
+                await getattr(document_store, method_name)(*args)
+            assert exc_info.value.__cause__ is err
 
     async def test_close_async(self):
         document_store = QdrantDocumentStore(location=":memory:")
@@ -342,34 +347,3 @@ class TestQdrantDocumentStoreAsync(
         assert len(updated_docs) == 1
         assert updated_docs[0].embedding is not None
         assert len(updated_docs[0].embedding) == 768
-
-    async def test_get_metadata_field_unique_values_with_meta_prefix_async(self, document_store: QdrantDocumentStore):
-        """Test that a 'meta.'-prefixed field name is normalized before lookup."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A"}),
-            Document(content="Doc 2", meta={"category": "B"}),
-        ]
-        await document_store.write_documents_async(docs)
-
-        values, total = await document_store.get_metadata_field_unique_values_async("meta.category")
-        assert set(values) == {"A", "B"}
-        assert total == 2
-
-    async def test_get_metadata_field_unique_values_with_search_term_async(self, document_store: QdrantDocumentStore):
-        """Test that search_term filters unique values by a case-insensitive substring match on the field value."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "Apple"}),
-            Document(content="Doc 2", meta={"category": "Banana"}),
-            Document(content="Doc 3", meta={"category": "Apricot"}),
-        ]
-        await document_store.write_documents_async(docs)
-
-        values, total = await document_store.get_metadata_field_unique_values_async("category", search_term="ap")
-        assert set(values) == {"Apple", "Apricot"}
-        assert total == 2
-
-        values, total = await document_store.get_metadata_field_unique_values_async(
-            "category", search_term="nonexistent"
-        )
-        assert values == []
-        assert total == 0