dynamoid 3.10.0 → 3.11.0

data/lib/dynamoid/criteria/chain.rb

@@ -95,20 +95,27 @@ module Dynamoid
       #
       # Internally +where+ performs either +Scan+ or +Query+ operation.
       #
+      # Conditions can be specified as an expression as well:
+      #
+      #   Post.where('links_count = :v', v: 2)
+      #
+      # This way complex expressions can be constructed (e.g. with AND, OR, and NOT
+      # keyword):
+      #
+      #   Address.where('city = :c AND (post_code = :pc1 OR post_code = :pc2)', city: 'A', pc1: '001', pc2: '002')
+      #
+      # See documentation for condition expression's syntax and examples:
+      # - https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html
+      # - https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.FilterExpression.html
+      #
       # @return [Dynamoid::Criteria::Chain]
       # @since 0.2.0
-      def where(args)
-        detector = NonexistentFieldsDetector.new(args, @source)
-        if detector.found?
-          Dynamoid.logger.warn(detector.warning_message)
+      def where(conditions, placeholders = nil)
+        if conditions.is_a?(Hash)
+          where_with_hash(conditions)
+        else
+          where_with_string(conditions, placeholders)
         end
-
-        @where_conditions.update(args.symbolize_keys)
-
-        # we should re-initialize keys detector every time we change @where_conditions
-        @key_fields_detector = KeyFieldsDetector.new(@where_conditions, @source, forced_index_name: @forced_index_name)
-
-        self
       end
 
       # Turns on strongly consistent reads.
@@ -500,6 +507,29 @@ module Dynamoid
 
       private
 
+      def where_with_hash(conditions)
+        detector = NonexistentFieldsDetector.new(conditions, @source)
+        if detector.found?
+          Dynamoid.logger.warn(detector.warning_message)
+        end
+
+        @where_conditions.update_with_hash(conditions.symbolize_keys)
+
+        # we should re-initialize keys detector every time we change @where_conditions
+        @key_fields_detector = KeyFieldsDetector.new(@where_conditions, @source, forced_index_name: @forced_index_name)
+
+        self
+      end
+
+      def where_with_string(query, placeholders)
+        @where_conditions.update_with_string(query, placeholders)
+
+        # we should re-initialize keys detector every time we change @where_conditions
+        @key_fields_detector = KeyFieldsDetector.new(@where_conditions, @source, forced_index_name: @forced_index_name)
+
+        self
+      end
+
       # The actual records referenced by the association.
       #
       # @return [Enumerator] an iterator of the found records.
@@ -635,12 +665,12 @@ module Dynamoid
       end
 
       def query_non_key_conditions
-        opts = {}
+        hash_conditions = {}
 
         # Honor STI and :type field if it presents
         if @source.attributes.key?(@source.inheritance_field) &&
            @key_fields_detector.hash_key.to_sym != @source.inheritance_field.to_sym
-          @where_conditions.update(sti_condition)
+          @where_conditions.update_with_hash(sti_condition)
         end
 
         # TODO: Separate key conditions and non-key conditions properly:
