Class: Archsight::Query::Evaluator

Inherits:
Object
  • Object
show all
Defined in:
lib/archsight/query/evaluator.rb

Instance Method Summary collapse

Constructor Details

#initialize(database) ⇒ Evaluator

Returns a new instance of Evaluator.



7
8
9
10
 
# File 'lib/archsight/query/evaluator.rb', line 7

def initialize(database)
  @database = database
  @subquery_cache = {} # Cache for pre-computed subquery results
end

Instance Method Details

#filter(query_node) ⇒ Object

Filter all instances matching query



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/archsight/query/evaluator.rb', line 31

def filter(query_node)
  results = []

  target_instances = if query_node.kind_filter
                       klass = Archsight::Resources[query_node.kind_filter]
                       return [] unless klass

                       @database.instances[klass]&.values || []
                     else
                       all = []
                       @database.instances.each_value { |h| all.concat(h.values) }
                       all
                     end

  # If no expression, return all target instances (kind filter only)
  return target_instances if query_node.expression.nil?

  # Pre-compute ALL subqueries before the main filter loop
  # This is the key optimization - subqueries are evaluated once, not per-instance
  @subquery_cache = {}
  precompute_subqueries(query_node.expression)

  target_instances.each do |instance|
    results << instance if evaluate(query_node.expression, instance)
  end

  results
end

#matches?(query_node, instance) ⇒ Boolean

Main entry point: evaluate query against instance, returns boolean

Returns:

  • (Boolean) 


13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/archsight/query/evaluator.rb', line 13

def matches?(query_node, instance)
  # Check kind filter first
  if query_node.kind_filter
    instance_kind = instance.class.to_s.split("::").last
    return false unless instance_kind == query_node.kind_filter
  end

  # If no expression, kind filter alone is sufficient (match all of that kind)
  return true if query_node.expression.nil?

  # Pre-compute subqueries for this evaluation
  @subquery_cache = {}
  precompute_subqueries(query_node.expression)

  evaluate(query_node.expression, instance)
end