pgvector-haystack 6.2.0__py3-none-any.whl → 6.3.1__py3-none-any.whl

haystack_integrations/components/retrievers/pgvector/embedding_retriever.py

@@ -66,8 +66,10 @@ class PgvectorEmbeddingRetriever:
         top_k: int = 10,
         vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
         filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
-    ):
+    ) -> None:
         """
+        Initialize the PgvectorEmbeddingRetriever.
+
         :param document_store: An instance of `PgvectorDocumentStore`.
         :param filters: Filters applied to the retrieved Documents.
         :param top_k: Maximum number of Documents to return.

haystack_integrations/components/retrievers/pgvector/keyword_retriever.py

@@ -55,8 +55,10 @@ class PgvectorKeywordRetriever:
         filters: dict[str, Any] | None = None,
         top_k: int = 10,
         filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
-    ):
+    ) -> None:
         """
+        Initialize the PgvectorKeywordRetriever.
+
         :param document_store: An instance of `PgvectorDocumentStore`.
         :param filters: Filters applied to the retrieved Documents.
         :param top_k: Maximum number of Documents to return.

haystack_integrations/document_stores/pgvector/converters.py

@@ -10,8 +10,9 @@ logger = logging.getLogger(__name__)
 
 def _from_haystack_to_pg_documents(documents: list[Document]) -> list[dict[str, Any]]:
     """
-    Internal method to convert a list of Haystack Documents to a list of dictionaries that can be used to insert
-    documents into the PgvectorDocumentStore.
+    Internal method to convert a list of Haystack Documents to a list of dictionaries.
+
+    The resulting dictionaries can be used to insert documents into the PgvectorDocumentStore.
     """
 
     db_documents = []

haystack_integrations/document_stores/pgvector/document_store.py

@@ -96,9 +96,10 @@ class PgvectorDocumentStore:
         hnsw_index_name: str = "haystack_hnsw_index",
         hnsw_ef_search: int | None = None,
         keyword_index_name: str = "haystack_keyword_index",
-    ):
+    ) -> None:
         """
         Creates a new PgvectorDocumentStore instance.
+
         It is meant to be connected to a PostgreSQL database with the pgvector extension installed.
         A specific table to store Haystack documents will be created if it doesn't exist yet.
 
@@ -223,7 +224,7 @@ class PgvectorDocumentStore:
         return default_from_dict(cls, data)
 
     @staticmethod
-    def _connection_is_valid(connection):
+    def _connection_is_valid(connection: Connection) -> bool:
         """
         Internal method to check if the connection is still valid.
         """
@@ -238,7 +239,7 @@ class PgvectorDocumentStore:
         return True
 
     @staticmethod
-    async def _connection_is_valid_async(connection):
+    async def _connection_is_valid_async(connection: AsyncConnection) -> bool:
         """
         Internal method to check if the async connection is still valid.
         """
@@ -250,18 +251,18 @@ class PgvectorDocumentStore:
 
     @overload
     def _execute_sql(
-        self, cursor: Cursor, sql_query: Composed, params: tuple | None = None, error_msg: str = ""
+        self, cursor: Cursor, sql_query: SQL | Composed, params: tuple | None = None, error_msg: str = ""
     ) -> Cursor: ...
 
     @overload
     def _execute_sql(
-        self, cursor: Cursor[DictRow], sql_query: Composed, params: tuple | None = None, error_msg: str = ""
+        self, cursor: Cursor[DictRow], sql_query: SQL | Composed, params: tuple | None = None, error_msg: str = ""
     ) -> Cursor[DictRow]: ...
 
     def _execute_sql(
         self,
         cursor: Cursor | Cursor[DictRow],
-        sql_query: Composed,
+        sql_query: SQL | Composed,
         params: tuple | None = None,
         error_msg: str = "",
     ) -> Cursor | Cursor[DictRow]:
@@ -299,18 +300,18 @@ class PgvectorDocumentStore:
 
     @overload
     async def _execute_sql_async(
-        self, cursor: AsyncCursor, sql_query: Composed, params: tuple | None = None, error_msg: str = ""
+        self, cursor: AsyncCursor, sql_query: SQL | Composed, params: tuple | None = None, error_msg: str = ""
     ) -> AsyncCursor: ...
 
     @overload
     async def _execute_sql_async(
-        self, cursor: AsyncCursor[DictRow], sql_query: Composed, params: tuple | None = None, error_msg: str = ""
+        self, cursor: AsyncCursor[DictRow], sql_query: SQL | Composed, params: tuple | None = None, error_msg: str = ""
     ) -> AsyncCursor[DictRow]: ...
 
     async def _execute_sql_async(
         self,
         cursor: AsyncCursor | AsyncCursor[DictRow],
-        sql_query: Composed,
+        sql_query: SQL | Composed,
         params: tuple | None = None,
         error_msg: str = "",
     ) -> AsyncCursor | AsyncCursor[DictRow]:
@@ -346,9 +347,10 @@ class PgvectorDocumentStore:
 
         return result
 
-    def _ensure_db_setup(self):
+    def _ensure_db_setup(self) -> None:
         """
         Ensures that the connection to the PostgreSQL database exists and is valid.
