lutaml 0.10.2 → 0.10.3

data/lib/lutaml/qea/factory/class_transformer.rb

@@ -108,15 +108,9 @@ module Lutaml
         def load_attributes(object_id)
           return [] if object_id.nil?
 
-          # Query t_attribute table
-          query = "SELECT * FROM t_attribute WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
+          ea_attributes = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
 
-          ea_attributes = rows.map do |row|
-            Models::EaAttribute.from_db_row(row)
-          end
-
-          # Transform to UML attributes
           attribute_transformer = AttributeTransformer.new(database)
           attribute_transformer.transform_collection(ea_attributes)
         end
@@ -127,15 +121,9 @@ module Lutaml
         def load_operations(object_id)
           return [] if object_id.nil?
 
-          # Query t_operation table
-          query = "SELECT * FROM t_operation WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          ea_operations = rows.map do |row|
-            Models::EaOperation.from_db_row(row)
-          end
+          ea_operations = database.operations_for_object(object_id)
+            .sort_by { |op| op.pos || 0 }
 
-          # Transform to UML operations
           operation_transformer = OperationTransformer.new(database)
           operation_transformer.transform_collection(ea_operations)
         end
@@ -245,24 +233,21 @@ module Lutaml
           return nil unless current_obj
 
           # 2. Find generalization connector where this class is the subtype
-          query = "SELECT * FROM t_connector WHERE Start_Object_ID = ? " \
-                  "AND Connector_Type = 'Generalization' LIMIT 1"
-          rows = database.connection.execute(query, object_id)
+          ea_connector = database.connectors_for_object(object_id)
+            .find { |c| c.generalization? && c.start_object_id == object_id }
 
           # 3. Create generalization object for current class
           # Even if no parent exists, we need a Generalization
           # representing this class
-          if rows.empty?
+          gen_transformer = GeneralizationTransformer.new(database)
+          generalization = if ea_connector.nil?
             # No parent - create terminal generalization
-            gen_transformer = GeneralizationTransformer.new(database)
-            generalization = gen_transformer.transform(nil, current_obj)
+            gen_transformer.transform(nil, current_obj)
           else
             # Has parent - create generalization with parent connector
-            ea_connector = Models::EaConnector.from_db_row(rows.first)
-            gen_transformer = GeneralizationTransformer.new(database)
-            generalization = gen_transformer
+            gen_transformer
               .transform(ea_connector, current_obj)
-          end
+                           end
           return nil unless generalization
 
           # 4. Load CURRENT object attributes and convert to GeneralAttribute
@@ -452,19 +437,13 @@ module Lutaml
         def load_association_generalizations(object_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
           return [] if object_id.nil?
 
-          # Query for ALL generalization connectors for this class
-          query = "SELECT ea_guid, End_Object_ID FROM t_connector " \
-                  "WHERE Start_Object_ID = ? " \
-                  "AND Connector_Type = 'Generalization'"
-          rows = database.connection.execute(query, object_id)
+          # Find ALL generalization connectors for this class
+          gen_connectors = database.connectors_for_object(object_id)
+            .select { |c| c.generalization? && c.start_object_id == object_id }
 
-          rows.filter_map do |row|
-            guid = row.is_a?(Hash) ? (row["ea_guid"] || row[:ea_guid]) : row[0]
-            parent_object_id = if row.is_a?(Hash)
-                                 row["End_Object_ID"] || row[:End_Object_ID]
-                               else
-                                 row[1]
-                               end
+          gen_connectors.filter_map do |ea_connector|
+            guid = ea_connector.ea_guid
+            parent_object_id = ea_connector.end_object_id
 
             # Find parent object to get its GUID
             parent_obj = find_object_by_id(parent_object_id)
@@ -493,16 +472,11 @@ module Lutaml
           normalized_owner_xmi_id = normalize_guid_to_xmi_format(object_guid,
                                                                  "EAID")
 
-          # Find all association-type connectors where this class participates
-          query = "SELECT * FROM t_connector " \
-                  "WHERE (Start_Object_ID = ? OR End_Object_ID = ?) " \
-                  "AND Connector_Type IN " \
-                  "('Association', 'Aggregation', 'Composition')"
-          rows = database.connection.execute(query, [object_id, object_id])
-
-          rows.each do |row| # rubocop:disable Metrics/BlockLength
-            ea_connector = Models::EaConnector.from_db_row(row)
+          assoc_types = ["Association", "Aggregation", "Composition"].freeze
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| assoc_types.include?(c.connector_type) }
 
