pgvector-haystack 5.4.0__tar.gz → 5.5.0__tar.gz

{pgvector_haystack-5.4.0 → pgvector_haystack-5.5.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [integrations/pgvector-v5.4.0] - 2025-12-05
+
+### 📚 Documentation
+
+- Add pydoc configurations for Docusaurus (#2411)
+
+### ⚙️ CI
+
+- Change pytest command (#2475)
+
+### 🧹 Chores
+
+- Remove Readme API CI workflow and configs (#2573)
+- Pgvector - document expected connection string and raise informative error (#2583)
+
+### 🌀 Miscellaneous
+
+- Enhancement: Adopt PEP 585 type hinting (part 5) (#2528)
+
 ## [integrations/pgvector-v5.3.0] - 2025-10-17
 
 ### 🚀 Features

{pgvector_haystack-5.4.0 → pgvector_haystack-5.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 5.4.0
+Version: 5.5.0
 Summary: An integration of pgvector (vector search extension for Postgres) 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/pgvector/README.md

{pgvector_haystack-5.4.0 → pgvector_haystack-5.5.0}/src/haystack_integrations/document_stores/pgvector/document_store.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
+
 from typing import Any, Literal, Optional, Union, overload
 
 from haystack import default_from_dict, default_to_dict, logging
@@ -13,6 +14,7 @@ from psycopg.cursor_async import AsyncCursor
 from psycopg.rows import DictRow, dict_row
 from psycopg.sql import SQL, Composed, Identifier
 from psycopg.sql import Literal as SQLLiteral
+from psycopg.types.json import Jsonb
 
 from pgvector.psycopg import register_vector, register_vector_async
 
@@ -1036,6 +1038,190 @@ class PgvectorDocumentStore:
             error_msg="Could not delete all documents from PgvectorDocumentStore",
         )
 
+    def delete_by_filter(self, filters: dict[str, Any]) -> int:
+        """
+        Deletes all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for deletion.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :returns: The number of documents deleted.
+        """
+        _validate_filters(filters)
+
+        delete_sql = SQL("DELETE FROM {schema_name}.{table_name}").format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params = ()
+        if filters:
+            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+            delete_sql += sql_where_clause
+
+        self._ensure_db_setup()
+        assert self._cursor is not None
+
+        try:
+            self._execute_sql(
+                cursor=self._cursor,
+                sql_query=delete_sql,
+                params=params,
+                error_msg="Could not delete documents by filter from PgvectorDocumentStore",
+            )
+            deleted_count = self._cursor.rowcount
+            logger.info(
+                "Deleted {n_docs} documents from table '{schema}.{table}' using filters.",
+                n_docs=deleted_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return deleted_count
+        except Error as e:
+            msg = f"Failed to delete documents by filter from PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
+    async def delete_by_filter_async(self, filters: dict[str, Any]) -> int:
+        """
+        Asynchronously deletes all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for deletion.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :returns: The number of documents deleted.
+        """
+        _validate_filters(filters)
+
+        delete_sql = SQL("DELETE FROM {schema_name}.{table_name}").format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params = ()
+        if filters:
+            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+            delete_sql += sql_where_clause
+
+        await self._ensure_db_setup_async()
+        assert self._async_cursor is not None
+
+        try:
+            await self._execute_sql_async(
+                cursor=self._async_cursor,
+                sql_query=delete_sql,
+                params=params,
+                error_msg="Could not delete documents by filter from PgvectorDocumentStore",
+            )
+            deleted_count = self._async_cursor.rowcount
+            logger.info(
+                "Deleted {n_docs} documents from table '{schema}.{table}' using filters.",
+                n_docs=deleted_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return deleted_count
+        except Error as e:
+            msg = f"Failed to delete documents by filter from PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
+    def update_by_filter(self, filters: dict[str, Any], meta: dict[str, Any]) -> int:
+        """
+        Updates the metadata of all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for updating.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :param meta: The metadata fields to update.
+        :returns: The number of documents updated.
+        """
+        _validate_filters(filters)
+
+        if not meta:
+            msg = "meta must be a non-empty dictionary"
+            raise ValueError(msg)
+
+        update_sql = SQL(
+            "UPDATE {schema_name}.{table_name} SET meta = COALESCE(meta, '{{}}'::jsonb) || %s::jsonb"
+        ).format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params: tuple[Any, ...] = (Jsonb(meta),)
+        if filters:
+            sql_where_clause, where_params = _convert_filters_to_where_clause_and_params(filters)
+            update_sql += sql_where_clause
+            params = params + where_params
+
+        self._ensure_db_setup()
+        assert self._cursor is not None
+
+        try:
+            self._execute_sql(
+                cursor=self._cursor,
+                sql_query=update_sql,
+                params=params,
+                error_msg="Could not update documents by filter from PgvectorDocumentStore",
+            )
+            updated_count = self._cursor.rowcount
+            logger.info(
+                "Updated {n_docs} documents in table '{schema}.{table}' using filters.",
+                n_docs=updated_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return updated_count
+        except Error as e:
+            msg = f"Failed to update documents by filter in PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
+    async def update_by_filter_async(self, filters: dict[str, Any], meta: dict[str, Any]) -> int:
+        """
+        Asynchronously updates the metadata of all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for updating.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :param meta: The metadata fields to update.
+        :returns: The number of documents updated.
+        """
+        _validate_filters(filters)
+
+        if not meta:
+            msg = "meta must be a non-empty dictionary"
+            raise ValueError(msg)
+
+        update_sql = SQL(
+            "UPDATE {schema_name}.{table_name} SET meta = COALESCE(meta, '{{}}'::jsonb) || %s::jsonb"
+        ).format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params: tuple[Any, ...] = (Jsonb(meta),)
+        if filters:
+            sql_where_clause, where_params = _convert_filters_to_where_clause_and_params(filters)
+            update_sql += sql_where_clause
+            params = params + where_params
+
+        await self._ensure_db_setup_async()
+        assert self._async_cursor is not None
+
+        try:
+            await self._execute_sql_async(
+                cursor=self._async_cursor,
+                sql_query=update_sql,
+                params=params,
+                error_msg="Could not update documents by filter from PgvectorDocumentStore",
+            )
+            updated_count = self._async_cursor.rowcount
+            logger.info(
+                "Updated {n_docs} documents in table '{schema}.{table}' using filters.",
+                n_docs=updated_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return updated_count
+        except Error as e:
+            msg = f"Failed to update documents by filter in PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
     def _build_keyword_retrieval_query(
         self, query: str, top_k: int, filters: Optional[dict[str, Any]] = None
     ) -> tuple[Composed, tuple]:

{pgvector_haystack-5.4.0 → pgvector_haystack-5.5.0}/tests/test_document_store.py

@@ -260,3 +260,221 @@ def test_delete_table_first_call(document_store):
     without triggering errors due to an uninitialized state.
     """
     document_store.delete_table()  # if throw error, test fails
+
+
+@pytest.mark.integration
+def test_delete_by_filter(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="Doc 1", meta={"category": "A", "year": 2023}),
+        Document(content="Doc 2", meta={"category": "B", "year": 2023}),
+        Document(content="Doc 3", meta={"category": "A", "year": 2024}),
+    ]
+    document_store.write_documents(docs)
+    assert document_store.count_documents() == 3
+
+    deleted_count = document_store.delete_by_filter(filters={"field": "meta.category", "operator": "==", "value": "A"})
+    assert deleted_count == 2
+    assert document_store.count_documents() == 1
+
+    remaining_docs = document_store.filter_documents()
+    assert len(remaining_docs) == 1
+    assert remaining_docs[0].meta["category"] == "B"
+
+    deleted_count = document_store.delete_by_filter(filters={"field": "meta.year", "operator": "==", "value": 2023})
+    assert deleted_count == 1
+    assert document_store.count_documents() == 0
+
+
+@pytest.mark.integration
+def test_delete_by_filter_no_matches(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="Doc 1", meta={"category": "A"}),
+        Document(content="Doc 2", meta={"category": "B"}),
+    ]
+    document_store.write_documents(docs)
+    assert document_store.count_documents() == 2
+
+    deleted_count = document_store.delete_by_filter(filters={"field": "meta.category", "operator": "==", "value": "C"})
+    assert deleted_count == 0
+    assert document_store.count_documents() == 2
+
+
+@pytest.mark.integration
+def test_delete_by_filter_advanced_filters(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="Doc 1", meta={"category": "A", "year": 2023, "status": "draft"}),
+        Document(content="Doc 2", meta={"category": "A", "year": 2024, "status": "published"}),
+        Document(content="Doc 3", meta={"category": "B", "year": 2023, "status": "draft"}),
+    ]
+    document_store.write_documents(docs)
+    assert document_store.count_documents() == 3
+
+    # AND condition
+    deleted_count = document_store.delete_by_filter(
+        filters={
+            "operator": "AND",
+            "conditions": [
+                {"field": "meta.category", "operator": "==", "value": "A"},
+                {"field": "meta.year", "operator": "==", "value": 2023},
+            ],
+        }
+    )
+    assert deleted_count == 1
+    assert document_store.count_documents() == 2
+
+    # OR condition
+    deleted_count = document_store.delete_by_filter(
+        filters={
+            "operator": "OR",
+            "conditions": [
+                {"field": "meta.category", "operator": "==", "value": "B"},
+                {"field": "meta.status", "operator": "==", "value": "published"},
+            ],
+        }
+    )
+    assert deleted_count == 2
+    assert document_store.count_documents() == 0
+
+
+@pytest.mark.integration
+def test_update_by_filter(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="Doc 1", meta={"category": "A", "status": "draft"}),
+        Document(content="Doc 2", meta={"category": "B", "status": "draft"}),
+        Document(content="Doc 3", meta={"category": "A", "status": "draft"}),
+    ]
+    document_store.write_documents(docs)
+    assert document_store.count_documents() == 3
+
+    # update status for category="A" documents
+    updated_count = document_store.update_by_filter(
+        filters={"field": "meta.category", "operator": "==", "value": "A"}, meta={"status": "published"}
+    )
+    assert updated_count == 2
+
+    # verify
+    published_docs = document_store.filter_documents(
+        filters={"field": "meta.status", "operator": "==", "value": "published"}
+    )
+    assert len(published_docs) == 2
+    for doc in published_docs:
+        assert doc.meta["category"] == "A"
+        assert doc.meta["status"] == "published"
+
+    # Verify category B still has draft status
+    draft_docs = document_store.filter_documents(filters={"field": "meta.status", "operator": "==", "value": "draft"})
+    assert len(draft_docs) == 1
+    assert draft_docs[0].meta["category"] == "B"
+
+
+@pytest.mark.integration
+def test_update_by_filter_multiple_fields(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="Doc 1", meta={"category": "A", "year": 2023}),
+        Document(content="Doc 2", meta={"category": "A", "year": 2023}),
+        Document(content="Doc 3", meta={"category": "B", "year": 2024}),
+    ]
+    document_store.write_documents(docs)
+    assert document_store.count_documents() == 3
+
+    # update multiple fields for category="A" documents
+    updated_count = document_store.update_by_filter(
+        filters={"field": "meta.category", "operator": "==", "value": "A"},
+        meta={"status": "published", "priority": "high", "reviewed": True},
+    )
+    assert updated_count == 2
+
+    # verify
+    published_docs = document_store.filter_documents(filters={"field": "meta.category", "operator": "==", "value": "A"})
+    assert len(published_docs) == 2
+    for doc in published_docs:
+        assert doc.meta["status"] == "published"
+        assert doc.meta["priority"] == "high"
+        assert doc.meta["reviewed"] is True
+        assert doc.meta["year"] == 2023  # Original field should still be present
+
+    # verify category B was not updated
+    b_docs = document_store.filter_documents(filters={"field": "meta.category", "operator": "==", "value": "B"})
+    assert len(b_docs) == 1
+    assert "status" not in b_docs[0].meta
+    assert "priority" not in b_docs[0].meta
+
+
+@pytest.mark.integration
+def test_update_by_filter_no_matches(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="Doc 1", meta={"category": "A"}),
+        Document(content="Doc 2", meta={"category": "B"}),
+    ]
+    document_store.write_documents(docs)
+    assert document_store.count_documents() == 2
+
+    # update documents with category="C" (no matches)
+    updated_count = document_store.update_by_filter(
+        filters={"field": "meta.category", "operator": "==", "value": "C"}, meta={"status": "published"}
+    )
+    assert updated_count == 0
+    assert document_store.count_documents() == 2
+
+    # verify no documents were updated
+    published_docs = document_store.filter_documents(
+        filters={"field": "meta.status", "operator": "==", "value": "published"}
+    )
+    assert len(published_docs) == 0
+
+
+@pytest.mark.integration
+def test_update_by_filter_advanced_filters(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="Doc 1", meta={"category": "A", "year": 2023, "status": "draft"}),
+        Document(content="Doc 2", meta={"category": "A", "year": 2024, "status": "draft"}),
+        Document(content="Doc 3", meta={"category": "B", "year": 2023, "status": "draft"}),
+    ]
+    document_store.write_documents(docs)
+    assert document_store.count_documents() == 3
+
+    # AND condition
+    updated_count = document_store.update_by_filter(
+        filters={
+            "operator": "AND",
+            "conditions": [
+                {"field": "meta.category", "operator": "==", "value": "A"},
+                {"field": "meta.year", "operator": "==", "value": 2023},
+            ],
+        },
+        meta={"status": "published"},
+    )
+    assert updated_count == 1
+
+    # verify only one document was updated
+    published_docs = document_store.filter_documents(
+        filters={"field": "meta.status", "operator": "==", "value": "published"}
+    )
+    assert len(published_docs) == 1
+    assert published_docs[0].meta["category"] == "A"
+    assert published_docs[0].meta["year"] == 2023
+
+    # OR condition
+    updated_count = document_store.update_by_filter(
+        filters={
+            "operator": "OR",
+            "conditions": [
+                {"field": "meta.category", "operator": "==", "value": "B"},
+                {"field": "meta.year", "operator": "==", "value": 2024},
+            ],
+        },
+        meta={"featured": True},
+    )
+    assert updated_count == 2
+
+    featured_docs = document_store.filter_documents(filters={"field": "meta.featured", "operator": "==", "value": True})
+    assert len(featured_docs) == 2
+
+
+@pytest.mark.integration
+def test_update_by_filter_empty_meta_raises_error(document_store: PgvectorDocumentStore):
+    docs = [Document(content="Doc 1", meta={"category": "A"})]
+    document_store.write_documents(docs)
+
+    with pytest.raises(ValueError, match="meta must be a non-empty dictionary"):
+        document_store.update_by_filter(filters={"field": "meta.category", "operator": "==", "value": "A"}, meta={})

pgvector_haystack-5.5.0/tests/test_document_store_async.py

@@ -0,0 +1,450 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from unittest.mock import patch
+
+import psycopg
+import pytest
+from haystack.dataclasses.document import ByteStream, Document
+from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
+from haystack.document_stores.types import DuplicatePolicy
+from haystack.utils import Secret
+from psycopg.sql import SQL
+
+from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+class TestDocumentStoreAsync:
+    async def test_write_documents(self, document_store: PgvectorDocumentStore):
+        docs = [Document(id="1")]
+        assert await document_store.write_documents_async(docs) == 1
+        with pytest.raises(DuplicateDocumentError):
+            await document_store.write_documents_async(docs, DuplicatePolicy.FAIL)
+
+    async def test_write_blob(self, document_store: PgvectorDocumentStore):
+        bytestream = ByteStream(b"test", meta={"meta_key": "meta_value"}, mime_type="mime_type")
+        docs = [Document(id="1", blob=bytestream)]
+        await document_store.write_documents_async(docs)
+
+        retrieved_docs = await document_store.filter_documents_async()
+        assert retrieved_docs == docs
+
+    async def test_count_documents(self, document_store: PgvectorDocumentStore):
+        await document_store.write_documents_async(
+            [
+                Document(content="test doc 1"),
+                Document(content="test doc 2"),
+                Document(content="test doc 3"),
+            ]
+        )
+        assert await document_store.count_documents_async() == 3
+
+    async def test_filter_documents(self, document_store: PgvectorDocumentStore):
+        filterable_docs = [
+            Document(
+                content="1",
+                meta={
+                    "number": -10,
+                },
+            ),
+            Document(
+                content="2",
+                meta={
+                    "number": 100,
+                },
+            ),
+        ]
+        await document_store.write_documents_async(filterable_docs)
+        result = await document_store.filter_documents_async(
+            filters={"field": "meta.number", "operator": "==", "value": 100}
+        )
+
+        assert result == [d for d in filterable_docs if d.meta.get("number") == 100]
+
+    async def test_delete_documents(self, document_store: PgvectorDocumentStore):
+        doc = Document(content="test doc")
+        await document_store.write_documents_async([doc])
+        assert await document_store.count_documents_async() == 1
+
+        await document_store.delete_documents_async([doc.id])
+        assert await document_store.count_documents_async() == 0
+
+    async def test_connection_check_and_recreation(self, document_store: PgvectorDocumentStore):
+        await document_store._ensure_db_setup_async()
+        original_connection = document_store._async_connection
+
+        with patch.object(PgvectorDocumentStore, "_connection_is_valid_async", return_value=False):
+            await document_store._ensure_db_setup_async()
+            new_connection = document_store._async_connection
+
+        # verify that a new connection is created
+        assert new_connection is not original_connection
+        assert document_store._async_connection == new_connection
+        assert original_connection.closed
+
+        assert document_store._async_cursor is not None
+        assert document_store._async_dict_cursor is not None
+
+        # test with new connection
+        with patch.object(PgvectorDocumentStore, "_connection_is_valid_async", return_value=True):
+            await document_store._ensure_db_setup_async()
+            same_connection = document_store._async_connection
+            assert same_connection is document_store._async_connection
+
+    async def test_delete_all_documents_async(self, document_store: PgvectorDocumentStore) -> None:
+        document_store.write_documents([Document(id=str(i)) for i in range(10)])
+        await document_store.delete_all_documents_async()
+        assert document_store.count_documents() == 0
+        document_store.write_documents([Document(id="1")])
+        assert document_store.count_documents() == 1
+
+    async def test_invalid_connection_string(self, monkeypatch):
+        monkeypatch.setenv("PG_CONN_STR", "invalid_connection_string")
+        document_store = PgvectorDocumentStore()
+        with pytest.raises(DocumentStoreError) as e:
+            await document_store._ensure_db_setup_async()
+        assert "Failed to connect to PostgreSQL database" in str(e)
+
+    async def test_delete_by_filter_async(self, document_store: PgvectorDocumentStore):
+        docs = [
+            Document(content="Doc 1", meta={"category": "A", "year": 2023}),
+            Document(content="Doc 2", meta={"category": "B", "year": 2023}),
+            Document(content="Doc 3", meta={"category": "A", "year": 2024}),
+        ]
+        await document_store.write_documents_async(docs)
+        assert await document_store.count_documents_async() == 3
+
+        deleted_count = await document_store.delete_by_filter_async(
+            filters={"field": "meta.category", "operator": "==", "value": "A"}
+        )
+        assert deleted_count == 2
+        assert await document_store.count_documents_async() == 1
+
+        remaining_docs = await document_store.filter_documents_async()
+        assert len(remaining_docs) == 1
+        assert remaining_docs[0].meta["category"] == "B"
+
+        deleted_count = await document_store.delete_by_filter_async(
+            filters={"field": "meta.year", "operator": "==", "value": 2023}
+        )
+        assert deleted_count == 1
+        assert await document_store.count_documents_async() == 0
+
+    async def test_delete_by_filter_async_no_matches(self, document_store: PgvectorDocumentStore):
+        docs = [
+            Document(content="Doc 1", meta={"category": "A"}),
+            Document(content="Doc 2", meta={"category": "B"}),
+        ]
+        await document_store.write_documents_async(docs)
+        assert await document_store.count_documents_async() == 2
+
+        deleted_count = await document_store.delete_by_filter_async(
+            filters={"field": "meta.category", "operator": "==", "value": "C"}
+        )
+        assert deleted_count == 0
+        assert await document_store.count_documents_async() == 2
+
+    async def test_delete_by_filter_async_advanced_filters(self, document_store: PgvectorDocumentStore):
+        docs = [
+            Document(content="Doc 1", meta={"category": "A", "year": 2023, "status": "draft"}),
+            Document(content="Doc 2", meta={"category": "A", "year": 2024, "status": "published"}),
+            Document(content="Doc 3", meta={"category": "B", "year": 2023, "status": "draft"}),
+        ]
+        await document_store.write_documents_async(docs)
+        assert await document_store.count_documents_async() == 3
+
+        # AND condition
+        deleted_count = await document_store.delete_by_filter_async(
+            filters={
+                "operator": "AND",
+                "conditions": [
+                    {"field": "meta.category", "operator": "==", "value": "A"},
+                    {"field": "meta.year", "operator": "==", "value": 2023},
+                ],
+            }
+        )
+        assert deleted_count == 1
+        assert await document_store.count_documents_async() == 2
+
+        # OR condition
+        deleted_count = await document_store.delete_by_filter_async(
+            filters={
+                "operator": "OR",
+                "conditions": [
+                    {"field": "meta.category", "operator": "==", "value": "B"},
+                    {"field": "meta.status", "operator": "==", "value": "published"},
+                ],
+            }
+        )
+        assert deleted_count == 2
+        assert await document_store.count_documents_async() == 0
+
+    async def test_update_by_filter_async(self, document_store: PgvectorDocumentStore):
+        docs = [
+            Document(content="Doc 1", meta={"category": "A", "status": "draft"}),
+            Document(content="Doc 2", meta={"category": "B", "status": "draft"}),
+            Document(content="Doc 3", meta={"category": "A", "status": "draft"}),
+        ]
+        await document_store.write_documents_async(docs)
+        assert await document_store.count_documents_async() == 3
+
+        # Update status for category="A" documents
+        updated_count = await document_store.update_by_filter_async(
+            filters={"field": "meta.category", "operator": "==", "value": "A"}, meta={"status": "published"}
+        )
+        assert updated_count == 2
+
+        # Verify the updates
+        published_docs = await document_store.filter_documents_async(
+            filters={"field": "meta.status", "operator": "==", "value": "published"}
+        )
+        assert len(published_docs) == 2
+        for doc in published_docs:
+            assert doc.meta["category"] == "A"
+            assert doc.meta["status"] == "published"
+
+        # Verify category B still has draft status
+        draft_docs = await document_store.filter_documents_async(
+            filters={"field": "meta.status", "operator": "==", "value": "draft"}
+        )
+        assert len(draft_docs) == 1
+        assert draft_docs[0].meta["category"] == "B"
+
+    async def test_update_by_filter_async_multiple_fields(self, document_store: PgvectorDocumentStore):
+        docs = [
+            Document(content="Doc 1", meta={"category": "A", "year": 2023}),
+            Document(content="Doc 2", meta={"category": "A", "year": 2023}),
+            Document(content="Doc 3", meta={"category": "B", "year": 2024}),
+        ]
+        await document_store.write_documents_async(docs)
+        assert await document_store.count_documents_async() == 3
+
+        # update multiple fields for category="A" documents
+        updated_count = await document_store.update_by_filter_async(
+            filters={"field": "meta.category", "operator": "==", "value": "A"},
+            meta={"status": "published", "priority": "high", "reviewed": True},
+        )
+        assert updated_count == 2
+
+        # verify
+        published_docs = await document_store.filter_documents_async(
+            filters={"field": "meta.category", "operator": "==", "value": "A"}
+        )
+        assert len(published_docs) == 2
+        for doc in published_docs:
+            assert doc.meta["status"] == "published"
+            assert doc.meta["priority"] == "high"
+            assert doc.meta["reviewed"] is True
+            assert doc.meta["year"] == 2023  # Original field should still be present
+
+        # verify category B was not updated
+        b_docs = await document_store.filter_documents_async(
+            filters={"field": "meta.category", "operator": "==", "value": "B"}
+        )
+        assert len(b_docs) == 1
+        assert "status" not in b_docs[0].meta
+        assert "priority" not in b_docs[0].meta
+
+    async def test_update_by_filter_async_no_matches(self, document_store: PgvectorDocumentStore):
+        docs = [
+            Document(content="Doc 1", meta={"category": "A"}),
+            Document(content="Doc 2", meta={"category": "B"}),
+        ]
+        await document_store.write_documents_async(docs)
+        assert await document_store.count_documents_async() == 2
+
+        # update documents with category="C" (no matches)
+        updated_count = await document_store.update_by_filter_async(
+            filters={"field": "meta.category", "operator": "==", "value": "C"}, meta={"status": "published"}
+        )
+        assert updated_count == 0
+        assert await document_store.count_documents_async() == 2
+
+        # verify no documents were updated
+        published_docs = await document_store.filter_documents_async(
+            filters={"field": "meta.status", "operator": "==", "value": "published"}
+        )
+        assert len(published_docs) == 0
+
+    async def test_update_by_filter_async_advanced_filters(self, document_store: PgvectorDocumentStore):
+        docs = [
+            Document(content="Doc 1", meta={"category": "A", "year": 2023, "status": "draft"}),
+            Document(content="Doc 2", meta={"category": "A", "year": 2024, "status": "draft"}),
+            Document(content="Doc 3", meta={"category": "B", "year": 2023, "status": "draft"}),
+        ]
+        await document_store.write_documents_async(docs)
+        assert await document_store.count_documents_async() == 3
+
+        # AND condition
+        updated_count = await document_store.update_by_filter_async(
+            filters={
+                "operator": "AND",
+                "conditions": [
+                    {"field": "meta.category", "operator": "==", "value": "A"},
+                    {"field": "meta.year", "operator": "==", "value": 2023},
+                ],
+            },
+            meta={"status": "published"},
+        )
+        assert updated_count == 1
+
+        # verify
+        published_docs = await document_store.filter_documents_async(
+            filters={"field": "meta.status", "operator": "==", "value": "published"}
+        )
+        assert len(published_docs) == 1
+        assert published_docs[0].meta["category"] == "A"
+        assert published_docs[0].meta["year"] == 2023
+
+        # OR condition
+        updated_count = await document_store.update_by_filter_async(
+            filters={
+                "operator": "OR",
+                "conditions": [
+                    {"field": "meta.category", "operator": "==", "value": "B"},
+                    {"field": "meta.year", "operator": "==", "value": 2024},
+                ],
+            },
+            meta={"featured": True},
+        )
+        assert updated_count == 2
+
+        featured_docs = await document_store.filter_documents_async(
+            filters={"field": "meta.featured", "operator": "==", "value": True}
+        )
+        assert len(featured_docs) == 2
+
+    async def test_update_by_filter_async_empty_meta_raises_error(self, document_store: PgvectorDocumentStore):
+        docs = [Document(content="Doc 1", meta={"category": "A"})]
+        await document_store.write_documents_async(docs)
+
+        with pytest.raises(ValueError, match="meta must be a non-empty dictionary"):
+            await document_store.update_by_filter_async(
+                filters={"field": "meta.category", "operator": "==", "value": "A"}, meta={}
+            )
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_hnsw_index_recreation():
+    async def get_index_oid(cursor, document_store, schema_name, index_name):
+        sql_get_index_oid = SQL("""
+            SELECT c.oid
+            FROM pg_class c
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind = 'i'
+            AND n.nspname = %s
+            AND c.relname = %s;
+        """)
+        result = await document_store._execute_sql_async(
+            cursor=cursor, sql_query=sql_get_index_oid, params=(schema_name, index_name)
+        )
+        return (await result.fetchone())[0]
+
+    # create a new schema
+    connection_string = "postgresql://postgres:postgres@localhost:5432/postgres"
+    schema_name = "test_schema"
+    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
+        await conn.execute(f"CREATE SCHEMA IF NOT EXISTS {schema_name}")
+
+    # create a first document store and trigger the creation of the hnsw index
+    params = {
+        "connection_string": Secret.from_token(connection_string),
+        "schema_name": schema_name,
+        "table_name": "haystack_test_hnsw_index_recreation",
+        "search_strategy": "hnsw",
+    }
+    ds1 = PgvectorDocumentStore(**params)
+    await ds1._ensure_db_setup_async()
+
+    # get the hnsw index oid
+    hnws_index_name = "haystack_hnsw_index"
+    first_oid = await get_index_oid(
+        cursor=ds1._async_cursor, document_store=ds1, schema_name=ds1.schema_name, index_name=hnws_index_name
+    )
+
+    # create second document store with recreation enabled
+    ds2 = PgvectorDocumentStore(**params, hnsw_recreate_index_if_exists=True)
+    await ds2._ensure_db_setup_async()
+
+    # get the index oid
+    second_oid = await get_index_oid(
+        cursor=ds2._async_cursor, document_store=ds2, schema_name=ds2.schema_name, index_name=hnws_index_name
+    )
+
+    # verify that oids differ
+    assert second_oid != first_oid, "Index was not recreated (OID remained the same)"
+
+    # Clean up: drop the schema after the test
+    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
+        await conn.execute(f"DROP SCHEMA IF EXISTS {schema_name} CASCADE")
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_create_table_if_not_exists():
+    async def get_table_oid(cursor, document_store, schema_name, table_name):
+        sql_get_table_oid = SQL("""
+            SELECT c.oid
+            FROM pg_class c
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind = 'r'
+            AND n.nspname = %s
+            AND c.relname = %s;
+        """)
+        result = await document_store._execute_sql_async(
+            cursor=cursor, sql_query=sql_get_table_oid, params=(schema_name, table_name)
+        )
+        return (await result.fetchone())[0]
+
+    connection_string = "postgresql://postgres:postgres@localhost:5432/postgres"
+    schema_name = "test_schema"
+    table_name = "test_table"
+
+    # Create a new schema
+    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
+        await conn.execute(f"CREATE SCHEMA {schema_name}")
+
+    document_store = PgvectorDocumentStore(
+        connection_string=Secret.from_token(connection_string),
+        schema_name=schema_name,
+        table_name=table_name,
+    )
+
+    await document_store._ensure_db_setup_async()
+    await document_store._initialize_table_async()
+
+    first_table_oid = await get_table_oid(
+        cursor=document_store._async_cursor,
+        document_store=document_store,
+        schema_name=schema_name,
+        table_name=table_name,
+    )
+    assert first_table_oid is not None, "Table was not created"
+
+    await document_store._initialize_table_async()
+    second_table_oid = await get_table_oid(
+        cursor=document_store._async_cursor,
+        document_store=document_store,
+        schema_name=schema_name,
+        table_name=table_name,
+    )
+
+    assert first_table_oid == second_table_oid, "Table was recreated"
+
+    # Clean up: drop the schema after the test
+    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
+        await conn.execute(f"DROP SCHEMA IF EXISTS {schema_name} CASCADE")
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_delete_table_async_first_call(document_store):
+    """
+    Test that delete_table_async can be executed as the initial operation on the Document Store
+    without triggering errors due to an uninitialized state.
+    """
+    await document_store.delete_table_async()  # if throw error, test fails

pgvector_haystack-5.4.0/tests/test_document_store_async.py

@@ -1,232 +0,0 @@
-# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from unittest.mock import patch
-
-import psycopg
-import pytest
-from haystack.dataclasses.document import ByteStream, Document
-from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
-from haystack.document_stores.types import DuplicatePolicy
-from haystack.utils import Secret
-from psycopg.sql import SQL
-
-from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-class TestDocumentStoreAsync:
-    async def test_write_documents(self, document_store: PgvectorDocumentStore):
-        docs = [Document(id="1")]
-        assert await document_store.write_documents_async(docs) == 1
-        with pytest.raises(DuplicateDocumentError):
-            await document_store.write_documents_async(docs, DuplicatePolicy.FAIL)
-
-    async def test_write_blob(self, document_store: PgvectorDocumentStore):
-        bytestream = ByteStream(b"test", meta={"meta_key": "meta_value"}, mime_type="mime_type")
-        docs = [Document(id="1", blob=bytestream)]
-        await document_store.write_documents_async(docs)
-
-        retrieved_docs = await document_store.filter_documents_async()
-        assert retrieved_docs == docs
-
-    async def test_count_documents(self, document_store: PgvectorDocumentStore):
-        await document_store.write_documents_async(
-            [
-                Document(content="test doc 1"),
-                Document(content="test doc 2"),
-                Document(content="test doc 3"),
-            ]
-        )
-        assert await document_store.count_documents_async() == 3
-
-    async def test_filter_documents(self, document_store: PgvectorDocumentStore):
-        filterable_docs = [
-            Document(
-                content="1",
-                meta={
-                    "number": -10,
-                },
-            ),
-            Document(
-                content="2",
-                meta={
-                    "number": 100,
-                },
-            ),
-        ]
-        await document_store.write_documents_async(filterable_docs)
-        result = await document_store.filter_documents_async(
-            filters={"field": "meta.number", "operator": "==", "value": 100}
-        )
-
-        assert result == [d for d in filterable_docs if d.meta.get("number") == 100]
-
-    async def test_delete_documents(self, document_store: PgvectorDocumentStore):
-        doc = Document(content="test doc")
-        await document_store.write_documents_async([doc])
-        assert await document_store.count_documents_async() == 1
-
-        await document_store.delete_documents_async([doc.id])
-        assert await document_store.count_documents_async() == 0
-
-    async def test_connection_check_and_recreation(self, document_store: PgvectorDocumentStore):
-        await document_store._ensure_db_setup_async()
-        original_connection = document_store._async_connection
-
-        with patch.object(PgvectorDocumentStore, "_connection_is_valid_async", return_value=False):
-            await document_store._ensure_db_setup_async()
-            new_connection = document_store._async_connection
-
-        # verify that a new connection is created
-        assert new_connection is not original_connection
-        assert document_store._async_connection == new_connection
-        assert original_connection.closed
-
-        assert document_store._async_cursor is not None
-        assert document_store._async_dict_cursor is not None
-
-        # test with new connection
-        with patch.object(PgvectorDocumentStore, "_connection_is_valid_async", return_value=True):
-            await document_store._ensure_db_setup_async()
-            same_connection = document_store._async_connection
-            assert same_connection is document_store._async_connection
-
-    async def test_delete_all_documents_async(self, document_store: PgvectorDocumentStore) -> None:
-        document_store.write_documents([Document(id=str(i)) for i in range(10)])
-        await document_store.delete_all_documents_async()
-        assert document_store.count_documents() == 0
-        document_store.write_documents([Document(id="1")])
-        assert document_store.count_documents() == 1
-
-    async def test_invalid_connection_string(self, monkeypatch):
-        monkeypatch.setenv("PG_CONN_STR", "invalid_connection_string")
-        document_store = PgvectorDocumentStore()
-        with pytest.raises(DocumentStoreError) as e:
-            await document_store._ensure_db_setup_async()
-        assert "Failed to connect to PostgreSQL database" in str(e)
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_hnsw_index_recreation():
-    async def get_index_oid(cursor, document_store, schema_name, index_name):
-        sql_get_index_oid = SQL("""
-            SELECT c.oid
-            FROM pg_class c
-            JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind = 'i'
-            AND n.nspname = %s
-            AND c.relname = %s;
-        """)
-        result = await document_store._execute_sql_async(
-            cursor=cursor, sql_query=sql_get_index_oid, params=(schema_name, index_name)
-        )
-        return (await result.fetchone())[0]
-
-    # create a new schema
-    connection_string = "postgresql://postgres:postgres@localhost:5432/postgres"
-    schema_name = "test_schema"
-    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
-        await conn.execute(f"CREATE SCHEMA IF NOT EXISTS {schema_name}")
-
-    # create a first document store and trigger the creation of the hnsw index
-    params = {
-        "connection_string": Secret.from_token(connection_string),
-        "schema_name": schema_name,
-        "table_name": "haystack_test_hnsw_index_recreation",
-        "search_strategy": "hnsw",
-    }
-    ds1 = PgvectorDocumentStore(**params)
-    await ds1._ensure_db_setup_async()
-
-    # get the hnsw index oid
-    hnws_index_name = "haystack_hnsw_index"
-    first_oid = await get_index_oid(
-        cursor=ds1._async_cursor, document_store=ds1, schema_name=ds1.schema_name, index_name=hnws_index_name
-    )
-
-    # create second document store with recreation enabled
-    ds2 = PgvectorDocumentStore(**params, hnsw_recreate_index_if_exists=True)
-    await ds2._ensure_db_setup_async()
-
-    # get the index oid
-    second_oid = await get_index_oid(
-        cursor=ds2._async_cursor, document_store=ds2, schema_name=ds2.schema_name, index_name=hnws_index_name
-    )
-
-    # verify that oids differ
-    assert second_oid != first_oid, "Index was not recreated (OID remained the same)"
-
-    # Clean up: drop the schema after the test
-    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
-        await conn.execute(f"DROP SCHEMA IF EXISTS {schema_name} CASCADE")
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_create_table_if_not_exists():
-    async def get_table_oid(cursor, document_store, schema_name, table_name):
-        sql_get_table_oid = SQL("""
-            SELECT c.oid
-            FROM pg_class c
-            JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind = 'r'
-            AND n.nspname = %s
-            AND c.relname = %s;
-        """)
-        result = await document_store._execute_sql_async(
-            cursor=cursor, sql_query=sql_get_table_oid, params=(schema_name, table_name)
-        )
-        return (await result.fetchone())[0]
-
-    connection_string = "postgresql://postgres:postgres@localhost:5432/postgres"
-    schema_name = "test_schema"
-    table_name = "test_table"
-
-    # Create a new schema
-    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
-        await conn.execute(f"CREATE SCHEMA {schema_name}")
-
-    document_store = PgvectorDocumentStore(
-        connection_string=Secret.from_token(connection_string),
-        schema_name=schema_name,
-        table_name=table_name,
-    )
-
-    await document_store._ensure_db_setup_async()
-    await document_store._initialize_table_async()
-
-    first_table_oid = await get_table_oid(
-        cursor=document_store._async_cursor,
-        document_store=document_store,
-        schema_name=schema_name,
-        table_name=table_name,
-    )
-    assert first_table_oid is not None, "Table was not created"
-
-    await document_store._initialize_table_async()
-    second_table_oid = await get_table_oid(
-        cursor=document_store._async_cursor,
-        document_store=document_store,
-        schema_name=schema_name,
-        table_name=table_name,
-    )
-
-    assert first_table_oid == second_table_oid, "Table was recreated"
-
-    # Clean up: drop the schema after the test
-    async with await psycopg.AsyncConnection.connect(connection_string, autocommit=True) as conn:
-        await conn.execute(f"DROP SCHEMA IF EXISTS {schema_name} CASCADE")
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_delete_table_async_first_call(document_store):
-    """
-    Test that delete_table_async can be executed as the initial operation on the Document Store
-    without triggering errors due to an uninitialized state.
-    """
-    await document_store.delete_table_async()  # if throw error, test fails