dynamoid 3.9.0 → 3.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aedb91a28972fd9357cbb260341e617c3d0d35ae05a620d5ac8312f5d3edbf96
-  data.tar.gz: a026d8c3d1e53f4e6800dcffe2b8350da50f70d953a19ae86dfeff0f65555c8c
+  metadata.gz: e13af88750cfc2b8421710068215b18cf596f86b0c5caa207574535af04369cc
+  data.tar.gz: b0cc179fb6c547fd766c788300bfe8fc38a9e10117895c0b39b665fcc609e448
 SHA512:
-  metadata.gz: dcb483ea21eaa16246d82603d18952a70bab15556b65ea94fad3ac9dbfe6358f00730e1825275d241a18675fdc0a2e4c3c4b0553acb41f9205e5fe350337f54c
-  data.tar.gz: 4e4c96ed9b90ccab85f2f09ad848455affa681c93740dcf1f7b6283797f8e47bebd1c83a70a524eb6ea44906bdd6baec07549f67a9e6bd6561b857ea8997b692
+  metadata.gz: 3b363e83838f36600b1af31c59406ac4fccad981e24af8762d5ae73fd1b648a2d03754483be89ed648f7ca982dc1640901af242c0b626ef9fb34b3002438edb4
+  data.tar.gz: a1bc08e5ab754f0a2ee383d2ac335396e7e058ad3b91df2d7c532d346da79daa0d239053ab856a8dfd0a2bdfb213f70a654cecdd3b42901c0261e61bcaca9ad5

data/CHANGELOG.md

@@ -7,14 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Fixed
-
 ### Added
+### Changed
+### Removed
 
