dynamoid 3.8.0 → 3.12.1

data/dynamoid.gemspec

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dynamoid/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'dynamoid'
+  spec.version = Dynamoid::VERSION
+
+  # Keep in sync with README
+  spec.authors = [
+    'Josh Symonds',
+    'Logan Bowers',
+    'Craig Heneveld',
+    'Anatha Kumaran',
+    'Jason Dew',
+    'Luis Arias',
+    'Stefan Neculai',
+    'Philip White',
+    'Peeyush Kumar',
+    'Sumanth Ravipati',
+    'Pascal Corpet',
+    'Brian Glusman',
+    'Peter Boling',
+    'Andrew Konchin'
+  ]
+  spec.email = ['andry.konchin@gmail.com', 'peter.boling@gmail.com', 'brian@stellaservice.com']
+
+  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 committed files
+  spec.files = Dir[
+    'CHANGELOG.md',
+    'dynamoid.gemspec',
+    'lib/**/*',
+    'LICENSE.txt',
+    'README.md',
+    'SECURITY.md'
+  ]
+  spec.homepage = 'http://github.com/Dynamoid/dynamoid'
+  spec.licenses = ['MIT']
+  spec.require_paths = ['lib']
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = "https://github.com/Dynamoid/dynamoid/tree/v#{spec.version}"
+  spec.metadata['changelog_uri'] = "https://github.com/Dynamoid/dynamoid/blob/v#{spec.version}/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/Dynamoid/dynamoid/issues'
+  spec.metadata['documentation_uri'] = "https://www.rubydoc.info/gems/dynamoid/#{spec.version}"
+  spec.metadata['funding_uri'] = 'https://opencollective.com/dynamoid'
+  spec.metadata['wiki_uri'] = 'https://github.com/Dynamoid/dynamoid/wiki'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  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'
+  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
 
@@ -142,7 +142,7 @@ module Dynamoid
       end
     end
 
-    %i[batch_get_item delete_item get_item list_tables put_item truncate batch_write_item batch_delete_item].each do |m|
+    %i[batch_get_item delete_item get_item list_tables put_item truncate batch_write_item batch_delete_item execute].each do |m|
       # Method delegation with benchmark to the underlying adapter. Faster than relying on method_missing.
       #
       # @since 0.2.0
@@ -163,6 +163,7 @@ module Dynamoid
       # https://eregon.me/blog/2019/11/10/the-delegation-challenge-of-ruby27.html
 
       return benchmark(method, *args) { adapter.send(method, *args, &block) } if adapter.respond_to?(method)
+
       super
     end
 
@@ -170,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/execute_statement.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  # @private
+  module AdapterPlugin
+    class AwsSdkV3
+      # Excecute a PartiQL query
+      #
+      # Documentation:
+      # - https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ExecuteStatement.html
+      # - https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#execute_statement-instance_method
+      #
+      # NOTE: For reads result may be paginated. Only pagination with NextToken
+      # is implemented. Currently LastEvaluatedKey in response cannot be fed to
+      # ExecuteStatement to get the next page.
+      #
+      # See also:
+      # - https://repost.aws/questions/QUgNPbBYWiRoOlMsJv-XzrWg/how-to-use-last-evaluated-key-in-execute-statement-request
+      # - https://stackoverflow.com/questions/71438439/aws-dynamodb-executestatement-pagination
+      class ExecuteStatement
+        attr_reader :client, :statement, :parameters, :options
+
+        def initialize(client, statement, parameters, options)
+          @client = client
+          @statement = statement
+          @parameters = parameters
+          @options = options.symbolize_keys.slice(:consistent_read)
+        end
+
+        def call
+          request = {
+            statement: @statement,
+            parameters: @parameters,
+            consistent_read: @options[:consistent_read],
+          }
+
+          response = client.execute_statement(request)
+
+          unless response.next_token
+            return response_to_items(response)
+          end
+
+          Enumerator.new do |yielder|
+            yielder.yield(response_to_items(response))
+
+            while response.next_token
+              request[:next_token] = response.next_token
+              response = client.execute_statement(request)
+              yielder.yield(response_to_items(response))
+            end
+          end
+        end
+
+        private
+
+        def response_to_items(response)
+          response.items.map(&:symbolize_keys)
+        end
+      end
+    end
+  end
+end

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,10 +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|
-            v.is_a?(Hash) ? v.stringify_keys : v
+            if v.is_a?(Hash)
+              v.stringify_keys
+            elsif v.is_a?(Set) && v.empty?
+              nil
+            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

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/middleware/limit.rb

@@ -21,14 +21,17 @@ module Dynamoid
             # lower to obey limits. We can assume the difference won't be
             # negative due to break statements below but choose smaller limit
             # which is why we have 2 separate if statements.
+            #
             # NOTE: Adjusting based on record_limit can cause many HTTP requests
             # being made. We may want to change this behavior, but it affects
             # filtering on data with potentially large gaps.
+            #
             # Example:
             #    User.where('created_at.gte' => 1.day.ago).record_limit(1000)
             #    Records 1-999 User's that fit criteria
             #    Records 1000-2000 Users's that do not fit criteria
             #    Record 2001 fits criteria
+            #
             # The underlying implementation will have 1 page for records 1-999
             # then will request with limit 1 for records 1000-2000 (making 1000
             # requests of limit 1) until hit record 2001.

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