dynamoid 3.9.0 → 3.10.0

data/lib/dynamoid/criteria/chain.rb

@@ -1,29 +1,35 @@
 # frozen_string_literal: true
 
 require_relative 'key_fields_detector'
-require_relative 'ignored_conditions_detector'
-require_relative 'overwritten_conditions_detector'
 require_relative 'nonexistent_fields_detector'
+require_relative 'where_conditions'
 
 module Dynamoid
   module Criteria
     # The criteria chain is equivalent to an ActiveRecord relation (and realistically I should change the name from
     # chain to relation). It is a chainable object that builds up a query and eventually executes it by a Query or Scan.
     class Chain
-      attr_reader :query, :source, :consistent_read, :key_fields_detector
+      attr_reader :source, :consistent_read, :key_fields_detector
 
       include Enumerable
+
+      ALLOWED_FIELD_OPERATORS = Set.new(
+        %w[
+          eq ne gt lt gte lte between begins_with in contains not_contains null not_null
+        ]
+      ).freeze
+
       # Create a new criteria chain.
       #
       # @param [Class] source the class upon which the ultimate query will be performed.
       def initialize(source)
-        @query = {}
+        @where_conditions = WhereConditions.new
         @source = source
         @consistent_read = false
         @scan_index_forward = true
 
-        # we should re-initialize keys detector every time we change query
-        @key_fields_detector = KeyFieldsDetector.new(@query, @source)
+        # we should re-initialize keys detector every time we change @where_conditions
+        @key_fields_detector = KeyFieldsDetector.new(@where_conditions, @source)
       end
 
       # Returns a chain which is a result of filtering current chain with the specified conditions.
@@ -92,25 +98,15 @@ module Dynamoid
       # @return [Dynamoid::Criteria::Chain]
       # @since 0.2.0
       def where(args)
-        detector = IgnoredConditionsDetector.new(args)
-        if detector.found?
-          Dynamoid.logger.warn(detector.warning_message)
-        end
-
-        detector = OverwrittenConditionsDetector.new(@query, args)
-        if detector.found?
-          Dynamoid.logger.warn(detector.warning_message)
-        end
-
         detector = NonexistentFieldsDetector.new(args, @source)
         if detector.found?
           Dynamoid.logger.warn(detector.warning_message)
         end
 
-        query.update(args.symbolize_keys)
+        @where_conditions.update(args.symbolize_keys)
 
-        # we should re-initialize keys detector every time we change query
-        @key_fields_detector = KeyFieldsDetector.new(@query, @source, forced_index_name: @forced_index_name)
+        # we should re-initialize keys detector every time we change @where_conditions
+        @key_fields_detector = KeyFieldsDetector.new(@where_conditions, @source, forced_index_name: @forced_index_name)
 
         self
       end
@@ -187,7 +183,7 @@ module Dynamoid
       def first(*args)
         n = args.first || 1
 
-        return dup.scan_limit(n).to_a.first(*args) if @query.blank?
+        return dup.scan_limit(n).to_a.first(*args) if @where_conditions.empty?
         return super if @key_fields_detector.non_key_present?
 
         dup.record_limit(n).to_a.first(*args)
@@ -230,12 +226,12 @@ module Dynamoid
         ranges = []
 
         if @key_fields_detector.key_present?
-          Dynamoid.adapter.query(source.table_name, range_query).flat_map { |i| i }.collect do |hash|
+          Dynamoid.adapter.query(source.table_name, query_key_conditions, query_non_key_conditions, query_options).flat_map { |i| i }.collect do |hash|
             ids << hash[source.hash_key.to_sym]
             ranges << hash[source.range_key.to_sym] if source.range_key
           end
         else
-          Dynamoid.adapter.scan(source.table_name, scan_query, scan_opts).flat_map { |i| i }.collect do |hash|
+          Dynamoid.adapter.scan(source.table_name, scan_conditions, scan_options).flat_map { |i| i }.collect do |hash|
             ids << hash[source.hash_key.to_sym]
             ranges << hash[source.range_key.to_sym] if source.range_key
           end