+## 3.11.0
+
+### 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)
+* [#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)
 
-### Removed
+## 3.10.0
+### 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)
+### Added
+* [#656](https://github.com/Dynamoid/dynamoid/pull/656) Added a `create_table_on_save` configuration flag to create table on save (@imaximix)
+* [#697](https://github.com/Dynamoid/dynamoid/pull/697) Ensure Ruby 3.3 and Rails 7.1 versions are supported and added them on CI
+### Changed
+* [#655](https://github.com/Dynamoid/dynamoid/pull/655) Support multiple `where` in the same chain with multiple conditions for the same field
 
-## 3.9.0
+## 3.9.0 / 2023-04-13
 ### Fixed
 * [#610](https://github.com/Dynamoid/dynamoid/pull/610) Specs in JRuby; Support for JRuby 9.4.0.0 (@pboling)
 * [#624](https://github.com/Dynamoid/dynamoid/pull/624) Fixed `#increment!`/`#decrement!` methods and made them compatible with Rails counterparts
@@ -50,15 +71,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   * `#touch`
   * `#increment!`
   * `#decrement!`
-* [#642](https://github.com/Dynamoid/dynamoid/pull/642) Run specs on CI agains Ruby 3.2
+* [#642](https://github.com/Dynamoid/dynamoid/pull/642) Run specs on CI against Ruby 3.2
 * [#645](https://github.com/Dynamoid/dynamoid/pull/645) Added `after_find` callback
 ### Changed
 * [#610](https://github.com/Dynamoid/dynamoid/pull/610) Switch to [`rubocop-lts`](https://rubocop-lts.gitlab.io/) (@pboling)
-### Removed
 * [#633](https://github.com/Dynamoid/dynamoid/pull/633) Change `#inspect` method to return only attributes
 * [#623](https://github.com/Dynamoid/dynamoid/pull/623) Optimized performance of persisting to send only changed attributes in a request to DynamoDB
 
-## 3.8.0
+## 3.8.0 / 2022-11-09
 ### Fixed
 * [#525](https://github.com/Dynamoid/dynamoid/pull/525) Don't mark an attribute as changed if new assigned value equals the old one (@a5-stable)
 * Minor changes in the documentation:

data/README.md

@@ -67,10 +67,10 @@ For example, to configure AWS access:
 Create `config/initializers/aws.rb` as follows:
 
 ```ruby
-Aws.config.update({
-                    region: 'us-west-2',
+Aws.config.update(
+  region: 'us-west-2',
   credentials: Aws::Credentials.new('REPLACE_WITH_ACCESS_KEY_ID', 'REPLACE_WITH_SECRET_ACCESS_KEY'),
-                  })
+)
 ```
 
 Alternatively, if you don't want Aws connection settings to be
@@ -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 and 3.2, JRuby 9.4.x and against Rails versions: 4.2, 5.0, 5.1,
-5.2, 6.0, 6.1 and 7.0.
+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.
 
 ## Setup
 
@@ -342,6 +342,24 @@ class Document
 end
 ```
 
+#### Note on binary type
+
+By default binary fields are persisted as DynamoDB String value encoded
+in the Base64 encoding. DynamoDB supports binary data natively. To use
+it instead of String a `store_binary_as_native` field option should be
+set:
+
+```ruby
+class Document
+  include Dynamoid::Document
+
+  field :image, :binary, store_binary_as_native: true
+end
+```
+
+There is also a global config option `store_binary_as_native` that is
+`false` by default as well.
+
 #### Magic Columns
 
 You get magic columns of `id` (`string`), `created_at` (`datetime`), and
@@ -701,7 +719,7 @@ users = User.import([{ name: 'Josh' }, { name: 'Nick' }])
 
 ### Querying
 
-Querying can be done in one of three ways:
+Querying can be done in one of the following ways:
 
 ```ruby
 Address.find(address.id)              # Find directly by ID.
@@ -710,6 +728,27 @@ Address.where(city: 'Chicago').all    # Find by any number of matching criteria.
 Address.find_by_city('Chicago')       # The same as above, but using ActiveRecord's older syntax.
 ```
 
+There is also a way to `#where` with a condition expression:
+
+```ruby
+Address.where('city = :c', c: 'Chicago')
+```
+
+A condition expression may contain operators (e.g. `<`, `>=`, `<>`),
+keywords (e.g. `AND`, `OR`, `BETWEEN`) and built-in functions (e.g.
+`begins_with`, `contains`) (see (documentation
+)[https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html]
+for full syntax description).
+
+**Warning:** Values (specified for a String condition expression) are
+sent as is so Dynamoid field types that aren't supported natively by
+DynamoDB (e.g. `datetime` and `date`) require explicit casting.
+
+**Warning:** String condition expressions will be used by DynamoDB only
+at filtering, so conditions on key attributes should be specified as a
+Hash to perform Query operation instead of Scan. Don't use key
+attributes in `#where`'s String condition expressions.
+
 And you can also query on associations:
 
 ```ruby
@@ -723,18 +762,6 @@ join, but instead finds all the user's addresses and naively filters
 them in Ruby. For large associations this is a performance hit compared
 to relational database engines.
 
-**WARNING:** There is a limitation of conditions passed to `where`
-method. Only one condition for some particular field could be specified.
-The last one only will be applied and others will be ignored. E.g. in
-examples:
-
-```ruby
-User.where('age.gt': 10, 'age.lt': 20)
-User.where(name: 'Mike').where('name.begins_with': 'Ed')
-```
-
-the first one will be ignored and the last one will be used.
-
 **Warning:** There is a caveat with filtering documents by `nil` value
 attribute. By default Dynamoid ignores attributes with `nil` value and
 doesn't store them in a DynamoDB document. This behavior could be
@@ -752,7 +779,7 @@ If Dynamoid keeps `nil` value attributes `eq`/`ne` operators should be
 used instead:
 
 ```ruby
-Address.where('postcode': nil)
+Address.where(postcode: nil)
 Address.where('postcode.ne': nil)
 ```
 
@@ -926,8 +953,8 @@ If you have a range index, Dynamoid provides a number of additional
 other convenience methods to make your life a little easier:
 
 ```ruby
-User.where("created_at.gt": DateTime.now - 1.day).all
-User.where("created_at.lt": DateTime.now - 1.day).all
+User.where('created_at.gt': DateTime.now - 1.day).all
+User.where('created_at.lt': DateTime.now - 1.day).all
 ```
 
 It also supports `gte` and `lte`. Turning those into symbols and
@@ -946,7 +973,6 @@ validation and callbacks.
 Address.find(id).update_attributes(city: 'Chicago')
 Address.find(id).update_attribute(:city, 'Chicago')
 Address.update(id, city: 'Chicago')
-Address.update(id, { city: 'Chicago' }, if: { deliverable: true })
 ```
 
 There are also some low level methods `#update`, `.update_fields` and
@@ -975,7 +1001,7 @@ To idempotently create-but-not-update a record, apply the `unless_exists` condit
 to its keys when you upsert.
 
 ```ruby
-Address.upsert(id, { city: 'Chicago' }, if: { unless_exists: [:id] })
+Address.upsert(id, { city: 'Chicago' }, { unless_exists: [:id] })
 ```
 
 ### Deleting
@@ -1059,6 +1085,143 @@ resolving the fields with a second query against the table since a query
 against GSI then a query on base table is still likely faster than scan
 on the base table*
 
+### Transactions in Dynamoid
+
+> [!WARNING]
+> Please note that this API is experimental and can be changed in
+> future releases.
+
+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
+all fail.
+
+The following actions are supported:
+
+* `#create`/`#create!` - add a new model if it does not already exist
+* `#save`/`#save!` - create or update model
+* `#update_attributes`/`#update_attributes!` - modifies one or more attributes from an existig
+model
+* `#delete` - remove an model without callbacks nor validations
+* `#destroy`/`#destroy!` - remove an model
+* `#upsert` - add a new model or update an existing one, no callbacks
+* `#update_fields` - update a model without its instantiation
+
+These methods are supposed to behave exactly like their
+non-transactional counterparts.
+
+
+#### Create models
+
+Models can be created inside of a transaction. The partition and sort
+keys, if applicable, are used to determine uniqueness. Creating will
+fail with `Aws::DynamoDB::Errors::TransactionCanceledException` if a
+model already exists.
+
+This example creates a user with a unique id and unique email address by
+creating 2 models. An additional model is upserted in the same
+transaction. Upsert will update `updated_at` but will not create
+`created_at`.
+
+```ruby
+user_id = SecureRandom.uuid
+email = 'bob@bob.bob'
+
+Dynamoid::TransactionWrite.execute do |txn|
+  txn.create(User, id: user_id)
+  txn.create(UserEmail, id: "UserEmail##{email}", user_id: user_id)
+  txn.create(Address, id: 'A#2', street: '456')
+  txn.upsert(Address, 'A#1', street: '123')
+end
+```
+
+#### Save models
+
+Models can be saved in a transaction. New records are created otherwise
+the model is updated. Save, create, update, validate and destroy
+callbacks are called around the transaction as appropriate. Validation
+failures will throw `Dynamoid::Errors::DocumentNotValid`.
+
+```ruby
+user = User.find(1)
+article = Article.new(body: 'New article text', user_id: user.id)
+
+Dynamoid::TransactionWrite.execute do |txn|
+  txn.save(article)
+
+  user.last_article_id = article.id
+  txn.save(user)
+end
+```
+
+#### Update models
+
+A model can be updated by providing a model or primary key, and the fields to update.
+
+```ruby
+Dynamoid::TransactionWrite.execute do |txn|
+  # change name and title for a user
+  txn.update_attributes(user, name: 'bob', title: 'mister')
+
+  # 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')
+end
+```
+
+#### 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
+callbacks and validations.
+
+```ruby
+article = Article.find('1')
+tag = article.tag
+
+Dynamoid::TransactionWrite.execute do |txn|
+  txn.destroy(article)
+  txn.delete(tag)
+
+  txn.delete(Tag, '2') # delete record with hash key '2' if it exists
+  txn.delete(Tag, 'key#abcd', 'range#1') # when sort key is required
+end
+```
+
+#### 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.
+Ignoring validation failures can lead to confusion or bugs so always
+check return status when not using a method with `!`.
+
+```ruby
+user = User.find('1')
+user.red = true
+
+Dynamoid::TransactionWrite.execute do |txn|
+  if txn.save(user) # won't raise validation exception
+    txn.update_fields(UserCount, user.id, count: 5)
+  else
+    puts 'ALERT: user not valid, skipping'
+  end
+end
+```
+
+#### Incrementally building a transaction
+
+Transactions can also be built without a block.
+
+```ruby
+transaction = Dynamoid::TransactionWrite.new
+
+transaction.create(User, id: user_id)
+transaction.create(UserEmail, id: "UserEmail##{email}", user_id: user_id)
+transaction.upsert(Address, 'A#1', street: '123')
+
+transaction.commit # changes are persisted in this moment
+```
+
 ### PartiQL
 
 To run PartiQL statements `Dynamoid.adapter.execute` method should be
@@ -1142,14 +1305,18 @@ Listed below are all configuration options.
   fields in ISO 8601 string format. Default is `false`
 * `store_date_as_string` - if `true` then Dynamoid stores :date fields
   in ISO 8601 string format. Default is `false`
+* `store_empty_string_as_nil` - store attribute's empty String value as NULL. Default is `true`
 * `store_boolean_as_native` - if `true` Dynamoid stores boolean fields
   as native DynamoDB boolean values. Otherwise boolean fields are stored
-  as string values `'t'` and `'f'`. Default is true
+  as string values `'t'` and `'f'`. Default is `true`
+* `store_binary_as_native` - if `true` Dynamoid stores binary fields
+  as native DynamoDB binary values. Otherwise binary fields are stored
+  as Base64 encoded string values. Default is `false`
 * `backoff` - is a hash: key is a backoff strategy (symbol), value is
   parameters for the strategy. Is used in batch operations. Default id
   `nil`
 * `backoff_strategies`: is a hash and contains all available strategies.
-  Default is { constant: ..., exponential: ...}
+  Default is `{ constant: ..., exponential: ...}`
 * `log_formatter`: overrides default AWS SDK formatter. There are
   several canned formatters: `Aws::Log::Formatter.default`,
   `Aws::Log::Formatter.colored` and `Aws::Log::Formatter.short`. Please
@@ -1167,6 +1334,9 @@ Listed below are all configuration options.
 * `http_read_timeout`:The number of seconds to wait for HTTP response
   data. Default option value is `nil`. If not specified effected value
   is `60`
+* `create_table_on_save`: if `true` then Dynamoid creates a
+  corresponding table in DynamoDB at model persisting if the table
+  doesn't exist yet. Default is `true`
 
 
 ## Concurrency
@@ -1305,6 +1475,12 @@ RSpec.configure do |config|
 end
 ```
 
+In addition, the first test for each model may fail if the relevant models are not included in `included_models`. This can be fixed by adding this line before the `DynamoidReset` module:
+```ruby
+Dir[File.join(Dynamoid::Config.models_dir, '**/*.rb')].sort.each { |file| require file }
+```
+Note that this will require _all_ models in your models folder - you can also explicitly require only certain models if you would prefer to.
+
 In Rails, you may also want to ensure you do not delete non-test data
 accidentally by adding the following to your test environment setup:
 
@@ -1353,6 +1529,7 @@ just as accessible to the Ruby world as MongoDB.
 Also, without contributors the project wouldn't be nearly as awesome. So
 many thanks to:
 
+* [Chris Hobbs](https://github.com/ckhsponge)
 * [Logan Bowers](https://github.com/loganb)
 * [Lane LaRue](https://github.com/luxx)
 * [Craig Heneveld](https://github.com/cheneveld)

data/dynamoid.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
 
   spec.description = "Dynamoid is an ORM for Amazon's DynamoDB that supports offline development, associations, querying, and everything else you'd expect from an ActiveRecord-style replacement."
   spec.summary = "Dynamoid is an ORM for Amazon's DynamoDB"
-  # Ignore not commited files
+  # Ignore not committed files
   spec.files = Dir[
     'CHANGELOG.md',
     'dynamoid.gemspec',
@@ -51,16 +51,15 @@ Gem::Specification.new do |spec|
   spec.metadata['wiki_uri'] = 'https://github.com/Dynamoid/dynamoid/wiki'
   spec.metadata['rubygems_mfa_required'] = 'true'
 
-  spec.add_runtime_dependency 'activemodel', '>=4'
-  spec.add_runtime_dependency 'aws-sdk-dynamodb', '~> 1.0'
-  spec.add_runtime_dependency 'concurrent-ruby', '>= 1.0'
+  spec.add_dependency 'activemodel', '>=4'
+  spec.add_dependency 'aws-sdk-dynamodb', '~> 1.0'
+  spec.add_dependency 'concurrent-ruby', '>= 1.0'
 
   spec.add_development_dependency 'appraisal'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'pry', '~> 0.14'
   spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rexml'
   spec.add_development_dependency 'rspec', '~> 3.12'
-  # 'rubocop-lts' is for Ruby 2.3+, see https://rubocop-lts.gitlab.io/
-  spec.add_development_dependency 'rubocop-lts', '~> 10.0'
   spec.add_development_dependency 'yard'
 end

data/lib/dynamoid/adapter.rb

@@ -118,7 +118,7 @@ module Dynamoid
     # @param [Hash] query a hash of attributes: matching records will be returned by the scan
     #
     # @since 0.2.0
-    def scan(table, query = {}, opts = {})
+    def scan(table, query = [], opts = {})
       benchmark('Scan', table, query) { adapter.scan(table, query, opts) }
     end
 
@@ -171,19 +171,25 @@ module Dynamoid
     # only really useful for range queries, since it can only find by one hash key at once. Only provide
     # one range key to the hash.
     #
+    #   Dynamoid.adapter.query('users', { id: [[:eq, '1']], age: [[:between, [10, 30]]] }, { batch_size: 1000 })
+    #
     # @param [String] table_name the name of the table
-    # @param [Hash] opts the options to query the table with
-    # @option opts [String] :hash_value the value of the hash key to find
-    # @option opts [Range] :range_value find the range key within this range
-    # @option opts [Number] :range_greater_than find range keys greater than this
-    # @option opts [Number] :range_less_than find range keys less than this
-    # @option opts [Number] :range_gte find range keys greater than or equal to this
-    # @option opts [Number] :range_lte find range keys less than or equal to this
-    #
-    # @return [Array] an array of all matching items
-    #
-    def query(table_name, opts = {})
-      adapter.query(table_name, opts)
+    # @param [Array[Array]] key_conditions conditions for the primary key attributes
+    # @param [Array[Array]] non_key_conditions (optional) conditions for non-primary key attributes
+    # @param [Hash] options (optional) the options to query the table with
+    # @option options [Boolean] :consistent_read You can set the ConsistentRead parameter to true and obtain a strongly consistent result
+    # @option options [Boolean] :scan_index_forward Specifies the order for index traversal: If true (default), the traversal is performed in ascending order; if false, the traversal is performed in descending order.
+    # @option options [Symbop] :select The attributes to be returned in the result (one of ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, ...)
+    # @option options [Symbol] :index_name The name of an index to query. This index can be any local secondary index or global secondary index on the table.
+    # @option options [Hash] :exclusive_start_key The primary key of the first item that this operation will evaluate.
+    # @option options [Integer] :batch_size The number of items to lazily load one by one
+    # @option options [Integer] :record_limit The maximum number of items to return (not necessarily the number of evaluated items)
+    # @option options [Integer] :scan_limit The maximum number of items to evaluate (not necessarily the number of matching items)
+    # @option options [Array[Symbol]] :project The attributes to retrieve from the table
+    #
+    # @return [Enumerable] matching items
+    def query(table_name, key_conditions, non_key_conditions = {}, options = {})
+      adapter.query(table_name, key_conditions, non_key_conditions, options)
     end
 
     def self.adapter_plugin_class

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/create_table.rb

@@ -29,7 +29,7 @@ module Dynamoid
           gs_indexes = options[:global_secondary_indexes]
 
           key_schema = {
-            hash_key_schema: { key => (options[:hash_key_type] || :string) },
+            hash_key_schema: { key => options[:hash_key_type] || :string },
             range_key_schema: options[:range_key]
           }
           attribute_definitions = build_all_attribute_definitions(
@@ -69,7 +69,7 @@ module Dynamoid
             end
           end
           resp = client.create_table(client_opts)
-          options[:sync] = true if !options.key?(:sync) && ls_indexes.present? || gs_indexes.present?
+          options[:sync] = true if (!options.key?(:sync) && ls_indexes.present?) || gs_indexes.present?
 
           if options[:sync]
             status = PARSE_TABLE_STATUS.call(resp, :table_description)

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/filter_expression_convertor.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  # @private
+  module AdapterPlugin
+    class AwsSdkV3
+      class FilterExpressionConvertor
+        attr_reader :expression, :name_placeholders, :value_placeholders
+
+        def initialize(conditions, name_placeholders, value_placeholders, name_placeholder_sequence, value_placeholder_sequence)
+          @conditions = conditions
+          @name_placeholders = name_placeholders.dup
+          @value_placeholders = value_placeholders.dup
+          @name_placeholder_sequence = name_placeholder_sequence
+          @value_placeholder_sequence = value_placeholder_sequence
+
+          build
+        end
+
+        private
+
+        def build
+          clauses = []
+
+          @conditions.each do |conditions|
+            if conditions.is_a? Hash
+              clauses << build_for_hash(conditions) unless conditions.empty?
+            elsif conditions.is_a? Array
+              query, placeholders = conditions
+              clauses << build_for_string(query, placeholders)
+            else
+              raise ArgumentError, "expected Hash or Array but actual value is #{conditions}"
+            end
+          end
+
+          @expression = clauses.join(' AND ')
+        end
+
+        def build_for_hash(hash)
+          clauses = hash.map do |name, attribute_conditions|
+            attribute_conditions.map do |operator, value|
+              # replace attribute names with placeholders unconditionally to support
+              # - special characters (e.g. '.', ':', and '#') and
+              # - leading '_'
+              # See
+              # - https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.NamingRules
+              # - https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html#Expressions.ExpressionAttributeNames.AttributeNamesContainingSpecialCharacters
+              name_placeholder = name_placeholder_for(name)
+
+              case operator
+              when :eq
+                "#{name_placeholder} = #{value_placeholder_for(value)}"
+              when :ne
+                "#{name_placeholder} <> #{value_placeholder_for(value)}"
+              when :gt
+                "#{name_placeholder} > #{value_placeholder_for(value)}"
+              when :lt
+                "#{name_placeholder} < #{value_placeholder_for(value)}"
+              when :gte
+                "#{name_placeholder} >= #{value_placeholder_for(value)}"
+              when :lte
+                "#{name_placeholder} <= #{value_placeholder_for(value)}"
+              when :between
+                "#{name_placeholder} BETWEEN #{value_placeholder_for(value[0])} AND #{value_placeholder_for(value[1])}"
+              when :begins_with
+                "begins_with (#{name_placeholder}, #{value_placeholder_for(value)})"
+              when :in
+                list = value.map(&method(:value_placeholder_for)).join(' , ')
+                "#{name_placeholder} IN (#{list})"
+              when :contains
+                "contains (#{name_placeholder}, #{value_placeholder_for(value)})"
+              when :not_contains
+                "NOT contains (#{name_placeholder}, #{value_placeholder_for(value)})"
+              when :null
+                "attribute_not_exists (#{name_placeholder})"
+              when :not_null
+                "attribute_exists (#{name_placeholder})"
+              end
+            end
+          end.flatten
+
+          if clauses.empty?
+            nil
+          else
+            clauses.join(' AND ')
+          end
+        end
+
+        def build_for_string(query, placeholders)
+          placeholders.each do |(k, v)|
+            k = k.to_s
+            k = ":#{k}" unless k.start_with?(':')
+            @value_placeholders[k] = v
+          end
+
+          "(#{query})"
+        end
+
+        def name_placeholder_for(name)
+          placeholder = @name_placeholder_sequence.call
+          @name_placeholders[placeholder] = name
+          placeholder
+        end
+
+        def value_placeholder_for(value)
+          placeholder = @value_placeholder_sequence.call
+          @value_placeholders[placeholder] = value
+          placeholder
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/item_updater.rb

@@ -50,7 +50,19 @@ module Dynamoid
         # Replaces the values of one or more attributes
         #
         def set(values)
-          @updates.merge!(sanitize_attributes(values))
+          values_sanitized = sanitize_attributes(values)
+
+          if Dynamoid.config.store_attribute_with_nil_value
+            @updates.merge!(values_sanitized)
+          else
+            # delete explicitly attributes if assigned nil value and configured
+            # to not store nil values
+            values_to_update = values_sanitized.reject { |_, v| v.nil? }
+            values_to_delete = values_sanitized.select { |_, v| v.nil? }
+
+            @updates.merge!(values_to_update)
+            @deletions.merge!(values_to_delete)
+          end
         end
 
         #
@@ -85,18 +97,25 @@ module Dynamoid
 
         private
 
+        # It's a single low level component available in a public API (with
+        # Document#update/#update! methods). So duplicate sanitizing to some
+        # degree.
+        #
+        # Keep in sync with AwsSdkV3.sanitize_item.
         def sanitize_attributes(attributes)
+          # rubocop:disable Lint/DuplicateBranch
           attributes.transform_values do |v|
             if v.is_a?(Hash)
               v.stringify_keys
             elsif v.is_a?(Set) && v.empty?
               nil
-            elsif v.is_a?(String) && v.empty?
+            elsif v.is_a?(String) && v.empty? && Config.store_empty_string_as_nil
               nil
             else
               v
             end
           end
+          # rubocop:enable Lint/DuplicateBranch
         end
       end
     end