+
         If not, connection and cursors are created.
         If the table is not initialized, it will be set up.
         """
@@ -384,9 +386,10 @@ class PgvectorDocumentStore:
         if not self._table_initialized:
             self._initialize_table()
 
-    async def _ensure_db_setup_async(self):
+    async def _ensure_db_setup_async(self) -> None:
         """
         Async internal method.
+
         Ensures that the connection to the PostgreSQL database exists and is valid.
         If not, connection and cursors are created.
         If the table is not initialized, it will be set up.
@@ -426,7 +429,7 @@ class PgvectorDocumentStore:
         if not self._table_initialized:
             await self._initialize_table_async()
 
-    def _build_table_creation_queries(self):
+    def _build_table_creation_queries(self) -> tuple[SQL, Composed, SQL, Composed]:
         """
         Internal method to build the SQL queries for table creation.
         """
@@ -453,7 +456,7 @@ class PgvectorDocumentStore:
 
         return sql_table_exists, sql_create_table, sql_keyword_index_exists, sql_create_keyword_index
 
-    def _initialize_table(self):
+    def _initialize_table(self) -> None:
         """
         Internal method to initialize the table.
         """
@@ -497,7 +500,7 @@ class PgvectorDocumentStore:
 
         self._table_initialized = True
 
-    async def _initialize_table_async(self):
+    async def _initialize_table_async(self) -> None:
         """
         Internal async method to initialize the table.
         """
@@ -547,9 +550,10 @@ class PgvectorDocumentStore:
 
         self._table_initialized = True
 
-    def delete_table(self):
+    def delete_table(self) -> None:
         """
         Deletes the table used to store Haystack documents.
+
         The name of the schema (`schema_name`) and the name of the table (`table_name`)
         are defined when initializing the `PgvectorDocumentStore`.
         """
@@ -567,7 +571,7 @@ class PgvectorDocumentStore:
             error_msg=f"Could not delete table {self.schema_name}.{self.table_name} in PgvectorDocumentStore",
         )
 
-    async def delete_table_async(self):
+    async def delete_table_async(self) -> None:
         """
         Async method to delete the table used to store Haystack documents.
         """
@@ -585,7 +589,7 @@ class PgvectorDocumentStore:
             error_msg=f"Could not delete table {self.schema_name}.{self.table_name} in PgvectorDocumentStore",
         )
 
