dynamoid 3.8.0 → 3.12.1

data/lib/dynamoid/persistence.rb

@@ -8,7 +8,9 @@ require 'dynamoid/persistence/import'
 require 'dynamoid/persistence/update_fields'
 require 'dynamoid/persistence/upsert'
 require 'dynamoid/persistence/save'
+require 'dynamoid/persistence/inc'
 require 'dynamoid/persistence/update_validations'
+require 'dynamoid/persistence/item_updater_with_dumping'
 
 # encoding: utf-8
 module Dynamoid
@@ -17,8 +19,9 @@ module Dynamoid
   module Persistence
     extend ActiveSupport::Concern
 
-    attr_accessor :new_record
+    attr_accessor :new_record, :destroyed
     alias new_record? new_record
+    alias destroyed? destroyed
 
     # @private
     UNIX_EPOCH_DATE = Date.new(1970, 1, 1).freeze
@@ -165,7 +168,7 @@ module Dynamoid
 
       # Create a model.
       #
-      # Initializes a new model and immediately saves it to DynamoDB.
+      # Initializes a new model and immediately saves it into DynamoDB.
       #
       #   User.create(first_name: 'Mark', last_name: 'Tyler')
       #
@@ -173,7 +176,8 @@ module Dynamoid
       #
       #   User.create([{ first_name: 'Alice' }, { first_name: 'Bob' }])
       #
-      # Creates a model and pass it into a block to set other attributes.
+      # Instantiates a model and pass it into an optional block to set other
+      # attributes.
       #
       #   User.create(first_name: 'Mark') do |u|
       #     u.age = 21
@@ -181,7 +185,10 @@ module Dynamoid
       #
       # Validates model and runs callbacks.
       #
-      # @param attrs [Hash|Array[Hash]] Attributes of the models
+      # Raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is required
+      # but not specified or has value +nil+.
+      #
+      # @param attrs [Hash|Array<Hash>] Attributes of a model
       # @param block [Proc] Block to process a document after initialization
       # @return [Dynamoid::Document] The created document
       # @since 0.2.0
@@ -195,12 +202,31 @@ module Dynamoid
 
       # Create a model.
       #
-      # Initializes a new object and immediately saves it to the Dynamoid.
+      # Initializes a new object and immediately saves it into DynamoDB.
+      #
+      #   User.create!(first_name: 'Mark', last_name: 'Tyler')
+      #
       # Raises an exception +Dynamoid::Errors::DocumentNotValid+ if validation
-      # failed. Accepts both Hash and Array of Hashes and can create several
+      # failed.
+      #
+      # Accepts both Hash and Array of Hashes and can create several
       # models.
       #
-      # @param attrs [Hash|Array[Hash]] Attributes with which to create the object.
+      #   User.create!([{ first_name: 'Alice' }, { first_name: 'Bob' }])
+      #
+      # Instantiates a model and pass it into an optional block to set other
+      # attributes.
+      #
+      #   User.create!(first_name: 'Mark') do |u|
+      #     u.age = 21
+      #   end
+      #
+      # Validates model and runs callbacks.
+      #
+      # Raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is required
+      # but not specified or has value +nil+.
+      #
+      # @param attrs [Hash|Array<Hash>] Attributes with which to create the object.
       # @param block [Proc] Block to process a document after initialization
       # @return [Dynamoid::Document] The created document
       # @since 0.2.0
@@ -270,7 +296,7 @@ module Dynamoid
       # meets the specified conditions. Conditions can be specified as a +Hash+
       # with +:if+ key:
       #
-      #   User.update_fields('1', { age: 26 }, if: { version: 1 })
+      #   User.update_fields('1', { age: 26 }, { if: { version: 1 } })
       #
       # Here +User+ model has an integer +version+ field and the document will
       # be updated only if the +version+ attribute currently has value 1.
@@ -278,16 +304,29 @@ module Dynamoid
       # If a document with specified hash and range keys doesn't exist or
       # conditions were specified and failed the method call returns +nil+.
       #
+      # To check if some attribute (or attributes) isn't stored in a DynamoDB
+      # item (e.g. it wasn't set explicitly) there is another condition -
+      # +unless_exists+:
+      #
+      #   user = User.create(name: 'Tylor')
+      #   User.update_fields(user.id, { age: 18 }, { unless_exists: [:age] })
+      #
       # +update_fields+ uses the +UpdateItem+ operation so it saves changes and
       # loads an updated document back with one HTTP request.
       #
       # Raises a +Dynamoid::Errors::UnknownAttribute+ exception if any of the
       # attributes is not on the model
       #
