dynamoid 3.11.0 → 3.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e13af88750cfc2b8421710068215b18cf596f86b0c5caa207574535af04369cc
-  data.tar.gz: b0cc179fb6c547fd766c788300bfe8fc38a9e10117895c0b39b665fcc609e448
+  metadata.gz: f3e330233bdd01c0bb962fb7253b48629fe9f0aeb1ecdcb6cfe7d3272ddddbe0
+  data.tar.gz: 7f6ee27e8d6dedb5fe21bce21a6c00397f42d85dfa40b8d30dae4e13a8294d15
 SHA512:
-  metadata.gz: 3b363e83838f36600b1af31c59406ac4fccad981e24af8762d5ae73fd1b648a2d03754483be89ed648f7ca982dc1640901af242c0b626ef9fb34b3002438edb4
-  data.tar.gz: a1bc08e5ab754f0a2ee383d2ac335396e7e058ad3b91df2d7c532d346da79daa0d239053ab856a8dfd0a2bdfb213f70a654cecdd3b42901c0261e61bcaca9ad5
+  metadata.gz: f84a868794dd6b812ccd6936eaa16c91a8d0f87b2ae959b89a8b01802537490168449bfa83f62d92f8643a6c47043cefeb9168da3301ca4f005400bc1086406f
+  data.tar.gz: 528587c73879f49d25e660974fa5832464eed5773da06535a76bfe3c9c96311a1877eb801e68362c94eadc479cf65a8df053a0f47574c78fbf5919859cb88e66

data/CHANGELOG.md

@@ -11,21 +11,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 ### Removed
 
-## 3.11.0
+## 3.12.0
 
