dynamoid 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cb9dd0de78473763541261beed167d81d2431b1
-  data.tar.gz: 057eea674112a29e69a55794a2815f2af8b14a7d
+  metadata.gz: ec92a10397fa1be691eaebe98659952c7909ab97
+  data.tar.gz: 766016509f22d0ce3f4fe93ca68342ed6038d0b9
 SHA512:
-  metadata.gz: 2b231fdf9a13c129634234b3e01b587bbe52594f4063f28e9b682f55c2941db8c74ffc0d1da72c79911eff228443032c062c8f4430960872f969bdcd5583e2fe
-  data.tar.gz: 692db4e23c132dd5fb4266349c552f0e2561396f1443306380c1a3ae6d775b6a3a289720f3a26619f54332c08a0b0af07c6b9f977a289effb90d01678212fd9b
+  metadata.gz: 6b0de822f2cda614a74a933c714072b97525a7b1a03444f2b12034327a8769d61e13220eb9d0b0f7ec15b2fbc2bf244574efe45a0660fac26cc118bb84fe848e
+  data.tar.gz: d6f3287d3741c21167b521d35771a4d794a9dff90047f9b46ebaa09373c8776389d4afa161c1430559b6fda4e0b9728f22a0a0007dbcdce507d8eedccc31018c

data/CHANGELOG.md

@@ -6,6 +6,40 @@
 
 ## Fixes
 