+          assoc_connectors.each do |ea_connector| # rubocop:disable Metrics/BlockLength
             # Determine which end this class is on
             is_start = ea_connector.start_object_id == object_id
 
@@ -600,19 +574,13 @@ module Lutaml
 
           attributes = []
 
-          # Find all association-type connectors
-          # (Association, Aggregation, Composition)
-          query = "SELECT * FROM t_connector " \
-                  "WHERE (Start_Object_ID = ? OR End_Object_ID = ?) " \
-                  "AND Connector_Type IN " \
-                  "('Association', 'Aggregation', 'Composition')"
-          rows = database.connection.execute(query, [object_id, object_id])
+          assoc_types = ["Association", "Aggregation", "Composition"].freeze
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| assoc_types.include?(c.connector_type) }
           obj = find_object_by_id(object_id)
           obj_pkg_name = find_package_name(obj&.package_id)
 
-          rows.each do |row| # rubocop:disable Metrics/BlockLength
-            ea_connector = Models::EaConnector.from_db_row(row)
-
+          assoc_connectors.each do |ea_connector| # rubocop:disable Metrics/BlockLength
             # Check if this object is the source (owner) or target (member)
             if ea_connector.start_object_id == object_id
               # This class is the source - check for dest role
@@ -711,11 +679,7 @@ module Lutaml
         def find_package_name(package_id)
           return nil if package_id.nil?
 
-          query = "SELECT NAME FROM t_package WHERE Package_ID = ?"
-          rows = database.connection.execute(query, [package_id])
-          return nil if rows.empty?
-
-          rows.first["Name"]
+          database.find_package(package_id)&.name
         end
       end
     end

data/lib/lutaml/qea/factory/data_type_transformer.rb

@@ -64,12 +64,8 @@ module Lutaml
         def load_attributes(object_id)
           return [] if object_id.nil?
 
-          query = "SELECT * FROM t_attribute WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          ea_attributes = rows.map do |row|
-            Models::EaAttribute.from_db_row(row)
-          end
+          ea_attributes = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
 
           attribute_transformer = AttributeTransformer.new(database)
           attribute_transformer.transform_collection(ea_attributes)
@@ -81,12 +77,8 @@ module Lutaml
         def load_operations(object_id)
           return [] if object_id.nil?
 
-          query = "SELECT * FROM t_operation WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          ea_operations = rows.map do |row|
-            Models::EaOperation.from_db_row(row)
-          end
+          ea_operations = database.operations_for_object(object_id)
+            .sort_by { |op| op.pos || 0 }
 
           operation_transformer = OperationTransformer.new(database)
           operation_transformer.transform_collection(ea_operations)
@@ -129,19 +121,13 @@ module Lutaml
         def load_associations(object_id, object_guid) # rubocop:disable Metrics/MethodLength
           return [] if object_id.nil?
 
-          query = <<-SQL
-            SELECT * FROM t_connector
-            WHERE Connector_Type = 'Association'
-            AND (Start_Object_ID = ? OR End_Object_ID = ?)
-          SQL
-
-          rows = database.connection.execute(query, [object_id, object_id])
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| c.connector_type == "Association" }
 
           assoc_transformer = AssociationTransformer.new(database)
           normalized_xmi_id = normalize_guid_to_xmi_format(object_guid, "EAID")
 
-          rows.filter_map do |row|
-            ea_connector = Models::EaConnector.from_db_row(row)
+          assoc_connectors.filter_map do |ea_connector|
             assoc = assoc_transformer.transform(ea_connector)
 
             next unless assoc && assoc.owner_end_xmi_id == normalized_xmi_id

data/lib/lutaml/qea/factory/diagram_transformer.rb

