dynamoid 3.7.1 → 3.9.0

data/lib/dynamoid/adapter_plugin/aws_sdk_v3.rb

@@ -2,6 +2,7 @@
 
 require_relative 'aws_sdk_v3/query'
 require_relative 'aws_sdk_v3/scan'
+require_relative 'aws_sdk_v3/execute_statement'
 require_relative 'aws_sdk_v3/create_table'
 require_relative 'aws_sdk_v3/batch_get_item'
 require_relative 'aws_sdk_v3/item_updater'
@@ -163,30 +164,28 @@ module Dynamoid
       def batch_write_item(table_name, objects, options = {})
         items = objects.map { |o| sanitize_item(o) }
 
-        begin
-          while items.present?
-            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 => requests
-                },
-                return_consumed_capacity: 'TOTAL',
-                return_item_collection_metrics: 'SIZE'
-              }.merge!(options)
-            )
+        while items.present?
+          batch = items.shift(BATCH_WRITE_ITEM_REQUESTS_LIMIT)
+          requests = batch.map { |item| { put_request: { item: item } } }
 
-            yield(response.unprocessed_items.present?) if block_given?
+          response = client.batch_write_item(
+            {
+              request_items: {
+                table_name => requests
+              },
+              return_consumed_capacity: 'TOTAL',
+              return_item_collection_metrics: 'SIZE'
+            }.merge!(options)
+          )
 
-            if response.unprocessed_items.present?
-              items += response.unprocessed_items[table_name].map { |r| r.put_request.item }
-            end
+          yield(response.unprocessed_items.present?) if block_given?
+
+          if response.unprocessed_items.present?
+            items += response.unprocessed_items[table_name].map { |r| r.put_request.item }
           end
-        rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
-          raise Dynamoid::Errors::ConditionalCheckFailedException, e
         end
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
+        raise Dynamoid::Errors::ConditionalCheckFailedException, e
       end
 
       # Get many items at once from DynamoDB. More efficient than getting each item individually.
@@ -258,17 +257,15 @@ module Dynamoid
           end
         end
 
-        begin
-          requests.map do |request_items|
-            client.batch_write_item(
-              request_items: request_items,
-              return_consumed_capacity: 'TOTAL',
-              return_item_collection_metrics: 'SIZE'
-            )
-          end
-        rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
-          raise Dynamoid::Errors::ConditionalCheckFailedException, e
+        requests.each do |items|
+          client.batch_write_item(
+            request_items: items,
+            return_consumed_capacity: 'TOTAL',
+            return_item_collection_metrics: 'SIZE'
+          )
         end
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
+        raise Dynamoid::Errors::ConditionalCheckFailedException, e
       end
 
       # Create a table on DynamoDB. This usually takes a long time to complete.
@@ -397,7 +394,7 @@ module Dynamoid
         item = client.get_item(table_name: table_name,
                                key: key_stanza(table, key, range_key),
                                consistent_read: consistent_read)[:item]
-        item ? result_item_to_hash(item) : nil
+        item ? item_to_hash(item) : nil
       end
 
       # Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values
@@ -416,20 +413,19 @@ module Dynamoid
         conditions = options.delete(:conditions)
         table = describe_table(table_name)
 
-        yield(iu = ItemUpdater.new(table, key, range_key))
+        item_updater = ItemUpdater.new(table, key, range_key)
+        yield(item_updater)
 
         raise "non-empty options: #{options}" unless options.empty?
 
-        begin
-          result = client.update_item(table_name: table_name,
-                                      key: key_stanza(table, key, range_key),
-                                      attribute_updates: iu.to_h,
-                                      expected: expected_stanza(conditions),
-                                      return_values: 'ALL_NEW')
-          result_item_to_hash(result[:attributes])
-        rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
-          raise Dynamoid::Errors::ConditionalCheckFailedException, e
-        end
+        result = client.update_item(table_name: table_name,
+                                    key: key_stanza(table, key, range_key),
+                                    attribute_updates: item_updater.attribute_updates,
+                                    expected: expected_stanza(conditions),
+                                    return_values: 'ALL_NEW')
+        item_to_hash(result[:attributes])
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
+        raise Dynamoid::Errors::ConditionalCheckFailedException, e
       end
 
       # List all tables on DynamoDB.