+---
+
+
+
+# 3.1.0
+
+## Improvements
+* Feature: [#302](https://github.com/Dynamoid/dynamoid/pull/302) Add methods similar to `ActiveRecord::AttributeMethods::BeforeTypeCast`:
+  * method `attributes_before_type_cast`
+  * method `read_attribte_before_type_cast`
+  * methods `<name>_before_type_cast`
+* Feature: [#303](https://github.com/Dynamoid/dynamoid/pull/303) Add `#update_attributes!` method
+* Feature: [#304](https://github.com/Dynamoid/dynamoid/pull/304) Add `inheritance_field` option for `Document.table` method to specify column name for supporting STI and storing class name
+* Feature: [#305](https://github.com/Dynamoid/dynamoid/pull/305) Add increment/decrement methods:
+  * `#increment`
+  * `#increment!`
+  * `#decrement`
+  * `#decrement!`
+  * `.inc`
+* Feature: [#307](https://github.com/Dynamoid/dynamoid/pull/307) Allow to declare type of elements in `array`/`set` fields with `of` option. Only scalar types are supported as well as custom types
+* Feature: [#312](https://github.com/Dynamoid/dynamoid/pull/312) Add Ability to specify network timeout connection settings (@lulu-ulul)
+* Feature: [#313](https://github.com/Dynamoid/dynamoid/pull/313) Add support for backoff in scan and query (@bonty)
+* Improvement: [#314](https://github.com/Dynamoid/dynamoid/pull/314) Re-implement `count` for `where`-chain query efficiently. So now  `where(...).count` doesn't load all the documents, just statistics
+
+## Fixes
+* Bug: [#298](https://github.com/Dynamoid/dynamoid/pull/298) Fix `raw` field storing when value is a Hash with non-string keys
+* Bug: [#299](https://github.com/Dynamoid/dynamoid/pull/299) Fix `raw` fields - skip empty strings and sets
+* Bug: [#309](https://github.com/Dynamoid/dynamoid/pull/309) Fix loading of a document that contains not declared in model class fields
+* Bug: [#310](https://github.com/Dynamoid/dynamoid/pull/310) Fix `Adapter#list_tables` method to return names of all tables, not just first page (@knovoselic)
+* Bug: [#311](https://github.com/Dynamoid/dynamoid/pull/311) Fix `consistent_read` option of `.find` (@kokuyouwind)
+* Bug: [#319](https://github.com/Dynamoid/dynamoid/pull/319) Repair consistent reading for `find_all`
+* Bug: [#317](https://github.com/Dynamoid/dynamoid/pull/317) Fix `create_tables` rake task
+
+
 
 # 3.0.0
 

data/README.md

@@ -1,6 +1,6 @@
 # Dynamoid
 
-You are viewing the README for version 2 of Dynamoid.  See the [CHANGELOG](https://github.com/Dynamoid/Dynamoid/blob/master/CHANGELOG.md#200) for details on breaking changes since 1.3.x.
+You are viewing the README for version 3 of Dynamoid.  See the [CHANGELOG](https://github.com/Dynamoid/Dynamoid/blob/master/CHANGELOG.md#200) for details on breaking changes since 1.3.x.
 
 For version 1.3.x use the [1-3-stable branch](https://github.com/Dynamoid/Dynamoid/blob/1-3-stable/README.md).
 
@@ -20,9 +20,9 @@ But if you want a fast, scalable, simple, easy-to-use database (and a Gem that s
 | gem name                |  dynamoid         |
 | license                 |  MIT              |
 | download rank           |  [![Total Downloads](https://img.shields.io/gem/rt/Dynamoid.svg)](https://rubygems.org/gems/dynamoid) |
-| version                 |  [![Gem Version](https://badge.fury.io/rb/dynamoid.svg)](https://rubygems.org/gems/dynamoid) |
-| dependencies            |  [![Dependency Status](https://gemnasium.com/badges/github.com/Dynamoid/Dynamoid.svg)](https://gemnasium.com/github.com/Dynamoid/Dynamoid) [![Depfu](https://badges.depfu.com/badges/6661c063c8e77a5008344fc7283a50aa/status.svg)](https://depfu.com)|
-| code quality            |  [![Code Climate](https://codeclimate.com/github/Dynamoid/Dynamoid.svg)](https://codeclimate.com/github/Dynamoid/Dynamoid) |
+| version                 |  [![Gem Version](https://badge.fury.io/rb/dynamoid.svg)](https://badge.fury.io/rb/dynamoid) |
+| dependencies            |  [![Depfu](https://badges.depfu.com/badges/6661c063c8e77a5008344fc7283a50aa/status.svg)](https://depfu.com) |
+| code quality            |  [![Code Climate](https://codeclimate.com/github/Dynamoid/dynamoid.svg)](https://codeclimate.com/github/Dynamoid/dynamoid) |
 | continuous integration  |  [![Build Status](https://travis-ci.org/Dynamoid/dynamoid.svg?branch=master)](https://travis-ci.org/Dynamoid/dynamoid) |
 | test coverage           |  [![Coverage Status](https://coveralls.io/repos/github/Dynamoid/Dynamoid/badge.svg?branch=master)](https://coveralls.io/github/Dynamoid/Dynamoid?branch=master) |
 | triage helpers          |  [![CodeTriage Helpers](https://www.codetriage.com/dynamoid/dynamoid/badges/users.svg)](https://www.codetriage.com/dynamoid/dynamoid) |
@@ -191,8 +191,16 @@ You have two options if you need to use a `datetime` field as a range key:
 
 #### Note on set type
 
-There is `of` option to declare the type of set elements. You can use
-`:integer` value only
+`Dynamoid`'s type `set` is stored as DynamoDB's Set attribute type.
+DynamoDB supports only Set of strings, numbers and binary.
+Moreover Set *must* contain elements of the same type only.
+
+In order to use some other `Dynamoid`'s types you can specify `of` option
+to declare the type of set elements.
+
+As a result of that DynamoDB limitation, in Dynamoid only the following
+scalar types are supported (note: does not support `boolean`):
+`integer`, `number`, `date`, `datetime`, `serializable` and custom types.
 
 ```ruby
 class Document
@@ -202,6 +210,38 @@ class Document
 end
 ```
 
+It's possible to specify field options like `store_as_string` for `datetime` field
+or `serializer` for `serializable` field for `set` elements type:
+
+```ruby
+class Document
+  include DynamoId::Document
+
+  field :values, :set, of: { serialized: { serializer: JSON } }
+  field :dates, :set, of: { date: { store_as_string: true } }
+  field :datetimes, :set, of: { datetime: { store_as_string: false } }
+end
+```
+
+DynamoDB doesn't allow empty strings in fields configured as `set`.
+Abiding by this restriction, when `Dynamoid` saves a document it removes all empty strings in set fields.
+
+#### Note on array type
+
+`Dynamoid`'s type `array` is stored as DynamoDB's List attribute type.
+It can contain elements of different types (in contrast to Set attribute type).
+
+If you need to store in array field elements of `datetime`, `date`,
+`serializable` or some custom type, which DynamoDB doesn't support
+natively, you should specify element type with `of` option:
+
+```ruby
+class Document
+  include DynamoId::Document
+
+  field :dates, :array, of: :date
+end
+```
 
 #### Magic Columns
 
@@ -399,6 +439,57 @@ animal.class
 #=>  Cat
 ```
 
+If you already have DynamoDB tables and `type` field already exists and has its own semantic it leads to conflict.
+It's possible to tell Dynamoid to use another field (even not existing)
+instead of `type` one with `inheritance_field` table option:
+
+```ruby
+class Car
+  include Dynamoid::Document
+  table inheritance_field: :my_new_type
+
+  field :my_new_type
+end
+
+c = Car.create
+c.my_new_type
+#=> "Car"
+```
+
+### Type casting
+
+Dynamid supports type casting and tryes to do it in the most convinient way.
+Values for all fields (except custom type) are coerced to declared field types.
+
+Some obvious rules are used, e.g.:
+
+for boolean field:
+```ruby
+document.boolean_field = 'off'
+# => false
+document.boolean_field = 'false'
+# => false
+document.boolean_field = 'some string'
+# => true
+```
+
+or for integer field:
+```ruby
+document.integer_field = 42.3
+# => 42
+document.integer_field = '42.3'
+# => 42
+document.integer_field = true
+# => 1
+```
+
+If time zone isn't specified for `datetime` value - application time zone is used.
+
+To access field value before type casting following method could be
+used: `attributes_before_type_cast` and `read_attribute_before_type_cast`.
+
+There is `<name>_before_type_cast` method for every field in a model as well.
+
 ## Usage
 
 ### Object Creation
@@ -724,7 +815,7 @@ Calls to `update` and `update!` also increment the `lock_version`, however they
 ### Backoff strategies
 
 
-You can use several methods that run efficiently in batch mode like `.find_all` and `.import`.
+You can use several methods that run efficiently in batch mode like `.find_all` and `.import`. It affects `Query` and `Scan` operations as well.
 
 The backoff strategy will be used when, for any reason, some items could not be processed as part of a batch mode command.
 Operations will be re-run to process these items.
@@ -786,7 +877,7 @@ module DynamoidReset
     end
     Dynamoid.adapter.tables.clear
     # Recreate all tables to avoid unexpected errors
-    Dynamoid.included_models.each(&:create_table)
+    Dynamoid.included_models.each { |m| m.create_table(sync: true) }
   end
 end
 

data/dynamoid.gemspec

@@ -43,6 +43,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'activemodel', '>=4'
   spec.add_runtime_dependency 'aws-sdk-dynamodb', '~> 1'
   spec.add_runtime_dependency 'concurrent-ruby', '>= 1.0'
+  spec.add_runtime_dependency 'null-logger'
 
   spec.add_development_dependency 'appraisal'
   spec.add_development_dependency 'bundler'

data/lib/dynamoid/adapter_plugin/aws_sdk_v3.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'query'
+require_relative 'scan'
+
 module Dynamoid
   module AdapterPlugin
     # The AwsSdkV3 adapter provides support for the aws-sdk version 2 for ruby.
@@ -49,6 +52,8 @@ module Dynamoid
       }
       BATCH_WRITE_ITEM_REQUESTS_LIMIT = 25
 
+      CONNECTION_CONFIG_OPTIONS = %i[endpoint region http_continue_timeout http_idle_timeout http_open_timeout http_read_timeout].freeze
+
       attr_reader :table_cache
 
       # Establish the connection to DynamoDB.
@@ -62,8 +67,8 @@ module Dynamoid
       def connection_config
         @connection_hash = {}
 
-        if Dynamoid::Config.endpoint?
-          @connection_hash[:endpoint] = Dynamoid::Config.endpoint
+        (Dynamoid::Config.settings.compact.keys & CONNECTION_CONFIG_OPTIONS).each do |option|
+          @connection_hash[option] = Dynamoid::Config.send(option)
         end
         if Dynamoid::Config.access_key?
           @connection_hash[:access_key_id] = Dynamoid::Config.access_key
@@ -71,9 +76,6 @@ module Dynamoid
         if Dynamoid::Config.secret_key?
           @connection_hash[:secret_access_key] = Dynamoid::Config.secret_key
         end
-        if Dynamoid::Config.region?
-          @connection_hash[:region] = Dynamoid::Config.region
-        end
 
         # https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-core/lib/aws-sdk-core/plugins/logging.rb
         # https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-core/lib/aws-sdk-core/log/formatter.rb
@@ -177,7 +179,7 @@ module Dynamoid
       # @since 1.0.0
       #
       # @todo: Provide support for passing options to underlying batch_get_item
-      def batch_get_item(table_ids, _options = {})
+      def batch_get_item(table_ids, options = {})
         request_items = Hash.new { |h, k| h[k] = [] }
         return request_items if table_ids.all? { |_k, v| v.blank? }
 
@@ -206,7 +208,8 @@ module Dynamoid
                    end
 
             request_items[t] = {
-              keys: keys
+              keys: keys,
+              consistent_read: options[:consistent_read]
             }
 
             results = client.batch_get_item(
@@ -426,12 +429,16 @@ module Dynamoid
       #
       # @todo Provide support for various options http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#get_item-instance_method
       def get_item(table_name, key, options = {})
+        options = options.dup
         options ||= {}
+
         table = describe_table(table_name)
         range_key = options.delete(:range_key)
+        consistent_read = options.delete(:consistent_read)
 
         item = client.get_item(table_name: table_name,
-                               key: key_stanza(table, key, range_key))[:item]
+                               key: key_stanza(table, key, range_key),
+                               consistent_read: consistent_read)[:item]
         item ? result_item_to_hash(item) : nil
       end
 
@@ -445,6 +452,8 @@ module Dynamoid
       #
       # @todo Provide support for various options http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#update_item-instance_method
       def update_item(table_name, key, options = {})
+        options = options.dup
+
         range_key = options.delete(:range_key)
         conditions = options.delete(:conditions)
         table = describe_table(table_name)
@@ -467,10 +476,16 @@ module Dynamoid
       # List all tables on DynamoDB.
       #
       # @since 1.0.0
-      #
-      # @todo Provide limit support http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#update_item-instance_method
       def list_tables
-        client.list_tables[:table_names]
+        [].tap do |result|
+          start_table_name = nil
+          loop do
+            result_page = client.list_tables exclusive_start_table_name: start_table_name
+            start_table_name = result_page.last_evaluated_table_name
+            result.concat result_page.table_names
+            break unless start_table_name
+          end
+        end
       end
 
       # Persists an item on DynamoDB.
@@ -503,191 +518,66 @@ module Dynamoid
       # one range key to the hash.
       #
       # @param [String] table_name the name of the table
-      # @param [Hash] opts the options to query the table with
-      # @option opts [String] :hash_value the value of the hash key to find
-      # @option opts [Number, Number] :range_between find the range key within this range
-      # @option opts [Number] :range_greater_than find range keys greater than this
-      # @option opts [Number] :range_less_than find range keys less than this
-      # @option opts [Number] :range_gte find range keys greater than or equal to this
-      # @option opts [Number] :range_lte find range keys less than or equal to this
+      # @param [Hash] options the options to query the table with
+      # @option options [String] :hash_value the value of the hash key to find
+      # @option options [Number, Number] :range_between find the range key within this range
+      # @option options [Number] :range_greater_than find range keys greater than this
+      # @option options [Number] :range_less_than find range keys less than this
+      # @option options [Number] :range_gte find range keys greater than or equal to this
+      # @option options [Number] :range_lte find range keys less than or equal to this
       #
       # @return [Enumerable] matching items
       #
       # @since 1.0.0
       #
       # @todo Provide support for various other options http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#query-instance_method
-      def query(table_name, opts = {})
+      def query(table_name, options = {})
         table = describe_table(table_name)
-        hk    = (opts[:hash_key].present? ? opts.delete(:hash_key) : table.hash_key).to_s
-        rng   = (opts[:range_key].present? ? opts.delete(:range_key) : table.range_key).to_s
-        q     = opts.slice(
-          :consistent_read,
-          :scan_index_forward,
-          :select,
-          :index_name
-        )
 
-        opts.delete(:consistent_read)
-        opts.delete(:scan_index_forward)
-        opts.delete(:select)
-        opts.delete(:index_name)
-
-        # Deal with various limits and batching
-        record_limit = opts.delete(:record_limit)
-        scan_limit = opts.delete(:scan_limit)
-        batch_size = opts.delete(:batch_size)
-        exclusive_start_key = opts.delete(:exclusive_start_key)
-        limit = [record_limit, scan_limit, batch_size].compact.min
-
-        key_conditions = {
-          hk => {
-            comparison_operator: EQ,
-            attribute_value_list: attribute_value_list(EQ, opts.delete(:hash_value).freeze)
-          }
-        }
-
-        opts.each_pair do |k, _v|
-          next unless (op = RANGE_MAP[k])
-          key_conditions[rng] = {
-            comparison_operator: op,
-            attribute_value_list: attribute_value_list(op, opts.delete(k).freeze)
-          }
-        end
-
-        query_filter = {}
-        opts.reject { |k, _| k.in? RANGE_MAP.keys }.each do |attr, hash|
-          query_filter[attr] = {
-            comparison_operator: FIELD_MAP[hash.keys[0]],
-            attribute_value_list: attribute_value_list(FIELD_MAP[hash.keys[0]], hash.values[0].freeze)
-          }
+        Enumerator.new do |yielder|
+          Query.new(client, table, options).call.each do |page|
+            page.items.each { |row| yielder << result_item_to_hash(row) }
+          end
         end
+      end
 
-        q[:limit] = limit if limit
-        q[:exclusive_start_key] = exclusive_start_key if exclusive_start_key
-        q[:table_name]     = table_name
-        q[:key_conditions] = key_conditions
-        q[:query_filter]   = query_filter
-
-        Enumerator.new do |y|
-          record_count = 0
-          scan_count = 0
-          loop do
-            # Adjust the limit down if the remaining record and/or scan limit are
-            # lower to obey limits. We can assume the difference won't be
-            # negative due to break statements below but choose smaller limit
-            # which is why we have 2 separate if statements.
-            # NOTE: Adjusting based on record_limit can cause many HTTP requests
-            # being made. We may want to change this behavior, but it affects
-            # filtering on data with potentially large gaps.
-            # Example:
-            #    User.where('created_at.gte' => 1.day.ago).record_limit(1000)
-            #    Records 1-999 User's that fit criteria
-            #    Records 1000-2000 Users's that do not fit criteria
-            #    Record 2001 fits criteria
-            # The underlying implementation will have 1 page for records 1-999
-            # then will request with limit 1 for records 1000-2000 (making 1000
-            # requests of limit 1) until hit record 2001.
-            if q[:limit] && record_limit && record_limit - record_count < q[:limit]
-              q[:limit] = record_limit - record_count
-            end
-            if q[:limit] && scan_limit && scan_limit - scan_count < q[:limit]
-              q[:limit] = scan_limit - scan_count
-            end
-
-            results = client.query(q)
-            results.items.each { |row| y << result_item_to_hash(row) }
-
-            record_count += results.items.size
-            break if record_limit && record_count >= record_limit
-
-            scan_count += results.scanned_count
-            break if scan_limit && scan_count >= scan_limit
+      def query_count(table_name, options = {})
+        table = describe_table(table_name)
+        options[:select] = 'COUNT'
 
-            if (lk = results.last_evaluated_key)
-              q[:exclusive_start_key] = lk
-            else
-              break
-            end
-          end
-        end
+        Query.new(client, table, options).call
+          .map(&:count)
+          .reduce(:+)
       end
 
       # Scan the DynamoDB table. This is usually a very slow operation as it naively filters all data on
       # the DynamoDB servers.
       #
       # @param [String] table_name the name of the table
-      # @param [Hash] scan_hash a hash of attributes: matching records will be returned by the scan
+      # @param [Hash] conditions a hash of attributes: matching records will be returned by the scan
       #
       # @return [Enumerable] matching items
       #
       # @since 1.0.0
       #
       # @todo: Provide support for various options http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#scan-instance_method
-      def scan(table_name, scan_hash = {}, select_opts = {})
-        request = { table_name: table_name }
-        request[:consistent_read] = true if select_opts.delete(:consistent_read)
-
-        # Deal with various limits and batching
-        record_limit = select_opts.delete(:record_limit)
-        scan_limit = select_opts.delete(:scan_limit)
-        batch_size = select_opts.delete(:batch_size)
-        exclusive_start_key = select_opts.delete(:exclusive_start_key)
-        request_limit = [record_limit, scan_limit, batch_size].compact.min
-        request[:limit] = request_limit if request_limit
-        request[:exclusive_start_key] = exclusive_start_key if exclusive_start_key
-
-        if scan_hash.present?
-          request[:scan_filter] = scan_hash.reduce({}) do |memo, (attr, cond)|
-            memo.merge(attr.to_s => {
-                         comparison_operator: FIELD_MAP[cond.keys[0]],
-                         attribute_value_list: attribute_value_list(FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
-                       })
+      def scan(table_name, conditions = {}, options = {})
+        table = describe_table(table_name)
+
+        Enumerator.new do |yielder|
+          Scan.new(client, table, conditions, options).call.each do |page|
+            page.items.each { |row| yielder << result_item_to_hash(row) }
           end
         end
+      end
 
-        Enumerator.new do |y|
-          record_count = 0
-          scan_count = 0
-          loop do
-            # Adjust the limit down if the remaining record and/or scan limit are
-            # lower to obey limits. We can assume the difference won't be
-            # negative due to break statements below but choose smaller limit
-            # which is why we have 2 separate if statements.
-            # NOTE: Adjusting based on record_limit can cause many HTTP requests
-            # being made. We may want to change this behavior, but it affects
-            # filtering on data with potentially large gaps.
-            # Example:
-            #    User.where('created_at.gte' => 1.day.ago).record_limit(1000)
-            #    Records 1-999 User's that fit criteria
-            #    Records 1000-2000 Users's that do not fit criteria
-            #    Record 2001 fits criteria
-            # The underlying implementation will have 1 page for records 1-999
-            # then will request with limit 1 for records 1000-2000 (making 1000
-            # requests of limit 1) until hit record 2001.
-            if request[:limit] && record_limit && record_limit - record_count < request[:limit]
-              request[:limit] = record_limit - record_count
-            end
-            if request[:limit] && scan_limit && scan_limit - scan_count < request[:limit]
-              request[:limit] = scan_limit - scan_count
-            end
-
-            results = client.scan(request)
-            results.items.each { |row| y << result_item_to_hash(row) }
-
-            record_count += results.items.size
-            break if record_limit && record_count >= record_limit
-
-            scan_count += results.scanned_count
-            break if scan_limit && scan_count >= scan_limit
+      def scan_count(table_name, conditions = {}, options = {})
+        table = describe_table(table_name)
+        options[:select] = 'COUNT'
 
-            # Keep pulling if we haven't finished paging in all data
-            if (lk = results[:last_evaluated_key])
-              request[:exclusive_start_key] = lk
-            else
-              break
-            end
-          end
-        end
+        Scan.new(client, table, conditions, options).call
+          .map(&:count)
+          .reduce(:+)
       end
 
       #
@@ -968,6 +858,10 @@ module Dynamoid
       # @params [String] operator: value of RANGE_MAP or FIELD_MAP hash, e.g. "EQ", "LT" etc
       # @params [Object] value: scalar value or array/set
       def attribute_value_list(operator, value)
+        self.class.attribute_value_list(operator, value)
+      end
+
+      def self.attribute_value_list(operator, value)
         # For BETWEEN and IN operators we should keep value as is (it should be already an array)
         # For all the other operators we wrap the value with array
         if %w[BETWEEN IN].include?(operator)
@@ -1018,6 +912,10 @@ module Dynamoid
         def item_count
           schema[:item_count]
         end
+
+        def name
+          schema[:table_name]
+        end
       end
 
       #
@@ -1043,7 +941,7 @@ module Dynamoid
         #               add. values must be a Set, Array, or Numeric
         #
         def add(values)
-          @additions.merge!(values)
+          @additions.merge!(sanitize_attributes(values))
         end
 
         #
@@ -1053,14 +951,14 @@ module Dynamoid
         #               to remove
         #
         def delete(values)
-          @deletions.merge!(values)
+          @deletions.merge!(sanitize_attributes(values))
         end
 
         #
         # Replaces the values of one or more attributes
         #
         def set(values)
-          @updates.merge!(values)
+          @updates.merge!(sanitize_attributes(values))
         end
 
         #
@@ -1091,6 +989,14 @@ module Dynamoid
           ret
         end
 
+        private
+
+        def sanitize_attributes(attributes)
+          attributes.transform_values do |v|
+            v.is_a?(Hash) ? v.stringify_keys : v
+          end
+        end
+
         ADD    = 'ADD'
         DELETE = 'DELETE'
         PUT    = 'PUT'
@@ -1099,6 +1005,8 @@ module Dynamoid
       def sanitize_item(attributes)
         attributes.reject do |_k, v|
           v.nil? || ((v.is_a?(Set) || v.is_a?(String)) && v.empty?)
+        end.transform_values do |v|
+          v.is_a?(Hash) ? v.stringify_keys : v
         end
       end
     end