dynamoid 3.9.0 → 3.11.0

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  # @private
+  module AdapterPlugin
+    class AwsSdkV3
+      class ProjectionExpressionConvertor
+        attr_reader :expression, :name_placeholders
+
+        def initialize(names, name_placeholders, name_placeholder_sequence)
+          @names = names
+          @name_placeholders = name_placeholders.dup
+          @name_placeholder_sequence = name_placeholder_sequence
+
+          build
+        end
+
+        private
+
+        def build
+          return if @names.nil? || @names.empty?
+
+          clauses = @names.map do |name|
+            # 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
+            placeholder = @name_placeholder_sequence.call
+            @name_placeholders[placeholder] = name
+            placeholder
+          end
+
+          @expression = clauses.join(' , ')
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,8 @@
 require_relative 'middleware/backoff'
 require_relative 'middleware/limit'
 require_relative 'middleware/start_key'
+require_relative 'filter_expression_convertor'
+require_relative 'projection_expression_convertor'
 
 module Dynamoid
   # @private
@@ -10,20 +12,19 @@ module Dynamoid
     class AwsSdkV3
       class Query
         OPTIONS_KEYS = %i[
-          limit hash_key hash_value range_key consistent_read scan_index_forward
-          select index_name batch_size exclusive_start_key record_limit scan_limit
-          project
+          consistent_read scan_index_forward select index_name batch_size
+          exclusive_start_key record_limit scan_limit project
         ].freeze
 
         attr_reader :client, :table, :options, :conditions
 
-        def initialize(client, table, opts = {})
+        def initialize(client, table, key_conditions, non_key_conditions, options)
           @client = client
           @table = table
 
-          opts = opts.symbolize_keys
-          @options = opts.slice(*OPTIONS_KEYS)
-          @conditions = opts.except(*OPTIONS_KEYS)
+          @key_conditions = key_conditions
+          @non_key_conditions = non_key_conditions
+          @options = options.slice(*OPTIONS_KEYS)
         end
 
         def call
@@ -53,6 +54,37 @@ module Dynamoid
         private
 
         def build_request
+          # expressions
+          name_placeholder = +'#_a0'
+          value_placeholder = +':_a0'
+
+          name_placeholder_sequence = -> { name_placeholder.next!.dup }
+          value_placeholder_sequence = -> { value_placeholder.next!.dup }
+
+          name_placeholders = {}
+          value_placeholders = {}
+
+          # Deal with various limits and batching
+          batch_size = options[:batch_size]
+          limit = [record_limit, scan_limit, batch_size].compact.min
+
+          # key condition expression
+          convertor = FilterExpressionConvertor.new([@key_conditions], name_placeholders, value_placeholders, name_placeholder_sequence, value_placeholder_sequence)
+          key_condition_expression = convertor.expression
+          value_placeholders = convertor.value_placeholders
+          name_placeholders = convertor.name_placeholders
+
+          # filter expression
+          convertor = FilterExpressionConvertor.new(@non_key_conditions, name_placeholders, value_placeholders, name_placeholder_sequence, value_placeholder_sequence)
+          filter_expression = convertor.expression
+          value_placeholders = convertor.value_placeholders
+          name_placeholders = convertor.name_placeholders
+
+          # projection expression
+          convertor = ProjectionExpressionConvertor.new(options[:project], name_placeholders, name_placeholder_sequence)
+          projection_expression = convertor.expression
+          name_placeholders = convertor.name_placeholders
+
           request = options.slice(
             :consistent_read,
             :scan_index_forward,
@@ -61,15 +93,13 @@ module Dynamoid
             :exclusive_start_key
           ).compact
 