@@ -459,17 +455,15 @@ module Dynamoid
         options ||= {}
         item = sanitize_item(object)
 
-        begin
-          client.put_item(
-            {
-              table_name: table_name,
-              item: item,
-              expected: expected_stanza(options)
-            }.merge!(options)
-          )
-        rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
-          raise Dynamoid::Errors::ConditionalCheckFailedException, e
-        end
+        client.put_item(
+          {
+            table_name: table_name,
+            item: item,
+            expected: expected_stanza(options)
+          }.merge!(options)
+        )
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
+        raise Dynamoid::Errors::ConditionalCheckFailedException, e
       end
 
       # Query the DynamoDB table. This employs DynamoDB's indexes so is generally faster than scanning, but is
@@ -496,7 +490,7 @@ module Dynamoid
 
           Query.new(client, table, options).call.each do |page|
             yielder.yield(
-              page.items.map { |row| result_item_to_hash(row) },
+              page.items.map { |item| item_to_hash(item) },
               last_evaluated_key: page.last_evaluated_key
             )
           end
@@ -529,7 +523,7 @@ module Dynamoid
 
           Scan.new(client, table, conditions, options).call.each do |page|
             yielder.yield(
-              page.items.map { |row| result_item_to_hash(row) },
+              page.items.map { |item| item_to_hash(item) },
               last_evaluated_key: page.last_evaluated_key
             )
           end
@@ -567,6 +561,28 @@ module Dynamoid
         describe_table(table_name, true).item_count
       end
 
+      # Run PartiQL query.
+      #
+      #   Dynamoid.adapter.execute("SELECT * FROM users WHERE id = ?", ["758"])
+      #
+      # @param [String] statement PartiQL statement
+      # @param [Array] parameters a list of bind parameters
+      # @param [Hash] options
+      # @option [Boolean] consistent_read
+      # @return [[] | Array[Hash] | Enumerator::Lazy[Hash]] items when used a SELECT statement and empty Array otherwise
+      #
+      def execute(statement, parameters = [], options = {})
+        items = ExecuteStatement.new(client, statement, parameters, options).call
+
+        if items.is_a?(Array)
+          items
+        else
+          items.lazy.flat_map { |array| array }
+        end
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
+        []
+      end
+
       protected
 
       #
@@ -612,10 +628,8 @@ module Dynamoid
       #
       # Converts a hash returned by get_item, scan, etc. into a key-value hash
       #
-      def result_item_to_hash(item)
-        {}.tap do |r|
-          item.each { |k, v| r[k.to_sym] = v }
-        end
+      def item_to_hash(hash)
+        hash.symbolize_keys
       end
 
       def sanitize_item(attributes)

data/lib/dynamoid/associations/single_association.rb

@@ -64,18 +64,37 @@ module Dynamoid
         target == other
       end
 
-      # Delegate methods we don't find directly to the target.
-      #
-      # @private
-      # @since 0.2.0
-      def method_missing(method, *args)
-        if target.respond_to?(method)
-          target.send(method, *args)
-        else
-          super
+      if ::RUBY_VERSION < '2.7'
+        # Delegate methods we don't find directly to the target.
+        #
+        # @private
+        # @since 0.2.0
+        def method_missing(method, *args, &block)
+          if target.respond_to?(method)
+            target.send(method, *args, &block)
+          else
+            super
+          end
+        end
+      else
+        # Delegate methods we don't find directly to the target.
+        #
+        # @private
+        # @since 0.2.0
+        def method_missing(method, *args, **kwargs, &block)
+          if target.respond_to?(method)
+            target.send(method, *args, **kwargs, &block)
+          else
+            super
+          end
         end
       end
 