@@ -72,11 +72,7 @@ module Lutaml
         def find_package(package_id)
           return nil if package_id.nil?
 
-          query = "SELECT * FROM t_package WHERE Package_ID = ?"
-          rows = database.connection.execute(query, package_id)
-          return nil if rows.empty?
-
-          Models::EaPackage.from_db_row(rows.first)
+          database.find_package(package_id)
         end
 
         # Load diagram objects for a diagram
@@ -85,11 +81,8 @@ module Lutaml
         def load_diagram_objects(diagram_id)
           return [] if diagram_id.nil?
 
-          query = "SELECT * FROM t_diagramobjects WHERE Diagram_ID = ?"
-          rows = database.connection.execute(query, diagram_id)
-
-          rows.filter_map do |row|
-            ea_obj = Models::EaDiagramObject.from_db_row(row)
+          ea_objects = database.diagram_objects_for(diagram_id)
+          ea_objects.filter_map do |ea_obj|
             transform_diagram_object(ea_obj)
           end
         end
@@ -127,11 +120,8 @@ module Lutaml
         def load_diagram_links(diagram_id)
           return [] if diagram_id.nil?
 
-          query = "SELECT * FROM t_diagramlinks WHERE DiagramID = ?"
-          rows = database.connection.execute(query, diagram_id)
-
-          rows.filter_map do |row|
-            ea_link = Models::EaDiagramLink.from_db_row(row)
+          ea_links = database.diagram_links_for(diagram_id)
+          ea_links.filter_map do |ea_link|
             transform_diagram_link(ea_link)
           end
         end
@@ -167,11 +157,7 @@ module Lutaml
         def find_connector_by_id(connector_id)
           return nil if connector_id.nil?
 
-          query = "SELECT * FROM t_connector WHERE Connector_ID = ?"
-          rows = database.connection.execute(query, connector_id)
-          return nil if rows.empty?
-
-          Models::EaConnector.from_db_row(rows.first)
+          database.find_connector(connector_id)
         end
       end
     end

data/lib/lutaml/qea/factory/enum_transformer.rb