-    def _build_hnsw_queries(self):
+    def _build_hnsw_queries(self) -> tuple[Composed | None, SQL, Composed, Composed]:
         """Common method to build all HNSW-related SQL queries"""
 
         sql_set_hnsw_ef_search = (
@@ -633,9 +637,10 @@ class PgvectorDocumentStore:
 
         return sql_set_hnsw_ef_search, sql_hnsw_index_exists, sql_drop_hnsw_index, sql_create_hnsw_index
 
-    def _handle_hnsw(self):
+    def _handle_hnsw(self) -> None:
         """
         Internal method to handle the HNSW index creation.
+
         It also sets the `hnsw.ef_search` parameter for queries if it is specified.
         """
 
@@ -645,7 +650,7 @@ class PgvectorDocumentStore:
 
         assert self._cursor is not None
 
-        if self.hnsw_ef_search:
+        if sql_set_hnsw_ef_search is not None:
             self._execute_sql(
                 cursor=self._cursor, sql_query=sql_set_hnsw_ef_search, error_msg="Could not set hnsw.ef_search"
             )
@@ -671,7 +676,7 @@ class PgvectorDocumentStore:
 
         self._execute_sql(cursor=self._cursor, sql_query=sql_create_hnsw_index, error_msg="Could not create HNSW index")
 
-    async def _handle_hnsw_async(self):
+    async def _handle_hnsw_async(self) -> None:
         """
         Internal async method to handle the HNSW index creation.
         """
@@ -682,7 +687,7 @@ class PgvectorDocumentStore:
 
         assert self._async_cursor is not None
 
-        if self.hnsw_ef_search:
+        if sql_set_hnsw_ef_search is not None:
             await self._execute_sql_async(
                 cursor=self._async_cursor, sql_query=sql_set_hnsw_ef_search, error_msg="Could not set hnsw.ef_search"
             )
@@ -1346,10 +1351,13 @@ class PgvectorDocumentStore:
         # cosine_similarity and inner_product are modified from the result of the operator
         if vector_function == "cosine_similarity":
             score_definition = f"1 - (embedding <=> {query_embedding_for_postgres}) AS score"
+            order_by_definition = f"embedding <=> {query_embedding_for_postgres}"
         elif vector_function == "inner_product":
             score_definition = f"(embedding <#> {query_embedding_for_postgres}) * -1 AS score"
+            order_by_definition = f"embedding <#> {query_embedding_for_postgres}"
         elif vector_function == "l2_distance":
             score_definition = f"embedding <-> {query_embedding_for_postgres} AS score"
+            order_by_definition = f"embedding <-> {query_embedding_for_postgres}"
 
         sql_select = SQL("SELECT *, {score} FROM {schema_name}.{table_name}").format(
             schema_name=Identifier(self.schema_name),
@@ -1362,13 +1370,9 @@ class PgvectorDocumentStore:
         if filters:
             sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
 
-        # we always want to return the most similar documents first
-        # so when using l2_distance, the sort order must be ASC
-        sort_order = "ASC" if vector_function == "l2_distance" else "DESC"
-
-        sql_sort = SQL(" ORDER BY score {sort_order} LIMIT {top_k}").format(
+        sql_sort = SQL(" ORDER BY {order_by} ASC LIMIT {top_k}").format(
             top_k=SQLLiteral(top_k),
-            sort_order=SQL(sort_order),
+            order_by=SQL(order_by_definition),
         )
 
         sql_query = sql_select + sql_where_clause + sql_sort
@@ -1418,8 +1422,9 @@ class PgvectorDocumentStore:
         vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> list[Document]:
         """
-        Asynchronously retrieves documents that are most similar to the query embedding using a
-        vector similarity metric.
+        Asynchronously retrieves documents that are most similar to the query embedding.
+
+        Uses a vector similarity metric for comparison.
         """
 
         sql_query, params = self._check_and_build_embedding_retrieval_query(
@@ -1439,7 +1444,7 @@ class PgvectorDocumentStore:
         docs = _from_pg_to_haystack_documents(records)
         return docs
 
-    def _prepare_filters_count_documents(self, filters):
+    def _prepare_filters_count_documents(self, filters: dict[str, Any] | None) -> tuple[tuple[Any, ...], Composed]:
         _validate_filters(filters)
         sql_count = SQL("SELECT COUNT(*) FROM {schema_name}.{table_name}").format(
             schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
@@ -1571,8 +1576,9 @@ class PgvectorDocumentStore:
 
     def count_unique_metadata_by_filter(self, filters: dict[str, Any], metadata_fields: list[str]) -> dict[str, int]:
         """
-        Returns the count of unique values for each specified metadata field,
-        considering only documents that match the provided filters.
+        Returns the count of unique values for each specified metadata field.
+
+        Considers only documents that match the provided filters.
 
         :param filters: The filters to apply to select documents.
             For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
@@ -1604,8 +1610,9 @@ class PgvectorDocumentStore:
         self, filters: dict[str, Any], metadata_fields: list[str]
     ) -> dict[str, int]:
         """
-        Asynchronously returns the count of unique values for each specified metadata field,
-        considering only documents that match the provided filters.
+        Asynchronously returns the count of unique values for each specified metadata field.
+
+        Considers only documents that match the provided filters.
 
         :param filters: The filters to apply to select documents.
             For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
@@ -1661,7 +1668,7 @@ class PgvectorDocumentStore:
         :param records: List of database records containing 'meta' field.
         :returns: A dictionary mapping field names to their type information.
         """
-        fields_info: dict[str, dict[str, str]] = {"content": {"type": "text"}}
+        fields_info: dict[str, dict[str, str]] = {}
 
         # Analyze metadata from all documents
         for record in records:
@@ -1681,7 +1688,7 @@ class PgvectorDocumentStore:
 
         return fields_info
 
-    def _analyze_metadata_from_docs_query(self):
+    def _analyze_metadata_from_docs_query(self) -> Composed:
         # query all documents to analyze metadata structure
         sql_query = SQL("SELECT meta FROM {schema_name}.{table_name} WHERE meta IS NOT NULL").format(
             schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
@@ -1698,7 +1705,6 @@ class PgvectorDocumentStore:
         Example return:
         ```python
         {
-            'content': {'type': 'text'},
             'category': {'type': 'text'},
             'status': {'type': 'text'},
             'priority': {'type': 'integer'},
@@ -1838,15 +1844,14 @@ class PgvectorDocumentStore:
         :returns: A dictionary with 'min' and 'max' keys containing the minimum and maximum values.
             For numeric fields (integer, real), returns numeric min/max.
             For text fields, returns lexicographic min/max based on database collation.
-        :raises ValueError: If the field doesn't exist or has no values.
+            Returns `{"min": None, "max": None}` when the field has no values or the store is empty.
         """
         normalized_field = PgvectorDocumentStore._normalize_metadata_field_name(metadata_field)
 
         # Get field type information from metadata fields info
         fields_info = self.get_metadata_fields_info()
         if normalized_field not in fields_info:
-            msg = f"Metadata field '{metadata_field}' not found in document store"
-            raise ValueError(msg)
+            return {"min": None, "max": None}
 
         field_type = fields_info[normalized_field]["type"]
         sql_query = self._build_min_max_query(normalized_field, field_type)
@@ -1871,15 +1876,14 @@ class PgvectorDocumentStore:
         :returns: A dictionary with 'min' and 'max' keys containing the minimum and maximum values.
             For numeric fields (integer, real), returns numeric min/max.
             For text fields, returns lexicographic min/max based on database collation.
-        :raises ValueError: If the field doesn't exist or has no values.
+            Returns ``{"min": None, "max": None}`` when the field has no values or the store is empty.
         """
         normalized_field = PgvectorDocumentStore._normalize_metadata_field_name(metadata_field)
 
         # Get field type information from metadata fields info
         fields_info = await self.get_metadata_fields_info_async()
         if normalized_field not in fields_info:
-            msg = f"Metadata field '{metadata_field}' not found in document store"
-            raise ValueError(msg)
+            return {"min": None, "max": None}
 
         field_type = fields_info[normalized_field]["type"]
         sql_query = self._build_min_max_query(normalized_field, field_type)

haystack_integrations/document_stores/pgvector/filters.py

@@ -2,13 +2,13 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import re
 from datetime import datetime
 from itertools import chain
 from typing import Any, Literal
 
 from haystack.errors import FilterError
-from psycopg.sql import SQL, Composed
+from psycopg.sql import SQL, Composable, Composed, Identifier
+from psycopg.sql import Literal as SQLLiteral
 from psycopg.types.json import Jsonb
 
 # we need this mapping to cast meta values to the correct type,
@@ -21,7 +21,6 @@ PYTHON_TYPES_TO_PG_TYPES = {
 }
 
 NO_VALUE = "no_value"
-SAFE_META_FIELD_RE = re.compile(r"^[a-zA-Z0-9_-]+$")
 
 
 def _validate_filters(filters: dict[str, Any] | None = None) -> None:
@@ -48,13 +47,13 @@ def _convert_filters_to_where_clause_and_params(
     else:
         query, values = _parse_logical_condition(filters)
 
-    where_clause = SQL(f" {operator} ") + SQL(query)
+    where_clause = SQL(f" {operator} ") + query
     params = tuple(value for value in values if value != NO_VALUE)
 
     return where_clause, params
 
 
-def _parse_logical_condition(condition: dict[str, Any]) -> tuple[str, list[Any]]:
+def _parse_logical_condition(condition: dict[str, Any]) -> tuple[Composed, list[Any]]:
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"
         raise FilterError(msg)
@@ -84,17 +83,14 @@ def _parse_logical_condition(condition: dict[str, Any]) -> tuple[str, list[Any]]
         values = list(chain.from_iterable(values))
 
     if operator == "AND":
-        sql_query = f"({' AND '.join(query_parts)})"
-    elif operator == "OR":
-        sql_query = f"({' OR '.join(query_parts)})"
-    else:
-        msg = f"Unknown logical operator '{operator}'"
-        raise FilterError(msg)
+        sql_query = SQL("(") + SQL(" AND ").join(query_parts) + SQL(")")
+    else:  # operator == "OR"
+        sql_query = SQL("(") + SQL(" OR ").join(query_parts) + SQL(")")
 
     return sql_query, values
 
 
-def _parse_comparison_condition(condition: dict[str, Any]) -> tuple[str, list[Any]]:
+def _parse_comparison_condition(condition: dict[str, Any]) -> tuple[Composed, list[Any]]:
     field: str = condition["field"]
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"
@@ -110,34 +106,36 @@ def _parse_comparison_condition(condition: dict[str, Any]) -> tuple[str, list[An
     value: Any = condition["value"]
 
     if field.startswith("meta."):
-        field = _treat_meta_field(field, value)
+        sql_field: Composable = _treat_meta_field(field, value)
+    else:
+        sql_field = Identifier(field)
 
-    field, value = COMPARISON_OPERATORS[operator](field, value)
-    return field, [value]
+    sql_expr, value = COMPARISON_OPERATORS[operator](sql_field, value)
+    return sql_expr, [value]
 
 
-def _treat_meta_field(field: str, value: Any) -> str:
+def _treat_meta_field(field: str, value: Any) -> Composed:
     """
-    Internal method that modifies the field str
-    to make the meta JSONB field queryable.
+    Internal method that returns a psycopg Composed object to make the meta JSONB field queryable safely.
+
+    Uses psycopg.sql.Literal to embed the field name, preventing SQL injection
+    via metadata field names without requiring regex validation.
+
+    Use the ->> operator to access keys in the meta JSONB field.
 
     Examples:
     >>> _treat_meta_field(field="meta.number", value=9)
-    "(meta->>'number')::integer"
+    Composed([SQL('(meta->>'), Literal('number'), SQL(')::integer')])
 
     >>> _treat_meta_field(field="meta.name", value="my_name")
-    "meta->>'name'"
-    """
+    Composed([SQL('meta->>'), Literal('name')])
 
-    # use the ->> operator to access keys in the meta JSONB field
+    """
     field_name = field.split(".", 1)[-1]
-    if not SAFE_META_FIELD_RE.match(field_name):
-        msg = (
-            f"Invalid metadata field name '{field_name}'. "
-            "Only alphanumeric characters, dashes, and underscores are allowed."
-        )
-        raise FilterError(msg)
-    field = f"meta->>'{field_name}'"
+
+    # Use SQLLiteral to safely embed the field name as a SQL string literal,
+    # preventing SQL injection via metadata field names.
+    composed: Composed = SQL("meta->>") + SQLLiteral(field_name)
 
     # meta fields are stored as strings in the JSONB field,
     # so we need to cast them to the correct type
@@ -146,25 +144,24 @@ def _treat_meta_field(field: str, value: Any) -> str:
         type_value = PYTHON_TYPES_TO_PG_TYPES.get(type(value[0]))
 
     if type_value:
-        field = f"({field})::{type_value}"
+        composed = SQL("(") + composed + SQL(f")::{type_value}")
 
-    return field
+    return composed
 
 
-def _equal(field: str, value: Any) -> tuple[str, Any]:
+def _equal(field: Composable, value: Any) -> tuple[Composed, Any]:
     if value is None:
-        # NO_VALUE is a placeholder that will be removed in _convert_filters_to_where_clause_and_params
-        return f"{field} IS NULL", NO_VALUE
-    return f"{field} = %s", value
+        return SQL("{} IS NULL").format(field), NO_VALUE
+    return SQL("{} = %s").format(field), value
 
 
-def _not_equal(field: str, value: Any) -> tuple[str, Any]:
+def _not_equal(field: Composable, value: Any) -> tuple[Composed, Any]:
     # we use IS DISTINCT FROM to correctly handle NULL values
     # (not handled by !=)
-    return f"{field} IS DISTINCT FROM %s", value
+    return SQL("{} IS DISTINCT FROM %s").format(field), value
 
 
-def _greater_than(field: str, value: Any) -> tuple[str, Any]:
+def _greater_than(field: Composable, value: Any) -> tuple[Composed, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -177,11 +174,10 @@ def _greater_than(field: str, value: Any) -> tuple[str, Any]:
     if type(value) in [list, Jsonb]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
+    return SQL("{} > %s").format(field), value
 
-    return f"{field} > %s", value
 
-
-def _greater_than_equal(field: str, value: Any) -> tuple[str, Any]:
+def _greater_than_equal(field: Composable, value: Any) -> tuple[Composed, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -194,11 +190,10 @@ def _greater_than_equal(field: str, value: Any) -> tuple[str, Any]:
     if type(value) in [list, Jsonb]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
-
-    return f"{field} >= %s", value
+    return SQL("{} >= %s").format(field), value
 
 
-def _less_than(field: str, value: Any) -> tuple[str, Any]:
+def _less_than(field: Composable, value: Any) -> tuple[Composed, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -211,11 +206,10 @@ def _less_than(field: str, value: Any) -> tuple[str, Any]:
     if type(value) in [list, Jsonb]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
+    return SQL("{} < %s").format(field), value
 
-    return f"{field} < %s", value
 
-
-def _less_than_equal(field: str, value: Any) -> tuple[str, Any]:
+def _less_than_equal(field: Composable, value: Any) -> tuple[Composed, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -228,39 +222,37 @@ def _less_than_equal(field: str, value: Any) -> tuple[str, Any]:
     if type(value) in [list, Jsonb]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
-
-    return f"{field} <= %s", value
+    return SQL("{} <= %s").format(field), value
 
 
-def _not_in(field: str, value: Any) -> tuple[str, list]:
+def _not_in(field: Composable, value: Any) -> tuple[Composed, list]:
     if not isinstance(value, list):
         msg = f"{field}'s value must be a list when using 'not in' comparator in Pinecone"
         raise FilterError(msg)
-
-    return f"{field} IS NULL OR {field} != ALL(%s)", [value]
+    return SQL("{} IS NULL OR {} != ALL(%s)").format(field, field), [value]
 
 
-def _in(field: str, value: Any) -> tuple[str, list]:
+def _in(field: Composable, value: Any) -> tuple[Composed, list]:
     if not isinstance(value, list):
         msg = f"{field}'s value must be a list when using 'in' comparator in Pinecone"
         raise FilterError(msg)
 
     # see https://www.psycopg.org/psycopg3/docs/basic/adapt.html#lists-adaptation
-    return f"{field} = ANY(%s)", [value]
+    return SQL("{} = ANY(%s)").format(field), [value]
 
 
-def _like(field: str, value: Any) -> tuple[str, Any]:
+def _like(field: Composable, value: Any) -> tuple[Composed, Any]:
     if not isinstance(value, str):
         msg = f"{field}'s value must be a str when using 'LIKE' "
         raise FilterError(msg)
-    return f"{field} LIKE %s", value
+    return SQL("{} LIKE %s").format(field), value
 
 
-def _not_like(field: str, value: Any) -> tuple[str, Any]:
+def _not_like(field: Composable, value: Any) -> tuple[Composed, Any]:
     if not isinstance(value, str):
         msg = f"{field}'s value must be a str when using 'LIKE' "
         raise FilterError(msg)
-    return f"{field} NOT LIKE %s", value
+    return SQL("{} NOT LIKE %s").format(field), value
 
 
 COMPARISON_OPERATORS = {

{pgvector_haystack-6.2.0.dist-info → pgvector_haystack-6.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 6.2.0
+Version: 6.3.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
@@ -15,10 +15,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: haystack-ai>=2.24.0
+Requires-Dist: haystack-ai>=2.28.0
 Requires-Dist: pgvector>=0.3.0
 Requires-Dist: psycopg[binary]
 Description-Content-Type: text/markdown

{pgvector_haystack-6.2.0.dist-info → pgvector_haystack-6.3.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
 haystack_integrations/components/retrievers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haystack_integrations/components/retrievers/pgvector/__init__.py,sha256=n4q4pUApJ9DZakJ_JL-egwOzlefdnI_ZxjU1Lu44Sqo,296
-haystack_integrations/components/retrievers/pgvector/embedding_retriever.py,sha256=sscmA93jovW7-qY_G9ZiYKsAZLrcaiKMdIvIVTv5GYE,9130
-haystack_integrations/components/retrievers/pgvector/keyword_retriever.py,sha256=6Qam_QABa67Yfs8UW0a5FArhLTFGU2fYQ4wGZjVHzUI,6792
+haystack_integrations/components/retrievers/pgvector/embedding_retriever.py,sha256=WnKXvRgzAyKQ2KfqnkiCTjy0WtiMNL4mK3_ZxJ16Lfk,9190
+haystack_integrations/components/retrievers/pgvector/keyword_retriever.py,sha256=tks3Wror_cfrUPxObzWzPmii_5ryNU1KEq3Q-DWnJ8U,6850
 haystack_integrations/document_stores/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haystack_integrations/document_stores/pgvector/__init__.py,sha256=Ge-7ggarfr3x8UqNdFHUuFGiu52u49sOVe3l16WEwZU,197
-haystack_integrations/document_stores/pgvector/converters.py,sha256=SXLDpb-GfaKSHl5Oann38T27QWR-8pamTmdLklK9my0,3181
-haystack_integrations/document_stores/pgvector/document_store.py,sha256=nwxyI450JqN5rP50ZMWRs_2otT2J5kWuxbejteLhZUE,84473
-haystack_integrations/document_stores/pgvector/filters.py,sha256=SpfqFvSLhQOs42QPBJuWj63Zv-q6J1ja9xaXR36S2Pw,9300
-pgvector_haystack-6.2.0.dist-info/METADATA,sha256=DEi8WE03yyge9p0xI6AiRmwWtkQ2c96U5inGdg-hQ18,2095
-pgvector_haystack-6.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-pgvector_haystack-6.2.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-pgvector_haystack-6.2.0.dist-info/RECORD,,
+haystack_integrations/document_stores/pgvector/converters.py,sha256=ZJ28EC7ianclAdkjlGsGLwqCqUv2H-1UYz9PqnLX_aU,3205
+haystack_integrations/document_stores/pgvector/document_store.py,sha256=SdXnbOSns1pUDCSy9pifK5WrPDsvrCdbAiTIneIXF0Q,84725
+haystack_integrations/document_stores/pgvector/filters.py,sha256=91TiRZULHiKWCIIGXP7ppgiHJeDEV6oS2kR8EkQE-uI,9659
+pgvector_haystack-6.3.1.dist-info/METADATA,sha256=0OzM0VaPjJsTe8CbbHIZK-O1WINU2BQRaHYs7o1x6LE,2146
+pgvector_haystack-6.3.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pgvector_haystack-6.3.1.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+pgvector_haystack-6.3.1.dist-info/RECORD,,