+      # @private
+      def respond_to_missing?(method_name, include_private = false)
+        target.respond_to?(method_name, include_private) || super
+      end
+
       # @private
       def nil?
         target.nil?

data/lib/dynamoid/components.rb

@@ -11,10 +11,9 @@ module Dynamoid
       extend ActiveModel::Translation
       extend ActiveModel::Callbacks
 
-      define_model_callbacks :create, :save, :destroy, :initialize, :update
+      define_model_callbacks :create, :save, :destroy, :update
+      define_model_callbacks :initialize, :find, :touch, only: :after
 
-      before_create :set_created_at
-      before_save :set_updated_at
       before_save :set_expires_field
       after_initialize :set_inheritance_field
     end

data/lib/dynamoid/criteria/chain.rb

@@ -187,10 +187,10 @@ module Dynamoid
       def first(*args)
         n = args.first || 1
 
-        return scan_limit(n).to_a.first(*args) if @query.blank?
+        return dup.scan_limit(n).to_a.first(*args) if @query.blank?
         return super if @key_fields_detector.non_key_present?
 
-        record_limit(n).to_a.first(*args)
+        dup.record_limit(n).to_a.first(*args)
       end
 
       # Returns the last item matching the criteria.
@@ -486,15 +486,17 @@ module Dynamoid
       # @return [Array]
       def pluck(*args)
         fields = args.map(&:to_sym)
-        @project = fields
+
+        scope = dup
+        scope.project(*fields)
 
         if fields.many?
-          items.map do |item|
+          scope.items.map do |item|
             fields.map { |key| Undumping.undump_field(item[key], source.attributes[key]) }
           end.to_a
         else
           key = fields.first
-          items.map { |item| Undumping.undump_field(item[key], source.attributes[key]) }.to_a
+          scope.items.map { |item| Undumping.undump_field(item[key], source.attributes[key]) }.to_a
         end
       end
 
@@ -513,6 +515,7 @@ module Dynamoid
       def items
         raw_pages.lazy.flat_map { |items, _| items }
       end
+      protected :items
 
       # Arrays of records, sized based on the actual pages produced by DynamoDB
       #
@@ -522,6 +525,7 @@ module Dynamoid
       def pages
         raw_pages.lazy.map do |items, options|
           models = items.map { |i| source.from_database(i) }
+          models.each { |m| m.run_callbacks :find }
           [models, options]
         end.each
       end
@@ -568,7 +572,7 @@ module Dynamoid
 
       def issue_scan_warning
         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 index declaration to #{source.to_s.downcase}.rb:"
+        Dynamoid.logger.warn "You can index this query by adding index declaration to #{source.to_s.underscore}.rb:"
         Dynamoid.logger.warn "* global_secondary_index hash_key: 'some-name', range_key: 'some-another-name'"
         Dynamoid.logger.warn "* local_secondary_index range_key: 'some-name'"
         Dynamoid.logger.warn "Not indexed attributes: #{query.keys.sort.collect { |name| ":#{name}" }.join(', ')}"
@@ -784,9 +788,9 @@ module Dynamoid
         condition = {}
         type = @source.inheritance_field
 
-        if @source.attributes.key?(type)
-          class_names = @source.deep_subclasses.map(&:name) << @source.name
-          condition[:"#{type}.in"] = class_names
+        if @source.attributes.key?(type) && !@source.abstract_class?
+          sti_names = @source.deep_subclasses.map(&:sti_name) << @source.sti_name
+          condition[:"#{type}.in"] = sti_names
         end
 
         condition

data/lib/dynamoid/criteria.rb

@@ -9,12 +9,15 @@ module Dynamoid
 
     # @private
     module ClassMethods
-      %i[where consistent all first last delete_all destroy_all each record_limit scan_limit batch start scan_index_forward find_by_pages project pluck].each do |meth|
+      %i[
+        where consistent all first last delete_all destroy_all each record_limit
+        scan_limit batch start scan_index_forward find_by_pages project pluck
+      ].each do |name|
         # Return a criteria chain in response to a method that will begin or end a chain. For more information,
         # see Dynamoid::Criteria::Chain.
         #
         # @since 0.2.0
