dynamoid 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2fdea2ccbdac2b53135bbd2bed6dedc5b501551
-  data.tar.gz: 31174f8f8b12baf0b7f40ab573dc7eed0f05d057
+  metadata.gz: c5d8f6269824b26eaae72aa50582f732cf12d32a
+  data.tar.gz: b2d435682f178120634e816294f9903c205c2a41
 SHA512:
-  metadata.gz: 1de8d6315cbef5ce26f26a850cb95669e93a4d4b3e4badc2ea5305e224dcdf4ffcaf66cf2d0cd5baca4e7644b57765bb92cf31f841ed1fed1cc1d6a789433d7a
-  data.tar.gz: 33f582e685f63655d6b57c9cb5484eacf71d04634e34829370aff67fc173511c4f26acba4affb151f0774998477577ed8dd0a66f8af8615e41d12797163212ac
+  metadata.gz: 8cda5990c7916d53b5a34fb1c6b66cba13191f51627bd100fb276354e391c73168a7c06b01c27da946b3b164e12b15727ef1f41aa1ebd60b4e17128ce6ab2e4c
+  data.tar.gz: 821224d319424d6bb75e76b8ba17ed9832a73d9efab46622b6666ab0239c46515b883a37797e3fbec527fec98b0cd09929e5804e81d926d633d4c41bacc4c9ba

data/CHANGELOG.md

@@ -12,6 +12,38 @@
 
 * N/A
 