@@ -650,11 +680,17 @@ module Dynamoid
           .reject { |k, _| k.to_s =~ /^#{@key_fields_detector.range_key}\./ }
         keys.each do |key|
           name, condition = field_condition(key, @where_conditions[key])
-          opts[name] ||= []
-          opts[name] << condition
+          hash_conditions[name] ||= []
+          hash_conditions[name] << condition
         end
 
-        opts
+        string_conditions = []
+        @where_conditions.string_conditions.each do |query, placeholders|
+          placeholders ||= {}
+          string_conditions << [query, placeholders]
+        end
+
+        [hash_conditions] + string_conditions
       end
 
       # TODO: casting should be operator aware
@@ -721,16 +757,25 @@ module Dynamoid
       def scan_conditions
         # Honor STI and :type field if it presents
         if sti_condition
-          @where_conditions.update(sti_condition)
+          @where_conditions.update_with_hash(sti_condition)
         end
 
-        {}.tap do |opts|
+        hash_conditions = {}
+        hash_conditions.tap do |opts|
           @where_conditions.keys.map(&:to_sym).each do |key|
             name, condition = field_condition(key, @where_conditions[key])
             opts[name] ||= []
             opts[name] << condition
           end
         end
+
+        string_conditions = []
+        @where_conditions.string_conditions.each do |query, placeholders|
+          placeholders ||= {}
+          string_conditions << [query, placeholders]
+        end
+
+        [hash_conditions] + string_conditions
       end
 
       def scan_options

data/lib/dynamoid/criteria/where_conditions.rb

@@ -4,24 +4,31 @@ module Dynamoid
   module Criteria
     # @private
     class WhereConditions
+      attr_reader :string_conditions
+
       def initialize
-        @conditions = []
+        @hash_conditions = []
+        @string_conditions = []
+      end
+
+      def update_with_hash(hash)
+        @hash_conditions << hash.symbolize_keys
       end
 
-      def update(hash)
-        @conditions << hash.symbolize_keys
+      def update_with_string(query, placeholders)
+        @string_conditions << [query, placeholders]
       end
 
       def keys
-        @conditions.flat_map(&:keys)
+        @hash_conditions.flat_map(&:keys)
       end
 
       def empty?
-        @conditions.empty?
+        @hash_conditions.empty? && @string_conditions.empty?
       end
 
       def [](key)
-        hash = @conditions.find { |h| h.key?(key) }
+        hash = @hash_conditions.find { |h| h.key?(key) }
         hash[key] if hash
       end
     end

data/lib/dynamoid/dirty.rb

@@ -36,8 +36,11 @@ module Dynamoid
         end
       end
 
-      def from_database(*)
-        super.tap(&:clear_changes_information)
+      def from_database(attributes_from_database)
+        super.tap do |model|
+          model.clear_changes_information
+          model.assign_attributes_from_database(DeepDupper.dup_attributes(model.attributes, model.class))
+        end
       end
     end
 
@@ -108,7 +111,7 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |name| [name, attribute_change(name)] }]
+      ActiveSupport::HashWithIndifferentAccess[changed_attributes.map { |name, old_value| [name, [old_value, read_attribute(name)]] }]
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -132,19 +135,21 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changed_attributes
-      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      attributes_changed_by_setter.merge(attributes_changed_in_place)
     end
 
     # Clear all dirty data: current changes and previous changes.
     def clear_changes_information
       @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_from_database = HashWithIndifferentAccess.new(DeepDupper.dup_attributes(@attributes, self.class))
     end
 
     # Clears dirty data and moves +changes+ to +previous_changes+.
     def changes_applied
       @previously_changed = changes
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      @attributes_from_database = HashWithIndifferentAccess.new(DeepDupper.dup_attributes(@attributes, self.class))
     end
 
     # Remove changes information for the provided attributes.
@@ -152,6 +157,9 @@ module Dynamoid
     # @param attributes [Array[String]] - a list of attributes to clear changes for
     def clear_attribute_changes(names)
       attributes_changed_by_setter.except!(*names)
+
+      slice = HashWithIndifferentAccess.new(@attributes).slice(*names)
+      attributes_from_database.merge!(DeepDupper.dup_attributes(slice, self.class))
     end
 
     # Handle <tt>*_changed?</tt> for +method_missing+.
@@ -220,12 +228,16 @@ module Dynamoid
       previous_changes[name] if attribute_previously_changed?(name)
     end
 
+    # @private
+    def assign_attributes_from_database(attributes_from_database)
+      @attributes_from_database = HashWithIndifferentAccess.new(attributes_from_database)
+    end
+
     private
 
     def changes_include?(name)
-      attributes_changed_by_setter.include?(name)
+      attribute_changed_by_setter?(name) || attribute_changed_in_place?(name)
     end
-    alias attribute_changed_by_setter? changes_include?
 
     # Handle <tt>*_change</tt> for +method_missing+.
     def attribute_change(name)
@@ -259,13 +271,76 @@ module Dynamoid
       previous_changes.include?(name)
     end
 
-    # This is necessary because `changed_attributes` might be overridden in
-    # other implemntations (e.g. in `ActiveRecord`)
-    alias attributes_changed_by_setter changed_attributes
+    def attributes_changed_by_setter
+      @attributes_changed_by_setter ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def attribute_changed_by_setter?(name)
+      attributes_changed_by_setter.include?(name)
+    end
+
+    def attributes_from_database
+      @attributes_from_database ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
 
     # Force an attribute to have a particular "before" value
     def set_attribute_was(name, old_value)
       attributes_changed_by_setter[name] = old_value
     end