+      # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+      # +nil+ and +Dynamoid::Errors::MissingRangeKey+ if a sort key is required
+      # but has value +nil+.
+      #
       # @param hash_key_value [Scalar value] hash key
       # @param range_key_value [Scalar value] range key (optional)
       # @param attrs [Hash]
       # @param conditions [Hash] (optional)
+      # @option conditions [Hash] :if conditions on attribute values
+      # @option conditions [Hash] :unless_exists conditions on attributes presence
       # @return [Dynamoid::Document|nil] Updated document
       def update_fields(hash_key_value, range_key_value = nil, attrs = {}, conditions = {})
         optional_params = [range_key_value, attrs, conditions].compact
@@ -322,23 +361,36 @@ module Dynamoid
       # meets the specified conditions. Conditions can be specified as a +Hash+
       # with +:if+ key:
       #
-      #   User.upsert('1', { age: 26 }, if: { version: 1 })
+      #   User.upsert('1', { age: 26 }, { if: { version: 1 } })
       #
       # Here +User+ model has an integer +version+ field and the document will
       # be updated only if the +version+ attribute currently has value 1.
       #
+      # To check if some attribute (or attributes) isn't stored in a DynamoDB
+      # item (e.g. it wasn't set explicitly) there is another condition -
+      # +unless_exists+:
+      #
+      #   user = User.create(name: 'Tylor')
+      #   User.upsert(user.id, { age: 18 }, { unless_exists: [:age] })
+      #
       # If conditions were specified and failed the method call returns +nil+.
       #
       # +upsert+ uses the +UpdateItem+ operation so it saves changes and loads
       # an updated document back with one HTTP request.
       #
       # Raises a +Dynamoid::Errors::UnknownAttribute+ exception if any of the
-      # attributes is not on the model
+      # attributes is not declared in the model class.
+      #
+      # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+      # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+      # required but has value +nil+.
       #
       # @param hash_key_value [Scalar value] hash key
       # @param range_key_value [Scalar value] range key (optional)
       # @param attrs [Hash]
       # @param conditions [Hash] (optional)
+      # @option conditions [Hash] :if conditions on attribute values
+      # @option conditions [Hash] :unless_exists conditions on attributes presence
       # @return [Dynamoid::Document|nil] Updated document
       def upsert(hash_key_value, range_key_value = nil, attrs = {}, conditions = {})
         optional_params = [range_key_value, attrs, conditions].compact
@@ -378,28 +430,22 @@ module Dynamoid
       # Doesn't run validations and callbacks. Doesn't update +created_at+ and
       # +updated_at+ as well.
       #
+      # When `:touch` option is passed the timestamp columns are updating. If
+      # attribute names are passed, they are updated along with updated_at
+      # attribute:
+      #
+      #   User.inc('1', age: 2, touch: true)
+      #   User.inc('1', age: 2, touch: :viewed_at)
+      #   User.inc('1', age: 2, touch: [:viewed_at, :accessed_at])
+      #
       # @param hash_key_value [Scalar value] hash key
       # @param range_key_value [Scalar value] range key (optional)
       # @param counters [Hash] value to increase by
+      # @option counters [true | Symbol | Array<Symbol>] :touch to update update_at attribute and optionally the specified ones
       # @return [Model class] self
       def inc(hash_key_value, range_key_value = nil, counters)
-        options = if range_key
-                    value_casted = TypeCasting.cast_field(range_key_value, attributes[range_key])
-                    value_dumped = Dumping.dump_field(value_casted, attributes[range_key])
-                    { range_key: value_dumped }
-                  else
-                    {}
-                  end
-
-        Dynamoid.adapter.update_item(table_name, hash_key_value, options) do |t|
-          counters.each do |k, v|
-            value_casted = TypeCasting.cast_field(v, attributes[k])
-            value_dumped = Dumping.dump_field(value_casted, attributes[k])
-
-            t.add(k => value_dumped)
-          end
-        end
-
+        # It's similar to Rails' #update_counters.
+        Inc.call(self, hash_key_value, range_key_value, counters)
         self
       end
     end
@@ -410,17 +456,43 @@ module Dynamoid
     #
     #   post.touch
     #
-    # Can update another field in addition with the same timestamp if it's name passed as argument.
+    # Can update other fields in addition with the same timestamp if their
+    # names passed as arguments.
     #
