Fix the test: a node can't be part of itself so we can subtract 1 from the estimated worst case scenario

Author: thomaskrause

CHANGELOG.md

@@ -10,6 +10,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `execute_query_on_graph` now skips nodes that are not part of the output
   (optional negated nodes) and makes sure the resulting iterator only produces
   unique results.
+- Queries with `@` could have extremly slow execution plans when the query
+  planner introduces an inverted `@` operator and miscalculated the cost
+  compared to the non-inverted version.
 
 ## [4.0.0] - 2025-08-20
 

graphannis/src/annis/db/aql/operators/edge_op.rs

@@ -24,7 +24,7 @@ struct BaseEdgeOpSpec {
     pub edge_anno: Option<EdgeAnnoSearchSpec>,
     pub is_reflexive: bool,
     pub op_str: Option<String>,
-    pub check_cost_for_inverse_operator: bool,
+    pub inverse_operator_needs_cost_check: bool,
 }
 
 struct BaseEdgeOp {
@@ -61,24 +61,30 @@ fn calculate_max_node_estimate(
     gs: &Vec<Arc<dyn GraphStorage>>,
     inverse: bool,
 ) -> Result<usize> {
-    let all_part_of_components = spec
+    let all_components_are_partof = spec
         .components
         .iter()
         .all(|c| c.get_type() == AnnotationComponentType::PartOf);
-    let max_nodes_estimate = if all_part_of_components && gs.len() == 1 {
-        // PartOf components have a very skewed distribution of root nodes
-        // vs. the actual possible targets, thus do not use all nodes as
-        // population but only the non-roots.
+    let max_nodes_estimate = if all_components_are_partof && gs.len() == 1 {
+        // PartOf components have a very skewed distribution of root nodes vs.
+        // the actual possible targets, thus do not use all nodes as population
+        // but only the non-roots. We can only use this formula for the actual
+        // @* operator, but not the inverted one.
         if !inverse && let Some(stats) = gs[0].get_statistics() {
             stats.nodes - stats.root_nodes
         } else {
-            // Fallback to guessing by using the node type
-            db.get_node_annos().guess_max_count(
-                Some(&NODE_TYPE_KEY.ns),
-                &NODE_TYPE_KEY.name,
-                "corpus",
-                "datasource",
-            )?
+            // Fallback to guessing how many nodes have the node type "corpus"
+            // or "datasource" and thus could be reachable as RHS in a worst case
+            // scenario. Since a node can't be part of itself, subtract 1 for
+            // the node on the LHS.
+            db.get_node_annos()
+                .guess_max_count(
+                    Some(&NODE_TYPE_KEY.ns),
+                    &NODE_TYPE_KEY.name,
+                    "corpus",
+                    "datasource",
+                )?
+                .saturating_sub(1)
         }
     } else {
         db.get_node_annos().guess_max_count(
@@ -303,7 +309,7 @@ impl BinaryOperatorBase for BaseEdgeOp {
         // don't provide an inverse operator, because the plans would not
         // account for the different costs
         for g in &self.gs {
-            if self.spec.check_cost_for_inverse_operator && !g.inverse_has_same_cost() {
+            if self.spec.inverse_operator_needs_cost_check && !g.inverse_has_same_cost() {
                 return Ok(None);
             }
             if let Some(stat) = g.get_statistics() {
@@ -640,7 +646,7 @@ impl BinaryOperatorSpec for DominanceSpec {
             dist: self.dist.clone(),
             edge_anno: self.edge_anno.clone(),
             is_reflexive: true,
-            check_cost_for_inverse_operator: true,
+            inverse_operator_needs_cost_check: true,
         };
         base.create_operator(db, cost_estimate)
     }
@@ -692,7 +698,7 @@ impl BinaryOperatorSpec for PointingSpec {
             edge_anno: self.edge_anno.clone(),
             is_reflexive: true,
             op_str: Some(op_str),
-            check_cost_for_inverse_operator: true,
+            inverse_operator_needs_cost_check: true,
         };
         base.create_operator(db, cost_estimate)
     }
@@ -737,7 +743,7 @@ impl BinaryOperatorSpec for PartOfSubCorpusSpec {
             ANNIS_NS.into(),
             "".into(),
         )];
-        let check_cost_for_inverse_operator = if let Some((_, rhs)) = cost_estimate {
+        let inverse_operator_needs_cost_check = if let Some((_, rhs)) = cost_estimate {
             // Only ignore different cost and risk a nested loop join if the RHS
             // has an estimated output size of 1 and thus a nested loop is not
             // as costly.
@@ -751,7 +757,7 @@ impl BinaryOperatorSpec for PartOfSubCorpusSpec {
             dist: self.dist.clone(),
             edge_anno: None,
             is_reflexive: false,
-            check_cost_for_inverse_operator,
+            inverse_operator_needs_cost_check,
         };
 
         base.create_operator(db, cost_estimate)