cypher-graphdb 0.2.4__tar.gz → 0.2.6__tar.gz

{cypher_graphdb-0.2.4/src/cypher_graphdb.egg-info → cypher_graphdb-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cypher_graphdb
-Version: 0.2.4
+Version: 0.2.6
 Summary: ORM like library and CLI for cypher query language supporting graph databases.
 Author-email: Wolfgang Miller <wolfgang.miller@petrarca-labs.com>
 License-Expression: Apache-2.0

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/src/cypher_graphdb/backend.py

@@ -6,6 +6,7 @@ CypherBackend: Abstract base class for implementing graph database backends.
 """
 
 import abc
+import re
 from enum import Enum, auto
 from typing import Any
 
@@ -18,6 +19,11 @@ from .modelprovider import ModelProvider
 from .models import TabularResult
 from .statistics import GraphStatistics, IndexInfo, LabelStatistics
 
+# Regex for safe property names and values in the Cypher fallback.
+# Matches alphanumeric, underscore, hyphen — sufficient for source_key / lang values.
+_SAFE_FILTER_KEY_RE = re.compile(r"^[a-zA-Z0-9_]+$")
+_SAFE_FILTER_VAL_RE = re.compile(r"^[a-zA-Z0-9_.:\-]+$")
+
 
 class BackendCapability(Enum):
     """Enumeration of backend capabilities for feature detection."""
@@ -29,6 +35,7 @@ class BackendCapability(Enum):
     UNIQUE_CONSTRAINT = auto()  # Supports create_unique_constraint
     FULLTEXT_INDEX = auto()  # Supports create_fulltext_index
     VECTOR_INDEX = auto()  # Supports create_vector_index
+    BULK_DELETE = auto()  # Supports bulk_delete_nodes (optimized batch deletion with edge cascade)
 
 
 class ExecStatistics(GraphStatistics):
@@ -356,8 +363,8 @@ class CypherBackend(abc.ABC):
         self,
         label: str,
         edges: list[dict],
-        src_label: str = "",
-        dst_label: str = "",
+        src_label: str,
+        dst_label: str,
         src_ref_prop: str = "id",
         dst_ref_prop: str = "id",
         batch_size: int = 500,
@@ -371,8 +378,8 @@ class CypherBackend(abc.ABC):
         Args:
             label: Edge label for all created edges.
             edges: List of dicts with "src", "dst", and optional edge properties.
-            src_label: Label of source nodes (empty string for any label).
-            dst_label: Label of destination nodes (empty string for any label).
+            src_label: Label of source nodes. Required for optimal performance on AGE.
+            dst_label: Label of destination nodes. Required for optimal performance on AGE.
             src_ref_prop: Property name on source nodes to match against "src".
             dst_ref_prop: Property name on destination nodes to match against "dst".
             batch_size: Number of edges per UNWIND batch.
@@ -385,6 +392,44 @@ class CypherBackend(abc.ABC):
         """
         raise NotImplementedError(f"Backend {self.name} does not support bulk_create_edges")
 
+    def bulk_delete_nodes(self, label: str, filters: dict[str, str]) -> int:
+        """Delete all nodes of a label matching property filters, cascading to edges.
+
+        Removes nodes where all specified property key=value pairs match, plus
+        all edges referencing the deleted nodes (equivalent to Cypher DETACH DELETE).
+
+        The default implementation uses Cypher DETACH DELETE. Backends that declare
+        ``BULK_DELETE`` capability override this with an optimized implementation
+        (e.g. direct table access).
+
+        Args:
+            label: Node label to delete from (e.g. "Method", "Class").
+            filters: Property filters to match. All must match (AND semantics).
+                     Example: {"source_key": "nais-platform", "lang": "ts"}
+
+        Returns:
+            Number of nodes deleted.
+        """
+        if not filters:
+            raise ValueError("filters must not be empty (would delete all nodes of the label)")
+        if not _SAFE_FILTER_KEY_RE.match(label):
+            raise ValueError(f"label must be alphanumeric/underscore, got: {label!r}")
+        for k, v in filters.items():
+            if not _SAFE_FILTER_KEY_RE.match(k):
+                raise ValueError(f"filter key must be alphanumeric/underscore, got: {k!r}")
+            if not _SAFE_FILTER_VAL_RE.match(v):
+                raise ValueError(f"filter value must be alphanumeric/underscore/hyphen/dot/colon, got: {v!r}")
+        where_parts = " AND ".join(f"n.{k} = '{v}'" for k, v in filters.items())
+        count_cypher = f"MATCH (n:{label}) WHERE {where_parts} RETURN count(n)"
+        parsed = self.parse_cypher(count_cypher)
+        result, _ = self.execute_cypher(parsed)
+        count = result[0][0] if result else 0
+        if count > 0:
+            delete_cypher = f"MATCH (n:{label}) WHERE {where_parts} DETACH DELETE n"
+            parsed = self.parse_cypher(delete_cypher)
+            self.execute_cypher(parsed)
+        return count
+
     @property
     def __dict__(self):
         """Return backend state as a dictionary for introspection."""

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/src/cypher_graphdb/backends/age/agebulkwriter.py

@@ -19,6 +19,7 @@ from typing import Literal
 import psycopg
 from loguru import logger
 from psycopg.sql import SQL, Identifier
+from psycopg.sql import Literal as SQLLiteral
 
 from cypher_graphdb.utils import chunk_list
 
@@ -26,6 +27,24 @@ from .ageserializer import escape_value
 from .agesqlbuilder import SQLBuilder
 
 
+def _build_agtype_conditions(filters: dict[str, str], alias: str | None = None) -> str:
+    """Build a SQL WHERE expression matching AGE vertex properties.
+
+    Uses agtype_access_operator so the expression btree index is used.
+    Values are escaped via SQLLiteral to prevent injection.
+
+    Args:
+        filters: Property key=value pairs (all ANDed together).
+        alias: Optional table alias prefix (e.g. "n" produces "n.properties").
+    """
+    prefix = f"{alias}." if alias else ""
+    return " AND ".join(
+        f"ag_catalog.agtype_access_operator(VARIADIC ARRAY[{prefix}properties, "
+        f"{SQLLiteral(chr(34) + k + chr(34)).as_string(None)}::ag_catalog.agtype])::text = {SQLLiteral(v).as_string(None)}"
+        for k, v in filters.items()
+    )
+
+
 class AGEBulkWriter:
     """Direct SQL bulk writer for AGE label tables.
 
@@ -44,6 +63,10 @@ class AGEBulkWriter:
         # Invalidated by invalidate_graphid_cache() after node inserts that
         # change the graphid mapping.
         self._graphid_cache: dict[tuple[str, str], dict[str, int]] = {}
+        # Cached list of edge label names for bulk_delete_nodes.
+        # Edge labels are stable within a connection lifetime -- populated on
+        # first call to _list_edge_labels() and reused for all subsequent deletes.
+        self._edge_labels_cache: list[str] | None = None
 
     # -- Public API -----------------------------------------------------------
 
@@ -178,6 +201,91 @@ class AGEBulkWriter:
             logger.debug("Direct SQL: {} {} edges inserted", total, label)
         return total
 
+    def bulk_delete_nodes(self, label: str, filters: dict[str, str]) -> int:
+        """Delete nodes matching property filters via direct SQL, cascading to edges.
+
+        Uses server-side joined DELETEs -- PostgreSQL resolves the node filter
+        via the expression index on the vertex table, then joins to each edge
+        table via the indexed start_id/end_id columns. No large ID arrays are
+        transferred to Python; the entire operation runs inside the database.
+
+        On a fresh graph where the label table does not yet exist, returns 0.
+
+        Args:
+            label: Vertex label to delete from (e.g. "Method").
+            filters: Property key=value filters (AND semantics).
+
+        Returns:
+            Number of nodes deleted.
+        """
+        if not filters:
+            raise ValueError("filters must not be empty (would delete all nodes of the label)")
+
+        # Build filter conditions in two forms:
+        # - with alias "n." for the USING join (edge DELETE references vertex as n)
+        # - without alias for the plain vertex DELETE
+        join_conditions = _build_agtype_conditions(filters, alias="n")
+        node_conditions = _build_agtype_conditions(filters, alias=None)
+        edge_labels = self._list_edge_labels()
+
+        try:
+            with self._conn.cursor() as cursor:
+                # Step 1: delete edges via JOIN -- lets PG use expression indexes
+                # on the vertex table + start_id/end_id indexes on edge tables.
+                for elabel in edge_labels:
+                    cursor.execute(
+                        SQL(
+                            "DELETE FROM {egraph}.{etable} e "
+                            "USING {vgraph}.{vtable} n "
+                            "WHERE (e.start_id = n.id OR e.end_id = n.id) "
+                            "AND {cond}"
+                        ).format(
+                            egraph=Identifier(self._graph_name),
+                            etable=Identifier(elabel),
+                            vgraph=Identifier(self._graph_name),
+                            vtable=Identifier(label),
+                            cond=SQL(join_conditions),
+                        )
+                    )
+                # Step 2: delete the nodes
+                cursor.execute(
+                    SQL("DELETE FROM {schema}.{table} WHERE {cond} RETURNING id").format(
+                        schema=Identifier(self._graph_name),
+                        table=Identifier(label),
+                        cond=SQL(node_conditions),
+                    )
+                )
+                deleted = len(cursor.fetchall())
+        except psycopg.errors.UndefinedTable:
+            # Label table does not exist (fresh graph, never written to).
+            self._conn.rollback()
+            return 0
+
+        self.invalidate_graphid_cache(label)
+        logger.debug("Direct SQL: {} {} nodes deleted (+ edges from {} edge tables)", deleted, label, len(edge_labels))
+        return deleted
+
+    def _list_edge_labels(self) -> list[str]:
+        """Return all edge label names in the graph, cached for the connection lifetime.
+
+        Edge labels are stable within a session -- they grow monotonically as new
+        labels are created, never shrink. Caching avoids repeated catalog queries
+        when bulk_delete_nodes is called many times in the same cleanup pass.
+        """
+        if self._edge_labels_cache is not None:
+            return self._edge_labels_cache
+        with self._conn.cursor() as cursor:
+            cursor.execute(
+                SQL(
+                    "SELECT name FROM ag_catalog.ag_label "
+                    "WHERE graph = (SELECT graphid FROM ag_catalog.ag_graph WHERE name = %s) "
+                    "AND kind = 'e' AND name != '_ag_label_edge'"
+                ),
+                (self._graph_name,),
+            )
+            self._edge_labels_cache = [row[0] for row in cursor.fetchall()]
+        return self._edge_labels_cache
+
     # -- Internal helpers -----------------------------------------------------
 
     def _ensure_label(self, label: str, kind: Literal["v", "e"] = "v") -> int:

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/src/cypher_graphdb/backends/age/agegraphdb.py

@@ -8,6 +8,7 @@ Classes:
     AGEGraphDB: Main backend class for Apache AGE database operations.
 """
 
+import contextlib
 import hashlib
 import json
 import time
@@ -203,7 +204,11 @@ class AGEGraphDB(CypherBackend):
         return hashlib.md5(query.encode()).hexdigest()[:8]
 
     def _get_or_prepare_statement(self, cypher_sql, query: str) -> str:
-        """Get existing prepared statement or create a new one."""
+        """Get existing prepared statement or create a new one.
+
+        Rolls back the connection if PREPARE fails so the connection is
+        returned to the pool in a clean state rather than left in INERROR.
+        """
         query_hash = self._get_query_hash(query)
 
         if query_hash not in self._prepared_statements:
@@ -226,9 +231,16 @@ class AGEGraphDB(CypherBackend):
             stmt_name = f"cypher_stmt_{query_hash}"
             logger.trace("Creating new prepared statement {} for query hash {}", stmt_name, query_hash)
 
-            with self._fetch_cursor(row_factory=None) as cursor:
-                prepare_sql = SQL("PREPARE {} AS {}").format(Identifier(stmt_name), cypher_sql)
-                cursor.execute(prepare_sql)
+            try:
+                with self._fetch_cursor(row_factory=None) as cursor:
+                    prepare_sql = SQL("PREPARE {} AS {}").format(Identifier(stmt_name), cypher_sql)
+                    cursor.execute(prepare_sql)
+            except psycopg.Error as e:
+                # PREPARE failed -- roll back so the connection is not left in
+                # INERROR state (which would corrupt the connection pool).
+                with contextlib.suppress(Exception):
+                    self._connection.rollback()
+                raise e
 
             self._prepared_statements[query_hash] = stmt_name
             logger.trace("Prepared statement cached. Total cached: {}", len(self._prepared_statements))
@@ -262,25 +274,29 @@ class AGEGraphDB(CypherBackend):
         execute_sql = SQL("EXECUTE {} (%s)").format(Identifier(stmt_name))
 
         try:
-            with self._fetch_cursor(
-                row_factory=age_row_factory(exec_stats, self._model_provider) if not raw_data else None
-            ) as exec_cursor:
-                exec_cursor.execute(execute_sql, (params_json,))
-
-                if fetch_one:
-                    row = exec_cursor.fetchone()
-                    result = [row] if row is not None else []
-                else:
-                    result = exec_cursor.fetchall()
-
-                col_names = [col.name for col in exec_cursor.description] if exec_cursor.description else []
-                sql_stats = SqlStatistics(sql_stmt=cypher_sql.as_string(), col_names=col_names)
-
-            if self.autocommit:
-                self._connection.commit()
-
+            result, sql_stats = self._run_prepared(execute_sql, params_json, cypher_sql, exec_stats, fetch_one, raw_data)
+        except psycopg.errors.InvalidSqlStatementName:
+            # Server-side prepared statement was dropped (connection recycled,
+            # PgBouncer reset, idle timeout). Roll back, evict the stale cache
+            # entry, re-prepare, and retry once.
+            logger.debug("Prepared statement {} gone from server, re-preparing", stmt_name)
+            with contextlib.suppress(Exception):
+                self._connection.rollback()
+            query_hash = self._get_query_hash(cypher_query.parsed_query)
+            self._prepared_statements.pop(query_hash, None)
+            stmt_name = self._get_or_prepare_statement(cypher_sql, cypher_query.parsed_query)
+            execute_sql = SQL("EXECUTE {} (%s)").format(Identifier(stmt_name))
+            try:
+                result, sql_stats = self._run_prepared(execute_sql, params_json, cypher_sql, exec_stats, fetch_one, raw_data)
+            except Exception as e:
+                error_details = f"AGE query execution failed after re-prepare: {e}"
+                self._prepared_statements.clear()
+                self._connection.close()
+                self._connection = None
+                raise AGEExecutionError(error_details) from e
         except Exception as e:
             error_details = f"AGE query execution failed: {e}"
+            self._prepared_statements.clear()
             self._connection.close()
             self._connection = None
             raise AGEExecutionError(error_details) from e
@@ -290,6 +306,27 @@ class AGEGraphDB(CypherBackend):
 
         return (result, exec_stats, sql_stats)
 
+    def _run_prepared(self, execute_sql, params_json, cypher_sql, exec_stats, fetch_one, raw_data):
+        """Execute a prepared statement and return (result, sql_stats)."""
+        with self._fetch_cursor(
+            row_factory=age_row_factory(exec_stats, self._model_provider) if not raw_data else None
+        ) as exec_cursor:
+            exec_cursor.execute(execute_sql, (params_json,))
+
+            if fetch_one:
+                row = exec_cursor.fetchone()
+                result = [row] if row is not None else []
+            else:
+                result = exec_cursor.fetchall()
+
+            col_names = [col.name for col in exec_cursor.description] if exec_cursor.description else []
+            sql_stats = SqlStatistics(sql_stmt=cypher_sql.as_string(), col_names=col_names)
+
+        if self.autocommit:
+            self._connection.commit()
+
+        return result, sql_stats
+
     def _cleanup_prepared_statements(self):
         """Deallocate all cached prepared statements."""
         if not self._connection or not self._prepared_statements:
@@ -525,6 +562,8 @@ class AGEGraphDB(CypherBackend):
             case BackendCapability.PROPERTY_INDEX:
                 # AGE supports GIN property indexes via PostgreSQL SQL
                 return True
+            case BackendCapability.BULK_DELETE:
+                return True
             case _:
                 # Delegate unknown capabilities to superclass
                 return super().get_capability(capability)
@@ -674,6 +713,13 @@ class AGEGraphDB(CypherBackend):
         # Edge traversal indexes -- auto-created on edge label tables
         return bool(indexname.endswith("_start_id_idx") or indexname.endswith("_end_id_idx"))
 
+    # ── Bulk delete operations ─────────────────────────────────────────────
+
+    def bulk_delete_nodes(self, label: str, filters: dict[str, str]) -> int:
+        """Delete nodes matching property filters, cascading to edges."""
+        self._require_connection()
+        return self._get_bulk_writer().bulk_delete_nodes(label, filters)
+
     # ── Bulk write operations ─────────────────────────────────────────────
 
     def bulk_create_nodes(self, label: str, rows: list[dict], batch_size: int = 200) -> int:
@@ -708,8 +754,8 @@ class AGEGraphDB(CypherBackend):
         self,
         label: str,
         edges: list[dict],
-        src_label: str = "",
-        dst_label: str = "",
+        src_label: str,
+        dst_label: str,
         src_ref_prop: str = "id",
         dst_ref_prop: str = "id",
         batch_size: int = 500,
@@ -723,8 +769,8 @@ class AGEGraphDB(CypherBackend):
         Args:
             label: Edge label for all created edges.
             edges: List of dicts with at least "src" and "dst" keys.
-            src_label: Label of source nodes (empty string for any label).
-            dst_label: Label of destination nodes (empty string for any label).
+            src_label: Label of source nodes. Required for optimal performance on AGE.
+            dst_label: Label of destination nodes. Required for optimal performance on AGE.
             src_ref_prop: Property name on source nodes to match against "src".
             dst_ref_prop: Property name on destination nodes to match against "dst".
             batch_size: Number of edges per batch.
@@ -741,9 +787,9 @@ class AGEGraphDB(CypherBackend):
                 label, edges, src_label, dst_label, src_ref_prop, dst_ref_prop, batch_size
             )
 
