Support Map attribute and List element referencing in where condition

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamoid (3.8.0)
+    dynamoid (3.9.0)
       activemodel (>= 4)
       aws-sdk-dynamodb (~> 1.0)
       concurrent-ruby (>= 1.0)

lib/dynamoid/adapter_plugin/aws_sdk_v3/create_table.rb

@@ -168,6 +168,7 @@ def attribute_definition_element(name, dynamoid_type)
         # Converts from symbol to the API string for the given data type
         # E.g. :number -> 'N'
         def api_type(type)
+          # TODO: seems we need more types to support
           case type
           when :string then STRING_TYPE
           when :number then NUM_TYPE

lib/dynamoid/adapter_plugin/aws_sdk_v3/filter_expression_convertor.rb

@@ -20,9 +20,9 @@ def initialize(conditions, name_placeholders, value_placeholders, name_placehold
         private
 
         def build
-          clauses = @conditions.map do |name, attribute_conditions|
+          clauses = @conditions.map do |path, attribute_conditions|
             attribute_conditions.map do |operator, value|
-              name_or_placeholder = name_or_placeholder_for(name)
+              name_or_placeholder = name_or_placeholder_for(path)
 
               case operator
               when :eq
@@ -59,12 +59,21 @@ def build
           @expression = clauses.join(' AND ')
         end
 
-        def name_or_placeholder_for(name)
-          return name unless name.upcase.in?(Dynamoid::AdapterPlugin::AwsSdkV3::RESERVED_WORDS)
+        # Replace reserved words with placeholders
+        def name_or_placeholder_for(path) # TODO: support List elements
+          sections = path.to_s.split('.')
 
-          placeholder = @name_placeholder_sequence.call
-          @name_placeholders[placeholder] = name
-          placeholder
+          sanitized = sections.map do |name|
+            unless name.upcase.to_sym.in?(Dynamoid::AdapterPlugin::AwsSdkV3::RESERVED_WORDS)
+              next name
+            end
+
+            placeholder = @name_placeholder_sequence.call
+            @name_placeholders[placeholder] = name
+            placeholder
+          end
+
+          sanitized.join('.')
         end
 
         def value_placeholder_for(value)

lib/dynamoid/criteria/chain.rb

@@ -585,14 +585,37 @@ def count_via_scan
       end
 
       def field_condition(key, value_before_type_casting)
-        name, operator = key.to_s.split('.')
-        value = type_cast_condition_parameter(name, value_before_type_casting)
-        operator ||= 'eq'
+        sections = key.to_s.split('.')
+
+        if sections.size == 1
+          name = sections[0]
+          path = name
+          operator = nil
+        elsif sections.last.in? ALLOWED_FIELD_OPERATORS
+          name = sections[0]
+          path = sections[0...-1].join('.')
+          operator = sections[-1]
+        else
+          name = sections[0]
+          path = sections.join('.')
+          operator = nil
+        end
 
-        unless operator.in? ALLOWED_FIELD_OPERATORS
-          raise Dynamoid::Errors::Error, "Unsupported operator #{operator} in #{key}"
+        type = source.attributes[name.to_sym][:type]
+        if type != :map && name != path
+          raise Dynamoid::Errors::Error,
+            "Dereference operator '.' in '#{key}' document path is not allowed for not :map field '#{name}'"
         end
 
+        # we don't know types of nested attributes
+        value = if name == path
+                  type_cast_condition_parameter(name, value_before_type_casting)
+                else
+                  value_before_type_casting
+                end
+
+        operator ||= 'eq'
+
         condition = \
           case operator
             # NULL/NOT_NULL operators don't have parameters
@@ -606,7 +629,7 @@ def field_condition(key, value_before_type_casting)
             [operator.to_sym, value]
           end
 
-        [name.to_sym, condition]
+        [path, condition]
       end
 
       def query_key_conditions
@@ -725,10 +748,11 @@ def scan_conditions
         end
 
         {}.tap do |opts|
-          @where_conditions.keys.map(&:to_sym).each do |key|
-            name, condition = field_condition(key, @where_conditions[key])
-            opts[name] ||= []
-            opts[name] << condition
+          @where_conditions.keys.map(&:to_sym).each do |key| # TODO: remove map to_sym
+            selector, condition = field_condition(key, @where_conditions[key])
+
+            opts[selector] ||= []
+            opts[selector] << condition
           end
         end
       end

lib/dynamoid/criteria/where_conditions.rb

@@ -22,7 +22,10 @@ def empty?
 
       def [](key)
         hash = @conditions.find { |h| h.key?(key) }
-        hash[key] if hash
+
+        return nil unless hash
+
+        hash[key]
       end
     end
   end