@@ -384,7 +380,7 @@ module Dynamoid
         raise Dynamoid::Errors::InvalidIndex, "Unknown index #{index_name}" unless @source.find_index_by_name(index_name)
 
         @forced_index_name = index_name
-        @key_fields_detector = KeyFieldsDetector.new(@query, @source, forced_index_name: index_name)
+        @key_fields_detector = KeyFieldsDetector.new(@where_conditions, @source, forced_index_name: index_name)
         self
       end
 
@@ -451,9 +447,9 @@ module Dynamoid
       # It takes one or more field names and returns a collection of models with only
       # these fields set.
       #
-      #   Post.where('views_count.gt' => 1000).select(:title)
-      #   Post.where('views_count.gt' => 1000).select(:title, :created_at)
-      #   Post.select(:id)
+      #   Post.where('views_count.gt' => 1000).project(:title)
+      #   Post.where('views_count.gt' => 1000).project(:title, :created_at)
+      #   Post.project(:id)
       #
       # It can be used to avoid loading large field values and to decrease a
       # memory footprint.
@@ -487,6 +483,8 @@ module Dynamoid
       def pluck(*args)
         fields = args.map(&:to_sym)
 
+        # `project` has a side effect - it sets `@project` instance variable.
+        # So use a duplicate to not pollute original chain.
         scope = dup
         scope.project(*fields)
 
@@ -535,7 +533,7 @@ module Dynamoid
         if @key_fields_detector.key_present?
           raw_pages_via_query
         else
-          issue_scan_warning if Dynamoid::Config.warn_on_scan && query.present?
+          issue_scan_warning if Dynamoid::Config.warn_on_scan && !@where_conditions.empty?
           raw_pages_via_scan
         end
       end
@@ -547,7 +545,7 @@ module Dynamoid
       # @since 3.1.0
       def raw_pages_via_query
         Enumerator.new do |y|
-          Dynamoid.adapter.query(source.table_name, range_query).each do |items, metadata|
+          Dynamoid.adapter.query(source.table_name, query_key_conditions, query_non_key_conditions, query_options).each do |items, metadata|
             options = metadata.slice(:last_evaluated_key)
 
             y.yield items, options
@@ -562,7 +560,7 @@ module Dynamoid
       # @since 3.1.0
       def raw_pages_via_scan
         Enumerator.new do |y|
-          Dynamoid.adapter.scan(source.table_name, scan_query, scan_opts).each do |items, metadata|
+          Dynamoid.adapter.scan(source.table_name, scan_conditions, scan_options).each do |items, metadata|
             options = metadata.slice(:last_evaluated_key)
 
             y.yield items, options
@@ -575,121 +573,88 @@ module Dynamoid
         Dynamoid.logger.warn "You can index this query by adding index declaration to #{source.to_s.underscore}.rb:"
         Dynamoid.logger.warn "* global_secondary_index hash_key: 'some-name', range_key: 'some-another-name'"
         Dynamoid.logger.warn "* local_secondary_index range_key: 'some-name'"
-        Dynamoid.logger.warn "Not indexed attributes: #{query.keys.sort.collect { |name| ":#{name}" }.join(', ')}"
+        Dynamoid.logger.warn "Not indexed attributes: #{@where_conditions.keys.sort.collect { |name| ":#{name}" }.join(', ')}"
       end
 
       def count_via_query
-        Dynamoid.adapter.query_count(source.table_name, range_query)
+        Dynamoid.adapter.query_count(source.table_name, query_key_conditions, query_non_key_conditions, query_options)
       end
 
       def count_via_scan
-        Dynamoid.adapter.scan_count(source.table_name, scan_query, scan_opts)
-      end
-
-      def range_hash(key)
-        name, operation = key.to_s.split('.')
-        val = type_cast_condition_parameter(name, query[key])
-
-        case operation
-        when 'gt'
-          { range_greater_than: val }
-        when 'lt'
-          { range_less_than: val }
-        when 'gte'
-          { range_gte: val }
-        when 'lte'
-          { range_lte: val }
-        when 'between'
-          { range_between: val }
-        when 'begins_with'
-          { range_begins_with: val }
-        end
+        Dynamoid.adapter.scan_count(source.table_name, scan_conditions, scan_options)
       end
 
