Module: Card::Query::CardQuery::Interpretation

Included in:
Card::Query::CardQuery
Defined in:
lib/card/query/card_query/interpretation.rb

Overview

Interpret CQL. Once interpreted, SQL can be generated.

Constant Summary collapse

INTERPRET_METHOD = 
{ basic: :add_condition,
relational: :relate,
plus_relational: :relate_compound,
conjunction: :send }.freeze

Instance Method Summary collapse

Instance Method Details

#bad_attribute!(attribute) ⇒ Object

Raises:



55
56
57
 
# File 'lib/card/query/card_query/interpretation.rb', line 55

def bad_attribute! attribute
  raise Error::BadQuery, "Invalid attribute: #{attribute}"
end

#interpret(clause) ⇒ Object

normalize and extract meaning from a clause

Parameters:

  • clause (Hash, String, Integer) —

    statement or chunk thereof



14
15
16
17
18
 
# File 'lib/card/query/card_query/interpretation.rb', line 14

def interpret clause
  normalize_clause(clause).each do |key, val|
    interpret_item key, val
  end
end

#interpret_as_content?(key) ⇒ Boolean

Returns:

  • (Boolean) 


30
31
32
33
34
 
# File 'lib/card/query/card_query/interpretation.rb', line 30

def interpret_as_content? key
  # eg "match" is both operator and attribute;
  # interpret as attribute when "match" is key
  OPERATORS.key?(key.to_s) && !ATTRIBUTES[key]
end

#interpret_as_modifier?(key, val) ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
39
40
 
# File 'lib/card/query/card_query/interpretation.rb', line 36

def interpret_as_modifier? key, val
  # eg when "sort" is hash, it can have subqueries
  # and must be interpreted like an attribute
  MODIFIERS.key?(key) && !val.is_a?(Hash)
end

#interpret_attributes(key, val) ⇒ Object 



46
47
48
49
50
51
52
53
 
# File 'lib/card/query/card_query/interpretation.rb', line 46

def interpret_attributes key, val
  attribute = ATTRIBUTES[key]
  if (method = INTERPRET_METHOD[attribute])
    send method, key, val
  elsif attribute != :ignore
    bad_attribute! key
  end
end

#interpret_item(key, val) ⇒ Object 



20
21
22
23
24
25
26
27
28
 
# File 'lib/card/query/card_query/interpretation.rb', line 20

def interpret_item key, val
  if interpret_as_content? key
    interpret content: [key, val]
  elsif interpret_as_modifier? key, val
    interpret_modifier key, val
  else
    interpret_attributes key, val
  end
end

#interpret_modifier(key, val) ⇒ Object 



42
43
44
 
# File 'lib/card/query/card_query/interpretation.rb', line 42

def interpret_modifier key, val
  @mods[key] = val.is_a?(Array) ? val : val.to_s
end

#relate(key, val, opts = {}) ⇒ Object 



66
67
68
69
70
71
72
73
74
 
# File 'lib/card/query/card_query/interpretation.rb', line 66

def relate key, val, opts={}
  multiple = opts[:multiple].nil? ? val.is_a?(Array) : opts[:multiple]
  method = opts[:method] || :send
  if multiple
    relate_multi_value method, key, val
  else
    send method, key, val
  end
end

#relate_compound(key, val) ⇒ Object 



59
60
61
62
63
64
 
# File 'lib/card/query/card_query/interpretation.rb', line 59

def relate_compound key, val
  has_multiple_values =
    val.is_a?(Array) &&
    (val.first.is_a?(Array) || conjunction(val.first).present?)
  relate key, val, multiple: has_multiple_values
end

#relate_multi_value(method, key, val) ⇒ Object 



76
77
78
79
80
81
82
83
84
 
# File 'lib/card/query/card_query/interpretation.rb', line 76

def relate_multi_value method, key, val
  conj = conjunction(val.first) ? conjunction(val.shift) : :and
  if conj == current_conjunction
    # same conjunction as container, no need for subcondition
    val.each { |v| send method, key, v }
  else
    send conj, (val.map { |v| { key => v } })
  end
end