-        # Cypher UNWIND fallback (when labels not specified or direct insert disabled)
-        src_pat = f"(a:{src_label} {{{src_ref_prop}: e.src}})" if src_label else f"(a {{{src_ref_prop}: e.src}})"
-        dst_pat = f"(b:{dst_label} {{{dst_ref_prop}: e.dst}})" if dst_label else f"(b {{{dst_ref_prop}: e.dst}})"
+        # Cypher UNWIND fallback (direct_bulk_insert disabled).
+        src_pat = f"(a:{src_label} {{{src_ref_prop}: e.src}})"
+        dst_pat = f"(b:{dst_label} {{{dst_ref_prop}: e.dst}})"
 
         total = 0
         for batch in chunk_list(edges, batch_size):

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/src/cypher_graphdb/backends/memgraph/memgraphdb.py

@@ -541,8 +541,8 @@ class MemgraphDB(CypherBackend):
         self,
         label: str,
         edges: list[dict],
-        src_label: str = "",
-        dst_label: str = "",
+        src_label: str,
+        dst_label: str,
         src_ref_prop: str = "id",
         dst_ref_prop: str = "id",
         batch_size: int = 500,
@@ -555,8 +555,8 @@ class MemgraphDB(CypherBackend):
         Args:
             label: Edge label for all created edges.
             edges: List of dicts with "src", "dst", and optional edge properties.