+# 2.1.0
+
+## Breaking
+
+* N/A
+
+## Improvements
+
+* Feature: [#221](https://github.com/Dynamoid/Dynamoid/pull/221) Add field declaration option `of` to specify the type of `set` elements (@pratik60)
+* Feature: [#223](https://github.com/Dynamoid/Dynamoid/pull/223) Add field declaration option `store_as_string` to store `datetime` as ISO-8601 formatted strings (@william101)
+* Feature: [#228](https://github.com/Dynamoid/Dynamoid/pull/228) Add field declaration option `store_as_string` to store `date` as ISO-8601 formatted strings (@andrykonchin)
+* Feature: [#229](https://github.com/Dynamoid/Dynamoid/pull/229) Support hash argument for `start` chain method (@mnussbaumer)
+* Feature: [#236](https://github.com/Dynamoid/Dynamoid/pull/236) Change log level from `info` to `debug` for benchmark logging (@kicktheken)
+* Feature: [#239](https://github.com/Dynamoid/Dynamoid/pull/239) Add methods for low-level updating: `.update`, `.update_fields` and `.upsert` (@andrykonchin)
+* Feature: [#243](https://github.com/Dynamoid/Dynamoid/pull/243) Support `ne` condition operator (@andrykonchin)
+* Feature: [#246](https://github.com/Dynamoid/Dynamoid/pull/246) Added support of backoff in batch operations (@andrykonchin)
+    * added global config options `backoff` and `backoff_strategies` to configure backoff
+    * added `constant` and `exponential` built-in backoff strategies
+    * `.find_all` and `.import` support new backoff options
+
+## Fixes
+
+* Bug: [#216](https://github.com/Dynamoid/Dynamoid/pull/216) Fix global index detection in queries with conditions other than equal (@andrykonchin)
+* Bug: [#224](https://github.com/Dynamoid/Dynamoid/pull/224) Fix how `contains` operator works with `set` and `array` field types (@andrykonchin)
+* Bug: [#225](https://github.com/Dynamoid/Dynamoid/pull/225) Fix equal conditions for `array` fields (@andrykonchin)
+* Bug: [#229](https://github.com/Dynamoid/Dynamoid/pull/229) Repair support `start` chain method on Scan operation (@mnussbaumer)
+* Bug: [#238](https://github.com/Dynamoid/Dynamoid/pull/238) Fix default value of `models_dir` config option (@baloran)
+* Bug: [#244](https://github.com/Dynamoid/Dynamoid/pull/244) Allow to pass empty strings and sets to `.import` (@andrykonchin)
+* Bug: [#246](https://github.com/Dynamoid/Dynamoid/pull/246) Batch operations (`batch_write_item` and `batch_read_item`) handle unprocessed items themselves (@andrykonchin)
+* Bug: [#250](https://github.com/Dynamoid/Dynamoid/pull/250) Update outdated warning message about inefficient query and missing indices (@andrykonchin)
+* Bug: [252](https://github.com/Dynamoid/Dynamoid/pull/252) Don't loose nanoseconds when store DateTime as float number
+
 # 2.0.0
 
 ## Breaking

data/LICENSE.txt

@@ -1,20 +1,22 @@
+MIT License
+
 Copyright (c) 2012 Josh Symonds
+Copyright (c) 2013 - 2018 Dynamoid, https://github.com/Dynamoid
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,7 +1,7 @@
 # Dynamoid
 
-You are viewing the README for the unreleased version 2 of 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.
+
 For version 1.3.x use the [1-3-stable branch](https://github.com/Dynamoid/Dynamoid/blob/1-3-stable/README.md).
 
 Dynamoid is an ORM for Amazon's DynamoDB for Ruby applications. It
@@ -19,13 +19,13 @@ 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.png)](https://rubygems.org/gems/dynamoid) |
-| version                 |  [![Gem Version](https://badge.fury.io/rb/dynamoid.png)](http://badge.fury.io/rb/dynamoid) |
-| dependencies            |  [![Dependency Status](https://gemnasium.com/badges/github.com/Dynamoid/Dynamoid.png)](https://gemnasium.com/github.com/Dynamoid/Dynamoid) |
-| code quality            |  [![Code Climate](https://codeclimate.com/github/Dynamoid/Dynamoid.png)](https://codeclimate.com/github/Dynamoid/Dynamoid) |
-| continuous integration  |  [![Build Status](https://secure.travis-ci.org/Dynamoid/Dynamoid.png?branch=master)](https://travis-ci.org/Dynamoid/Dynamoid) |
-| test coverage           |  [![Coverage Status](https://coveralls.io/repos/github/Dynamoid/Dynamoid/badge.png?branch=master)](https://coveralls.io/github/Dynamoid/Dynamoid?branch=master) |
-| triage helpers          |  [![Coverage Status](https://www.codetriage.com/dynamoid/dynamoid/badges/users.png)](https://www.codetriage.com/dynamoid/dynamoid) |
+| 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) |
+| 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) |
 | homepage                |  [https://github.com/Dynamoid/Dynamoid](https://github.com/Dynamoid/Dynamoid) |
 | documentation           |  [http://rdoc.info/github/Dynamoid/Dynamoid/frames](http://rdoc.info/github/Dynamoid/Dynamoid/frames) |
 
@@ -34,11 +34,11 @@ But if you want a fast, scalable, simple, easy-to-use database (and a Gem that s
 Installing Dynamoid is pretty simple. First include the Gem in your Gemfile:
 
 ```ruby
-gem 'dynamoid', '~> 1'
+gem 'dynamoid', '~> 2'
 ```
 ## Prerequisities
 
-Dynamoid depends on the aws-sdk, and this is tested on the current version of aws-sdk (~> 2), rails (~> 4).
+Dynamoid depends on the aws-sdk, and this is tested on the current version of aws-sdk (~> 2), rails (>= 4).
 Hence the configuration as needed for aws to work will be dealt with by aws setup.
 
 Here are the steps to setup aws-sdk.
@@ -49,7 +49,18 @@ gem 'aws-sdk', '~>2'
 
 (or) include the aws-sdk in your Gemfile.
 
-**NOTE:** Dynamoid-1.0 doesn't support aws-sdk Version 1 (Use Dynamoid Major Version 0 for aws-sdk 1)
+### AWS SDK Version Compatibility
+
+Make sure you are using the version for the right AWS SDK.
+
+| Dynamoid version | AWS SDK Version |
+| ---------------- | --------------- |
+| 0.x              | 1.x             |
+| 1.x              | 2.x             |
+| 2.x              | 2.x             |
+| 3.x (unreleased) | 3.x             |
+
+### AWS Configuration
 
 Configure AWS access:
 [Reference](https://github.com/aws/aws-sdk-ruby)
@@ -70,6 +81,7 @@ Create config/initializers/aws.rb as follows:
 Alternatively, if you don't want Aws connection settings to be overwritten for you entire project, you can specify connection settings for Dynamoid only, by setting those in the `Dynamoid.configure` clause:
 
 ```ruby
+  require 'dynamoid'
   Dynamoid.configure do |config|
     config.access_key = 'REPLACE_WITH_ACCESS_KEY_ID'
     config.secret_key = 'REPLACE_WITH_SECRET_ACCESS_KEY'
@@ -83,6 +95,7 @@ For a full list of the DDB regions, you can go
 Then you need to initialize Dynamoid config to get it going. Put code similar to this somewhere (a Rails initializer would be a great place for this if you're using Rails):
 
 ```ruby
+  require 'dynamoid'
   Dynamoid.configure do |config|
     config.namespace = "dynamoid_app_development" # To namespace tables created by Dynamoid from other tables you might have. Set to nil to avoid namespacing.
     config.endpoint = 'http://localhost:3000' # [Optional]. If provided, it communicates with the DB listening at the endpoint. This is useful for testing with [Amazon Local DB] (http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html).
@@ -90,7 +103,7 @@ Then you need to initialize Dynamoid config to get it going. Put code similar to
 
 ```
 
-### Compatibility Matrix
+### Ruby  & Rails Compatibility Matrix
 
 | Ruby / Active Record  | 4.0.x | 4.1.x | 4.2.x | 5.0.x |
 |:---------------------:|:-----:|:-----:|:-----:|:-----:|
@@ -153,6 +166,44 @@ class Document
 end
 ```
 
+#### Note on date type
+
+By default date fields are persisted as days count since 1 January 1970 like UNIX time. If you prefer dates to be stored as ISO-8601 formatted strings instead then set `store_as_string` to `true`
+
+```ruby
+class Document
+  include DynamoId::Document
+
+  field :sent_at, :datetime, store_as_string: true
+end
+```
+
+#### Note on datetime type
+
+By default datetime fields are persisted as UNIX timestamps with milisecond precission in DynamoDB. If you prefer datetimes to be stored as ISO-8601 formatted strings instead then set `store_as_string` to `true`
+
+```ruby
+class Document
+  include DynamoId::Document
+
+  field :sent_at, :datetime, store_as_string: true
+end
+```
+
+### Note on set type
+
+There is `of` option to declare the type of set elements. You can use
+`:integer` value only
+
+```ruby
+class Document
+  include DynamoId::Document
+
+  field :tags, :set, of: :integer
+end
+```
+
+
 #### Magic Columns
 
 You get magic columns of id (string), created_at (datetime), and updated_at (datetime) for free.
@@ -403,11 +454,13 @@ There are three types of limits that you can query with:
 Using these in various combinations results in the underlying requests to be made in the smallest size possible and
 the query returns once `record_limit` or `scan_limit` is satisfied. It will attempt to batch whenever possible.
 
-You can thus limit the number of evaluated records, or select a record from which to start, to support pagination:
+You can thus limit the number of evaluated records, or select a record from which to start in order to support pagination.
 
 ```ruby
 Address.record_limit(5).start(address) # Only 5 addresses starting at `address`
 ```
+Where `address` is an instance of the model or a hash `{the_model_hash_key: 'value', the_model_range_key: 'value'}`:
+Keep in mind that if you are passing a hash to `.start()` you need to explicitly define all required keys in it including range keys, depending on table or secondary indexes signatures, otherwise you'll get an `Aws::DynamoDB::Errors::ValidationException` either for `Exclusive Start Key must have same size as table's key schema` or `The provided starting key is invalid`
 
 If you are potentially running over a large data set and this is especially true when using certain filters, you may
 want to consider limiting the number of scanned records (the number of records DynamoDB infrastructure looks through
@@ -472,6 +525,41 @@ User.where("created_at.lt" => DateTime.now - 1.day).all
 
 It also supports .gte and .lte. Turning those into symbols and allowing a Rails SQL-style string syntax is in the works. You can only have one range argument per query, because of DynamoDB's inherent limitations, so use it sensibly!
 
+
+### Updating
+
+In order to update document you can use high level methods
+`#update_attributes`, `#update_attribute` and `.update`.
+They run validation and collbacks.
+
+```ruby
+Address.find(id).update_attributes(city: 'Chicago')
+Address.find(id).update_attribute(city, 'Chicago')
+Address.update(id, city: 'Chicago')
+Address.update(id, { city: 'Chicago' }, if: { deliverable: true })
+```
+
+There are also some low level methods `#update`, `.update_fields` and
+`.upsert`. They don't run validation and callbacks (except `#update` - it
+runs `update` callbacks). All of them support conditional updates.
+`#upsert` will create new document if document with specified `id`
+doesn't exist.
+
+```ruby
+Adderess.find(id).update do |i|
+  i.set city: 'Chicago'
+  i.add latitude: 100
+  i.delete set_of_numbers: 10
+end
+Adderess.find(id).update(if: { deliverable: true }) do |i|
+  i.set city: 'Chicago'
+end
+Address.update_fields(id, city: 'Chicago')
+Address.update_fields(id, { city: 'Chicago' }, if: { deliverable: true })
+Address.upsert(id, city: 'Chicago')
+Address.upsert(id, { city: 'Chicago' }, if: { deliverable: true })
+```
+
 ### Deleting
 
 In order to delete some items `delete_all` method should be used.
@@ -587,9 +675,13 @@ Listed below are all configuration options.
 * `sync_retry_max_times` - when Dynamoid creates or deletes table synchronously it checks for completion specified times. Default is 60 (times). It's a bit over 2 minutes by default
 * `sync_retry_wait_seconds` - time to wait between retries. Default is 2 (seconds)
 * `convert_big_decimal` - if `true` then Dynamoid converts numbers stored in `Hash` in `raw` field to float. Default is `false`
-* `models_dir` - `dynamoid:create_tables` rake task loads DynamoDb models from this directory. Default is `app/models`. In Rails application you should set `./app/models` value
+* `models_dir` - `dynamoid:create_tables` rake task loads DynamoDb models from this directory. Default is `./app/models`.
 * `application_timezone` - Dynamoid converts all `datetime` fields to specified time zone when loads data from the storage.
   Acceptable values - `utc`, `local` (to use system time zone) and time zone name e.g. `Eastern Time (US & Canada)`. Default is `local`
+* `store_datetime_as_string` - if `true` then Dynamoid stores :datetime fields in ISO 8601 string format. Default is `false`
+* `store_date_as_string` - if `true` then Dynamoid stores :date fields in ISO 8601 string format. Default is `false`
+* `backoff` - is a hash: key is a backoff strategy (symbol), value is parameters for the strategy. Is used in batch operations. Default id `nil`
+* `backoff_strategies`: is a hash and contains all available strategies. Default is { constant: ..., exponential: ...}
 
 
 ## Concurrency
@@ -610,6 +702,52 @@ In this example, all saves to `MyTable` will raise an `Dynamoid::Errors::StaleOb
 
 Calls to `update` and `update!` also increment the `lock_version`, however they do not check the existing value. This guarantees that a update operation will raise an exception in a concurrent save operation, however a save operation will never cause an update to fail. Thus, `update` is useful & safe only for doing atomic operations (e.g. increment a value, add/remove from a set, etc), but should not be used in a read-modify-write pattern.
 
+
+### Backoff strategies
+
+
+You can use several methods that run efficiently in batch mode like `.find_all` and `.import`.
+
+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.
+
+Exponential backoff is the recommended way to handle throughput limits exceeding and throttling on the table.
+
+There are two built-in strategies - constant delay and truncated binary exponential backoff.
+By default no backoff is used but you can specify one of the built-in ones:
+
+```ruby
+Dynamoid.configure do |config|
+  config.backoff = { constant: 2.second }
+end
+
+Dynamoid.configure do |config|
+  config.backoff = { exponential: { base_backoff: 0.2.seconds, ceiling: 10 } }
+end
+
+```
+
+You can just specify strategy without any arguments to use default presets:
+
+```ruby
+Dynamoid.configure do |config|
+  config.backoff = :constant
+end
+```
+
+You can use your own strategy in following way:
+
+```ruby
+Dynamoid.configure do |config|
+  config.backoff_strategies[:custom] = lambda do |n|
+    -> { sleep rand(n) }
+  end
+
+  config.backoff = { custom: 10 }
+end
+```
+
+
 ## Rake Tasks
 
   * `rake dynamoid:create_tables`
@@ -676,6 +814,7 @@ Also, without contributors the project wouldn't be nearly as awesome. So many th
 * [Pascal Corpet](https://github.com/pcorpet)
 * [Brian Glusman](https://github.com/bglusman) *
 * [Peter Boling](https://github.com/pboling) *
+* [Andrew Konchin](https://github.com/andrykonchin) *
 
 \* Current Maintainers
 

data/dynamoid.gemspec

@@ -21,7 +21,8 @@ Gem::Specification.new do |spec|
       "Sumanth Ravipati",
       "Pascal Corpet",
       "Brian Glusman",
-      "Peter Boling"
+      "Peter Boling",
+      "Andrew Konchin"
   ]
   spec.email = ["peter.boling@gmail.com", "brian@stellaservice.com"]
 

data/lib/dynamoid/adapter.rb

@@ -51,7 +51,7 @@ module Dynamoid
     def benchmark(method, *args)
       start = Time.now
       result = yield
-      Dynamoid.logger.info "(#{((Time.now - start) * 1000.0).round(2)} ms) #{method.to_s.split('_').collect(&:upcase).join(' ')}#{ " - #{args.inspect}" unless args.nil? || args.empty? }"
+      Dynamoid.logger.debug "(#{((Time.now - start) * 1000.0).round(2)} ms) #{method.to_s.split('_').collect(&:upcase).join(' ')}#{ " - #{args.inspect}" unless args.nil? || args.empty? }"
       return result
     end
 
@@ -80,12 +80,12 @@ module Dynamoid
     #                        unless multiple ids are passed in.
     #
     # @since 0.2.0
-    def read(table, ids, options = {})
+    def read(table, ids, options = {}, &blk)
       range_key = options.delete(:range_key)
 
       if ids.respond_to?(:each)
         ids = ids.collect{|id| range_key ? [id, range_key] : id}
-        batch_get_item({table => ids}, options)
+        batch_get_item({table => ids}, options, &blk)
       else
         options[:range_key] = range_key if range_key
         get_item(table, ids, options)
@@ -144,8 +144,12 @@ module Dynamoid
       # Method delegation with benchmark to the underlying adapter. Faster than relying on method_missing.
       #
       # @since 0.2.0
-      define_method(m) do |*args|
-        benchmark("#{m.to_s}", *args) {adapter.send(m, *args)}
+      define_method(m) do |*args, &blk|
+        if blk.present?
+          benchmark("#{m.to_s}", *args) { adapter.send(m, *args, &blk) }
+        else
+          benchmark("#{m.to_s}", *args) { adapter.send(m, *args) }
+        end
       end
     end
 

data/lib/dynamoid/adapter_plugin/aws_sdk_v2.rb

@@ -18,6 +18,7 @@ module Dynamoid
       # we declare schema in models
       FIELD_MAP = {
           eq:           'EQ',
+          ne:           'NE',
           gt:           'GT',
           lt:           'LT',
           gte:          'GE',
@@ -83,36 +84,54 @@ module Dynamoid
         @client
       end
 
-      # Puts or deletes multiple items in one or more tables
+      # Puts multiple items in one table
+      #
+      # If optional block is passed it will be called for each written batch of items, meaning once per batch.
+      # Block receives boolean flag which is true if there are some unprocessed items, otherwise false.
+      #
+      # @example Saves several items to the table testtable
+      #   Dynamoid::AdapterPlugin::AwsSdkV2.batch_write_item('table1', [{ id: '1', name: 'a' }, { id: '2', name: 'b'}])
+      #
+      # @example Pass block
+      #   Dynamoid::AdapterPlugin::AwsSdkV2.batch_write_item('table1', items) do |bool|
+      #     if bool
+      #       puts 'there are unprocessed items'
+      #     end
+      #   end
       #
       # @param [String] table_name the name of the table
       # @param [Array]  items to be processed
       # @param [Hash]   additional options
+      # @param [Proc]   optional block
       #
       # See:
       # * http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
       # * http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#batch_write_item-instance_method
-      #
-      # TODO handle rejections because of exceeding limit for the whole request - 16 MB,
-      # item size limit - 400 KB or because provisioned throughput is exceeded
       def batch_write_item table_name, objects, options = {}
-        requests = []
-
-        objects.each_slice(BATCH_WRITE_ITEM_REQUESTS_LIMIT) do |os|
-          requests << os.map { |o| { put_request: { item: o } } }
-        end
+        items = objects.map { |o| sanitize_item(o) }
 
         begin
-          requests.each do |request_items|
-            client.batch_write_item(
+          while items.present? do
+            batch = items.shift(BATCH_WRITE_ITEM_REQUESTS_LIMIT)
+            requests = batch.map { |item| { put_request: { item: item } } }
+
+            response = client.batch_write_item(
               {
                 request_items: {
-                  table_name => request_items,
+                  table_name => requests,
                 },
                 return_consumed_capacity: 'TOTAL',
                 return_item_collection_metrics: 'SIZE'
               }.merge!(options)
             )
+
+            if block_given?
+              yield(response.unprocessed_items.present?)
+            end
+
+            if response.unprocessed_items.present?
+              items += response.unprocessed_items[table_name].map { |r| r.put_request.item }
+            end
           end
         rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
           raise Dynamoid::Errors::ConditionalCheckFailedException, e
@@ -121,17 +140,37 @@ module Dynamoid
 
       # Get many items at once from DynamoDB. More efficient than getting each item individually.
       #
+      # If optional block is passed `nil` will be returned and the block will be called for each read batch of items,
+      # meaning once per batch.
+      #
+      # Block receives parameters:
+      # * hash with items like `{ table_name: [items]}`
+      # * and boolean flag is true if there are some unprocessed keys, otherwise false.
+      #
       # @example Retrieve IDs 1 and 2 from the table testtable
-      #   Dynamoid::AdapterPlugin::AwsSdkV2.batch_get_item({'table1' => ['1', '2']})
+      #   Dynamoid::AdapterPlugin::AwsSdkV2.batch_get_item('table1' => ['1', '2'])
+      #
+      # @example Pass block to receive each batch
+      #   Dynamoid::AdapterPlugin::AwsSdkV2.batch_get_item('table1' => ids) do |hash, bool|
+      #     puts hash['table1']
+      #
+      #     if bool
+      #       puts 'there are unprocessed keys'
+      #     end
+      #   end
       #
       # @param [Hash] table_ids the hash of tables and IDs to retrieve
       # @param [Hash] options to be passed to underlying BatchGet call
+      # @param [Proc] optional block can be passed to handle each batch of items
       #
       # @return [Hash] a hash where keys are the table names and the values are the retrieved items
       #
+      #  See:
+      #  * http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#batch_get_item-instance_method
+      #
       # @since 1.0.0
       #
-      # @todo: Provide support for passing options to underlying batch_get_item http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#batch_get_item-instance_method
+      # @todo: Provide support for passing options to underlying batch_get_item
       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?}
@@ -140,19 +179,22 @@ module Dynamoid
 
         table_ids.each do |t, ids|
           next if ids.blank?
+          ids = Array(ids).dup
           tbl = describe_table(t)
           hk  = tbl.hash_key.to_s
           rng = tbl.range_key.to_s
 
-          Array(ids).each_slice(Dynamoid::Config.batch_size) do |ids|
+          while ids.present? do
+            batch = ids.shift(Dynamoid::Config.batch_size)
+
             request_items = Hash.new{|h, k| h[k] = []}
 
             keys = if rng.present?
-              Array(ids).map do |h, r|
+              Array(batch).map do |h, r|
                 { hk => h, rng => r }
               end
             else
-              Array(ids).map do |id|
+              Array(batch).map do |id|
                 { hk => id }
               end
             end
@@ -165,13 +207,29 @@ module Dynamoid
               request_items: request_items
             )
 
-            results.data[:responses].each do |table, rows|
-              ret[table] += rows.collect { |r| result_item_to_hash(r) }
+            unless block_given?
+              results.data[:responses].each do |table, rows|
+                ret[table] += rows.collect { |r| result_item_to_hash(r) }
+              end
+            else
+              batch_results = Hash.new([].freeze)
+
+              results.data[:responses].each do |table, rows|
+                batch_results[table] += rows.collect { |r| result_item_to_hash(r) }
+              end
+
+              yield(batch_results, results.unprocessed_keys.present?)
+            end
+
+            if results.unprocessed_keys.present?
+              ids += results.unprocessed_keys[t].keys.map { |h| h[hk] }
             end
           end
         end
 
-        ret
+        unless block_given?
+          ret
+        end
       end
 
       # Delete many items at once from DynamoDB. More efficient than delete each item individually.
@@ -421,13 +479,8 @@ module Dynamoid
       #
       # See: http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#put_item-instance_method
       def put_item(table_name, object, options = {})
-        item = {}
         options ||= {}
-
-        object.each do |k, v|
-          next if v.nil? || ((v.is_a?(Set) || v.is_a?(String)) && v.empty?)
-          item[k.to_s] = v
-        end
+        item = sanitize_item(object)
 
         begin
           client.put_item(
@@ -480,39 +533,21 @@ module Dynamoid
         record_limit = opts.delete(:record_limit)
         scan_limit = opts.delete(:scan_limit)
         batch_size = opts.delete(:batch_size)
-        limit = [record_limit, scan_limit, batch_size].compact.min
-        q[:limit] = limit if limit
-
-        opts.delete(:next_token).tap do |token|
-          break unless token
-          q[:exclusive_start_key] = {
-            hk  => token[:hash_key_element],
-            rng => token[:range_key_element]
-          }
-          # For secondary indices the start key must contain the indices composite key
-          # but also the table's composite keys
-          q[:exclusive_start_key][table.hash_key] = token[:table_hash_key_element] if token[:table_hash_key_element]
-          q[:exclusive_start_key][table.range_key] = token[:table_range_key_element] if token[:table_range_key_element]
-        end
+        exclusive_start_key = opts.delete(:exclusive_start_key)
+        limit = [record_limit, scan_limit, batch_size].compact.min        
 
         key_conditions = {
           hk => {
-            # TODO: Provide option for other operators like NE, IN, LE, etc
             comparison_operator: EQ,
-            attribute_value_list: [
-              opts.delete(:hash_value).freeze
-            ]
+            attribute_value_list: attribute_value_list(EQ, opts.delete(:hash_value).freeze)
           }
         }
 
         opts.each_pair do |k, v|
-          # TODO: ATM, only few comparison operators are supported, provide support for all operators
           next unless(op = RANGE_MAP[k])
           key_conditions[rng] = {
             comparison_operator: op,
-            attribute_value_list: [
-              opts.delete(k).freeze
-            ].flatten # Flatten as BETWEEN operator specifies array of two elements
+            attribute_value_list: attribute_value_list(op, opts.delete(k).freeze)
           }
         end
 
@@ -520,12 +555,12 @@ module Dynamoid
         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: [
-              hash.values[0].freeze
-            ].flatten # Flatten as BETWEEN operator specifies array of two elements
+            attribute_value_list: attribute_value_list(FIELD_MAP[hash.keys[0]], hash.values[0].freeze)
           }
         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
@@ -593,15 +628,16 @@ module Dynamoid
         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)|
-            # Flatten as BETWEEN operator specifies array of two elements
             memo.merge(attr.to_s => {
               comparison_operator: FIELD_MAP[cond.keys[0]],
-              attribute_value_list: [cond.values[0].freeze].flatten
+              attribute_value_list: attribute_value_list(FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
             })
           end
         end
@@ -748,6 +784,10 @@ module Dynamoid
         conditions.delete(:unless_exists).try(:each) do |col|
           expected[col.to_s][:exists] = false
         end
+        conditions.delete(:if_exists).try(:each) do |col, val|
+          expected[col.to_s][:exists] = true
+          expected[col.to_s][:value] = val
+        end
         conditions.delete(:if).try(:each) do |col, val|
           expected[col.to_s][:value] = val
         end
@@ -919,6 +959,21 @@ module Dynamoid
         }
       end
 
+      # Build an array of values for Condition
+      # Is used in ScanFilter and QueryFilter
+      # https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html
+      # @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)
+        # 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 ["BETWEEN", "IN"].include?(operator)
+          [value].flatten
+        else
+          [value]
+        end
+      end
+
       #
       # Represents a table. Exposes data from the "DescribeTable" API call, and also
       # provides methods for coercing values to the proper types based on the table's schema data
@@ -1035,6 +1090,12 @@ module Dynamoid
         DELETE = 'DELETE'.freeze
         PUT    = 'PUT'.freeze
       end
+
+      def sanitize_item(attributes)
+        attributes.reject do |k, v|
+          v.nil? || ((v.is_a?(Set) || v.is_a?(String)) && v.empty?)
+        end
+      end
     end
   end
 end

data/lib/dynamoid/config.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 require 'uri'
 require 'dynamoid/config/options'
+require 'dynamoid/config/backoff_strategies/constant_backoff'
+require 'dynamoid/config/backoff_strategies/exponential_backoff'
 
 module Dynamoid
 
@@ -26,8 +28,15 @@ module Dynamoid
     option :sync_retry_max_times, default: 60 # a bit over 2 minutes
     option :sync_retry_wait_seconds, default: 2
     option :convert_big_decimal, default: false
-    option :models_dir, default: 'app/models' # perhaps you keep your dynamoid models in a different directory?
+    option :models_dir, default: './app/models' # perhaps you keep your dynamoid models in a different directory?
     option :application_timezone, default: :local # available values - :utc, :local, time zone names
+    option :store_datetime_as_string, default: false # store Time fields in ISO 8601 string format
+    option :store_date_as_string, default: false # store Date fields in ISO 8601 string format
+    option :backoff, default: nil # callable object to handle exceeding of table throughput limit
+    option :backoff_strategies, default: {
+      constant: BackoffStrategies::ConstantBackoff,
+      exponential: BackoffStrategies::ExponentialBackoff
+    }
 
     # The default logger for Dynamoid: either the Rails logger or just stdout.
     #
@@ -55,5 +64,15 @@ module Dynamoid
       end
     end
 
+    def build_backoff
+      if backoff.is_a?(Hash)
+        name = backoff.keys[0]
+        args = backoff.values[0]
+
+        backoff_strategies[name].call(args)
+      else
+        backoff_strategies[backoff].call
+      end
+    end
   end
 end

data/lib/dynamoid/config/backoff_strategies/constant_backoff.rb

@@ -0,0 +1,11 @@
+module Dynamoid
+  module Config
+    module BackoffStrategies
+      class ConstantBackoff
+        def self.call(n = 1)
+          -> { sleep n }
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/config/backoff_strategies/exponential_backoff.rb

@@ -0,0 +1,25 @@
+module Dynamoid
+  module Config
+    module BackoffStrategies
+      # Truncated binary exponential backoff algorithm
+      # See https://en.wikipedia.org/wiki/Exponential_backoff
+      class ExponentialBackoff
+        def self.call(opts = {})
+          opts = { base_backoff: 0.5, ceiling: 3 }.merge(opts)
+          base_backoff = opts[:base_backoff]
+          ceiling = opts[:ceiling]
+
+          times = 1
+
+          lambda do
+            power = [times - 1, ceiling - 1].min
+            backoff = base_backoff * (2 ** power)
+            sleep backoff
+
+            times += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/criteria/chain.rb

@@ -161,7 +161,10 @@ module Dynamoid #:nodoc:
       def records_via_scan
         if Dynamoid::Config.warn_on_scan
           Dynamoid.logger.warn 'Queries without an index are forced to use scan and are generally much slower than indexed queries!'
-          Dynamoid.logger.warn "You can index this query by adding this to #{source.to_s.downcase}.rb: index [#{query.keys.sort.collect{|name| ":#{name}"}.join(', ')}]"
+          Dynamoid.logger.warn "You can index this query by adding index declaration to #{source.to_s.downcase}.rb:"
+          Dynamoid.logger.warn "* global_secondary_index hash_key: 'some-name', range_key: 'some-another-name'"
+          Dynamoid.logger.warn "* local_secondary_indexe range_key: 'some-name'"
+          Dynamoid.logger.warn "Not indexed attributes: #{query.keys.sort.collect{|name| ":#{name}"}.join(', ')}"
         end
 
         Enumerator.new do |yielder|
@@ -196,6 +199,8 @@ module Dynamoid #:nodoc:
         val = type_cast_condition_parameter(name, query[key])
 
         hash = case operation
+        when 'ne'
+          { ne: val }
         when 'gt'
           { gt: val }
         when 'lt'
@@ -258,6 +263,8 @@ module Dynamoid #:nodoc:
       end
 
       def type_cast_condition_parameter(key, value)
+        return value if [:array, :set].include?(source.attributes[key.to_sym][:type])
+
         if !value.respond_to?(:to_ary)
           source.dump_field(value, source.attributes[key.to_sym])
         else
@@ -294,7 +301,7 @@ module Dynamoid #:nodoc:
         # But only do so if projects ALL attributes otherwise we won't
         # get back full data
         source.global_secondary_indexes.each do |_, gsi|
-          next unless query_keys.include?(gsi.hash_key.to_s) && gsi.projected_attributes == :all
+          next unless query.keys.map(&:to_s).include?(gsi.hash_key.to_s) && gsi.projected_attributes == :all
           @hash_key = gsi.hash_key
           @range_key = gsi.range_key
           @index_name = gsi.name
@@ -309,21 +316,22 @@ module Dynamoid #:nodoc:
       # If using a secondary index then we must include the index's composite key
       # as well as the tables composite key.
       def start_key
+        return @start if @start.is_a?(Hash)
         hash_key = @hash_key || source.hash_key
         range_key = @range_key || source.range_key
 
         key = {}
-        key[:hash_key_element] = type_cast_condition_parameter(hash_key, @start.send(hash_key))
-        key[:range_key_element] = type_cast_condition_parameter(range_key, @start.send(range_key)) if range_key
-
-        # Add table composite keys if differ from secondary index used composite key
+        key[hash_key] = type_cast_condition_parameter(hash_key, @start.send(hash_key))
+        if range_key
+          key[range_key] = type_cast_condition_parameter(range_key, @start.send(range_key))
+        end
+        # Add table composite keys if they differ from secondary index used composite key
         if hash_key != source.hash_key
-          key[:table_hash_key_element] = type_cast_condition_parameter(source.hash_key, @start.hash_key)
+          key[source.hash_key] = type_cast_condition_parameter(source.hash_key, @start.hash_key)
         end
         if source.range_key && range_key != source.range_key
-          key[:table_range_key_element] = type_cast_condition_parameter(source.range_key, @start.range_value)
+          key[source.range_key] = type_cast_condition_parameter(source.range_key, @start.range_value)
         end
-
         key
       end
 
@@ -334,7 +342,7 @@ module Dynamoid #:nodoc:
         opts[:record_limit] = @record_limit if @record_limit
         opts[:scan_limit] = @scan_limit if @scan_limit
         opts[:batch_size] = @batch_size if @batch_size
-        opts[:next_token] = start_key if @start
+        opts[:exclusive_start_key] = start_key if @start
         opts[:scan_index_forward] = @scan_index_forward
         opts
       end
@@ -357,7 +365,7 @@ module Dynamoid #:nodoc:
         opts[:record_limit] = @record_limit if @record_limit
         opts[:scan_limit] = @scan_limit if @scan_limit
         opts[:batch_size] = @batch_size if @batch_size
-        opts[:next_token] = start_key if @start
+        opts[:exclusive_start_key] = start_key if @start
         opts[:consistent_read] = true if @consistent_read
         opts
       end

data/lib/dynamoid/document.rb

@@ -119,6 +119,77 @@ module Dynamoid #:nodoc:
         end
       end
 
+      def update(hash_key, range_key_value=nil, attrs)
+        if range_key.present?
+          range_key_value = dump_field(range_key_value, attributes[self.range_key])
+        else
+          range_key_value = nil
+        end
+
+        model = find(hash_key, range_key: range_key_value, consistent_read: true)
+        model.update_attributes(attrs)
+        model
+      end
+
+      def update_fields(hash_key_value, range_key_value=nil, attrs={}, conditions={})
+        optional_params = [range_key_value, attrs, conditions].compact
+        if optional_params.first.is_a?(Hash)
+          range_key_value = nil
+          attrs, conditions = optional_params[0 .. 1]
+        else
+          range_key_value = optional_params.first
+          attrs, conditions = optional_params[1 .. 2]
+        end
+
+        options = if range_key
+                    { range_key: dump_field(range_key_value, attributes[range_key]) }
+                  else
+                    {}
+                  end
+
+        (conditions[:if_exists] ||= {})[hash_key] = hash_key_value
+        options[:conditions] = conditions
+
+        begin
+          new_attrs = Dynamoid.adapter.update_item(table_name, hash_key_value, options) do |t|
+            attrs.symbolize_keys.each do |k, v|
+              t.set k => dump_field(v, attributes[k])
+            end
+          end
+          new(new_attrs)
+        rescue Dynamoid::Errors::ConditionalCheckFailedException
+        end
+      end
+
+      def upsert(hash_key_value, range_key_value=nil, attrs={}, conditions={})
+        optional_params = [range_key_value, attrs, conditions].compact
+        if optional_params.first.is_a?(Hash)
+          range_key_value = nil
+          attrs, conditions = optional_params[0 .. 1]
+        else
+          range_key_value = optional_params.first
+          attrs, conditions = optional_params[1 .. 2]
+        end
+
+        options = if range_key
+                    { range_key: dump_field(range_key_value, attributes[range_key]) }
+                  else
+                    {}
+                  end
+
+        options[:conditions] = conditions
+
+        begin
+          new_attrs = Dynamoid.adapter.update_item(table_name, hash_key_value, options) do |t|
+            attrs.symbolize_keys.each do |k, v|
+              t.set k => dump_field(v, attributes[k])
+            end
+          end
+          new(new_attrs)
+        rescue Dynamoid::Errors::ConditionalCheckFailedException
+        end
+      end
+
       def deep_subclasses
         subclasses + subclasses.map(&:deep_subclasses).flatten
       end

data/lib/dynamoid/finders.rb

@@ -52,9 +52,11 @@ module Dynamoid
         end
       end
 
-      # Return objects found by the given array of ids, either hash keys, or hash/range key combinations using BatchGet.
+      # Return objects found by the given array of ids, either hash keys, or hash/range key combinations using BatchGetItem.
       # Returns empty array if no results found.
       #
+      # Uses backoff specified by `Dynamoid::Config.backoff` config option
+      #
       # @param [Array<ID>] ids
       # @param [Hash] options: Passed to the underlying query.
       #
@@ -65,8 +67,26 @@ module Dynamoid
       #   find all the tweets using hash key and range key with consistent read
       #   Tweet.find_all([['1', 'red'], ['1', 'green']], :consistent_read => true)
       def find_all(ids, options = {})
-        items = Dynamoid.adapter.read(self.table_name, ids, options)
-        items ? items[self.table_name].map{|i| from_database(i)} : []
+        results = unless Dynamoid.config.backoff
+          items = Dynamoid.adapter.read(self.table_name, ids, options)
+          items ? items[self.table_name] : []
+        else
+          items = []
+          backoff = nil
+          Dynamoid.adapter.read(self.table_name, ids, options) do |hash, has_unprocessed_items|
+            items += hash[self.table_name]
+
+            if has_unprocessed_items
+              backoff ||= Dynamoid.config.build_backoff
+              backoff.call
+            else
+              backoff = nil
+            end
+          end
+          items
+        end
+
+        results ? results.map {|i| from_database(i) } : []
       end
 
       # Find one object directly by id.

data/lib/dynamoid/persistence.rb

@@ -117,25 +117,14 @@ module Dynamoid
                   value
                 end
               when :set
-                Set.new(value)
+                undump_set(options, value)
               when :datetime
-                if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
-                  value
-                else
-                  case Dynamoid::Config.application_timezone
-                    when :utc
-                      ActiveSupport::TimeZone['UTC'].at(value).to_datetime
-                    when :local
-                      Time.at(value).to_datetime
-                    when String
-                      ActiveSupport::TimeZone[Dynamoid::Config.application_timezone].at(value).to_datetime
-                  end
-                end
+                parse_datetime(value, options)
               when :date
                 if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
                   value.to_date
                 else
-                  UNIX_EPOCH_DATE + value.to_i
+                  parse_date(value, options)
                 end
               when :boolean
                 if value == 't' || value == true
@@ -152,6 +141,17 @@ module Dynamoid
         end
       end
 
+      def undump_set(options, value)
+        case options[:of]
+        when :integer
+          value.map { |v| Integer(v) }.to_set
+        when :number
+          value.map { |v| BigDecimal.new(v.to_s) }.to_set
+        else
+          value.is_a?(Set) ? value : Set.new(value)
+        end
+      end
+
       def dump_field(value, options)
         if (field_class = options[:type]).is_a?(Class)
           if value.respond_to?(:dynamoid_dump)
@@ -174,9 +174,9 @@ module Dynamoid
             when :array
               !value.nil? ? value : nil
             when :datetime
-              !value.nil? ? value.to_time.to_f : nil
+              !value.nil? ? format_datetime(value, options) : nil
             when :date
-              !value.nil? ? (value.to_date - UNIX_EPOCH_DATE).to_i : nil
+              !value.nil? ? format_date(value, options) : nil
             when :serialized
               options[:serializer] ? options[:serializer].dump(value) : value.to_yaml
             when :raw
@@ -212,14 +212,38 @@ module Dynamoid
         end
       end
 
+      # Creates several models at once.
+      # Neither callbacks nor validations run.
+      # It works efficiently because of using BatchWriteItem.
+      #
+      # Returns array of models
+      #
+      # Uses backoff specified by `Dynamoid::Config.backoff` config option
+      #
+      # @param [Array<Hash>] items
+      #
+      # @example
+      #   User.import([{ name: 'a' }, { name: 'b' }])
       def import(objects)
-        documents = objects.map { |attrs|
-          self.build(attrs).tap { |item|
+        documents = objects.map do |attrs|
+          self.build(attrs).tap do |item|
             item.hash_key = SecureRandom.uuid if item.hash_key.blank?
-          }
-        }
+          end
+        end
 
-        Dynamoid.adapter.batch_write_item(self.table_name, documents.map(&:dump))
+        unless Dynamoid.config.backoff
+          Dynamoid.adapter.batch_write_item(self.table_name, documents.map(&:dump))
+        else
+          backoff = nil
+          Dynamoid.adapter.batch_write_item(self.table_name, documents.map(&:dump)) do |has_unprocessed_items|
+            if has_unprocessed_items
+              backoff ||= Dynamoid.config.build_backoff
+              backoff.call
+            else
+              backoff = nil
+            end
+          end
+        end
 
         documents.each { |d| d.new_record = false }
         documents
@@ -250,6 +274,63 @@ module Dynamoid
         end
       end
 
+      def format_datetime(value, options)
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_datetime_as_string \
+          : options[:store_as_string]
+
+        if use_string_format
+          value.to_time.iso8601
+        else
+          unless value.respond_to?(:to_i) && value.respond_to?(:nsec)
+            value = value.to_time
+          end
+          BigDecimal("%d.%09d" % [value.to_i, value.nsec])
+        end
+      end
+
+      def format_date(value, options)
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_date_as_string \
+          : options[:store_as_string]
+
+        unless use_string_format
+          (value.to_date - UNIX_EPOCH_DATE).to_i
+        else
+          value.to_date.iso8601
+        end
+      end
+
+      def parse_datetime(value, options)
+        return value if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_datetime_as_string \
+          : options[:store_as_string]
+        value = DateTime.iso8601(value).to_time.to_i if use_string_format
+
+        case Dynamoid::Config.application_timezone
+          when :utc
+            ActiveSupport::TimeZone['UTC'].at(value).to_datetime
+          when :local
+            Time.at(value).to_datetime
+          when String
+            ActiveSupport::TimeZone[Dynamoid::Config.application_timezone].at(value).to_datetime
+        end
+      end
+
+      def parse_date(value, options)
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_date_as_string \
+          : options[:store_as_string]
+
+        unless use_string_format
+          UNIX_EPOCH_DATE + value.to_i
+        else
+          Date.iso8601(value)
+        end
+      end
+
       # Evaluates the default value given, this is used by undump
       # when determining the value of the default given for a field options.
       #

data/lib/dynamoid/version.rb

@@ -1,3 +1,3 @@
 module Dynamoid
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamoid
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Josh Symonds
@@ -17,10 +17,11 @@ authors:
 - Pascal Corpet
 - Brian Glusman
 - Peter Boling
+- Andrew Konchin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-20 00:00:00.000000000 Z
+date: 2018-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -234,6 +235,8 @@ files:
 - lib/dynamoid/associations/single_association.rb
 - lib/dynamoid/components.rb
 - lib/dynamoid/config.rb
+- lib/dynamoid/config/backoff_strategies/constant_backoff.rb
+- lib/dynamoid/config/backoff_strategies/exponential_backoff.rb
 - lib/dynamoid/config/options.rb
 - lib/dynamoid/criteria.rb
 - lib/dynamoid/criteria/chain.rb
@@ -271,7 +274,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Dynamoid is an ORM for Amazon's DynamoDB