Class: ActiveDynamo::Query::QueryGenerator

Inherits:
Object
  • Object
show all
Defined in:
lib/active_dynamo/query/query_generator.rb

Defined Under Namespace

Classes: Lexer

Instance Method Summary collapse

Constructor Details

#initialize(initiator) ⇒ QueryGenerator

Returns a new instance of QueryGenerator.



4
5
6
 
# File 'lib/active_dynamo/query/query_generator.rb', line 4

def initialize(initiator)
  @initiator = initiator
end

Instance Method Details

#call(args) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/active_dynamo/query/query_generator.rb', line 8

def call(args)
  augmented_args = if args.is_a? String
                     tokenize_string_query(args).map(&:symbolize_keys)
                    else
                      args.reduce([]) do |arr, (k, v)|
                        arr << { key: k, value: v, operator: '=' }
                      end
                    end

  key_condition_expression_args = []
  filter_expression_args        = []
  expression_attribute_names    = {}
  expression_attribute_values   = {}

  augmented_args.each_with_index do |arg, index|
    key      = arg[:key].to_sym
    operator = arg[:operator] || '='

    key_alias   = "#key_#{key}_#{index}"
    expression_attribute_names.update(key_alias => key)

    key_type_parser = method(@initiator.attr_types.fetch(key).to_s)

    unless operator == 'BETWEEN'
      value = key_type_parser.call(arg[:value])
      value_alias = ":key_#{key}_#{index}_value"

      sub_expression = [key_alias, value_alias].join(" #{operator} ")
      expression_attribute_values.update(value_alias => value)
    else
      value1 = key_type_parser.call(arg[:value1])
      value2 = key_type_parser.call(arg[:value2])

      value1_alias = ":key_#{key}_#{index}_value_1"
      value2_alias = ":key_#{key}_#{index}_value_2"

      sub_expression = [key_alias, [value1_alias, value2_alias].join(' AND ')].join(" #{operator} ")

      expression_attribute_values.update(value1_alias => value1)
      expression_attribute_values.update(value2_alias => value2)
    end

    if key == @initiator.partition_key || key == @initiator.sort_key
      key_condition_expression_args.push(sub_expression)
    else
      filter_expression_args.push(sub_expression)
    end
  end

  query = {
    table_name: @initiator.table_name,
    key_condition_expression: key_condition_expression_args.join(' and '),
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values
  }

  unless filter_expression_args.empty?
    query[:filter_expression] = filter_expression_args.join(' and ')
  end

  query
end

#tokenize_string_query(query) ⇒ Object 



71
72
73
 
# File 'lib/active_dynamo/query/query_generator.rb', line 71

def tokenize_string_query(query)
  Lexer.new(query).call()
end