@@ -50,12 +50,10 @@ module Lutaml
         def load_enum_values(object_id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           return [] if object_id.nil?
 
-          query = "SELECT * FROM t_attribute WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          rows.filter_map do |row|
-            ea_attr = Models::EaAttribute.from_db_row(row)
+          ea_attrs = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
 
+          ea_attrs.filter_map do |ea_attr|
             Lutaml::Uml::Value.new.tap do |value|
               value.name = ea_attr.name
               value.id = normalize_guid_to_xmi_format(ea_attr.ea_guid, "EAID")

data/lib/lutaml/qea/factory/generalization_transformer.rb

@@ -72,11 +72,7 @@ module Lutaml
         def find_object(object_id)
           return nil if object_id.nil?
 
-          query = "SELECT * FROM t_object WHERE Object_ID = ?"
-          rows = database.connection.execute(query, object_id)
-          return nil if rows.empty?
-
-          Models::EaObject.from_db_row(rows.first)
+          database.find_object(object_id)
         end
 
         # Find package by ID
@@ -84,9 +80,8 @@ module Lutaml
         # @return [EaPackage, nil] EA package or nil if not found
         def find_package(package_id)
           return nil if package_id.nil?
-          return nil unless database.packages
 
-          database.packages.find { |pkg| pkg.package_id == package_id }
+          database.find_package(package_id)
         end
 
         # Extract package prefix from package

data/lib/lutaml/qea/factory/instance_transformer.rb

@@ -54,11 +54,7 @@ module Lutaml
         def find_classifier(classifier_id)
           return nil if classifier_id.nil? || classifier_id.zero?
 
-          query = "SELECT * FROM t_object WHERE Object_ID = ?"
-          rows = database.connection.execute(query, classifier_id)
-          return nil if rows.empty?
-
-          Models::EaObject.from_db_row(rows.first)
+          database.find_object(classifier_id)
         end
 
         # Find classifier object by GUID
@@ -67,11 +63,7 @@ module Lutaml
         def find_classifier_by_guid(classifier_guid)
           return nil if classifier_guid.nil? || classifier_guid.empty?
 
-          query = "SELECT * FROM t_object WHERE ea_guid = ?"
-          rows = database.connection.execute(query, classifier_guid)
-          return nil if rows.empty?
-
-          Models::EaObject.from_db_row(rows.first)
+          database.find_object_by_guid(classifier_guid)
         end
 
         # Load and transform tagged values for an instance

data/lib/lutaml/qea/factory/operation_transformer.rb

@@ -60,14 +60,8 @@ module Lutaml
         def load_parameters(operation_id)
           return [] if operation_id.nil?
 
-          # Query t_operationparams table
-          query = "SELECT * FROM t_operationparams WHERE OperationID = ? " \
-                  "ORDER BY Pos"
-          rows = database.connection.execute(query, operation_id)
-
-          rows.map do |row|
-            Models::EaOperationParam.from_db_row(row)
-          end
+          database.operation_params_for(operation_id)
+            .sort_by { |p| p.pos || 0 }
         end
       end
     end

data/lib/lutaml/qea/factory/package_transformer.rb

@@ -70,11 +70,8 @@ module Lutaml
         def load_child_packages(parent_id)
           return [] if parent_id.nil?
 
-          query = "SELECT * FROM t_package WHERE Parent_ID = ? " \
-                  "ORDER BY TPos"
-          rows = database.connection.execute(query, parent_id)
-
-          rows.map { |row| Models::EaPackage.from_db_row(row) }
+          database.child_packages_for(parent_id)
+            .sort_by { |p| p.tpos || 0 }
         end
 
         # Load package contents (objects and diagrams)
@@ -94,10 +91,7 @@ module Lutaml
         # @param pkg [Lutaml::Uml::Package] UML package
         # @param package_id [Integer] Package ID
         def load_package_objects(pkg, package_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          query = "SELECT * FROM t_object WHERE Package_ID = ?"
-          rows = database.connection.execute(query, package_id)
-
-          ea_objects = rows.map { |row| Models::EaObject.from_db_row(row) }
+          ea_objects = database.objects_in_package(package_id)
 
           class_transformer = ClassTransformer.new(database)
           enum_transformer = EnumTransformer.new(database)
@@ -155,10 +149,7 @@ module Lutaml
         def load_package_diagrams(pkg, package_id)
           diagram_transformer = DiagramTransformer.new(database)
 
-          query = "SELECT * FROM t_diagram WHERE Package_ID = ?"
-          rows = database.connection.execute(query, package_id)
-
-          ea_diagrams = rows.map { |row| Models::EaDiagram.from_db_row(row) }
+          ea_diagrams = database.diagrams_in_package(package_id)
           pkg.diagrams = diagram_transformer.transform_collection(ea_diagrams)
         end
 

data/lib/lutaml/uml_repository/index_builder.rb

@@ -42,18 +42,8 @@ module Lutaml
       #   - :class_to_qname - Maps class XMI IDs to qualified names
       #   - :classes - Maps class XMI IDs to Class objects
       #   - :associations - Maps association XMI IDs to Association objects
-      def self.build_all(document) # rubocop:disable Metrics/MethodLength
-        {
-          package_paths: build_package_paths(document),
-          qualified_names: build_qualified_names(document),
-          stereotypes: build_stereotypes(document),
-          inheritance_graph: build_inheritance_graph(document, nil),
-          diagram_index: build_diagram_index(document, nil),
-          package_to_path: build_package_to_path(document),
-          class_to_qname: build_class_to_qname(document),
-          classes: build_classes(document),
-          associations: build_associations(document),
-        }.freeze
+      def self.build_all(document)
+        new(document).build_all
       end
 
       # Build package paths index
@@ -160,6 +150,8 @@ module Lutaml
         @class_to_qname = {}
         @classes = {}
         @associations = {}
+        @simple_name_to_qnames = {}
+        @package_to_classes = {}
       end
 
       # Build all indexes and return them as a frozen hash
@@ -183,6 +175,7 @@ module Lutaml
           class_to_qname: @class_to_qname.freeze,
           classes: @classes.freeze,
           associations: @associations.freeze,
+          package_to_classes: plain_hash(@package_to_classes).freeze,
         }.freeze
       end
 
@@ -358,6 +351,9 @@ module Lutaml
               qualified_name
           end
           @classes[classifier.xmi_id] = classifier if classifier.xmi_id
+          @simple_name_to_qnames[classifier.name] ||= []
+          @simple_name_to_qnames[classifier.name] << qualified_name
+          (@package_to_classes[package_path] ||= []) << classifier
         end
       end
 
@@ -466,12 +462,18 @@ module Lutaml
         local_qname = "#{current_package_path}::#{name}"
         return local_qname if @qualified_names.key?(local_qname)
 
-        # Try to find in all qualified names (simple name match)
-        @qualified_names.each_key do |qname|
-          return qname if qname.end_with?("::#{name}")
-        end
+        # O(1) lookup using reverse index instead of O(n) scan
+        candidates = @simple_name_to_qnames[name]
+        candidates&.first
+      end
 
-        nil
+      private
+
+      # Convert a hash with default proc to a plain hash (Marshal-safe)
+      # @param hash [Hash] Hash possibly with default proc
+      # @return [Hash] Plain hash without default proc
+      def plain_hash(hash_with_default)
+        hash_with_default.each_with_object({}) { |(k, v), h| h[k] = v }
       end
     end
   end

data/lib/lutaml/uml_repository/queries/class_query.rb

@@ -69,38 +69,72 @@ module Lutaml
         def in_package(package_path_string, recursive: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
           return [] if package_path_string.nil? || package_path_string.empty?
 
-          package_path = Lutaml::Uml::PackagePath.new(package_path_string)
+          pkg_to_classes = indexes[:package_to_classes]
+          if pkg_to_classes
+            in_package_indexed(package_path_string, pkg_to_classes,
+                               recursive: recursive)
+          else
+            in_package_scan(package_path_string, recursive: recursive)
+          end
+        end
+
+        private
+
+        # O(1) indexed lookup for in_package
+        def in_package_indexed(package_path_string, pkg_to_classes, recursive:) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          is_absolute = package_path_string.start_with?("::")
+          search_segs = package_path_string.split("::").reject(&:empty?)
+
           results = []
+          pkg_to_classes.each do |path, classes|
+            path_segs = path.split("::")
+            matched = if is_absolute
+                        if recursive
+                          path == package_path_string ||
+                            path.start_with?("#{package_path_string}::")
+                        else
+                          path == package_path_string
+                        end
+                      elsif recursive
+                        # Relative: match when path ends with search segments
+                        (0..(path_segs.size - search_segs.size)).any? do |i|
+                          path_segs[i, search_segs.size] == search_segs
+                        end
+                      else
+                        path_segs.size >= search_segs.size &&
+                          path_segs[-search_segs.size..] == search_segs
+                      end
 
-          # Check if the path is absolute (starts with ModelRoot)
+            results.concat(classes) if matched
+          end
+          results
+        end
+
+        # Fallback: original O(n) scan
+        def in_package_scan(package_path_string, recursive:)
+          package_path = Lutaml::Uml::PackagePath.new(package_path_string)
+          results = []
           is_absolute = package_path.absolute?
 
-          indexes[:qualified_names].each do |qname_string, klass| # rubocop:disable Metrics/BlockLength
+          indexes[:qualified_names].each do |qname_string, klass|
             qname = Lutaml::Uml::QualifiedName.new(qname_string)
 
             matched = if is_absolute
-                        # Absolute path - exact match
                         if recursive
                           qname.package_path.starts_with?(package_path)
                         else
                           qname.package_path == package_path
                         end
                       else
-                        # Relative path - match if the class's package path ends with
-                        # the given path
                         class_pkg_segs = qname.package_path.segments
                         search_segs = package_path.segments
 
                         if recursive
-                          # For recursive, check if any suffix of the class path
-                          # starts with search_segs
                           (0..(class_pkg_segs.size - search_segs.size))
                             .any? do |i|
                             class_pkg_segs[i, search_segs.size] == search_segs
                           end
                         else
-                          # For non-recursive, check if class path ends with
-                          # search_segs
                           class_pkg_segs.size >= search_segs.size &&
                             class_pkg_segs[-search_segs.size..] == search_segs
                         end

data/lib/lutaml/uml_repository/repository.rb

@@ -646,25 +646,29 @@ module Lutaml
       # Get all associations as an array
       # Collects from both document-level (XMI) and class-level (QEA/EA)
       # @return [Array<Lutaml::Uml::Association>] All associations
-      def associations_index # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      def associations_index # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics:MethodLength,Metrics:PerceivedComplexity
         # Use cached index if available (built by IndexBuilder)
         return @indexes[:associations].values if @indexes[:associations]
 
         # Fallback for edge cases: collect from document and classes
+        seen = Set.new
         associations = []
 
-        # Document-level associations (XMI format)
-        associations.concat(@document.associations) if @document.associations
+        (@document.associations || []).each do |assoc|
+          if assoc.xmi_id && !seen.include?(assoc.xmi_id)
+            seen << assoc.xmi_id
+            associations << assoc
+          end
+        end
 
-        # Class-level associations (QEA/EA format)
         classes_index.each do |klass|
           next unless klass.respond_to?(:associations) && klass.associations
 
           klass.associations.each do |assoc|
-            # Avoid duplicates - check xmi_id
-            next if associations.any? { |a| a.xmi_id == assoc.xmi_id }
-
-            associations << assoc
+            if assoc.xmi_id && !seen.include?(assoc.xmi_id)
+              seen << assoc.xmi_id
+              associations << assoc
+            end
           end
         end
 

data/lib/lutaml/uml_repository/statistics_calculator.rb

@@ -262,12 +262,14 @@ module Lutaml
       def max_inheritance_depth
         return 0 if @indexes[:inheritance_graph].empty?
 
-        max = 0
+        @inheritance_depth_cache ||= {}
+        max_depth = 0
+
         @indexes[:qualified_names].each_key do |qname|
-          depth = calculate_inheritance_depth(qname)
-          max = depth if depth > max
+          depth = memoized_inheritance_depth(qname)
+          max_depth = depth if depth > max_depth
         end
-        max
+        max_depth
       end
 
       # Calculate inheritance depth for a class
@@ -275,23 +277,33 @@ module Lutaml
       # @param qname [String] Qualified name of the class
       # @param visited [Set] Set of visited classes (to detect cycles)
       # @return [Integer] Depth of inheritance chain
-      def calculate_inheritance_depth(qname, visited = Set.new) # rubocop:disable Metrics/MethodLength
-        return 0 if visited.include?(qname)
-
-        visited.add(qname)
+      def calculate_inheritance_depth(qname, visited = Set.new)
+        memoized_inheritance_depth(qname, visited)
+      end
 
-        # Find parent
-        parent_qname = nil
-        @indexes[:inheritance_graph].each do |parent, children|
-          if children.include?(qname)
-            parent_qname = parent
-            break
+      # Build reverse index: child_qname => parent_qname
+      def child_to_parent_index
+        @child_to_parent_index ||= begin
+          idx = {}
+          @indexes[:inheritance_graph].each do |parent, children|
+            children.each { |child| idx[child] = parent }
           end
+          idx
         end
+      end
+
+      # Memoized inheritance depth calculation using reverse index
+      def memoized_inheritance_depth(qname, visited = Set.new)
+        return 0 if visited.include?(qname)
+        return @inheritance_depth_cache[qname] if @inheritance_depth_cache.key?(qname)
 
-        return 0 unless parent_qname
+        parent = child_to_parent_index[qname]
+        return 0 unless parent
 
-        1 + calculate_inheritance_depth(parent_qname, visited)
+        visited.add(qname)
+        depth = 1 + memoized_inheritance_depth(parent, visited)
+        @inheritance_depth_cache[qname] = depth
+        depth
       end
 
       # Get count of abstract classes

data/lib/lutaml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lutaml
-  VERSION = "0.10.2"
+  VERSION = "0.10.3"
 end