Batch hasChildren resolution in class tree endpoint

Resolve hasChildren for the whole node set in a single grouped count
query instead of one LIMIT 1 SPARQL round-trip per node. hasChildren is
exactly (childrenCount > 0), so Class.load_has_children_batch derives it
from already-loaded data (the children-count aggregate or loaded
children) and falls back to one grouped query for the rest, pre-warming
@intlHasChildren so the per-node load_has_children calls become no-ops.

Wired into Concept::Tree#tree (path nodes + their children) and
OntologySubmission#roots (gated on :hasChildren), removing the per-root
N+1 that hits up to FLAT_ROOTS_LIMIT queries for flat ontologies.

Adds regression tests asserting hasChildren <-> childrenCount across OWL
and SKOS trees and that roots(:hasChildren) preserves loaded attributes.

#296

Author: alexskr

lib/ontologies_linked_data/concerns/concepts/concept_tree.rb

@@ -24,10 +24,20 @@ def tree(concept_schemes: [], concept_collections: [], roots: nil)
           path.last.instance_variable_set("@children", [])
 
           childrens_hash = {}
+          path.each do |m|
+            next if m.id.to_s["#Thing"]
+            m.children.each { |c| childrens_hash[c.id.to_s] = c }
+          end
+
+          # Resolve hasChildren for every node we are about to compute attributes
+          # on in a single grouped query, so the per-node load_has_children calls
+          # made by load_computed_attributes below become no-ops.
+          has_children_nodes = path.reject { |m| m.id.to_s["#Thing"] } + childrens_hash.values
+          LinkedData::Models::Class.load_has_children_batch(has_children_nodes, submission)
+
           path.each do |m|
             next if m.id.to_s["#Thing"]
             m.children.each do |c|
-              childrens_hash[c.id.to_s] = c
               c.load_computed_attributes(to_load:extra_include ,
                                          options: {schemes: concept_schemes, collections: concept_collections})
             end

lib/ontologies_linked_data/models/class.rb

@@ -483,6 +483,40 @@ def self.partially_load_children(models, threshold, submission)
         self.in(submission).models(single_load).include({children: ld}).all if single_load.length > 0
       end
 
+      # Resolves hasChildren for a set of classes, pre-warming each instance's
+      # @intlHasChildren so subsequent per-node #load_has_children calls become
+      # no-ops. hasChildren is true iff the class has at least one child, which
+      # is exactly (children count > 0) -- #children and #hasChildren both use
+      # tree_view_property -- so we derive it from data already on hand and fall
+      # back to a single grouped count query for the rest, instead of issuing
+      # one has_children_query SPARQL round-trip per node.
+      def self.load_has_children_batch(models, submission)
+        models = models.to_a.compact.reject do |m|
+          !m.instance_variable_get("@intlHasChildren").nil? || m.id.to_s["#Thing"]
+        end
+        return if models.empty?
+
+        remaining = []
+        models.each do |m|
+          if m.aggregates
+            agg = m.aggregates.find { |x| x.attribute == :children && x.aggregate == :count }
+            m.instance_variable_set("@intlHasChildren", agg.value > 0) if agg
+          elsif m.loaded_attributes.include?(:children)
+            m.instance_variable_set("@intlHasChildren", !m.children.empty?)
+          else
+            remaining << m
+          end
+        end
+
+        return if remaining.empty?
+
+        self.in(submission).models(remaining).aggregate(:count, :children).all
+        remaining.each do |m|
+          agg = m.aggregates&.find { |x| x.attribute == :children && x.aggregate == :count }
+          m.instance_variable_set("@intlHasChildren", agg.value > 0) if agg
+        end
+      end
+
       def load_computed_attributes(to_load:, options:)
         self.load_has_children if to_load&.include?(:hasChildren)
         self.load_is_in_scheme(options[:schemes]) if to_load&.include?(:isInActiveScheme)

lib/ontologies_linked_data/models/ontology_submission.rb