-      def field_hash(key)
-        name, operation = key.to_s.split('.')
-        val = type_cast_condition_parameter(name, query[key])
-
-        hash = case operation
-               when 'ne'
-                 { ne: val }
-               when 'gt'
-                 { gt: val }
-               when 'lt'
-                 { lt: val }
-               when 'gte'
-                 { gte: val }
-               when 'lte'
-                 { lte: val }
-               when 'between'
-                 { between: val }
-               when 'begins_with'
-                 { begins_with: val }
-               when 'in'
-                 { in: val }
-               when 'contains'
-                 { contains: val }
-               when 'not_contains'
-                 { not_contains: val }
-               # NULL/NOT_NULL operators don't have parameters
-               # So { null: true } means NULL check and { null: false } means NOT_NULL one
-               # The same logic is used for { not_null: BOOL }
-               when 'null'
-                 val ? { null: nil } : { not_null: nil }
-               when 'not_null'
-                 val ? { not_null: nil } : { null: nil }
-               end
-
-        { name.to_sym => hash }
-      end
-
-      def consistent_opts
-        { consistent_read: consistent_read }
-      end
-
-      def range_query
-        opts = {}
-        query = self.query
+      def field_condition(key, value_before_type_casting)
+        name, operator = key.to_s.split('.')
+        value = type_cast_condition_parameter(name, value_before_type_casting)
+        operator ||= 'eq'
 
-        # Honor STI and :type field if it presents
-        if @source.attributes.key?(@source.inheritance_field) &&
-           @key_fields_detector.hash_key.to_sym != @source.inheritance_field.to_sym
-          query.update(sti_condition)
+        unless operator.in? ALLOWED_FIELD_OPERATORS
+          raise Dynamoid::Errors::Error, "Unsupported operator #{operator} in #{key}"
         end
 
+        condition =
+          case operator
+            # NULL/NOT_NULL operators don't have parameters
+            # So { null: true } means NULL check and { null: false } means NOT_NULL one
+            # The same logic is used for { not_null: BOOL }
+          when 'null'
+            value ? [:null, nil] : [:not_null, nil]
+          when 'not_null'
+            value ? [:not_null, nil] : [:null, nil]
+          else
+            [operator.to_sym, value]
+          end
+
+        [name.to_sym, condition]
+      end
+
+      def query_key_conditions
+        opts = {}
+
         # Add hash key
-        opts[:hash_key] = @key_fields_detector.hash_key
-        opts[:hash_value] = type_cast_condition_parameter(@key_fields_detector.hash_key, query[@key_fields_detector.hash_key])
+        # TODO: always have hash key in @where_conditions?
+        _, condition = field_condition(@key_fields_detector.hash_key, @where_conditions[@key_fields_detector.hash_key])
+        opts[@key_fields_detector.hash_key] = [condition]
 
         # Add range key
         if @key_fields_detector.range_key
-          add_range_key_to_range_query(query, opts)
-        end
+          if @where_conditions[@key_fields_detector.range_key].present?
+            _, condition = field_condition(@key_fields_detector.range_key, @where_conditions[@key_fields_detector.range_key])
+            opts[@key_fields_detector.range_key] = [condition]
+          end
 