+
+    def attributes_changed_in_place
+      attributes_from_database.select do |name, _|
+        attribute_changed_in_place?(name)
+      end
+    end
+
+    def attribute_changed_in_place?(name)
+      return false if attribute_changed_by_setter?(name)
+
+      value_from_database = attributes_from_database[name]
+      return false if value_from_database.nil?
+
+      value = read_attribute(name)
+      value != value_from_database
+    end
+
+    module DeepDupper
+      def self.dup_attributes(attributes, klass)
+        attributes.map do |name, value|
+          type_options = klass.attributes[name.to_sym]
+          value_duplicate = dup_attribute(value, type_options)
+          [name, value_duplicate]
+        end.to_h
+      end
+
+      def self.dup_attribute(value, type_options)
+        type, of = type_options.values_at(:type, :of)
+
+        case value
+        when NilClass, TrueClass, FalseClass, Numeric, Symbol, IO
+          # till Ruby 2.4 these immutable objects could not be duplicated
+          # IO objects cannot be duplicated - is used for binary fields
+          value
+        when String
+          value.dup
+        when Array
+          if of.is_a? Class # custom type
+            value.map { |e| dup_attribute(e, type: of) }
+          else
+            value.deep_dup
+          end
+        when Set
+          Set.new(value.map { |e| dup_attribute(e, type: of) })
+        when Hash
+          value.deep_dup
+        else
+          if type.is_a? Class # custom type
+            Marshal.load(Marshal.dump(value)) # dup instance variables
+          else
+            value.dup # date, datetime
+          end
+        end
+      end
+    end
   end
 end

data/lib/dynamoid/dumping.rb

@@ -70,7 +70,8 @@ module Dynamoid
       end
 
       def invalid_value?(value)
-        (value.is_a?(Set) || value.is_a?(String)) && value.empty?
+        (value.is_a?(Set) && value.empty?) ||
+          (value.is_a?(String) && value.empty? && Config.store_empty_string_as_nil)
       end
     end
 
@@ -86,6 +87,12 @@ module Dynamoid
 
     # string -> string
     class StringDumper < Base
+      def process(string)
+        return nil if string.nil?
+        return nil if string.empty? && Config.store_empty_string_as_nil
+
+        string
+      end
     end
 
     # integer -> number
@@ -101,6 +108,8 @@ module Dynamoid
       ALLOWED_TYPES = %i[string integer number date datetime serialized].freeze
 
       def process(set)
+        return nil if set.is_a?(Set) && set.empty?
+
         if @options.key?(:of)
           process_typed_collection(set)
         else
@@ -112,13 +121,13 @@ module Dynamoid
 
       def process_typed_collection(set)
         if allowed_type?
-          dumper = Dumping.find_dumper(element_options)
-          result = set.map { |el| dumper.process(el) }
-
-          if element_type == :string
-            result.reject!(&:empty?)
+          # StringDumper may replace "" with nil so we cannot distinguish it from an explicit nil
+          if element_type == :string && Config.store_empty_string_as_nil
+            set.reject! { |s| s && s.empty? }
           end
 
+          dumper = Dumping.find_dumper(element_options)
+          result = set.map { |el| dumper.process(el) }
           result.to_set
         else
           raise ArgumentError, "Set element type #{element_type} isn't supported"
@@ -164,14 +173,13 @@ module Dynamoid
 
       def process_typed_collection(array)
         if allowed_type?
-          dumper = Dumping.find_dumper(element_options)
-          result = array.map { |el| dumper.process(el) }
-
-          if element_type == :string
-            result.reject!(&:empty?)
+          # StringDumper may replace "" with nil so we cannot distinguish it from an explicit nil
+          if element_type == :string && Config.store_empty_string_as_nil
+            array.reject! { |s| s && s.empty? }
           end
 
-          result
+          dumper = Dumping.find_dumper(element_options)
+          array.map { |el| dumper.process(el) }
         else
           raise ArgumentError, "Array element type #{element_type} isn't supported"
         end
