pgvector-haystack 8.0.0__tar.gz → 8.1.1__tar.gz

{pgvector_haystack-8.0.0 → pgvector_haystack-8.1.1}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [integrations/pgvector-v8.1.0] - 2026-10-20
+
+### 🚀 Features
+
+- *(pgvector)* Make PgvectorDocumentStore connection overridable for PostgreSQL-backed stores (#4129)
+
+
+## [integrations/pgvector-v8.0.0] - 2026-10-16
+
+### 🧪 Testing
+
+- Test compatible integrations with Python 3.15; update pyproject (#4104)
+
+### 🧹 Chores
+
+- Drop redundant deserialize_secrets_inplace calls in integrations requiring haystack-ai>=2.23 (#4058)
+- [**breaking**] Drop Python 3.10 support (#4105)
+
+
 ## [integrations/pgvector-v7.0.0] - 2026-09-29
 
 ### 🐛 Bug Fixes

{pgvector_haystack-8.0.0 → pgvector_haystack-8.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pgvector-haystack
-Version: 8.0.0
+Version: 8.1.1
 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-8.0.0 → pgvector_haystack-8.1.1}/src/haystack_integrations/document_stores/pgvector/document_store.py

@@ -370,6 +370,47 @@ class PgvectorDocumentStore:
 
         return result
 
+    def _create_connection(self) -> Connection:
+        """
+        Opens a new connection to the PostgreSQL database.
+
+        Subclasses can override this method to connect differently (e.g. through a cloud provider's connector).
+        It must only open and return the connection: autocommit, the pgvector extension, vector type
+        registration, cursors, and table initialization are handled by `_ensure_db_setup`.
+
+        :raises DocumentStoreError: If the connection cannot be opened.
+        """
+        conn_str = self.connection_string.resolve_value() or ""
+        try:
+            return Connection.connect(conn_str)
+        except Error as e:
+            msg = (
+                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
+                "PostgreSQL connection specification: "
+                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
+            )
+            raise DocumentStoreError(msg) from e
+
+    async def _create_connection_async(self) -> AsyncConnection:
+        """
+        Opens a new async connection to the PostgreSQL database.
+
+        Async counterpart of `_create_connection`, overridable in the same way. Everything else is handled by
+        `_ensure_db_setup_async`.
+
+        :raises DocumentStoreError: If the connection cannot be opened.
+        """
+        conn_str = self.connection_string.resolve_value() or ""
+        try:
+            return await AsyncConnection.connect(conn_str)
+        except Error as e:
+            msg = (
+                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
+                "PostgreSQL connection specification: "
+                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
+            )
+            raise DocumentStoreError(msg) from e
+
     def _ensure_db_setup(self) -> None:
         """
         Ensures that the connection to the PostgreSQL database exists and is valid.
@@ -387,16 +428,7 @@ class PgvectorDocumentStore:
             except Error as e:
                 logger.debug("Failed to close connection: {e}", e=str(e))
 
-        conn_str = self.connection_string.resolve_value() or ""
-        try:
-            connection = Connection.connect(conn_str)
-        except Error as e:
-            msg = (
-                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
-                "PostgreSQL connection specification: "
-                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
-            )
-            raise DocumentStoreError(msg) from e
+        connection = self._create_connection()
         connection.autocommit = True
         if self.create_extension:
             connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
@@ -430,16 +462,7 @@ class PgvectorDocumentStore:
         if self._async_connection:
             await self._async_connection.close()
 
-        conn_str = self.connection_string.resolve_value() or ""
-        try:
-            async_connection = await AsyncConnection.connect(conn_str)
-        except Error as e:
-            msg = (
-                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
-                "PostgreSQL connection specification: "
-                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
-            )
-            raise DocumentStoreError(msg) from e
+        async_connection = await self._create_connection_async()
         await async_connection.set_autocommit(True)
         if self.create_extension:
             await async_connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
@@ -1000,18 +1023,19 @@ class PgvectorDocumentStore:
         if not document_ids:
             return
 
-        document_ids_str = ", ".join(f"'{document_id}'" for document_id in document_ids)
-
-        delete_sql = SQL("DELETE FROM {schema_name}.{table_name} WHERE id IN ({document_ids_str})").format(
+        # pass the ids as a bound parameter, so they are never interpreted as SQL
+        delete_sql = SQL("DELETE FROM {schema_name}.{table_name} WHERE id = ANY(%s)").format(
             schema_name=Identifier(self.schema_name),
             table_name=Identifier(self.table_name),
-            document_ids_str=SQL(document_ids_str),
         )
 
         self._ensure_db_setup()
         assert self._cursor is not None
         self._execute_sql(
-            cursor=self._cursor, sql_query=delete_sql, error_msg="Could not delete documents from PgvectorDocumentStore"
+            cursor=self._cursor,
+            sql_query=delete_sql,
+            params=(document_ids,),
+            error_msg="Could not delete documents from PgvectorDocumentStore",
         )
 
     async def delete_documents_async(self, document_ids: list[str]) -> None:
@@ -1023,12 +1047,10 @@ class PgvectorDocumentStore:
         if not document_ids:
             return
 
-        document_ids_str = ", ".join(f"'{document_id}'" for document_id in document_ids)
-
-        delete_sql = SQL("DELETE FROM {schema_name}.{table_name} WHERE id IN ({document_ids_str})").format(
+        # pass the ids as a bound parameter, so they are never interpreted as SQL
+        delete_sql = SQL("DELETE FROM {schema_name}.{table_name} WHERE id = ANY(%s)").format(
             schema_name=Identifier(self.schema_name),
             table_name=Identifier(self.table_name),
-            document_ids_str=SQL(document_ids_str),
         )
 
         await self._ensure_db_setup_async()
@@ -1036,6 +1058,7 @@ class PgvectorDocumentStore:
         await self._execute_sql_async(
             cursor=self._async_cursor,
             sql_query=delete_sql,
+            params=(document_ids,),
             error_msg="Could not delete documents from PgvectorDocumentStore",
         )
 

{pgvector_haystack-8.0.0 → pgvector_haystack-8.1.1}/tests/test_document_store.py

@@ -448,6 +448,27 @@ def test_close_is_exception_safe(mock_store):
     assert mock_store._connection is None
 
 
+@pytest.mark.usefixtures("patches_for_unit_tests")
+def test_ensure_db_setup_uses_overridden_create_connection(monkeypatch):
+    monkeypatch.setenv("PG_CONN_STR", "some-connection-string")
+    mock_connection = Mock(spec=Connection)
+
+    class CustomConnectionDocumentStore(PgvectorDocumentStore):
+        def _create_connection(self) -> Connection:
+            return mock_connection
+
+    store = CustomConnectionDocumentStore()
+    with patch.object(CustomConnectionDocumentStore, "_initialize_table") as mock_initialize_table:
+        store._ensure_db_setup()
+
+    assert store._connection is mock_connection
+    assert mock_connection.autocommit is True
+    mock_connection.execute.assert_called_once_with("CREATE EXTENSION IF NOT EXISTS vector")
+    assert store._cursor is not None
+    assert store._dict_cursor is not None
+    mock_initialize_table.assert_called_once()
+
+
 @pytest.mark.integration
 def test_halfvec_hnsw_write_documents(document_store_w_halfvec_hnsw_index: PgvectorDocumentStore):
     documents = [
@@ -584,6 +605,27 @@ def test_delete_documents_empty_list_is_noop(document_store: PgvectorDocumentSto
     assert after == before
 
 
+@pytest.mark.integration
+def test_delete_documents_with_quotes_in_ids(document_store: PgvectorDocumentStore):
+    """
+    The ids are passed as a bound parameter, so quotes in them are not interpreted as SQL.
+    """
+    docs = [
+        Document(id="O'Brien", content="quote in id"),
+        Document(id="x') OR ('1'='1", content="injection-shaped id"),
+        Document(id="1", content="hello"),
+        Document(id="2", content="world"),
+    ]
+    document_store.write_documents(docs)
+
+    document_store.delete_documents(["O'Brien"])
+    assert sorted(doc.id for doc in document_store.filter_documents()) == ["1", "2", "x') OR ('1'='1"]
+
+    # only matches the document with this exact id, instead of every document
+    document_store.delete_documents(["x') OR ('1'='1"])
+    assert sorted(doc.id for doc in document_store.filter_documents()) == ["1", "2"]
+
+
 @pytest.mark.integration
 def test_update_by_filter_empty_meta_raises_error(document_store: PgvectorDocumentStore):
     docs = [Document(content="Doc 1", meta={"category": "A"})]

{pgvector_haystack-8.0.0 → pgvector_haystack-8.1.1}/tests/test_document_store_async.py

@@ -189,6 +189,27 @@ class TestDocumentStoreAsync(
         """
         await document_store.delete_table_async()  # if throw error, test fails
 
+    async def test_delete_documents_async_with_quotes_in_ids(self, document_store: PgvectorDocumentStore):
+        """
+        The ids are passed as a bound parameter, so quotes in them are not interpreted as SQL.
+        """
+        docs = [
+            Document(id="O'Brien", content="quote in id"),
+            Document(id="x') OR ('1'='1", content="injection-shaped id"),
+            Document(id="1", content="hello"),
+            Document(id="2", content="world"),
+        ]
+        await document_store.write_documents_async(docs)
+
+        await document_store.delete_documents_async(["O'Brien"])
+        remaining = await document_store.filter_documents_async()
+        assert sorted(doc.id for doc in remaining) == ["1", "2", "x') OR ('1'='1"]
+
+        # only matches the document with this exact id, instead of every document
+        await document_store.delete_documents_async(["x') OR ('1'='1"])
+        remaining = await document_store.filter_documents_async()
+        assert sorted(doc.id for doc in remaining) == ["1", "2"]
+
     async def test_close_async_and_reopen(self, document_store: PgvectorDocumentStore):
         assert await document_store.count_documents_async() == 0
         assert document_store._async_connection is not None
@@ -409,3 +430,30 @@ async def test_close_async_is_exception_safe(mock_store):
     await mock_store.close_async()
 
     assert mock_store._async_connection is None
+
+
+@pytest.mark.asyncio
+async def test_ensure_db_setup_async_uses_overridden_create_connection_async(monkeypatch):
+    monkeypatch.setenv("PG_CONN_STR", "some-connection-string")
+    mock_connection = Mock(spec=AsyncConnection)
+    mock_connection.set_autocommit = AsyncMock()
+    mock_connection.execute = AsyncMock()
+
+    class CustomConnectionDocumentStore(PgvectorDocumentStore):
+        async def _create_connection_async(self) -> AsyncConnection:
+            return mock_connection
+
+    store = CustomConnectionDocumentStore()
+    with (
+        patch("haystack_integrations.document_stores.pgvector.document_store.register_vector_async") as mock_register,
+        patch.object(CustomConnectionDocumentStore, "_initialize_table_async") as mock_initialize_table,
+    ):
+        await store._ensure_db_setup_async()
+
+    assert store._async_connection is mock_connection
+    mock_connection.set_autocommit.assert_awaited_once_with(True)
+    mock_connection.execute.assert_awaited_once_with("CREATE EXTENSION IF NOT EXISTS vector")
+    mock_register.assert_awaited_once_with(mock_connection)
+    assert store._async_cursor is not None
+    assert store._async_dict_cursor is not None
+    mock_initialize_table.assert_awaited_once()