-    #   user.touch(:last_login_at)
+    #   user.touch(:last_login_at, :viewed_at)
     #
-    # @param name [Symbol] attribute name to update (optional)
+    # Some specific value can be used to save:
+    #
+    #   user.touch(time: 1.hour.ago)
+    #
+    # No validation is performed and only +after_touch+ callback is called.
+    #
+    # The method must be used on a persisted object, otherwise
+    # +Dynamoid::Errors::Error+ will be thrown.
+    #
+    # @param names [*Symbol] a list of attribute names to update (optional)
+    # @param time [Time] datetime value that can be used instead of the current time (optional)
     # @return [Dynamoid::Document] self
-    def touch(name = nil)
-      now = DateTime.now
-      self.updated_at = now
-      attributes[name] = now if name
-      save
+    def touch(*names, time: nil)
+      if new_record?
+        raise Dynamoid::Errors::Error, 'cannot touch on a new or destroyed record object'
+      end
+
+      time_to_assign = time || DateTime.now
+
+      self.updated_at = time_to_assign
+      names.each do |name|
+        attributes[name] = time_to_assign
+      end
+
+      attribute_names = names.map(&:to_sym) + [:updated_at]
+      attributes_with_values = attributes.slice(*attribute_names)
+
+      run_callbacks :touch do
+        self.class.update_fields(hash_key, range_value, attributes_with_values)
+        clear_attribute_changes(attribute_names.map(&:to_s))
+      end
+
       self
     end
 
@@ -456,7 +528,7 @@ module Dynamoid
     #
     # +save+ by default sets timestamps attributes - +created_at+ and
     # +updated_at+ when creates new model and updates +updated_at+ attribute
-    # when update already existing one.
+    # when updates already existing one.
     #
     # Changing +updated_at+ attribute at updating a model can be skipped with
     # +touch: false+ option:
@@ -466,7 +538,8 @@ module Dynamoid
     # If a model is new and hash key (+id+ by default) is not assigned yet
     # it was assigned implicitly with random UUID value.
     #
-    # If +lock_version+ attribute is declared it will be incremented. If it's blank then it will be initialized with 1.
+    # If +lock_version+ attribute is declared it will be incremented. If it's
+    # blank then it will be initialized with 1.
     #
     # +save+ method call raises +Dynamoid::Errors::RecordNotUnique+ exception
     # if primary key (hash key + optional range key) already exists in a
@@ -477,6 +550,11 @@ module Dynamoid
     # already changed concurrently and +lock_version+ was consequently
     # increased.
     #
+    # Raises +Dynamoid::Errors::MissingHashKey+ if a model is already persisted
+    # and a partition key has value +nil+ and raises
+    # +Dynamoid::Errors::MissingRangeKey+ if a sort key is required but has
+    # value +nil+.
+    #
     # When a table is not created yet the first +save+ method call will create
     # a table. It's useful in test environment to avoid explicit table
     # creation.
@@ -487,21 +565,102 @@ module Dynamoid
     # @return [true|false] Whether saving successful or not
     # @since 0.2.0
     def save(options = {})
-      self.class.create_table(sync: true)
+      if Dynamoid.config.create_table_on_save
+        self.class.create_table(sync: true)
+      end
 