@@ -289,10 +297,24 @@ module Dynamoid
       end
     end
 
-    # string -> string
+    # string -> StringIO
     class BinaryDumper < Base
       def process(value)
-        Base64.strict_encode64(value)
+        store_as_binary = if @options[:store_as_native_binary].nil?
+                            Dynamoid.config.store_binary_as_native
+                          else
+                            @options[:store_as_native_binary]
+                          end
+
+        if store_as_binary
+          if value.is_a?(StringIO) || value.is_a?(IO)
+            value
+          else
+            StringIO.new(value)
+          end
+        else
+          Base64.strict_encode64(value)
+        end
       end
     end
 

data/lib/dynamoid/errors.rb

@@ -6,6 +6,7 @@ module Dynamoid
     # Generic Dynamoid error
     class Error < StandardError; end
 
+    class MissingHashKey < Error; end
     class MissingRangeKey < Error; end
 
     class MissingIndex < Error; end
@@ -15,18 +16,27 @@ module Dynamoid
     class InvalidIndex < Error
       def initialize(item)
         if item.is_a? String
-          super(item)
+          super
         else
           super("Validation failed: #{item.errors.full_messages.join(', ')}")
         end
       end
     end
 
+    class RecordNotSaved < Error
+      attr_reader :record
+
+      def initialize(record)
+        super('Failed to save the item')
+        @record = record
+      end
+    end
+
     class RecordNotDestroyed < Error
       attr_reader :record
 
       def initialize(record)
-        super('Failed to destroy item')
+        super('Failed to destroy the item')
         @record = record
       end
     end
@@ -79,5 +89,7 @@ module Dynamoid
     class UnknownAttribute < Error; end
 
     class SubclassNotFound < Error; end
+
+    class Rollback < Error; end
   end
 end

data/lib/dynamoid/finders.rb

@@ -78,7 +78,7 @@ 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 = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all is deprecated! Call .find instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all is deprecated! Call .find instead of')
 
         _find_all(ids, options)
       end