-            src_label: Label of source nodes (empty string for any label).
-            dst_label: Label of destination nodes (empty string for any label).
+            src_label: Label of source nodes. Required for optimal performance on AGE.
+            dst_label: Label of destination nodes. Required for optimal performance on AGE.
             src_ref_prop: Property name on source nodes to match against "src".
             dst_ref_prop: Property name on destination nodes to match against "dst".
             batch_size: Number of edges per UNWIND batch.

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/src/cypher_graphdb/cyphergraphdb/cyphergraphdb.py

@@ -255,6 +255,11 @@ class CypherGraphDB(ConnectionMixin, BatchMixin, IndexingMixin, SchemaMixin, Sea
     # Property for convenience access
     settings = property(lambda self: self.get_settings())
 
+    @property
+    def connected(self) -> bool:
+        """Return True if the backend has an active connection."""
+        return self._backend.connected if self._backend else False
+
     @property
     def read_only(self) -> bool:
         """Check if the connection is in read-only mode.

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/src/cypher_graphdb/cyphergraphdb/indexing.py

@@ -93,6 +93,24 @@ class IndexingMixin:
         assert self._backend
         return self._backend.list_indexes(include_internal=include_internal)
 
+    def bulk_delete_nodes(self, label: str, filters: dict[str, str]) -> int:
+        """Delete all nodes of a label matching property filters, cascading to edges.
+
+        Delegates to the backend's ``bulk_delete_nodes``. Backends that declare
+        ``BULK_DELETE`` capability provide an optimized implementation; others
+        fall back to Cypher DETACH DELETE.
+
+        Args:
+            label: Node label to delete from (e.g. "Method", "Class").
+            filters: Property key=value filters (AND semantics).
+                     Example: {"source_key": "nais-platform", "lang": "ts"}
+
+        Returns:
+            Number of nodes deleted.
+        """
+        assert self._backend
+        return self._backend.bulk_delete_nodes(label, filters)
+
     def bulk_create_nodes(
         self,
         rows: Sequence[dict] | Sequence[GraphNode],
@@ -138,11 +156,11 @@ class IndexingMixin:
     def bulk_create_edges(
         self,
         edges: Sequence[dict] | Sequence[GraphEdge],
+        src_label: str,
+        dst_label: str,
         src_refs: Sequence[Any] | None = None,
         dst_refs: Sequence[Any] | None = None,
         label: str | None = None,
-        src_label: str = "",
-        dst_label: str = "",
         src_ref_prop: str = "id",
         dst_ref_prop: str = "id",
         batch_size: int = 500,
@@ -169,8 +187,8 @@ class IndexingMixin:
             dst_refs: Parallel list of destination match values. Required for
                 typed input; must be None for dict input.
             label: Edge label. Required for dicts; optional for typed input.
-            src_label: Label of source nodes (empty string for any label).
-            dst_label: Label of destination nodes (empty string for any label).
+            src_label: Label of source nodes. Required for optimal performance on AGE.
+            dst_label: Label of destination nodes. Required for optimal performance on AGE.
             src_ref_prop: Property name on source nodes to match against src refs.
             dst_ref_prop: Property name on destination nodes to match against dst refs.
             batch_size: Number of edges per batch.

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/src/cypher_graphdb/dbpool.py

@@ -249,6 +249,8 @@ class CypherGraphDBPool:
 
         Silently ignores connections not tracked by this pool. If the pool
         has been closed the connection is disconnected instead of re-queued.
+        Disconnected instances (connection lost during use) are discarded
+        rather than re-queued to prevent stale connections re-entering idle.
         """
         if db is None:
             return
@@ -262,6 +264,11 @@ class CypherGraphDBPool:
                     db.disconnect()
                 logger.trace("Release disconnect (closed) id={}", id(db))
                 return
+            # Discard instances that lost their connection during use.
+            if not db.connected:
+                logger.debug("Release discard id={} (disconnected)", id(db))
+                self._not_empty.notify()
+                return
             # compute and append expiry (0.0 sentinel if no TTL)
             self._idle.append((self._expiry(), db))
             self._stats.released += 1

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6/src/cypher_graphdb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cypher_graphdb
-Version: 0.2.4
+Version: 0.2.6
 Summary: ORM like library and CLI for cypher query language supporting graph databases.
 Author-email: Wolfgang Miller <wolfgang.miller@petrarca-labs.com>
 License-Expression: Apache-2.0

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/tests/integration/test_indexes_and_bulk.py

@@ -235,7 +235,7 @@ class TestBulkCreateEdges:
     @pytest.mark.parametrize("test_db", ["memgraph_db", "age_db"], indirect=True)
     def test_bulk_create_edges_empty(self, clean_db):
         """bulk_create_edges with empty list should return 0."""
-        count = clean_db.bulk_create_edges([], label="KNOWS")
+        count = clean_db.bulk_create_edges([], label="KNOWS", src_label="Person", dst_label="Person")
         assert count == 0
 
     @pytest.mark.parametrize("test_db", ["memgraph_db", "age_db"], indirect=True)
@@ -494,3 +494,106 @@ class TestBulkDataCorrectness:
         # Reverse direction should not match
         rev = clean_db.execute("MATCH (a:DirNode {id: 'dst_node'})-[:POINTS_TO]->(b) RETURN b.id")
         assert rev == [] or rev is None
+
+
+# ── Bulk delete nodes ─────────────────────────────────────────────────────
+
+
+class TestBulkDeleteNodes:
+    """Test bulk_delete_nodes for both backends."""
+
+    @pytest.mark.parametrize("test_db", ["memgraph_db", "age_db"], indirect=True)
+    def test_delete_by_single_filter(self, clean_db):
+        """bulk_delete_nodes should remove only matching nodes."""
+        clean_db.bulk_create_nodes(
+            [{"id": f"a{i}", "source_key": "alpha", "lang": "py"} for i in range(5)],
+            label="DelNode",
+        )
+        clean_db.bulk_create_nodes(
+            [{"id": f"b{i}", "source_key": "beta", "lang": "py"} for i in range(3)],
+            label="DelNode",
+        )
+        clean_db.commit()
+
+        deleted = clean_db.bulk_delete_nodes("DelNode", {"source_key": "alpha"})
+        clean_db.commit()
+
+        assert deleted == 5
+        remaining = clean_db.execute("MATCH (n:DelNode) RETURN count(n)", unnest_result=True)
+        assert remaining == 3
+
+    @pytest.mark.parametrize("test_db", ["memgraph_db", "age_db"], indirect=True)
+    def test_delete_by_multiple_filters(self, clean_db):
+        """bulk_delete_nodes with multiple filters should AND them."""
+        clean_db.bulk_create_nodes(
+            [{"id": f"a{i}", "source_key": "src", "lang": "py"} for i in range(4)],
+            label="MFNode",
+        )
+        clean_db.bulk_create_nodes(
+            [{"id": f"b{i}", "source_key": "src", "lang": "ts"} for i in range(3)],
+            label="MFNode",
+        )
+        clean_db.commit()
+
+        deleted = clean_db.bulk_delete_nodes("MFNode", {"source_key": "src", "lang": "py"})
+        clean_db.commit()
+
+        assert deleted == 4
+        remaining = clean_db.execute("MATCH (n:MFNode) RETURN count(n)", unnest_result=True)
+        assert remaining == 3
+
+    @pytest.mark.parametrize("test_db", ["memgraph_db", "age_db"], indirect=True)
+    def test_delete_cascades_to_edges(self, clean_db):
+        """bulk_delete_nodes should also remove edges referencing deleted nodes."""
+        clean_db.bulk_create_nodes(
+            [{"id": "x1", "source_key": "s"}, {"id": "x2", "source_key": "s"}],
+            label="CascNode",
+        )
+        clean_db.bulk_create_nodes(
+            [{"id": "y1", "source_key": "other"}],
+            label="CascNode",
+        )
+        clean_db.create_property_index("CascNode", "id")
+        clean_db.commit()
+
+        clean_db.bulk_create_edges(
+            [{"src": "x1", "dst": "x2"}, {"src": "x1", "dst": "y1"}],
+            label="LINKS",
+            src_label="CascNode",
+            dst_label="CascNode",
+        )
+        clean_db.commit()
+
+        # Verify edges exist
+        edge_count = clean_db.execute("MATCH ()-[r:LINKS]->() RETURN count(r)", unnest_result=True)
+        assert edge_count == 2
+
+        # Delete only source_key='s' nodes
+        deleted = clean_db.bulk_delete_nodes("CascNode", {"source_key": "s"})
+        clean_db.commit()
+
+        assert deleted == 2
+        # Both edges should be gone (x1 was start of both)
+        edge_count = clean_db.execute("MATCH ()-[r:LINKS]->() RETURN count(r)", unnest_result=True)
+        assert edge_count == 0
+        # y1 should still exist
+        remaining = clean_db.execute("MATCH (n:CascNode) RETURN count(n)", unnest_result=True)
+        assert remaining == 1
+
+    @pytest.mark.parametrize("test_db", ["memgraph_db", "age_db"], indirect=True)
+    def test_delete_no_match_returns_zero(self, clean_db):
+        """bulk_delete_nodes with no matching nodes should return 0."""
+        clean_db.bulk_create_nodes([{"id": "z1", "source_key": "keep"}], label="NoMatch")
+        clean_db.commit()
+
+        deleted = clean_db.bulk_delete_nodes("NoMatch", {"source_key": "nonexistent"})
+        assert deleted == 0
+
+        remaining = clean_db.execute("MATCH (n:NoMatch) RETURN count(n)", unnest_result=True)
+        assert remaining == 1
+
+    @pytest.mark.parametrize("test_db", ["memgraph_db", "age_db"], indirect=True)
+    def test_delete_empty_filters_raises(self, clean_db):
+        """bulk_delete_nodes with empty filters should raise ValueError."""
+        with pytest.raises(ValueError, match="filters must not be empty"):
+            clean_db.bulk_delete_nodes("SomeLabel", {})

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/tests/unit/mock_backend.py

@@ -29,6 +29,10 @@ class MockBackend(CypherBackend):
         self.next_edge_id = 1000
         self._commits = 0
 
+    @property
+    def connected(self) -> bool:
+        return True
+
     # ---- abstract method implementations (no-op/trivial) ----
     def connect(self, *args, **kwargs):  # noqa: D401
         return None

{cypher_graphdb-0.2.4 → cypher_graphdb-0.2.6}/tests/unit/test_indexing.py

@@ -170,7 +170,7 @@ class TestDefaultBackendMethods:
 
     def test_bulk_create_edges_raises(self):
         with pytest.raises(NotImplementedError, match="does not support bulk_create_edges"):
-            self.backend.bulk_create_edges("Label", [{"src": "a", "dst": "b"}])
+            self.backend.bulk_create_edges("Label", [{"src": "a", "dst": "b"}], "SrcLabel", "DstLabel")
 
     def test_has_capability_false_for_property_index(self):
         """MinimalBackend doesn't override get_capability, so PROPERTY_INDEX is unsupported."""