@@ -769,6 +769,12 @@ def roots(extra_include = [], page = nil, pagesize = nil, concept_schemes: [], c
 
         LinkedData::Models::Class.partially_load_children(classes, 99, self) if load_children.length > 0
 
+        # Resolve hasChildren for all roots in one grouped query rather than one
+        # has_children_query per root (up to FLAT_ROOTS_LIMIT for flat ontologies).
+        if extra_include&.include?(:hasChildren)
+          LinkedData::Models::Class.load_has_children_batch(classes, self)
+        end
+
         classes.delete_if { |c|
           obs = !c.obsolete.nil? && c.obsolete == true
           if !obs

test/models/test_class.rb

@@ -260,6 +260,42 @@ def test_bro_tree
     end
   end
 
+  # Guards the hasChildren <-> childrenCount contract on every node of a built
+  # tree. The batched hasChildren optimization derives hasChildren from the
+  # child-count aggregate, so this asserts the two stay consistent and that
+  # hasChildren is always loaded (never raises) on tree nodes.
+  def test_bro_tree_has_children
+    if !LinkedData::Models::Ontology.find("BROTEST123").first
+      submission_parse("BROTEST123", "SOME BROTEST Bla", "./test/data/ontology_files/BRO_v3.2.owl", 123,
+                       process_rdf: true, index_search: false,
+                       run_metrics: false, reasoning: true)
+    end
+    os = LinkedData::Models::Ontology.find("BROTEST123").first.latest_submission(status: [:rdf])
+    statistical_Text_Analysis = "http://bioontology.org/ontologies/BiomedicalResourceOntology.owl#Statistical_Text_Analysis"
+    cls = LinkedData::Models::Class.find(RDF::URI.new(statistical_Text_Analysis)).in(os).first
+
+    tree_root = cls.tree
+
+    checked = 0
+    stack = [tree_root]
+    until stack.empty?
+      node = stack.pop
+
+      hc = node.hasChildren
+      assert_includes [true, false], hc, "hasChildren not a boolean for #{node.id}"
+
+      cc = node.aggregates ? node.childrenCount : nil
+      unless cc.nil?
+        assert_equal((cc > 0), hc, "hasChildren/childrenCount mismatch for #{node.id}")
+        checked += 1
+      end
+
+      stack.concat(node.children)
+    end
+
+    assert checked > 0, "expected at least one node with a child-count aggregate"
+  end
+
 
   def test_include_ancestors
     if !LinkedData::Models::Ontology.find("BROTEST123").first

test/models/test_ontology_submission.rb

@@ -870,6 +870,26 @@ def test_submission_root_classes
     assert_equal 6, roots.length
   end
 
+  # roots(:hasChildren) is the path the class-tree endpoint takes. Guards that
+  # the batched hasChildren resolution leaves the other loaded attributes
+  # (prefLabel) intact and stays consistent with childrenCount.
+  def test_submission_root_classes_has_children
+    acr = "CSTPROPS"
+    init_test_ontology_msotest acr
+    os = LinkedData::Models::OntologySubmission.where(ontology: [acronym: acr], submissionId: 1).all.first
+
+    roots = os.roots([:hasChildren])
+    refute_empty roots
+
+    roots.each do |r|
+      assert_includes r.loaded_attributes.to_a, :prefLabel, "prefLabel not loaded for #{r.id}"
+      refute_nil r.prefLabel, "prefLabel nil for #{r.id}"
+      assert_includes [true, false], r.hasChildren, "hasChildren not a boolean for #{r.id}"
+      cc = r.aggregates ? r.childrenCount : nil
+      assert_equal((cc > 0), r.hasChildren, "hasChildren/childrenCount mismatch for #{r.id}") unless cc.nil?
+    end
+  end
+
   #escaping sequences
   def test_submission_parse_sbo
     acronym = "SBO-TST"

test/models/test_skos_submission.rb

@@ -131,5 +131,56 @@ def test_roots_of_scheme_collections
       assert_equal r.isInActiveCollection, selected_collections unless selected_collections.empty?
     end
   end
+
+  # Builds a tree from a SKOS concept and asserts the structural invariants the
+  # tree endpoint relies on. Guards the SKOS branch of Class#tree (computed
+  # attributes, isInActiveScheme) and the hasChildren <-> childrenCount
+  # contract that the batched hasChildren optimization must preserve.
+  def test_skos_class_tree
+    sub = before_suite
+    roots = sub.roots
+    refute_empty roots, 'expected SKOS roots'
+
+    # Find a root that has children and descend one level so the path to root
+    # is non-trivial (root -> target).
+    target = nil
+    roots.each do |r|
+      LinkedData::Models::Class.in(sub).models([r]).include(children: [:prefLabel]).all
+      next if r.children.empty?
+
+      target = LinkedData::Models::Class.find(r.children.first.id).in(sub).first
+      break
+    end
+    refute_nil target, 'expected a SKOS root with at least one child'
+
+    tree_root = target.tree
+
+    # The tree must terminate at one of the submission roots.
+    assert_includes roots.map { |x| x.id.to_s }, tree_root.id.to_s
+
+    # Walk the whole tree and check the invariants on every node.
+    seen_target = false
+    stack = [tree_root]
+    until stack.empty?
+      node = stack.pop
+      seen_target ||= node.id.to_s == target.id.to_s
+
+      # hasChildren must be loaded (no raise) and a boolean.
+      hc = node.hasChildren
+      assert_includes [true, false], hc, "hasChildren not a boolean for #{node.id}"
+
+      # When the child-count aggregate is present it must agree with hasChildren.
+      # This is the semantic contract the batched optimization preserves.
+      cc = node.aggregates ? node.childrenCount : nil
+      assert_equal((cc > 0), hc, "hasChildren/childrenCount mismatch for #{node.id}") unless cc.nil?
+
+      # SKOS computed scheme attribute must be loaded on tree nodes.
+      assert_kind_of Array, node.isInActiveScheme
+
+      stack.concat(node.children)
+    end
+
+    assert seen_target, 'target class not found within its own tree'
+  end
 end