-        (query.keys.map(&:to_sym) - [@key_fields_detector.hash_key.to_sym, @key_fields_detector.range_key.try(:to_sym)])
-          .reject { |k, _| k.to_s =~ /^#{@key_fields_detector.range_key}\./ }
-          .each do |key|
-          if key.to_s.include?('.')
-            opts.update(field_hash(key))
-          else
-            value = type_cast_condition_parameter(key, query[key])
-            opts[key] = { eq: value }
+          @where_conditions.keys.select { |k| k.to_s =~ /^#{@key_fields_detector.range_key}\./ }.each do |key|
+            name, condition = field_condition(key, @where_conditions[key])
+            opts[name] ||= []
+            opts[name] << condition
           end
         end
 
-        opts.merge(query_opts).merge(consistent_opts)
+        opts
       end
 
-      def add_range_key_to_range_query(query, opts)
-        opts[:range_key] = @key_fields_detector.range_key
-        if query[@key_fields_detector.range_key].present?
-          value = type_cast_condition_parameter(@key_fields_detector.range_key, query[@key_fields_detector.range_key])
-          opts.update(range_eq: value)
+      def query_non_key_conditions
+        opts = {}
+
+        # Honor STI and :type field if it presents
+        if @source.attributes.key?(@source.inheritance_field) &&
+           @key_fields_detector.hash_key.to_sym != @source.inheritance_field.to_sym
+          @where_conditions.update(sti_condition)
         end
 
-        query.keys.select { |k| k.to_s =~ /^#{@key_fields_detector.range_key}\./ }.each do |key|
-          opts.merge!(range_hash(key))
+        # TODO: Separate key conditions and non-key conditions properly:
+        #       only =, >, >=, <, <=, between and begins_with
+        #       could be used for sort key in KeyConditionExpression
+        keys = (@where_conditions.keys.map(&:to_sym) - [@key_fields_detector.hash_key.to_sym, @key_fields_detector.range_key.try(:to_sym)])
+          .reject { |k, _| k.to_s =~ /^#{@key_fields_detector.range_key}\./ }
+        keys.each do |key|
+          name, condition = field_condition(key, @where_conditions[key])
+          opts[name] ||= []
+          opts[name] << condition
         end
+
+        opts
       end
 
       # TODO: casting should be operator aware
@@ -737,7 +702,7 @@ module Dynamoid
         key
       end
 
-      def query_opts
+      def query_options
         opts = {}
         # Don't specify select = ALL_ATTRIBUTES option explicitly because it's
         # already a default value of Select statement. Explicite Select value
@@ -749,30 +714,26 @@ module Dynamoid
         opts[:exclusive_start_key] = start_key if @start
         opts[:scan_index_forward] = @scan_index_forward
         opts[:project] = @project
+        opts[:consistent_read] = true if @consistent_read
         opts
       end
 
-      def scan_query
-        query = self.query
-
+      def scan_conditions
         # Honor STI and :type field if it presents
         if sti_condition
-          query.update(sti_condition)
+          @where_conditions.update(sti_condition)
         end
 
         {}.tap do |opts|
-          query.keys.map(&:to_sym).each do |key|
-            if key.to_s.include?('.')
-              opts.update(field_hash(key))
-            else
-              value = type_cast_condition_parameter(key, query[key])
-              opts[key] = { eq: value }
-            end
+          @where_conditions.keys.map(&:to_sym).each do |key|
+            name, condition = field_condition(key, @where_conditions[key])
+            opts[name] ||= []
+            opts[name] << condition
           end
         end
       end
 
-      def scan_opts
+      def scan_options
         opts = {}
         opts[:index_name] = @key_fields_detector.index_name if @key_fields_detector.index_name
         opts[:record_limit] = @record_limit if @record_limit
@@ -784,6 +745,7 @@ module Dynamoid
         opts
       end
 
+      # TODO: return Array, not String
       def sti_condition
         condition = {}
         type = @source.inheritance_field

data/lib/dynamoid/criteria/key_fields_detector.rb

@@ -5,10 +5,10 @@ module Dynamoid
     # @private
     class KeyFieldsDetector
       class Query
-        def initialize(query_hash)
-          @query_hash = query_hash
-          @fields_with_operator = query_hash.keys.map(&:to_s)
-          @fields = query_hash.keys.map(&:to_s).map { |s| s.split('.').first }
+        def initialize(where_conditions)
+          @where_conditions = where_conditions
+          @fields_with_operator = where_conditions.keys.map(&:to_s)
+          @fields = where_conditions.keys.map(&:to_s).map { |s| s.split('.').first }
         end
 
         def contain_only?(field_names)
@@ -24,10 +24,9 @@ module Dynamoid
         end
       end
 
-      def initialize(query, source, forced_index_name: nil)
-        @query = query
+      def initialize(where_conditions, source, forced_index_name: nil)
         @source = source
-        @query = Query.new(query)
+        @query = Query.new(where_conditions)
         @forced_index_name = forced_index_name
         @result = find_keys_in_query
       end

data/lib/dynamoid/criteria/nonexistent_fields_detector.rb

@@ -20,8 +20,8 @@ module Dynamoid
         fields_list = @nonexistent_fields.map { |s| "`#{s}`" }.join(', ')
         count = @nonexistent_fields.size
 
-        'where conditions contain nonexistent' \
-          " field #{'name'.pluralize(count)} #{fields_list}"
+        'where conditions contain nonexistent ' \
+          "field #{'name'.pluralize(count)} #{fields_list}"
       end
 
       private

data/lib/dynamoid/criteria/where_conditions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Criteria
+    # @private
+    class WhereConditions
+      def initialize
+        @conditions = []
+      end
+
+      def update(hash)
+        @conditions << hash.symbolize_keys
+      end
+
+      def keys
+        @conditions.flat_map(&:keys)
+      end
+
+      def empty?
+        @conditions.empty?
+      end
+
+      def [](key)
+        hash = @conditions.find { |h| h.key?(key) }
+        hash[key] if hash
+      end
+    end
+  end
+end

data/lib/dynamoid/dirty.rb

@@ -238,7 +238,7 @@ module Dynamoid
 
       begin
         value = read_attribute(name)
-        value = value.duplicable? ? value.clone : value
+        value = value.clone if value.duplicable?
       rescue TypeError, NoMethodError
       end
 

data/lib/dynamoid/document.rb

@@ -260,7 +260,7 @@ module Dynamoid
     #
     # @return [Integer]
     def hash
-      hash_key.hash ^ range_value.hash
+      [hash_key, range_value].hash
     end
 
     # Return a model's hash key value.

data/lib/dynamoid/dumping.rb

@@ -210,7 +210,7 @@ module Dynamoid
     # datetime -> integer/string
     class DateTimeDumper < Base
       def process(value)
-        !value.nil? ? format_datetime(value, @options) : nil
+        value.nil? ? nil : format_datetime(value, @options)
       end
 
       private
@@ -237,7 +237,7 @@ module Dynamoid
     # date -> integer/string
     class DateDumper < Base
       def process(value)
-        !value.nil? ? format_date(value, @options) : nil
+        value.nil? ? nil : format_date(value, @options)
       end
 
       private

data/lib/dynamoid/fields/declare.rb

@@ -48,7 +48,7 @@ module Dynamoid
 
         @source.generated_methods.module_eval do
           define_method(name) { read_attribute(name) }
-          define_method("#{name}?") do
+          define_method(:"#{name}?") do
             value = read_attribute(name)
             case value
             when true        then true
@@ -57,8 +57,8 @@ module Dynamoid
               !value.nil?
             end
           end
-          define_method("#{name}=") { |value| write_attribute(name, value) }
-          define_method("#{name}_before_type_cast") { read_attribute_before_type_cast(name) }
+          define_method(:"#{name}=") { |value| write_attribute(name, value) }
+          define_method(:"#{name}_before_type_cast") { read_attribute_before_type_cast(name) }
         end
       end
 
@@ -70,9 +70,9 @@ module Dynamoid
 
         @source.generated_methods.module_eval do
           alias_method alias_name, name
-          alias_method "#{alias_name}=", "#{name}="
-          alias_method "#{alias_name}?", "#{name}?"
-          alias_method "#{alias_name}_before_type_cast", "#{name}_before_type_cast"
+          alias_method :"#{alias_name}=", :"#{name}="
+          alias_method :"#{alias_name}?", :"#{name}?"
+          alias_method :"#{alias_name}_before_type_cast", :"#{name}_before_type_cast"
         end
       end
 

data/lib/dynamoid/fields.rb

@@ -164,7 +164,7 @@ module Dynamoid
       #
       # @param name [Symbol] a range key attribute name
       # @param type [Symbol] a range key type (optional)
-      # @param options [Symbol] type options (optional)
+      # @param options [Hash] type options (optional)
       def range(name, type = :string, options = {})
         field(name, type, options)
         self.range_key = name
@@ -263,10 +263,8 @@ module Dynamoid
 
       # @private
       def generated_methods
-        @generated_methods ||= begin
-          Module.new.tap do |mod|
-            include(mod)
-          end
+        @generated_methods ||= Module.new.tap do |mod|
+          include(mod)
         end
       end
     end
@@ -362,7 +360,7 @@ module Dynamoid
         seconds = options[:after]
 
         if self[name].blank?
-          send("#{name}=", Time.now.to_i + seconds)
+          send(:"#{name}=", Time.now.to_i + seconds)
         end
       end
     end
@@ -374,12 +372,12 @@ module Dynamoid
 
       type = self.class.inheritance_field
       if self.class.attributes[type] && send(type).nil?
-        send("#{type}=", self.class.sti_name)
+        send(:"#{type}=", self.class.sti_name)
       end
     end
 
     def attribute_is_present_on_model?(attribute_name)
-      setter = "#{attribute_name}=".to_sym
+      setter = :"#{attribute_name}="
       respond_to?(setter)
     end
   end

data/lib/dynamoid/finders.rb

@@ -6,17 +6,6 @@ module Dynamoid
   module Finders
     extend ActiveSupport::Concern
 
-    # @private
-    RANGE_MAP = {
-      'gt'            => :range_greater_than,
-      'lt'            => :range_less_than,
-      'gte'           => :range_gte,
-      'lte'           => :range_lte,
-      'begins_with'   => :range_begins_with,
-      'between'       => :range_between,
-      'eq'            => :range_eq
-    }.freeze
-
     module ClassMethods
       # Find one or many objects, specified by one id or an array of ids.
       #
@@ -253,7 +242,6 @@ module Dynamoid
         range = options[:range] || {}
         hash_key_field, hash_key_value = hash.first
         range_key_field, range_key_value = range.first
-        range_op_mapped = nil
 
         if range_key_field
           range_key_field = range_key_field.to_s
@@ -261,27 +249,30 @@ module Dynamoid
           if range_key_field.include?('.')
             range_key_field, range_key_op = range_key_field.split('.', 2)
           end
-          range_op_mapped = RANGE_MAP.fetch(range_key_op)
         end
 
         # Find the index
         index = find_index(hash_key_field, range_key_field)
         raise Dynamoid::Errors::MissingIndex, "attempted to find #{[hash_key_field, range_key_field]}" if index.nil?
 
-        # query
-        opts = {
-          hash_key: hash_key_field.to_s,
-          hash_value: hash_key_value,
-          index_name: index.name
-        }
+        # Query
+        query_key_conditions = {}
+        query_key_conditions[hash_key_field.to_sym] = [[:eq, hash_key_value]]
         if range_key_field
-          opts[:range_key] = range_key_field
-          opts[range_op_mapped] = range_key_value
-        end
-        dynamo_options = opts.merge(options.reject { |key, _| key == :range })
-        Dynamoid.adapter.query(table_name, dynamo_options).flat_map { |i| i }.map do |item|
-          from_database(item)
+          query_key_conditions[range_key_field.to_sym] = [[range_key_op.to_sym, range_key_value]]
         end
+
+        query_non_key_conditions = options
+          .except(*Dynamoid::AdapterPlugin::AwsSdkV3::Query::OPTIONS_KEYS)
+          .except(:range)
+          .symbolize_keys
+
+        query_options = options.slice(*Dynamoid::AdapterPlugin::AwsSdkV3::Query::OPTIONS_KEYS)
+        query_options[:index_name] = index.name
+
+        Dynamoid.adapter.query(table_name, query_key_conditions, query_non_key_conditions, query_options)
+          .flat_map { |i| i }
+          .map { |item| from_database(item) }
       end
 
       # Find using exciting method_missing finders attributes. Uses criteria
@@ -308,7 +299,7 @@ module Dynamoid
           chain = Dynamoid::Criteria::Chain.new(self)
           chain = chain.where({}.tap { |h| attributes.each_with_index { |attr, index| h[attr.to_sym] = args[index] } })
 
-          if finder =~ /all/
+          if finder.include?('all')
             chain.all
           else
             chain.first