-        define_method(meth) do |*args, &blk|
+        define_method(name) do |*args, &blk|
           # Don't use keywork arguments delegating (with **kw). It works in
           # different way in different Ruby versions: <= 2.6, 2.7, 3.0 and in some
           # future 3.x versions. Providing that there are no downstream methods
@@ -23,11 +26,7 @@ module Dynamoid
           # https://eregon.me/blog/2019/11/10/the-delegation-challenge-of-ruby27.html
 
           chain = Dynamoid::Criteria::Chain.new(self)
-          if args
-            chain.send(meth, *args, &blk)
-          else
-            chain.send(meth, &blk)
-          end
+          chain.send(name, *args, &blk)
         end
       end
     end

data/lib/dynamoid/dirty.rb

@@ -25,32 +25,27 @@ module Dynamoid
     # @private
     module ClassMethods
       def update_fields(*)
-        if model = super
-          model.send(:clear_changes_information)
+        super.tap do |model|
+          model.clear_changes_information if model
         end
-        model
       end
 
       def upsert(*)
-        if model = super
-          model.send(:clear_changes_information)
+        super.tap do |model|
+          model.clear_changes_information if model
         end
-        model
       end
 
       def from_database(*)
-        super.tap do |m|
-          m.send(:clear_changes_information)
-        end
+        super.tap(&:clear_changes_information)
       end
     end
 
     # @private
     def save(*)
-      if status = super
-        changes_applied
+      super.tap do |status|
+        changes_applied if status
       end
-      status
     end
 
     # @private
@@ -113,7 +108,7 @@ module Dynamoid
     #
     # @return [ActiveSupport::HashWithIndifferentAccess]
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      ActiveSupport::HashWithIndifferentAccess[changed.map { |name| [name, attribute_change(name)] }]
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -140,6 +135,25 @@ module Dynamoid
       @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
     end
 
+    # Clear all dirty data: current changes and previous changes.
+    def clear_changes_information
+      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # Clears dirty data and moves +changes+ to +previous_changes+.
+    def changes_applied
+      @previously_changed = changes
+      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # Remove changes information for the provided attributes.
+    #
+    # @param attributes [Array[String]] - a list of attributes to clear changes for
+    def clear_attribute_changes(names)
+      attributes_changed_by_setter.except!(*names)
+    end
+
     # Handle <tt>*_changed?</tt> for +method_missing+.
     #
     #  person.attribute_changed?(:name) # => true
@@ -148,14 +162,14 @@ module Dynamoid
     #  person.attribute_changed?(:name, from: 'Alice', to: 'Bod')
     #
     # @private
-    # @param attr [Symbol] attribute name
+    # @param name [Symbol] attribute name
     # @param options [Hash] conditions on +from+ and +to+ value (optional)
     # @option options [Symbol] :from previous attribute value
     # @option options [Symbol] :to current attribute value
-    def attribute_changed?(attr, options = {})
-      result = changes_include?(attr)
-      result &&= options[:to] == __send__(attr) if options.key?(:to)
-      result &&= options[:from] == changed_attributes[attr] if options.key?(:from)
+    def attribute_changed?(name, options = {})
+      result = changes_include?(name)
+      result &&= options[:to] == read_attribute(name) if options.key?(:to)
+      result &&= options[:from] == changed_attributes[name] if options.key?(:from)
       result
     end
 
@@ -166,16 +180,16 @@ module Dynamoid
     #  person.attribute_was(:name) # => "Alice"
     #
     # @private
-    # @param attr [Symbol] attribute name
-    def attribute_was(attr)
-      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+    # @param name [Symbol] attribute name
+    def attribute_was(name)
+      attribute_changed?(name) ? changed_attributes[name] : read_attribute(name)
     end
 
     # Restore all previous data of the provided attributes.
     #
     # @param attributes [Array[Symbol]] a list of attribute names
