dynamoid 1.3.4 → 2.2.0

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/config/options.rb

@@ -43,7 +43,7 @@ module Dynamoid #:nodoc
           def #{name}?
             #{name}
           end
-          
+
           def reset_#{name}
             settings[#{name.inspect}] = defaults[#{name.inspect}]
           end

data/lib/dynamoid/criteria/chain.rb

@@ -18,6 +18,11 @@ module Dynamoid #:nodoc:
         @source = source
         @consistent_read = false
         @scan_index_forward = true
+
+        # Honor STI and :type field if it presents
+        if @source.attributes.key?(:type)
+          @query[:'type.in'] = @source.deep_subclasses.map(&:name) << @source.name
+        end
       end
 
       # The workhorse method of the criteria chain. Each key in the passed in hash will become another criteria that the
@@ -56,32 +61,36 @@ module Dynamoid #:nodoc:
       end
 
       # Returns the last fetched record matched the criteria
+      # Enumerable doesn't implement `last`, only `first`
+      # So we have to implement it ourselves
       #
       def last
-        all.last
+        all.to_a.last
       end
 
       # Destroys all the records matching the criteria.
       #
-      def destroy_all
+      def delete_all
         ids = []
+        ranges = []
 
         if key_present?
-          ranges = []
           Dynamoid.adapter.query(source.table_name, range_query).collect do |hash|
             ids << hash[source.hash_key.to_sym]
-            ranges << hash[source.range_key.to_sym]
+            ranges << hash[source.range_key.to_sym] if source.range_key
           end
 
-          Dynamoid.adapter.delete(source.table_name, ids,{:range_key => ranges})
+          Dynamoid.adapter.delete(source.table_name, ids, range_key: ranges.presence)
         else
-          Dynamoid.adapter.scan(source.table_name, query, scan_opts).collect do |hash|
+          Dynamoid.adapter.scan(source.table_name, scan_query, scan_opts).collect do |hash|
             ids << hash[source.hash_key.to_sym]
+            ranges << hash[source.range_key.to_sym] if source.range_key
           end
 
-          Dynamoid.adapter.delete(source.table_name, ids)
+          Dynamoid.adapter.delete(source.table_name, ids, range_key: ranges.presence)
         end
       end
+      alias_method :destroy_all, :delete_all
 
       # The record limit is the limit of evaluated records returned by the
       # query or scan.
@@ -121,10 +130,6 @@ module Dynamoid #:nodoc:
         records.each(&block)
       end
 
-      def consistent_opts
-        { :consistent_read => consistent_read }
-      end
-
       private
 
       # The actual records referenced by the association.
@@ -133,12 +138,11 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def records
-        results = if key_present?
+        if key_present?
           records_via_query
         else
           records_via_scan
         end
-        @batch_size ? results : Array(results)
       end
 
       def records_via_query
@@ -157,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|
@@ -173,17 +180,17 @@ module Dynamoid #:nodoc:
 
         case operation
         when 'gt'
-          { :range_greater_than => val }
+          { range_greater_than: val }
         when 'lt'
-          { :range_less_than  => val }
+          { range_less_than: val }
         when 'gte'
-          { :range_gte  => val }
+          { range_gte: val }
         when 'lte'
-          { :range_lte => val }
+          { range_lte: val }
         when 'between'
-          { :range_between => val }
+          { range_between: val }
         when 'begins_with'
-          { :range_begins_with => val }
+          { range_begins_with: val }
         end
       end
 
@@ -192,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'
@@ -215,6 +224,10 @@ module Dynamoid #:nodoc:
         return { name.to_sym => hash }
       end
 
+      def consistent_opts
+        { consistent_read: consistent_read }
+      end
+
       def range_query
         opts = {}
 
@@ -227,7 +240,7 @@ module Dynamoid #:nodoc:
           opts[:range_key] = @range_key
           if query[@range_key].present?
             value = type_cast_condition_parameter(@range_key, query[@range_key])
-            opts.update(:range_eq => value)
+            opts.update(range_eq: value)
           end
 
           query.keys.select { |k| k.to_s =~ /^#{@range_key}\./ }.each do |key|
@@ -250,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
@@ -261,7 +276,7 @@ module Dynamoid #:nodoc:
         query_keys = query.keys.collect { |k| k.to_s.split('.').first }
 
         # See if querying based on table hash key
-        if query_keys.include?(source.hash_key.to_s)
+        if query.keys.map(&:to_s).include?(source.hash_key.to_s)
           @hash_key = source.hash_key
 
           # Use table's default range key
@@ -286,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
@@ -301,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
 
@@ -326,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
@@ -349,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/dirty.rb

@@ -5,7 +5,7 @@ module Dynamoid
 
     module ClassMethods
       def from_database(*)
-        super.tap { |d| d.changed_attributes.clear }
+        super.tap { |d| d.send(:clear_changes_information) }
       end
     end
 
@@ -15,7 +15,7 @@ module Dynamoid
 
     def update!(*)
       ret = super
-      clear_changes #update! completely reloads all fields on the class, so any extant changes are wiped out
+      clear_changes # update! completely reloads all fields on the class, so any extant changes are wiped out
       ret
     end
 
@@ -26,9 +26,9 @@ module Dynamoid
     def clear_changes
       previous = changes
       (block_given? ? yield : true).tap do |result|
-        unless result == false #failed validation; nil is OK.
+        unless result == false # failed validation; nil is OK.
           @previously_changed = previous
-          changed_attributes.clear
+          clear_changes_information
         end
       end
     end
@@ -43,5 +43,24 @@ module Dynamoid
     def attribute_method?(attr)
       super || self.class.attributes.has_key?(attr.to_sym)
     end
+
+    if ActiveModel::VERSION::STRING >= '5.2.0'
+      # The ActiveModel::Dirty API was changed
+      # https://github.com/rails/rails/commit/c3675f50d2e59b7fc173d7b332860c4b1a24a726#diff-aaddd42c7feb0834b1b5c66af69814d3
+      # So we just try to disable new functionality
+
+      def mutations_from_database
+        @mutations_from_database ||= ActiveModel::NullMutationTracker.instance
+      end
+
+      def forget_attribute_assignments
+      end
+    end
+
+    if ActiveModel::VERSION::STRING < '4.2.0'
+      def clear_changes_information
+        changed_attributes.clear
+      end
+    end
   end
 end

data/lib/dynamoid/document.rb

@@ -72,7 +72,11 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def create(attrs = {})
-        build(attrs).tap(&:save)
+        if attrs.is_a?(Array)
+          attrs.map { |attr| create(attr) }
+        else
+          build(attrs).tap(&:save)
+        end
       end
 
       # Initialize a new object and immediately save it to the database. Raise an exception if persistence failed.
@@ -83,7 +87,11 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def create!(attrs = {})
-        build(attrs).tap(&:save!)
+        if attrs.is_a?(Array)
+          attrs.map { |attr| create!(attr) }
+        else
+          build(attrs).tap(&:save!)
+        end
       end
 
       # Initialize a new object.
@@ -106,9 +114,84 @@ module Dynamoid #:nodoc:
       # @since 0.2.0
       def exists?(id_or_conditions = {})
         case id_or_conditions
-          when Hash then ! where(id_or_conditions).all.empty?
-          else !! find(id_or_conditions)
+          when Hash then where(id_or_conditions).first.present?
+          else !! find_by_id(id_or_conditions)
+        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
     end
 
@@ -167,7 +250,7 @@ module Dynamoid #:nodoc:
     # @since 0.2.0
     def reload
       range_key_value = range_value ? dumped_range_value : nil
-      self.attributes = self.class.find(hash_key, :range_key => range_key_value, :consistent_read => true).attributes
+      self.attributes = self.class.find(hash_key, range_key: range_key_value, consistent_read: true).attributes
       @associations.values.each(&:reset)
       self
     end

data/lib/dynamoid/errors.rb

@@ -27,7 +27,7 @@ module Dynamoid
       attr_reader :record
 
       def initialize(record)
-        super("Failed to destroy item")
+        super('Failed to destroy item')
         @record = record
       end
     end
@@ -61,6 +61,9 @@ module Dynamoid
       end
     end
 
+    class RecordNotFound < Error
+    end
+
     class DocumentNotValid < Error
       attr_reader :document