-      @_touch_record = options[:touch]
+      create_or_update = new_record? ? :create : :update
+
+      run_callbacks(:save) do
+        run_callbacks(create_or_update) do
+          Save.call(self, touch: options[:touch])
+        end
+      end
+    end
+
+    # Create new model or persist changes.
+    #
+    # Run the validation and callbacks. Raises
+    # +Dynamoid::Errors::DocumentNotValid+ is validation fails.
+    #
+    #   user = User.create
+    #
+    #   user.age = 26
+    #   user.save! # => user
+    #
+    # Validation can be skipped with +validate: false+ option:
+    #
+    #   user = User.new(age: -1)
+    #   user.save!(validate: false) # => user
+    #
+    # +save!+ by default sets timestamps attributes - +created_at+ and
+    # +updated_at+ when creates new model and updates +updated_at+ attribute
+    # when updates already existing one.
+    #
+    # Changing +updated_at+ attribute at updating a model can be skipped with
+    # +touch: false+ option:
+    #
+    #   user.save!(touch: false)
+    #
+    # If a model is new and hash key (+id+ by default) is not assigned yet
+    # it was assigned implicitly with random UUID value.
+    #
+    # If +lock_version+ attribute is declared it will be incremented. If it's
+    # blank then it will be initialized with 1.
+    #
+    # +save!+ method call raises +Dynamoid::Errors::RecordNotUnique+ exception
+    # if primary key (hash key + optional range key) already exists in a
+    # table.
+    #
+    # +save!+ method call raises +Dynamoid::Errors::StaleObjectError+ exception
+    # if there is +lock_version+ attribute and the document in a table was
+    # already changed concurrently and +lock_version+ was consequently
+    # increased.
+    #
+    # +save!+ method call raises +Dynamoid::Errors::RecordNotSaved+ exception
+    # if some callback aborted execution.
+    #
+    # Raises +Dynamoid::Errors::MissingHashKey+ if a model is already persisted
+    # and a partition key has value +nil+ and raises
+    # +Dynamoid::Errors::MissingRangeKey+ if a sort key is required but has
+    # value +nil+.
+    #
+    # When a table is not created yet the first +save!+ method call will create
+    # a table. It's useful in test environment to avoid explicit table
+    # creation.
+    #
+    # @param options [Hash] (optional)
+    # @option options [true|false] :validate validate a model or not - +true+ by default (optional)
+    # @option options [true|false] :touch update tiemstamps fields or not - +true+ by default (optional)
+    # @return [true|false] Whether saving successful or not
+    def save!(options = {})
+      # validation is handled in the Validation module
+
+      if Dynamoid.config.create_table_on_save
+        self.class.create_table(sync: true)
+      end
 
       create_or_update = new_record? ? :create : :update
+      aborted = true
 
-      run_callbacks(create_or_update) do
-        run_callbacks(:save) do
-          Save.call(self)
+      run_callbacks(:save) do
+        run_callbacks(create_or_update) do
+          aborted = false
+          Save.call(self, touch: options[:touch])
         end
       end
+
+      if aborted
+        raise Dynamoid::Errors::RecordNotSaved, self
+      end
+
+      self
     end
 
     # Update multiple attributes at once, saving the object once the updates
-    # are complete. Returns +true+ if saving is successful and +false+
+    # are complete.
+    #
+    # Returns +true+ if saving is successful and +false+
     # otherwise.
     #
     #   user.update_attributes(age: 27, last_name: 'Tylor')
@@ -509,6 +668,10 @@ module Dynamoid
     # Raises a +Dynamoid::Errors::UnknownAttribute+ exception if any of the
     # attributes is not on the model
     #
+    # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+    # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+    # required but has value +nil+.
+    #
     # @param attributes [Hash] a hash of attributes to update
     # @return [true|false] Whether updating successful or not
     # @since 0.2.0
@@ -528,6 +691,10 @@ module Dynamoid
     # Raises a +Dynamoid::Errors::UnknownAttribute+ exception if any of the
     # attributes is not on the model
     #
+    # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+    # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+    # required but has value +nil+.
+    #
     # @param attributes [Hash] a hash of attributes to update
     def update_attributes!(attributes)
       attributes.each { |attribute, value| write_attribute(attribute, value) }
@@ -540,6 +707,8 @@ module Dynamoid
     #
     #   user.update_attribute(:last_name, 'Tylor')
     #
+    # Validation is skipped.
+    #
     # Raises a +Dynamoid::Errors::UnknownAttribute+ exception if any of the
     # attributes is not on the model
     #
@@ -550,21 +719,17 @@ module Dynamoid
     # @since 0.2.0
     def update_attribute(attribute, value)
       # final implementation is in the Dynamoid::Validation module
-      write_attribute(attribute, value)
-      save
-      self
     end
 
     # Update a model.
     #
-    # Runs validation and callbacks. Reloads all attribute values.
+    # Doesn't run validation. Runs only +update+ callbacks. Reloads all attribute values.
     #
     # Accepts mandatory block in order to specify operations which will modify
     # attributes. Supports following operations: +add+, +delete+ and +set+.
     #
     # Operation +add+ just adds a value for numeric attributes and join
-    # collections if attribute is a collection (one of +array+, +set+ or
-    # +map+).
+    # collections if attribute is a set.
     #
     #   user.update! do |t|
     #     t.add(age: 1, followers_count: 5)
@@ -589,7 +754,7 @@ module Dynamoid
     # {parameter}[https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributeUpdates.html]
     # of +UpdateItem+ operation.
     #
-    # It's an atomic operation. So adding or deleting elements in a collection
+    # It's atomic operations. So adding or deleting elements in a collection
     # or incrementing or decrementing a numeric field is atomic and does not
     # interfere with other write requests.
     #