-    def restore_attributes(attributes = changed)
-      attributes.each { |attr| restore_attribute! attr }
+    def restore_attributes(names = changed)
+      names.each { |name| restore_attribute! name }
     end
 
     # Handles <tt>*_previously_changed?</tt> for +method_missing+.
@@ -186,10 +200,10 @@ module Dynamoid
     #  person.attribute_changed?(:name) # => true
     #
     # @private
-    # @param attr [Symbol] attribute name
+    # @param name [Symbol] attribute name
     # @return [true|false]
-    def attribute_previously_changed?(attr)
-      previous_changes_include?(attr)
+    def attribute_previously_changed?(name)
+      previous_changes_include?(name)
     end
 
     # Handles <tt>*_previous_change</tt> for +method_missing+.
@@ -200,61 +214,49 @@ module Dynamoid
     #  person.attribute_previously_changed(:name) # => ["Alice", "Bob"]
     #
     # @private
-    # @param attr [Symbol]
+    # @param name [Symbol]
     # @return [Array]
-    def attribute_previous_change(attr)
-      previous_changes[attr] if attribute_previously_changed?(attr)
+    def attribute_previous_change(name)
+      previous_changes[name] if attribute_previously_changed?(name)
     end
 
     private
 
-    def changes_include?(attr_name)
-      attributes_changed_by_setter.include?(attr_name)
+    def changes_include?(name)
+      attributes_changed_by_setter.include?(name)
     end
     alias attribute_changed_by_setter? changes_include?
 
-    # Removes current changes and makes them accessible through +previous_changes+.
-    def changes_applied # :doc:
-      @previously_changed = changes
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-    end
-
-    # Clear all dirty data: current changes and previous changes.
-    def clear_changes_information # :doc:
-      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-    end
-
     # Handle <tt>*_change</tt> for +method_missing+.
-    def attribute_change(attr)
-      [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+    def attribute_change(name)
+      [changed_attributes[name], read_attribute(name)] if attribute_changed?(name)
     end
 
     # Handle <tt>*_will_change!</tt> for +method_missing+.
-    def attribute_will_change!(attr)
-      return if attribute_changed?(attr)
+    def attribute_will_change!(name)
+      return if attribute_changed?(name)
 
       begin
-        value = __send__(attr)
+        value = read_attribute(name)
         value = value.duplicable? ? value.clone : value
       rescue TypeError, NoMethodError
       end
 
-      set_attribute_was(attr, value)
+      set_attribute_was(name, value)
     end
 
     # Handle <tt>restore_*!</tt> for +method_missing+.
-    def restore_attribute!(attr)
-      if attribute_changed?(attr)
-        __send__("#{attr}=", changed_attributes[attr])
-        clear_attribute_changes([attr])
+    def restore_attribute!(name)
+      if attribute_changed?(name)
+        write_attribute(name, changed_attributes[name])
+        clear_attribute_changes([name])
       end
     end
 
-    # Returns +true+ if attr_name were changed before the model was saved,
+    # Returns +true+ if name were changed before the model was saved,
     # +false+ otherwise.
-    def previous_changes_include?(attr_name)
-      previous_changes.include?(attr_name)
+    def previous_changes_include?(name)
+      previous_changes.include?(name)
     end
 
     # This is necessary because `changed_attributes` might be overridden in
@@ -262,13 +264,8 @@ module Dynamoid
     alias attributes_changed_by_setter changed_attributes
 
     # Force an attribute to have a particular "before" value
-    def set_attribute_was(attr, old_value)
-      attributes_changed_by_setter[attr] = old_value
-    end
-
-    # Remove changes information for the provided attributes.
-    def clear_attribute_changes(attributes)
-      attributes_changed_by_setter.except!(*attributes)
+    def set_attribute_was(name, old_value)
+      attributes_changed_by_setter[name] = old_value
     end
   end
 end