-          # Deal with various limits and batching
-          batch_size = options[:batch_size]
-          limit = [record_limit, scan_limit, batch_size].compact.min
-
-          request[:limit]             = limit if limit
-          request[:table_name]        = table.name
-          request[:key_conditions]    = key_conditions
-          request[:query_filter]      = query_filter
-          request[:attributes_to_get] = attributes_to_get
+          request[:table_name]                  = table.name
+          request[:limit]                       = limit                     if limit
+          request[:key_condition_expression]    = key_condition_expression  if key_condition_expression.present?
+          request[:filter_expression]           = filter_expression         if filter_expression.present?
+          request[:expression_attribute_values] = value_placeholders        if value_placeholders.present?
+          request[:expression_attribute_names]  = name_placeholders         if name_placeholders.present?
+          request[:projection_expression]       = projection_expression     if projection_expression.present?
 
           request
         end
@@ -81,51 +111,6 @@ module Dynamoid
         def scan_limit
           options[:scan_limit]
         end
-
-        def hash_key_name
-          (options[:hash_key] || table.hash_key)
-        end
-
-        def range_key_name
-          (options[:range_key] || table.range_key)
-        end
-
-        def key_conditions
-          result = {
-            hash_key_name => {
-              comparison_operator: AwsSdkV3::EQ,
-              attribute_value_list: AwsSdkV3.attribute_value_list(AwsSdkV3::EQ, options[:hash_value].freeze)
-            }
-          }
-
-          conditions.slice(*AwsSdkV3::RANGE_MAP.keys).each do |k, _v|
-            op = AwsSdkV3::RANGE_MAP[k]
-
-            result[range_key_name] = {
-              comparison_operator: op,
-              attribute_value_list: AwsSdkV3.attribute_value_list(op, conditions[k].freeze)
-            }
-          end
-
-          result
-        end
-
-        def query_filter
-          conditions.except(*AwsSdkV3::RANGE_MAP.keys).reduce({}) do |result, (attr, cond)|
-            condition = {
-              comparison_operator: AwsSdkV3::FIELD_MAP[cond.keys[0]],
-              attribute_value_list: AwsSdkV3.attribute_value_list(AwsSdkV3::FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
-            }
-            result[attr] = condition
-            result
-          end
-        end
-
-        def attributes_to_get
-          return if options[:project].nil?
-
-          options[:project].map(&:to_s)
-        end
       end
     end
   end

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

@@ -3,6 +3,8 @@
 require_relative 'middleware/backoff'
 require_relative 'middleware/limit'
 require_relative 'middleware/start_key'
+require_relative 'filter_expression_convertor'
+require_relative 'projection_expression_convertor'
 
 module Dynamoid
   # @private
@@ -11,7 +13,7 @@ module Dynamoid
       class Scan
         attr_reader :client, :table, :conditions, :options
 
-        def initialize(client, table, conditions = {}, options = {})
+        def initialize(client, table, conditions = [], options = {})
           @client = client
           @table = table
           @conditions = conditions
@@ -45,6 +47,31 @@ module Dynamoid
         private
 
         def build_request
+          # expressions
+          name_placeholder = +'#_a0'
+          value_placeholder = +':_a0'
+
+          name_placeholder_sequence = -> { name_placeholder.next!.dup }
+          value_placeholder_sequence = -> { value_placeholder.next!.dup }
+
+          name_placeholders = {}
+          value_placeholders = {}
+
+          # Deal with various limits and batching
+          batch_size = options[:batch_size]
+          limit = [record_limit, scan_limit, batch_size].compact.min
+
+          # filter expression
+          convertor = FilterExpressionConvertor.new(conditions, name_placeholders, value_placeholders, name_placeholder_sequence, value_placeholder_sequence)
+          filter_expression = convertor.expression
+          value_placeholders = convertor.value_placeholders
+          name_placeholders = convertor.name_placeholders
+
+          # projection expression
+          convertor = ProjectionExpressionConvertor.new(options[:project], name_placeholders, name_placeholder_sequence)
+          projection_expression = convertor.expression
+          name_placeholders = convertor.name_placeholders
+
           request = options.slice(
             :consistent_read,
             :exclusive_start_key,
@@ -52,14 +79,12 @@ module Dynamoid
             :index_name
           ).compact
 
-          # Deal with various limits and batching
-          batch_size = options[:batch_size]
-          limit = [record_limit, scan_limit, batch_size].compact.min
-
-          request[:limit]             = limit if limit
-          request[:table_name]        = table.name
-          request[:scan_filter]       = scan_filter
-          request[:attributes_to_get] = attributes_to_get
+          request[:table_name]                  = table.name
+          request[:limit]                       = limit                 if limit
+          request[:filter_expression]           = filter_expression     if filter_expression.present?
+          request[:expression_attribute_values] = value_placeholders    if value_placeholders.present?
+          request[:expression_attribute_names]  = name_placeholders     if name_placeholders.present?
+          request[:projection_expression]       = projection_expression if projection_expression.present?
 
           request
         end
@@ -71,25 +96,6 @@ module Dynamoid
         def scan_limit
           options[:scan_limit]
         end
-
-        def scan_filter
-          conditions.reduce({}) do |result, (attr, cond)|
-            condition = {
-              comparison_operator: AwsSdkV3::FIELD_MAP[cond.keys[0]],
-              attribute_value_list: AwsSdkV3.attribute_value_list(AwsSdkV3::FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
-            }
-            # nil means operator doesn't require attribute value list
-            conditions.delete(:attribute_value_list) if conditions[:attribute_value_list].nil?
-            result[attr] = condition
-            result
-          end
-        end
-
-        def attributes_to_get
-          return if options[:project].nil?
-
-          options[:project].map(&:to_s)
-        end
       end
     end
   end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Prepare all the actions of the transaction for sending to the AWS SDK.
+module Dynamoid
+  module AdapterPlugin
+    class AwsSdkV3
+      class Transact
+        attr_reader :client
+
+        def initialize(client)
+          @client = client
+        end
+
+        # Perform all of the item actions in a single transaction.
+        #
+        # @param [Array] items of type Dynamoid::Transaction::Action or
+        # any other object whose to_h is a transact_item hash
+        #
+        def transact_write_items(items)
+          transact_items = items.map(&:to_h)
+          params = {
+            transact_items: transact_items,
+            return_consumed_capacity: 'TOTAL',
+            return_item_collection_metrics: 'SIZE'
+          }
+          client.transact_write_items(params) # returns this
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/adapter_plugin/aws_sdk_v3.rb

@@ -8,13 +8,14 @@ require_relative 'aws_sdk_v3/batch_get_item'
 require_relative 'aws_sdk_v3/item_updater'
 require_relative 'aws_sdk_v3/table'
 require_relative 'aws_sdk_v3/until_past_table_status'
+require_relative 'aws_sdk_v3/transact'
 
 module Dynamoid
   # @private
   module AdapterPlugin
     # The AwsSdkV3 adapter provides support for the aws-sdk version 2 for ruby.
 
-    # Note: Don't use keyword arguments in public methods as far as method
+    # NOTE: Don't use keyword arguments in public methods as far as method
     # calls on adapter are delegated to the plugin.
     #
     # There are breaking changes in Ruby related to delegating keyword
@@ -24,31 +25,6 @@ module Dynamoid
 
     class AwsSdkV3
       EQ = 'EQ'
-      RANGE_MAP = {
-        range_greater_than: 'GT',
-        range_less_than:    'LT',
-        range_gte:          'GE',
-        range_lte:          'LE',
-        range_begins_with:  'BEGINS_WITH',
-        range_between:      'BETWEEN',
-        range_eq:           'EQ'
-      }.freeze
-
-      FIELD_MAP = {
-        eq:           'EQ',
-        ne:           'NE',
-        gt:           'GT',
-        lt:           'LT',
-        gte:          'GE',
-        lte:          'LE',
-        begins_with:  'BEGINS_WITH',
-        between:      'BETWEEN',
-        in:           'IN',
-        contains:     'CONTAINS',
-        not_contains: 'NOT_CONTAINS',
-        null:         'NULL',
-        not_null:     'NOT_NULL',
-      }.freeze
       HASH_KEY  = 'HASH'
       RANGE_KEY = 'RANGE'
       STRING_TYPE  = 'S'
@@ -70,26 +46,72 @@ module Dynamoid
 
       CONNECTION_CONFIG_OPTIONS = %i[endpoint region http_continue_timeout http_idle_timeout http_open_timeout http_read_timeout].freeze
 
-      attr_reader :table_cache
+      # See https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html
+      # rubocop:disable Metrics/CollectionLiteralLength
+      RESERVED_WORDS = Set.new(
+        %i[
+          ABORT ABSOLUTE ACTION ADD AFTER AGENT AGGREGATE ALL ALLOCATE ALTER ANALYZE
+          AND ANY ARCHIVE ARE ARRAY AS ASC ASCII ASENSITIVE ASSERTION ASYMMETRIC AT
+          ATOMIC ATTACH ATTRIBUTE AUTH AUTHORIZATION AUTHORIZE AUTO AVG BACK BACKUP
+          BASE BATCH BEFORE BEGIN BETWEEN BIGINT BINARY BIT BLOB BLOCK BOOLEAN BOTH
+          BREADTH BUCKET BULK BY BYTE CALL CALLED CALLING CAPACITY CASCADE CASCADED
+          CASE CAST CATALOG CHAR CHARACTER CHECK CLASS CLOB CLOSE CLUSTER CLUSTERED
+          CLUSTERING CLUSTERS COALESCE COLLATE COLLATION COLLECTION COLUMN COLUMNS
+          COMBINE COMMENT COMMIT COMPACT COMPILE COMPRESS CONDITION CONFLICT CONNECT
+          CONNECTION CONSISTENCY CONSISTENT CONSTRAINT CONSTRAINTS CONSTRUCTOR
+          CONSUMED CONTINUE CONVERT COPY CORRESPONDING COUNT COUNTER CREATE CROSS
+          CUBE CURRENT CURSOR CYCLE DATA DATABASE DATE DATETIME DAY DEALLOCATE DEC
+          DECIMAL DECLARE DEFAULT DEFERRABLE DEFERRED DEFINE DEFINED DEFINITION
+          DELETE DELIMITED DEPTH DEREF DESC DESCRIBE DESCRIPTOR DETACH DETERMINISTIC
+          DIAGNOSTICS DIRECTORIES DISABLE DISCONNECT DISTINCT DISTRIBUTE DO DOMAIN
+          DOUBLE DROP DUMP DURATION DYNAMIC EACH ELEMENT ELSE ELSEIF EMPTY ENABLE
+          END EQUAL EQUALS ERROR ESCAPE ESCAPED EVAL EVALUATE EXCEEDED EXCEPT
+          EXCEPTION EXCEPTIONS EXCLUSIVE EXEC EXECUTE EXISTS EXIT EXPLAIN EXPLODE
+          EXPORT EXPRESSION EXTENDED EXTERNAL EXTRACT FAIL FALSE FAMILY FETCH FIELDS
+          FILE FILTER FILTERING FINAL FINISH FIRST FIXED FLATTERN FLOAT FOR FORCE
+          FOREIGN FORMAT FORWARD FOUND FREE FROM FULL FUNCTION FUNCTIONS GENERAL
+          GENERATE GET GLOB GLOBAL GO GOTO GRANT GREATER GROUP GROUPING HANDLER HASH
+          HAVE HAVING HEAP HIDDEN HOLD HOUR IDENTIFIED IDENTITY IF IGNORE IMMEDIATE
+          IMPORT IN INCLUDING INCLUSIVE INCREMENT INCREMENTAL INDEX INDEXED INDEXES
+          INDICATOR INFINITE INITIALLY INLINE INNER INNTER INOUT INPUT INSENSITIVE
+          INSERT INSTEAD INT INTEGER INTERSECT INTERVAL INTO INVALIDATE IS ISOLATION
+          ITEM ITEMS ITERATE JOIN KEY KEYS LAG LANGUAGE LARGE LAST LATERAL LEAD
+          LEADING LEAVE LEFT LENGTH LESS LEVEL LIKE LIMIT LIMITED LINES LIST LOAD
+          LOCAL LOCALTIME LOCALTIMESTAMP LOCATION LOCATOR LOCK LOCKS LOG LOGED LONG
+          LOOP LOWER MAP MATCH MATERIALIZED MAX MAXLEN MEMBER MERGE METHOD METRICS
+          MIN MINUS MINUTE MISSING MOD MODE MODIFIES MODIFY MODULE MONTH MULTI
+          MULTISET NAME NAMES NATIONAL NATURAL NCHAR NCLOB NEW NEXT NO NONE NOT NULL
+          NULLIF NUMBER NUMERIC OBJECT OF OFFLINE OFFSET OLD ON ONLINE ONLY OPAQUE
+          OPEN OPERATOR OPTION OR ORDER ORDINALITY OTHER OTHERS OUT OUTER OUTPUT
+          OVER OVERLAPS OVERRIDE OWNER PAD PARALLEL PARAMETER PARAMETERS PARTIAL
+          PARTITION PARTITIONED PARTITIONS PATH PERCENT PERCENTILE PERMISSION
+          PERMISSIONS PIPE PIPELINED PLAN POOL POSITION PRECISION PREPARE PRESERVE
+          PRIMARY PRIOR PRIVATE PRIVILEGES PROCEDURE PROCESSED PROJECT PROJECTION
+          PROPERTY PROVISIONING PUBLIC PUT QUERY QUIT QUORUM RAISE RANDOM RANGE RANK
+          RAW READ READS REAL REBUILD RECORD RECURSIVE REDUCE REF REFERENCE
+          REFERENCES REFERENCING REGEXP REGION REINDEX RELATIVE RELEASE REMAINDER
+          RENAME REPEAT REPLACE REQUEST RESET RESIGNAL RESOURCE RESPONSE RESTORE
+          RESTRICT RESULT RETURN RETURNING RETURNS REVERSE REVOKE RIGHT ROLE ROLES
+          ROLLBACK ROLLUP ROUTINE ROW ROWS RULE RULES SAMPLE SATISFIES SAVE SAVEPOINT
+          SCAN SCHEMA SCOPE SCROLL SEARCH SECOND SECTION SEGMENT SEGMENTS SELECT SELF
+          SEMI SENSITIVE SEPARATE SEQUENCE SERIALIZABLE SESSION SET SETS SHARD SHARE
+          SHARED SHORT SHOW SIGNAL SIMILAR SIZE SKEWED SMALLINT SNAPSHOT SOME SOURCE
+          SPACE SPACES SPARSE SPECIFIC SPECIFICTYPE SPLIT SQL SQLCODE SQLERROR
+          SQLEXCEPTION SQLSTATE SQLWARNING START STATE STATIC STATUS STORAGE STORE
+          STORED STREAM STRING STRUCT STYLE SUB SUBMULTISET SUBPARTITION SUBSTRING
+          SUBTYPE SUM SUPER SYMMETRIC SYNONYM SYSTEM TABLE TABLESAMPLE TEMP TEMPORARY
+          TERMINATED TEXT THAN THEN THROUGHPUT TIME TIMESTAMP TIMEZONE TINYINT TO
+          TOKEN TOTAL TOUCH TRAILING TRANSACTION TRANSFORM TRANSLATE TRANSLATION
+          TREAT TRIGGER TRIM TRUE TRUNCATE TTL TUPLE TYPE UNDER UNDO UNION UNIQUE UNIT
+          UNKNOWN UNLOGGED UNNEST UNPROCESSED UNSIGNED UNTIL UPDATE UPPER URL USAGE
+          USE USER USERS USING UUID VACUUM VALUE VALUED VALUES VARCHAR VARIABLE
+          VARIANCE VARINT VARYING VIEW VIEWS VIRTUAL VOID WAIT WHEN WHENEVER WHERE
+          WHILE WINDOW WITH WITHIN WITHOUT WORK WRAPPED WRITE YEAR ZONE
+        ]
+      ).freeze
+      # rubocop:enable Metrics/CollectionLiteralLength
 
-      # Build an array of values for Condition
-      # Is used in ScanFilter and QueryFilter
-      # https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html
-      # @param [String] operator value of RANGE_MAP or FIELD_MAP hash, e.g. "EQ", "LT" etc
-      # @param [Object] value scalar value or array/set
-      def self.attribute_value_list(operator, value)
-        # For BETWEEN and IN operators we should keep value as is (it should be already an array)
-        # NULL and NOT_NULL require absence of attribute list
-        # For all the other operators we wrap the value with array
-        # https://docs.aws.amazon.com/en_us/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Conditions.html
-        if %w[BETWEEN IN].include?(operator)
-          [value].flatten
-        elsif %w[NULL NOT_NULL].include?(operator)
-          nil
-        else
-          [value]
-        end
-      end
+      attr_reader :table_cache
 
       # Establish the connection to DynamoDB.
       #
@@ -268,6 +290,10 @@ module Dynamoid
         raise Dynamoid::Errors::ConditionalCheckFailedException, e
       end
 
+      def transact_write_items(items)
+        Transact.new(client).transact_write_items(items)
+      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
@@ -470,25 +496,32 @@ 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] options the options to query the table with
-      # @option options [String] :hash_value the value of the hash key to find
-      # @option options [Number, Number] :range_between find the range key within this range
-      # @option options [Number] :range_greater_than find range keys greater than this
-      # @option options [Number] :range_less_than find range keys less than this
-      # @option options [Number] :range_gte find range keys greater than or equal to this
-      # @option options [Number] :range_lte find range keys less than or equal to this
+      # @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
       #
       # @since 1.0.0
       #
       # @todo Provide support for various other options http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#query-instance_method
-      def query(table_name, options = {})
+      def query(table_name, key_conditions, non_key_conditions = [], options = {})
         Enumerator.new do |yielder|
           table = describe_table(table_name)
 
-          Query.new(client, table, options).call.each do |page|
+          Query.new(client, table, key_conditions, non_key_conditions, options).call.each do |page|
             yielder.yield(
               page.items.map { |item| item_to_hash(item) },
               last_evaluated_key: page.last_evaluated_key
@@ -497,11 +530,11 @@ module Dynamoid
         end
       end
 
-      def query_count(table_name, options = {})
+      def query_count(table_name, key_conditions, non_key_conditions, options)
         table = describe_table(table_name)
         options[:select] = 'COUNT'
 
-        Query.new(client, table, options).call
+        Query.new(client, table, key_conditions, non_key_conditions, options).call
           .map(&:count)
           .reduce(:+)
       end
@@ -517,7 +550,7 @@ module Dynamoid
       # @since 1.0.0
       #
       # @todo: Provide support for various options http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#scan-instance_method
-      def scan(table_name, conditions = {}, options = {})
+      def scan(table_name, conditions = [], options = {})
         Enumerator.new do |yielder|
           table = describe_table(table_name)
 
@@ -530,7 +563,7 @@ module Dynamoid
         end
       end
 
-      def scan_count(table_name, conditions = {}, options = {})
+      def scan_count(table_name, conditions = [], options = {})
         table = describe_table(table_name)
         options[:select] = 'COUNT'
 
@@ -558,7 +591,7 @@ module Dynamoid
       end
 
       def count(table_name)
-        describe_table(table_name, true).item_count
+        describe_table(table_name, reload: true).item_count
       end
 
       # Run PartiQL query.
@@ -605,10 +638,7 @@ module Dynamoid
         conditions.delete(:unless_exists).try(:each) do |col|
           expected[col.to_s][:exists] = false
         end
-        conditions.delete(:if_exists).try(:each) do |col, val|
-          expected[col.to_s][:exists] = true
-          expected[col.to_s][:value] = val
-        end
+
         conditions.delete(:if).try(:each) do |col, val|
           expected[col.to_s][:value] = val
         end
@@ -619,7 +649,7 @@ module Dynamoid
       #
       # New, semi-arbitrary API to get data on the table
       #
-      def describe_table(table_name, reload = false)
+      def describe_table(table_name, reload: false)
         (!reload && table_cache[table_name]) || begin
           table_cache[table_name] = Table.new(client.describe_table(table_name: table_name).data)
         end
@@ -637,8 +667,7 @@ module Dynamoid
         store_attribute_with_nil_value = config_value.nil? ? false : !!config_value
 
         attributes.reject do |_, v|
-          ((v.is_a?(Set) || v.is_a?(String)) && v.empty?) ||
-            (!store_attribute_with_nil_value && v.nil?)
+          !store_attribute_with_nil_value && v.nil?
         end.transform_values do |v|
           v.is_a?(Hash) ? v.stringify_keys : v
         end

data/lib/dynamoid/associations/belongs_to.rb

@@ -39,14 +39,14 @@ module Dynamoid
       #
       # @since 0.2.0
       def target_association
-        has_many_key_name = options[:inverse_of] || source.class.to_s.underscore.pluralize.to_sym
-        has_one_key_name = options[:inverse_of] || source.class.to_s.underscore.to_sym
-        unless target_class.associations[has_many_key_name].nil?
-          return has_many_key_name if target_class.associations[has_many_key_name][:type] == :has_many
+        name = options[:inverse_of] || source.class.to_s.underscore.pluralize.to_sym
+        if target_class.associations.dig(name, :type) == :has_many
+          return name
         end
 
-        unless target_class.associations[has_one_key_name].nil?
-          return has_one_key_name if target_class.associations[has_one_key_name][:type] == :has_one
+        name = options[:inverse_of] || source.class.to_s.underscore.to_sym
+        if target_class.associations.dig(name, :type) == :has_one
+          return name # rubocop:disable Style/RedundantReturn
         end
       end
     end

data/lib/dynamoid/associations.rb

@@ -265,7 +265,7 @@ module Dynamoid
           @associations[:"#{name}_ids"] ||= Dynamoid::Associations.const_get(type.to_s.camelcase).new(self, name, options)
         end
 
-        define_method("#{name}=".to_sym) do |objects|
+        define_method(:"#{name}=") do |objects|
           @associations[:"#{name}_ids"] ||= Dynamoid::Associations.const_get(type.to_s.camelcase).new(self, name, options)
           @associations[:"#{name}_ids"].setter(objects)
         end

data/lib/dynamoid/components.rb

@@ -13,6 +13,7 @@ module Dynamoid
 
       define_model_callbacks :create, :save, :destroy, :update
       define_model_callbacks :initialize, :find, :touch, only: :after
+      define_model_callbacks :commit, :rollback, only: :after
 
       before_save :set_expires_field
       after_initialize :set_inheritance_field

data/lib/dynamoid/config/options.rb

@@ -33,21 +33,21 @@ module Dynamoid
         defaults[name] = settings[name] = options[:default]
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}
-            settings[#{name.inspect}]
-          end
+          def #{name}                                               # def endpoint
+            settings[#{name.inspect}]                               #   settings["endpoint"]
+          end                                                       # end
 
-          def #{name}=(value)
-            settings[#{name.inspect}] = value
-          end
+          def #{name}=(value)                                       # def endpoint=(value)
+            settings[#{name.inspect}] = value                       #   settings["endpoint"] = value
+          end                                                       # end
 
-          def #{name}?
-            #{name}
-          end
+          def #{name}?                                              # def endpoint?
+            #{name}                                                 #   endpoint
+          end                                                       # end
 
-          def reset_#{name}
-            settings[#{name.inspect}] = defaults[#{name.inspect}]
-          end
+          def reset_#{name}                                         # def reset_endpoint
+            settings[#{name.inspect}] = defaults[#{name.inspect}]   #   settings["endpoint"] = defaults["endpoint"]
+          end                                                       # end
         RUBY
       end