@@ -599,6 +764,15 @@ module Dynamoid
     #     t.add(age: 1)
     #   end
     #
+    # To check if some attribute (or attributes) isn't stored in a DynamoDB
+    # item (e.g. it wasn't set explicitly) there is another condition -
+    # +unless_exists+:
+    #
+    #   user = User.create(name: 'Tylor')
+    #   user.update!(unless_exists: [:age]) do |t|
+    #     t.set(age: 18)
+    #   end
+    #
     # If a document doesn't meet conditions it raises
     # +Dynamoid::Errors::StaleObjectError+ exception.
     #
@@ -620,21 +794,33 @@ module Dynamoid
 
         begin
           table_name = self.class.table_name
+          partition_key_dumped = Dumping.dump_field(hash_key, self.class.attributes[self.class.hash_key])
+          conditions = conditions.dup
+          conditions[:if] ||= {}
+          conditions[:if][self.class.hash_key] = partition_key_dumped
+          if self.class.range_key
+            sort_key_dumped = Dumping.dump_field(range_value, self.class.attributes[self.class.range_key])
+            conditions[:if][self.class.range_key] = sort_key_dumped
+          end
+
           update_item_options = options.merge(conditions: conditions)
 
-          new_attrs = Dynamoid.adapter.update_item(table_name, hash_key, update_item_options) do |t|
-            t.add(lock_version: 1) if self.class.attributes[:lock_version]
+          new_attrs = Dynamoid.adapter.update_item(table_name, partition_key_dumped, update_item_options) do |t|
+            item_updater = ItemUpdaterWithDumping.new(self.class, t)
+
+            item_updater.add(lock_version: 1) if self.class.attributes[:lock_version]
 
             if self.class.timestamps_enabled?
-              time_now = DateTime.now.in_time_zone(Time.zone)
-              time_now_dumped = Dumping.dump_field(time_now, self.class.attributes[:updated_at])
-              t.set(updated_at: time_now_dumped)
+              item_updater.set(updated_at: DateTime.now.in_time_zone(Time.zone))
             end
 
             yield t
           end
           load(Undumping.undump_attributes(new_attrs, self.class.attributes))
         rescue Dynamoid::Errors::ConditionalCheckFailedException
+          # exception may be raised either because of failed user provided conditions
+          # or because of conditions on partition and sort keys. We cannot
+          # distinguish these two cases.
           raise Dynamoid::Errors::StaleObjectError.new(self, 'update')
         end
       end
@@ -644,14 +830,13 @@ module Dynamoid
 
     # Update a model.
     #
-    # Runs validation and callbacks. Reloads all attribute values.
+    # Doesn't run validation. Runs only +update+ callbacks. Reloads all attribute values.
     #
     # Accepts mandatory block in order to specify operations which will modify
     # attributes. Supports following operations: +add+, +delete+ and +set+.
     #
     # Operation +add+ just adds a value for numeric attributes and join
-    # collections if attribute is a collection (one of +array+, +set+ or
-    # +map+).
+    # collections if attribute is a set.
     #
     #   user.update do |t|
     #     t.add(age: 1, followers_count: 5)
@@ -695,6 +880,15 @@ module Dynamoid
     #     t.add(age: 1)
     #   end
     #
+    # To check if some attribute (or attributes) isn't stored in a DynamoDB
+    # item (e.g. it wasn't set explicitly) there is another condition -
+    # +unless_exists+:
+    #
+    #   user = User.create(name: 'Tylor')
+    #   user.update(unless_exists: [:age]) do |t|
+    #     t.set(age: 18)
+    #   end
+    #
     # If a document doesn't meet conditions it just returns +false+. Otherwise it returns +true+.
     #
     # It will increment the +lock_version+ attribute if a table has the column,
@@ -736,14 +930,32 @@ module Dynamoid
     #   user.increment!(:followers_count)
     #   user.increment!(:followers_count, 2)
     #
-    # Returns +true+ if a model was saved and +false+ otherwise.
+    # Only `attribute` is saved. The model itself is not saved. So any other
+    # modified attributes will still be dirty. Validations and callbacks are
+    # skipped.
+    #
+    # When `:touch` option is passed the timestamp columns are updating. If
+    # attribute names are passed, they are updated along with updated_at
+    # attribute:
+    #
+    #   user.increment!(:followers_count, touch: true)
+    #   user.increment!(:followers_count, touch: :viewed_at)
+    #   user.increment!(:followers_count, touch: [:viewed_at, :accessed_at])
     #
     # @param attribute [Symbol] attribute name
     # @param by [Numeric] value to add (optional)