@@ -100,7 +100,7 @@ module Dynamoid
       #
       # @since 0.2.0
       def find_by_id(id, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_by_id is deprecated! Call .find instead of', caller[1..-1])
+        Dynamoid.deprecator.warn('[Dynamoid] .find_by_id is deprecated! Call .find instead of')
 
         _find_by_id(id, options)
       end
@@ -180,7 +180,7 @@ module Dynamoid
       # @param range_key [Scalar value] range key of the object to find
       #
       def find_by_composite_key(hash_key, range_key, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_by_composite_key is deprecated! Call .find instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_by_composite_key is deprecated! Call .find instead of')
 
         _find_by_id(hash_key, options.merge(range_key: range_key))
       end
@@ -207,7 +207,7 @@ module Dynamoid
       #
       # @return [Array] an array of all matching items
       def find_all_by_composite_key(hash_key, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all_composite_key is deprecated! Call .where instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all_composite_key is deprecated! Call .where instead of')
 
         Dynamoid.adapter.query(table_name, options.merge(hash_value: hash_key)).flat_map { |i| i }.collect do |item|
           from_database(item)
@@ -237,7 +237,7 @@ module Dynamoid
       # @param options [Hash] conditions on range key e.g. +{ "rank.lte": 10 }, query filter, projected keys, scan_index_forward etc.
       # @return [Array] an array of all matching items
       def find_all_by_secondary_index(hash, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all_by_secondary_index is deprecated! Call .where instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all_by_secondary_index is deprecated! Call .where instead of')
 
         range = options[:range] || {}
         hash_key_field, hash_key_value = hash.first
@@ -291,7 +291,7 @@ module Dynamoid
       def method_missing(method, *args)
         # Cannot use Symbol#start_with? because it was introduced in Ruby 2.7, but we support Ruby >= 2.3
         if method.to_s.start_with?('find')
-          ActiveSupport::Deprecation.warn("[Dynamoid] .#{method} is deprecated! Call .where instead of")
+          Dynamoid.deprecator.warn("[Dynamoid] .#{method} is deprecated! Call .where instead of")
 
           finder = method.to_s.split('_by_').first
           attributes = method.to_s.split('_by_').last.split('_and_')

data/lib/dynamoid/loadable.rb

@@ -11,6 +11,7 @@ module Dynamoid
 
       self
     end
+    alias assign_attributes load
 
     # Reload an object from the database -- if you suspect the object has changed in the data store and you need those
     # changes to be reflected immediately, you would call this method. This is a consistent read.

data/lib/dynamoid/persistence/inc.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_casting_and_dumping'
+
 module Dynamoid
   module Persistence
     # @private
@@ -21,15 +23,17 @@ module Dynamoid
         touch = @counters.delete(:touch)
 
         Dynamoid.adapter.update_item(@model_class.table_name, @hash_key, update_item_options) do |t|
+          item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
+
           @counters.each do |name, value|
-            t.add(name => cast_and_dump_attribute_value(name, value))
+            item_updater.add(name => value)
           end
 
           if touch
             value = DateTime.now.in_time_zone(Time.zone)
 
             timestamp_attributes_to_touch(touch).each do |name|
-              t.set(name => cast_and_dump_attribute_value(name, value))
+              item_updater.set(name => value)
             end
           end
         end
@@ -48,11 +52,6 @@ module Dynamoid
         end
       end
 
-      def cast_and_dump_attribute_value(name, value)
-        value_casted = TypeCasting.cast_field(value, @model_class.attributes[name])
-        Dumping.dump_field(value_casted, @model_class.attributes[name])
-      end
-
       def timestamp_attributes_to_touch(touch)
         return [] unless touch
 

data/lib/dynamoid/persistence/item_updater_with_casting_and_dumping.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Persistence
+    # @private
+    class ItemUpdaterWithCastingAndDumping
+      def initialize(model_class, item_updater)
+        @model_class = model_class
+        @item_updater = item_updater
+      end
+
+      def add(attributes)
+        @item_updater.add(cast_and_dump(attributes))
+      end
+
+      def set(attributes)
+        @item_updater.set(cast_and_dump(attributes))
+      end
+
+      private
+
+      def cast_and_dump(attributes)
+        casted_and_dumped = {}
+
+        attributes.each do |name, value|
+          value_casted = TypeCasting.cast_field(value, @model_class.attributes[name])
+          value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[name])
+
+          casted_and_dumped[name] = value_dumped
+        end
+
+        casted_and_dumped
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence/item_updater_with_dumping.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Persistence
+    # @private
+    class ItemUpdaterWithDumping
+      def initialize(model_class, item_updater)
+        @model_class = model_class
+        @item_updater = item_updater
+      end
+
+      def add(attributes)
+        @item_updater.add(dump(attributes))
+      end
+
+      def set(attributes)
+        @item_updater.set(dump(attributes))
+      end
+
+      private
+
+      def dump(attributes)
+        dumped = {}
+
+        attributes.each do |name, value|
+          dumped[name] = Dumping.dump_field(value, @model_class.attributes[name])
+        end
+
+        dumped
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence/save.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_dumping'
+
 module Dynamoid
   module Persistence
     # @private
@@ -36,9 +38,10 @@ module Dynamoid
           attributes_to_persist = @model.attributes.slice(*@model.changed.map(&:to_sym))
 
           Dynamoid.adapter.update_item(@model.class.table_name, @model.hash_key, options_to_update_item) do |t|
+            item_updater = ItemUpdaterWithDumping.new(@model.class, t)
+
             attributes_to_persist.each do |name, value|
-              value_dumped = Dumping.dump_field(value, @model.class.attributes[name])
-              t.set(name => value_dumped)
+              item_updater.set(name => value)
             end
           end
         end

data/lib/dynamoid/persistence/update_fields.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_casting_and_dumping'
+
 module Dynamoid
   module Persistence
     # @private
@@ -32,10 +34,10 @@ module Dynamoid
 
       def update_item
         Dynamoid.adapter.update_item(@model_class.table_name, @partition_key, options_to_update_item) do |t|
+          item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
+
           @attributes.each do |k, v|
-            value_casted = TypeCasting.cast_field(v, @model_class.attributes[k])
-            value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[k])
-            t.set(k => value_dumped)
+            item_updater.set(k => v)
           end
         end
       end