+### Fixed
+* [#849](https://github.com/Dynamoid/dynamoid/pull/849) Fixed saving a field of custom type when it implements both `.dynamoid_dump()` and `#dynamoid_dump` method and use the former one.
+A proper behaviour is to use adapter's .dynamoid_dump method instead of a value's #dynamoid_dump method.
+* [#851](https://github.com/Dynamoid/dynamoid/pull/851) Fixed Dirty API and don't require custom types to implement `#==` method. Add field option `:comparable`.
+* [#913](https://github.com/Dynamoid/dynamoid/pull/913) Fixed saving partition keys of Dynamoid-specific types (e.g. `date` or `datetime`) and always convert them into a proper DynamoDB type
+* [#917](https://github.com/Dynamoid/dynamoid/pull/917) Fixed transactional write operations when primary key is of non-native DynamoDB type
+* [#927](https://github.com/Dynamoid/dynamoid/pull/927) Multiple fixes in transactional and non-transactional write methods and finders:
+  * Changed non-transactional method `#find` and raise `MissingHashKey` when a given partition key is `nil`
+  * Fixed non-transactional method `#save!` and raise `RecordNotSaved` when a callback throws `:abort` and terminates the process
+  * Check whether partition and sort key are specified in the non-transactional persistence methods and raise a proper exception (`MissingHashKey` or `MissingRangeKey`)
+  * Fixed methods `#inc`, `#increment!` and `#decrement!`, `#update` and `#update!` to not create a new item when an item with specified primary key is already deleted
+  * Fixed method `#update_attribute` to not raise `StaleObjectError` when an item with specified primary key is already deleted
+  * Fixed method `#where` with condition on a `:serialized` field to not raise an exception
+### Added
+* [#910](https://github.com/Dynamoid/dynamoid/pull/910) Added `key_type` option to the `table` method to change type of a partition key field (@ogidow)
+* [#916](https://github.com/Dynamoid/dynamoid/pull/916) Added new `error_on_scan` config option to raises an error and prevent table scans (DynamoDB's `Scan` operation) (@aaronalberg)
+* [#926](https://github.com/Dynamoid/dynamoid/pull/926) Implemented read transactions (using DynamoDB's `TransactGetItems` operation)
+### Changed
+* [#846](https://github.com/Dynamoid/dynamoid/pull/846) Changed transactional `update_fields()` method to accept a block and support low-level operations `set`, `add`, `delete`, `remove` (similar to the non-transactional `#update()` method) (@ckhsponge)
+### Removed
+
+## 3.11.0 / 2025-01-12
 ### Fixed
 * [#829](https://github.com/Dynamoid/dynamoid/pull/829) Fixed saving of in-place field changes
 * [#812](https://github.com/Dynamoid/dynamoid/pull/812) Restored sanitizing of attribute names in `#where` conditions
 * [#721](https://github.com/Dynamoid/dynamoid/pull/721) Fixed code examples in README.md (@ndjndj)
 ### Added
-* [#688](https://github.com/Dynamoid/dynamoid/pull/688) Transactional modifying was added utilizing `TransactWriteItems` operation (@ckhsponge)
+* [#688](https://github.com/Dynamoid/dynamoid/pull/688) Implemented write transactions (using DynamoDB's `TransactWriteItems` operation) (@ckhsponge)
 * [#794](https://github.com/Dynamoid/dynamoid/pull/794) Added new config option `store_empty_string_as_nil`
 * [#828](https://github.com/Dynamoid/dynamoid/pull/828) Added Ruby 3.4, Rails 8.0 and Rails 7.2 in CI
 ### Changed
 * [#832](https://github.com/Dynamoid/dynamoid/pull/832) Support String condition expressions with `#where`
 * [#822](https://github.com/Dynamoid/dynamoid/pull/822) Support binary type natively. Also added new config option `store_binary_as_native` (@dalibor)
 
-## 3.10.0
+## 3.10.0 / 2024-02-10
 ### Fixed
 * [#681](https://github.com/Dynamoid/dynamoid/pull/681) Fixed saving persisted model and deleting attributes with `nil` value if `config.store_attribute_with_nil_value` is `false`
 * [#716](https://github.com/Dynamoid/dynamoid/pull/716), [#691](https://github.com/Dynamoid/dynamoid/pull/691), [#687](https://github.com/Dynamoid/dynamoid/pull/687), [#660](https://github.com/Dynamoid/dynamoid/pull/660) Numerous fixes in README.md and RDoc documentation (@ndjndj, @kiharito, @dunkOnIT)

data/README.md

@@ -24,8 +24,8 @@ DynamoDB is not like other document-based databases you might know, and
 is very different indeed from relational databases. It sacrifices
 anything beyond the simplest relational queries and transactional
 support to provide a fast, cost-efficient, and highly durable storage
-solution. If your database requires complicated relational queries and
-transaction support, then this modest Gem cannot provide them for you,
+solution. If your database requires complicated relational queries
+then this modest Gem cannot provide them for you
 and neither can DynamoDB. In those cases you would do better to look
 elsewhere for your database needs.
 
@@ -102,8 +102,8 @@ credentials = Aws::AssumeRoleCredentials.new(
 )
 
 Dynamoid.configure do |config|
-  config.region = 'us-west-2',
-                  config.credentials = credentials
+  config.region = 'us-west-2'
+  config.credentials = credentials
 end
 ```
 
@@ -132,8 +132,8 @@ end
 Dynamoid supports Ruby >= 2.3 and Rails >= 4.2.
 
 Its compatibility is tested against following Ruby versions: 2.3, 2.4,
-2.5, 2.6, 2.7, 3.0, 3.1, 3.2 and 3.3, JRuby 9.4.x and against Rails versions: 4.2, 5.0, 5.1,
-5.2, 6.0, 6.1, 7.0 and 7.1.
+2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, and 3.4, JRuby 9.4.x and against Rails versions: 4.2, 5.0, 5.1,
+5.2, 6.0, 6.1, 7.0, 7.1, 7.2, and 8.0.
 
 ## Setup
 
@@ -471,6 +471,27 @@ method, which would return either `:string` or `:number`.
 DynamoDB may support some other attribute types that are not yet
 supported by Dynamoid.
 
+If a custom type implements `#==` method you can specify `comparable:
+true` option in a field declaration to specify that an object is safely
+comparable for the purpose of detecting changes. By default old and new
+objects will be compared by their serialized representation.
+
+```ruby
+class Money
+  # ...
+
+  def ==(other)
+    # comparison logic
+  end
+end
+
+class User
+  # ...
+
+  field :balance, Money, comparable: true
+end
+```
+
 ### Sort key
 
 Along with partition key table may have a sort key. In order to declare
@@ -620,6 +641,7 @@ with `inheritance_field` table option:
 ```ruby
 class Car
   include Dynamoid::Document
+
   table inheritance_field: :my_new_type
 
   field :my_new_type
@@ -914,6 +936,7 @@ It could be done with `project` method:
 ```ruby
 class User
   include Dynamoid::Document
+
   field :name
 end
 
@@ -1091,6 +1114,14 @@ on the base table*
 > Please note that this API is experimental and can be changed in
 > future releases.
 
+DynamoDB supports modifying and reading operations but there are some
+limitations:
+- read and write operation cannot be combined in the same transaction
+- operations are executed in batch, so operations should be given before
+  actual execution and cannot be changed on the fly
+
+#### Modifying transactions
+
 Multiple modifying actions can be grouped together and submitted as an
 all-or-nothing operation. Atomic modifying operations are supported in
 Dynamoid using transactions. If any action in the transaction fails they
@@ -1110,8 +1141,7 @@ model
 These methods are supposed to behave exactly like their
 non-transactional counterparts.
 
-
-#### Create models
+##### Create models
 
 Models can be created inside of a transaction. The partition and sort
 keys, if applicable, are used to determine uniqueness. Creating will
@@ -1135,7 +1165,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Save models
+##### Save models
 
 Models can be saved in a transaction. New records are created otherwise
 the model is updated. Save, create, update, validate and destroy
@@ -1154,7 +1184,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Update models
+##### Update models
 
 A model can be updated by providing a model or primary key, and the fields to update.
 
@@ -1166,10 +1196,23 @@ Dynamoid::TransactionWrite.execute do |txn|
   # sets the name and title for a user
   # The user is found by id (that equals 1)
   txn.update_fields(User, '1', name: 'bob', title: 'mister')
+
+  # sets the name, increments a count and deletes a field
+  txn.update_fields(User, 1) do |t|
+    t.set(name: 'bob')
+    t.add(article_count: 1)
+    t.delete(:title)
+  end
+
+  # adds to a set of integers and deletes from a set of strings
+  txn.update_fields(User, 2) do |t|
+    t.add(friend_ids: [1, 2])
+    t.delete(child_names: ['bebe'])
+  end
 end
 ```
 
-#### Destroy or delete models
+##### Destroy or delete models
 
 Models can be used or the model class and key can be specified.
 `#destroy` uses callbacks and validations. Use `#delete` to skip
@@ -1188,7 +1231,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Validation failures that don't raise
+##### Validation failures that don't raise
 
 All of the transaction methods can be called without the `!` which
 results in `false` instead of a raised exception when validation fails.
@@ -1208,7 +1251,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Incrementally building a transaction
+##### Incrementally building a transaction
 
 Transactions can also be built without a block.
 
@@ -1222,6 +1265,41 @@ transaction.upsert(Address, 'A#1', street: '123')
 transaction.commit # changes are persisted in this moment
 ```
 
+#### Reading transactions
+
+Multiple reading actions can be grouped together and submitted as an
+all-or-nothing operation. Atomic  operations are supported in Dynamoid
+using transactions. If any action in the transaction fails they all
+fail.
+
+The following actions are supported:
+
+* `#find` - load a single model or multiple models by its primary key
+
+These methods are supposed to behave exactly like their
+non-transactional counterparts.
+
+##### Find a model
+
+The `#find` action can load single model or multiple ones. Different
+model classes can be mixed in the same transactions. Result is returned
+as a plain list of all the found models. The order is preserved.
+
+```ruby
+user, address = Dynamoid::TransactionRead.execute do |t|
+  t.find(User, user_id)
+  t.find(Address, address_id)
+end
+```
+
+Multiple primary keys can be specified at once:
+
+```ruby
+users = Dynamoid::TransactionRead.execute do |t|
+  t.find(User, [id1, id2, id3])
+end
+```
+
 ### PartiQL
 
 To run PartiQL statements `Dynamoid.adapter.execute` method should be
@@ -1269,6 +1347,7 @@ Listed below are all configuration options.
 * `write_capacity` - is used at table or indices creation. Default is 20
   (units)
 * `warn_on_scan` - log warnings when scan table. Default is `true`
+* `error_on_scan` - raises an error when scan table. Default is `false`
 * `endpoint` - if provided, it communicates with the DynamoDB listening
   at the endpoint. This is useful for testing with
   [DynamoDB Local](http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html)
@@ -1501,6 +1580,7 @@ order to troubleshoot and debug issues just set it:
 ```ruby
 class User
   include Dynamoid::Document
+
   field name
 end
 

data/lib/dynamoid/adapter_plugin/aws_sdk_v3.rb

@@ -294,6 +294,14 @@ module Dynamoid
         Transact.new(client).transact_write_items(items)
       end
 
+      def transact_read_items(items)
+        request = {
+          transact_items: items,
+          return_consumed_capacity: 'TOTAL',
+        }
+        client.transact_get_items(request)
+      end
+
       # Create a table on DynamoDB. This usually takes a long time to complete.
       #
       # @param [String] table_name the name of the table to create

data/lib/dynamoid/config.rb

@@ -36,6 +36,7 @@ module Dynamoid
     option :read_capacity, default: 100
     option :write_capacity, default: 20
     option :warn_on_scan, default: true
+    option :error_on_scan, default: false
     option :endpoint, default: nil
     option :identity_map, default: false
     option :timestamps, default: true

data/lib/dynamoid/criteria/chain.rb

@@ -563,7 +563,7 @@ module Dynamoid
         if @key_fields_detector.key_present?
           raw_pages_via_query
         else
-          issue_scan_warning if Dynamoid::Config.warn_on_scan && !@where_conditions.empty?
+          validate_scan_conditions
           raw_pages_via_scan
         end
       end
@@ -598,6 +598,12 @@ module Dynamoid
         end
       end
 
+      def validate_scan_conditions
+        raise Dynamoid::Errors::ScanProhibited if Dynamoid::Config.error_on_scan && !@where_conditions.empty?
+
+        issue_scan_warning if Dynamoid::Config.warn_on_scan && !@where_conditions.empty?
+      end
+
       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.underscore}.rb:"
@@ -697,11 +703,13 @@ module Dynamoid
       # e.g. for NULL operator value should be boolean
       # and isn't related to an attribute own type
       def type_cast_condition_parameter(key, value)
-        return value if %i[array set].include?(source.attributes[key.to_sym][:type])
+        field_type = source.attributes[key.to_sym][:type]
+
+        return value if %i[array set].include?(field_type)
 
         if [true, false].include?(value) # Support argument for null/not_null operators
           value
-        elsif !value.respond_to?(:to_ary)
+        elsif !value.respond_to?(:to_ary) || field_type == :serialized
           options = source.attributes[key.to_sym]
           value_casted = TypeCasting.cast_field(value, options)
           Dumping.dump_field(value_casted, options)

data/lib/dynamoid/dirty.rb

@@ -301,7 +301,19 @@ module Dynamoid
       return false if value_from_database.nil?
 
       value = read_attribute(name)
-      value != value_from_database
+      type_options = self.class.attributes[name.to_sym]
+
+      unless type_options[:type].is_a?(Class) && !type_options[:comparable]
+        # common case
+        value != value_from_database
+      else
+        # objects of a custom type that does not implement its own `#==` method
+        # (that's declared by `comparable: false` or just not specifying the
+        # option `comparable`) are compared by comparing their dumps
+        dump = Dumping.dump_field(value, type_options)
+        dump_from_database = Dumping.dump_field(value_from_database, type_options)
+        dump != dump_from_database
+      end
     end
 
     module DeepDupper
@@ -318,26 +330,25 @@ module Dynamoid
 
         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
+          # Till Ruby 2.4 these immutable objects could not be duplicated.
+          # IO objects (used for the binary type) cannot be duplicated as well.
           value
-        when String
-          value.dup
         when Array
-          if of.is_a? Class # custom type
+          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
+          if type.is_a? Class
+            # custom type
+            dump = Dumping.dump_field(value, type_options)
+            Undumping.undump_field(dump.deep_dup, type_options)
           else
-            value.dup # date, datetime
+            value.deep_dup
           end
         end
       end

data/lib/dynamoid/dumping.rb

@@ -323,10 +323,10 @@ module Dynamoid
       def process(value)
         field_class = @options[:type]
 
-        if value.respond_to?(:dynamoid_dump)
-          value.dynamoid_dump
-        elsif field_class.respond_to?(:dynamoid_dump)
+        if field_class.respond_to?(:dynamoid_dump)
           field_class.dynamoid_dump(value)
+        elsif value.respond_to?(:dynamoid_dump)
+          value.dynamoid_dump
         else
           raise ArgumentError, "Neither #{field_class} nor #{value} supports serialization for Dynamoid."
         end

data/lib/dynamoid/errors.rb

@@ -86,10 +86,25 @@ module Dynamoid
 
     class UnsupportedKeyType < Error; end
 
-    class UnknownAttribute < Error; end
+    class UnknownAttribute < Error
+      attr_reader :model_class, :attribute_name
+
+      def initialize(model_class, attribute_name)
+        super("Attribute #{attribute_name} does not exist in #{model_class}")
+
+        @model_class = model_class
+        @attribute_name = attribute_name
+      end
+    end
 
     class SubclassNotFound < Error; end
 
     class Rollback < Error; end
+
+    class ScanProhibited < Error
+      def initialize(_msg = nil)
+        super('Scan operations prohibited. Modify Dynamoid::Config.error_on_scan to change this behavior.')
+      end
+    end
   end
 end

data/lib/dynamoid/fields.rb

@@ -197,9 +197,19 @@ module Dynamoid
       #     field :id, :integer
       #   end
       #
+      # To declare a new attribute with not-default type as a table hash key a
+      # :key_type option can be used:
+      #
+      #   class User
+      #     include Dynamoid::Document
+      #
+      #     table key: :user_id, key_type: :integer
+      #   end
+      #
       # @param options [Hash] options to override default table settings
       # @option options [Symbol] :name name of a table
       # @option options [Symbol] :key name of a hash key attribute
+      # @option options [Symbol] :key_type type of a hash key attribute
       # @option options [Symbol] :inheritance_field name of an attribute used for STI
       # @option options [Symbol] :capacity_mode table billing mode - either +provisioned+ or +on_demand+
       # @option options [Integer] :write_capacity table write capacity units
@@ -210,11 +220,11 @@ module Dynamoid
       # @since 0.4.0
       def table(options)
         self.options = options
-
         # a default 'id' column is created when Dynamoid::Document is included
         unless attributes.key? hash_key
           remove_field :id
-          field(hash_key)
+          key_type = options[:key_type] || :string
+          field(hash_key, key_type)
         end
 
         # The created_at/updated_at fields are declared in the `included` callback first.
@@ -291,7 +301,7 @@ module Dynamoid
       old_value = read_attribute(name)
 
       unless attribute_is_present_on_model?(name)
-        raise Dynamoid::Errors::UnknownAttribute, "Attribute #{name} is not part of the model"
+        raise Dynamoid::Errors::UnknownAttribute.new(self.class, name)
       end
 
       if association = @associations[name]

data/lib/dynamoid/finders.rb

@@ -14,12 +14,12 @@ module Dynamoid
       # specified +raise_error: false+ option then +find+ will not raise the
       # exception.
       #
-      # When a document schema includes range key it always should be specified
+      # When a document schema includes range key it should always be specified
       # in +find+ method call. In case it's missing +MissingRangeKey+ exception
       # will be raised.
       #
       # Please note that +find+ doesn't preserve order of models in result when
-      # passes multiple ids.
+      # given multiple ids.
       #
       # Supported following options:
       # * +consistent_read+
@@ -107,14 +107,28 @@ module Dynamoid
 
       # @private
       def _find_all(ids, options = {})
-        raise Errors::MissingRangeKey if range_key && ids.any? { |_pk, sk| sk.nil? }
-
-        if range_key
-          ids = ids.map do |pk, sk|
-            sk_casted = TypeCasting.cast_field(sk, attributes[range_key])
-            sk_dumped = Dumping.dump_field(sk_casted, attributes[range_key])
+        ids = ids.map do |id|
+          if range_key
+            # expect [hash key, range key] pair
+            pk, sk = id
+
+            if pk.nil?
+              raise Errors::MissingHashKey
+            end
+            if sk.nil?
+              raise Errors::MissingRangeKey
+            end
+
+            pk_dumped = cast_and_dump(hash_key, pk)
+            sk_dumped = cast_and_dump(range_key, sk)
+
+            [pk_dumped, sk_dumped]
+          else
+            if id.nil?
+              raise Errors::MissingHashKey
+            end
 
-            [pk, sk_dumped]
+            cast_and_dump(hash_key, id)
           end
         end
 
@@ -144,7 +158,7 @@ module Dynamoid
           models.each { |m| m.run_callbacks :find }
           models
         else
-          ids_list = range_key ? ids.map { |pk, sk| "(#{pk},#{sk})" } : ids.map(&:to_s)
+          ids_list = range_key ? ids.map { |pk, sk| "(#{pk.inspect},#{sk.inspect})" } : ids.map(&:inspect)
           message = "Couldn't find all #{name.pluralize} with primary keys [#{ids_list.join(', ')}] "
           message += "(found #{items.size} results, but was looking for #{ids.size})"
           raise Errors::RecordNotFound, message
@@ -153,22 +167,21 @@ module Dynamoid
 
       # @private
       def _find_by_id(id, options = {})
+        raise Errors::MissingHashKey if id.nil?
         raise Errors::MissingRangeKey if range_key && options[:range_key].nil?
 
-        if range_key
-          key = options[:range_key]
-          key_casted = TypeCasting.cast_field(key, attributes[range_key])
-          key_dumped = Dumping.dump_field(key_casted, attributes[range_key])
+        partition_key_dumped = cast_and_dump(hash_key, id)
 
-          options[:range_key] = key_dumped
+        if range_key
+          options[:range_key] = cast_and_dump(range_key, options[:range_key])
         end
 
-        if item = Dynamoid.adapter.read(table_name, id, options.slice(:range_key, :consistent_read))
+        if item = Dynamoid.adapter.read(table_name, partition_key_dumped, options.slice(:range_key, :consistent_read))
           model = from_database(item)
           model.run_callbacks :find
           model
         elsif options[:raise_error]
-          primary_key = range_key ? "(#{id},#{options[:range_key]})" : id
+          primary_key = range_key ? "(#{id.inspect},#{options[:range_key].inspect})" : id.inspect
           message = "Couldn't find #{name} with primary key #{primary_key}"
           raise Errors::RecordNotFound, message
         end
@@ -308,6 +321,14 @@ module Dynamoid
           super
         end
       end
+
+      private
+
+      def cast_and_dump(name, value)
+        attribute_options = attributes[name]
+        casted_value = TypeCasting.cast_field(value, attribute_options)
+        Dumping.dump_field(casted_value, attribute_options)
+      end
     end
   end
 end

data/lib/dynamoid/persistence/inc.rb

@@ -6,23 +6,25 @@ module Dynamoid
   module Persistence
     # @private
     class Inc
-      def self.call(model_class, hash_key, range_key = nil, counters)
-        new(model_class, hash_key, range_key, counters).call
+      def self.call(model_class, partition_key, sort_key = nil, counters)
+        new(model_class, partition_key, sort_key, counters).call
       end
 
       # rubocop:disable Style/OptionalArguments
-      def initialize(model_class, hash_key, range_key = nil, counters)
+      def initialize(model_class, partition_key, sort_key = nil, counters)
         @model_class = model_class
-        @hash_key = hash_key
-        @range_key = range_key
+        @partition_key = partition_key
+        @sort_key = sort_key
         @counters = counters
       end
       # rubocop:enable Style/OptionalArguments
 
       def call
         touch = @counters.delete(:touch)
+        partition_key_dumped = cast_and_dump(@model_class.hash_key, @partition_key)
+        options = update_item_options(partition_key_dumped)
 
-        Dynamoid.adapter.update_item(@model_class.table_name, @hash_key, update_item_options) do |t|
+        Dynamoid.adapter.update_item(@model_class.table_name, partition_key_dumped, options) do |t|
           item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
 
           @counters.each do |name, value|
@@ -37,19 +39,28 @@ module Dynamoid
             end
           end
         end
+      rescue Dynamoid::Errors::ConditionalCheckFailedException # rubocop:disable Lint/SuppressedException
       end
 
       private
 
-      def update_item_options
+      def update_item_options(partition_key_dumped)
+        options = {}
+
+        conditions = {
+          if: {
+            @model_class.hash_key => partition_key_dumped
+          }
+        }
+        options[:conditions] = conditions
+
         if @model_class.range_key
-          range_key_options = @model_class.attributes[@model_class.range_key]
-          value_casted = TypeCasting.cast_field(@range_key, range_key_options)
-          value_dumped = Dumping.dump_field(value_casted, range_key_options)
-          { range_key: value_dumped }
-        else
-          {}
+          sort_key_dumped = cast_and_dump(@model_class.range_key, @sort_key)
+          options[:range_key] = sort_key_dumped
+          options[:conditions][@model_class.range_key] = sort_key_dumped
         end
+
+        options
       end
 
       def timestamp_attributes_to_touch(touch)
@@ -60,6 +71,12 @@ module Dynamoid
         names += Array.wrap(touch) if touch != true
         names
       end
+
+      def cast_and_dump(name, value)
+        options = @model_class.attributes[name]
+        value_casted = TypeCasting.cast_field(value, options)
+        Dumping.dump_field(value_casted, options)
+      end
     end
   end
 end