-    # @return [true|false] whether saved model successfully
-    def increment!(attribute, by = 1)
+    # @param touch [true | Symbol | Array<Symbol>] to update update_at attribute and optionally the specified ones
+    # @return [Dynamoid::Document] self
+    def increment!(attribute, by = 1, touch: nil)
       increment(attribute, by)
-      save
+      change = read_attribute(attribute) - (attribute_was(attribute) || 0)
+
+      run_callbacks :touch do
+        self.class.inc(hash_key, range_value, attribute => change, touch: touch)
+        clear_attribute_changes(attribute)
+      end
+
+      self
     end
 
     # Change numeric attribute value.
@@ -758,9 +970,7 @@ module Dynamoid
     # @param by [Numeric] value to subtract (optional)
     # @return [Dynamoid::Document] self
     def decrement(attribute, by = 1)
-      self[attribute] ||= 0
-      self[attribute] -= by
-      self
+      increment(attribute, -by)
     end
 
     # Change numeric attribute value and save a model.
@@ -771,14 +981,24 @@ module Dynamoid
     #   user.decrement!(:followers_count)
     #   user.decrement!(:followers_count, 2)
     #
-    # Returns +true+ if a model was saved and +false+ otherwise.
+    # Only `attribute` is saved. The model itself is not saved. So any other
+    # modified attributes will still be dirty. Validations and callbacks are
+    # skipped.
+    #
+    # When `:touch` option is passed the timestamp columns are updating. If
+    # attribute names are passed, they are updated along with updated_at
+    # attribute:
+    #
+    #   user.decrement!(:followers_count, touch: true)
+    #   user.decrement!(:followers_count, touch: :viewed_at)
+    #   user.decrement!(:followers_count, touch: [:viewed_at, :accessed_at])
     #
     # @param attribute [Symbol] attribute name
     # @param by [Numeric] value to subtract (optional)
-    # @return [true|false] whether saved model successfully
-    def decrement!(attribute, by = 1)
-      decrement(attribute, by)
-      save
+    # @param touch [true | Symbol | Array<Symbol>] to update update_at attribute and optionally the specified ones
+    # @return [Dynamoid::Document] self
+    def decrement!(attribute, by = 1, touch: nil)
+      increment!(attribute, -by, touch: touch)
     end
 
     # Delete a model.
@@ -790,6 +1010,10 @@ module Dynamoid
     #
     # Returns +self+ if deleted successfully and +false+ otherwise.
     #
+    # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+    # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+    # required but has value +nil+.
+    #
     # @return [Dynamoid::Document|false] whether deleted successfully
     # @since 0.2.0
     def destroy
@@ -811,6 +1035,10 @@ module Dynamoid
     #
     # Raises +Dynamoid::Errors::RecordNotDestroyed+ exception if model deleting
     # failed.
+    #
+    # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+    # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+    # required but has value +nil+.
     def destroy!
       destroy || (raise Dynamoid::Errors::RecordNotDestroyed, self)
     end
@@ -823,10 +1051,18 @@ module Dynamoid
     # Raises +Dynamoid::Errors::StaleObjectError+ exception if cannot delete a
     # model.
     #
+    # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+    # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+    # required but has value +nil+.
+    #
     # @return [Dynamoid::Document] self
     # @since 0.2.0
     def delete
+      raise Dynamoid::Errors::MissingHashKey if hash_key.nil?
+      raise Dynamoid::Errors::MissingRangeKey if self.class.range_key? && range_value.nil?
+
       options = range_key ? { range_key: Dumping.dump_field(read_attribute(range_key), self.class.attributes[range_key]) } : {}
+      partition_key_dumped = Dumping.dump_field(hash_key, self.class.attributes[self.class.hash_key])
 
       # Add an optimistic locking check if the lock_version column exists
       if self.class.attributes[:lock_version]
@@ -842,9 +1078,9 @@ module Dynamoid
 
       @destroyed = true
 
-      Dynamoid.adapter.delete(self.class.table_name, hash_key, options)
+      Dynamoid.adapter.delete(self.class.table_name, partition_key_dumped, options)
 
-      self.class.associations.each do |name, options|
+      self.class.associations.each_key do |name|
         send(name).disassociate_source
       end