dynamoid 1.3.4 → 2.2.0

data/lib/dynamoid/fields.rb

@@ -23,7 +23,7 @@ module Dynamoid #:nodoc:
       field :created_at, :datetime
       field :updated_at, :datetime
 
-      field :id #Default primary key
+      field :id # Default primary key
     end
 
     module ClassMethods
@@ -50,7 +50,7 @@ module Dynamoid #:nodoc:
           Dynamoid.logger.warn("Field type :float, which you declared for '#{name}', is deprecated in favor of :number.")
           type = :number
         end
-        self.attributes = attributes.merge(name => {:type => type}.merge(options))
+        self.attributes = attributes.merge(name => {type: type}.merge(options))
 
         generated_methods.module_eval do
           define_method(named) { read_attribute(named) }
@@ -67,13 +67,13 @@ module Dynamoid #:nodoc:
         end
       end
 
-      def range(name, type = :string)
-        field(name, type)
+      def range(name, type = :string, options = {})
+        field(name, type, options)
         self.range_key = name
       end
 
       def table(options)
-        #a default 'id' column is created when Dynamoid::Document is included
+        # a default 'id' column is created when Dynamoid::Document is included
         unless(attributes.has_key? hash_key)
           remove_field :id
           field(hash_key)
@@ -82,7 +82,7 @@ module Dynamoid #:nodoc:
 
       def remove_field(field)
         field = field.to_sym
-        attributes.delete(field) or raise "No such field"
+        attributes.delete(field) or raise 'No such field'
 
         generated_methods.module_eval do
           remove_method field

data/lib/dynamoid/finders.rb

@@ -36,15 +36,27 @@ module Dynamoid
         ids = Array(ids.flatten.uniq)
         if ids.count == 1
           result = self.find_by_id(ids.first, options)
+          if result.nil?
+            message = "Couldn't find #{self.name} with '#{self.hash_key}'=#{ids[0]}"
+            raise Errors::RecordNotFound.new(message)
+          end
           expects_array ? Array(result) : result
         else
-          find_all(ids)
+          result = find_all(ids)
+          if result.size != ids.size
+            message = "Couldn't find all #{self.name.pluralize} with '#{self.hash_key}': (#{ids.join(', ')}) "
+            message << "(found #{result.size} results, but was looking for #{ids.size})"
+            raise Errors::RecordNotFound.new(message)
+          end
+          result
         end
       end
 
-      # Return objects found by the given array of ids, either hash keys, or hash/range key combinations using BatchGet.
+      # Return objects found by the given array of ids, either hash keys, or hash/range key combinations using BatchGetItem.
       # Returns empty array if no results found.
       #
+      # Uses backoff specified by `Dynamoid::Config.backoff` config option
+      #
       # @param [Array<ID>] ids
       # @param [Hash] options: Passed to the underlying query.
       #
@@ -55,8 +67,26 @@ module Dynamoid
       #   find all the tweets using hash key and range key with consistent read
       #   Tweet.find_all([['1', 'red'], ['1', 'green']], :consistent_read => true)
       def find_all(ids, options = {})
-        items = Dynamoid.adapter.read(self.table_name, ids, options)
-        items ? items[self.table_name].map{|i| from_database(i)} : []
+        results = unless Dynamoid.config.backoff
+          items = Dynamoid.adapter.read(self.table_name, ids, options)
+          items ? items[self.table_name] : []
+        else
+          items = []
+          backoff = nil
+          Dynamoid.adapter.read(self.table_name, ids, options) do |hash, has_unprocessed_items|
+            items += hash[self.table_name]
+
+            if has_unprocessed_items
+              backoff ||= Dynamoid.config.build_backoff
+              backoff.call
+            else
+              backoff = nil
+            end
+          end
+          items
+        end
+
+        results ? results.map {|i| from_database(i) } : []
       end
 
       # Find one object directly by id.
@@ -80,7 +110,7 @@ module Dynamoid
       # @param [String/Number] range_key of the object to find
       #
       def find_by_composite_key(hash_key, range_key, options = {})
-        find_by_id(hash_key, options.merge({:range_key => range_key}))
+        find_by_id(hash_key, options.merge(range_key: range_key))
       end
 
       # Find all objects by hash and range keys.
@@ -105,7 +135,7 @@ module Dynamoid
       # @return [Array] an array of all matching items
       #
       def find_all_by_composite_key(hash_key, options = {})
-        Dynamoid.adapter.query(self.table_name, options.merge({hash_value: hash_key})).collect do |item|
+        Dynamoid.adapter.query(self.table_name, options.merge(hash_value: hash_key)).collect do |item|
           from_database(item)
         end
       end
@@ -138,9 +168,9 @@ module Dynamoid
 
         if range_key_field
           range_key_field = range_key_field.to_s
-          range_key_op = "eq"
-          if range_key_field.include?(".")
-            range_key_field, range_key_op = range_key_field.split(".", 2)
+          range_key_op = 'eq'
+          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
@@ -151,9 +181,9 @@ module Dynamoid
 
         # query
         opts = {
-          :hash_key => hash_key_field.to_s,
-          :hash_value => hash_key_value,
-          :index_name => index.name,
+          hash_key: hash_key_field.to_s,
+          hash_value: hash_key_value,
+          index_name: index.name,
         }
         if range_key_field
           opts[:range_key] = range_key_field

data/lib/dynamoid/identity_map.rb

@@ -80,7 +80,6 @@ module Dynamoid
       super
     end
 
-
     def identity_map_key
       key = hash_key.to_s
       if self.class.range_key

data/lib/dynamoid/indexes.rb

@@ -39,8 +39,8 @@ module Dynamoid
         end
 
         index_opts = {
-            :read_capacity => Dynamoid::Config.read_capacity,
-            :write_capacity => Dynamoid::Config.write_capacity
+            read_capacity: Dynamoid::Config.read_capacity,
+            write_capacity: Dynamoid::Config.write_capacity
         }.merge(options)
 
         index_opts[:dynamoid_class] = self
@@ -52,7 +52,6 @@ module Dynamoid
         self
       end
 
-
       # Defines a local secondary index on a table. Will use the same primary
       # hash key as the table.
       #
@@ -83,11 +82,10 @@ module Dynamoid
             ' must use a different :range_key than the primary key')
         end
 
-        index_opts = options.merge({
-          :dynamoid_class => self,
-          :type => :local_secondary,
-          :hash_key => primary_hash_key
-        })
+        index_opts = options.merge(
+          dynamoid_class: self,
+          type: :local_secondary,
+          hash_key: primary_hash_key)
 
         index = Dynamoid::Indexes::Index.new(index_opts)
         key = index_key(primary_hash_key, index_range_key)
@@ -95,13 +93,11 @@ module Dynamoid
         self
       end
 
-
       def find_index(hash, range=nil)
         index = self.indexes[index_key(hash, range)]
         index
       end
 
-
       # Returns true iff the provided hash[,range] key combo is a local
       # secondary index.
       #
@@ -113,7 +109,6 @@ module Dynamoid
         self.local_secondary_indexes[index_key(hash, range)].present?
       end
 
-
       # Returns true iff the provided hash[,range] key combo is a global
       # secondary index.
       #
@@ -125,7 +120,6 @@ module Dynamoid
         self.global_secondary_indexes[index_key(hash, range)].present?
       end
 
-
       # Generates a convenient lookup key name for a hash/range index.
       # Should normally not be used directly.
       #
@@ -140,7 +134,6 @@ module Dynamoid
         name
       end
 
-
       # Generates a default index name.
       #
       # @param [Symbol] hash hash key name.
@@ -150,7 +143,6 @@ module Dynamoid
         "#{self.table_name}_index_#{self.index_key(hash, range)}"
       end
 
-
       # Convenience method to return all indexes on the table.
       #
       # @return [Hash<String, Object>] the combined hash of global and local
@@ -166,7 +158,6 @@ module Dynamoid
       end
     end
 
-
     # Represents the attributes of a DynamoDB index.
     class Index
       include ActiveModel::Validations
@@ -178,7 +169,6 @@ module Dynamoid
           :hash_key_schema, :range_key_schema, :projected_attributes,
           :read_capacity, :write_capacity
 
-
       validate do
         validate_index_type
         validate_hash_key
@@ -186,7 +176,6 @@ module Dynamoid
         validate_projected_attributes
       end
 
-
       def initialize(attrs={})
         unless attrs[:dynamoid_class].present?
           raise Dynamoid::Errors::InvalidIndex.new(':dynamoid_class is required')
@@ -205,7 +194,6 @@ module Dynamoid
         raise Dynamoid::Errors::InvalidIndex.new(self) unless self.valid?
       end
 
-
       # Convenience method to determine the projection type for an index.
       # Projection types are: :keys_only, :all, :include.
       #
@@ -218,56 +206,55 @@ module Dynamoid
         end
       end
 
-
       private
 
-        def validate_projected_attributes
-          unless (@projected_attributes.is_a?(Array) ||
-                  PROJECTION_TYPES.include?(@projected_attributes))
-            errors.add(:projected_attributes, 'Invalid projected attributes specified.')
-          end
+      def validate_projected_attributes
+        unless (@projected_attributes.is_a?(Array) ||
+                PROJECTION_TYPES.include?(@projected_attributes))
+          errors.add(:projected_attributes, 'Invalid projected attributes specified.')
         end
+      end
 
-        def validate_index_type
-          unless (@type.present? &&
-            [:local_secondary, :global_secondary].include?(@type))
-              errors.add(:type, 'Invalid index :type specified')
-          end
+      def validate_index_type
+        unless (@type.present? &&
+          [:local_secondary, :global_secondary].include?(@type))
+            errors.add(:type, 'Invalid index :type specified')
         end
+      end
 
-        def validate_range_key
-          if @range_key.present?
-            range_field_attributes = @dynamoid_class.attributes[@range_key]
-            if range_field_attributes.present?
-              range_key_type = range_field_attributes[:type]
-              if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(range_key_type)
-                @range_key_schema = {
-                  @range_key => @dynamoid_class.dynamo_type(range_key_type)
-                }
-              else
-                errors.add(:range_key, 'Index :range_key is not a valid key type')
-              end
+      def validate_range_key
+        if @range_key.present?
+          range_field_attributes = @dynamoid_class.attributes[@range_key]
+          if range_field_attributes.present?
+            range_key_type = range_field_attributes[:type]
+            if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(range_key_type)
+              @range_key_schema = {
+                @range_key => @dynamoid_class.dynamo_type(range_key_type)
+              }
             else
-              errors.add(:range_key, "No such field #{@range_key} defined on table")
+              errors.add(:range_key, 'Index :range_key is not a valid key type')
             end
+          else
+            errors.add(:range_key, "No such field #{@range_key} defined on table")
           end
         end
+      end
 
-        def validate_hash_key
-          hash_field_attributes = @dynamoid_class.attributes[@hash_key]
-          if hash_field_attributes.present?
-            hash_field_type = hash_field_attributes[:type]
-            if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(hash_field_type)
-              @hash_key_schema = {
-                @hash_key => @dynamoid_class.dynamo_type(hash_field_type)
-              }
-            else
-              errors.add(:hash_key, 'Index :hash_key is not a valid key type')
-            end
+      def validate_hash_key
+        hash_field_attributes = @dynamoid_class.attributes[@hash_key]
+        if hash_field_attributes.present?
+          hash_field_type = hash_field_attributes[:type]
+          if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(hash_field_type)
+            @hash_key_schema = {
+              @hash_key => @dynamoid_class.dynamo_type(hash_field_type)
+            }
           else
-            errors.add(:hash_key, "No such field #{@hash_key} defined on table")
+            errors.add(:hash_key, 'Index :hash_key is not a valid key type')
           end
+        else
+          errors.add(:hash_key, "No such field #{@hash_key} defined on table")
         end
+      end
     end
   end
 end

data/lib/dynamoid/persistence.rb

@@ -21,7 +21,7 @@ module Dynamoid
         table_base_name = options[:name] || base_class.name.split('::').last
           .downcase.pluralize
 
-        @table_name ||= [Dynamoid::Config.namespace.to_s,table_base_name].reject(&:empty?).join("_")
+        @table_name ||= [Dynamoid::Config.namespace.to_s, table_base_name].reject(&:empty?).join('_')
       end
 
       # Creates a table.
@@ -41,14 +41,14 @@ module Dynamoid
           range_key_hash = nil
         end
         options = {
-          :id => self.hash_key,
-          :table_name => self.table_name,
-          :write_capacity => self.write_capacity,
-          :read_capacity => self.read_capacity,
-          :range_key => range_key_hash,
-          :hash_key_type => dynamo_type(attributes[self.hash_key][:type]),
-          :local_secondary_indexes => self.local_secondary_indexes.values,
-          :global_secondary_indexes => self.global_secondary_indexes.values
+          id: self.hash_key,
+          table_name: self.table_name,
+          write_capacity: self.write_capacity,
+          read_capacity: self.read_capacity,
+          range_key: range_key_hash,
+          hash_key_type: dynamo_type(attributes[self.hash_key][:type]),
+          local_secondary_indexes: self.local_secondary_indexes.values,
+          global_secondary_indexes: self.global_secondary_indexes.values
         }.merge(options)
 
         Dynamoid.adapter.create_table(options[:table_name], options[:id], options)
@@ -74,9 +74,7 @@ module Dynamoid
             if incoming.has_key?(attribute)
               hash[attribute] = undump_field(incoming[attribute], options)
             elsif options.has_key?(:default)
-              default_value = options[:default]
-              value = default_value.respond_to?(:call) ? default_value.call : default_value.dup
-              hash[attribute] = value
+              hash[attribute] = evaluate_default_value(options[:default])
             else
               hash[attribute] = nil
             end
@@ -119,34 +117,22 @@ module Dynamoid
                   value
                 end
               when :set
-                Set.new(value)
+                undump_set(options, value)
               when :datetime
-                if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
-                  value
-                else
-                  case Dynamoid::Config.application_timezone
-                    when :utc
-                      ActiveSupport::TimeZone['UTC'].at(value).to_datetime
-                    when :local
-                      Time.at(value).to_datetime
-                    when String
-                      ActiveSupport::TimeZone[Dynamoid::Config.application_timezone].at(value).to_datetime
-                  end
-                end
+                parse_datetime(value, options)
               when :date
                 if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
                   value.to_date
                 else
-                  UNIX_EPOCH_DATE + value.to_i
+                  parse_date(value, options)
                 end
               when :boolean
-                # persisted as 't', but because undump is called during initialize it can come in as true
                 if value == 't' || value == true
                   true
                 elsif value == 'f' || value == false
                   false
                 else
-                  raise ArgumentError, "Boolean column neither true nor false"
+                  raise ArgumentError, 'Boolean column neither true nor false'
                 end
               else
                 raise ArgumentError, "Unknown type #{options[:type]}"
@@ -155,6 +141,17 @@ module Dynamoid
         end
       end
 
+      def undump_set(options, value)
+        case options[:of]
+        when :integer
+          value.map { |v| Integer(v) }.to_set
+        when :number
+          value.map { |v| BigDecimal.new(v.to_s) }.to_set
+        else
+          value.is_a?(Set) ? value : Set.new(value)
+        end
+      end
+
       def dump_field(value, options)
         if (field_class = options[:type]).is_a?(Class)
           if value.respond_to?(:dynamoid_dump)
@@ -177,15 +174,23 @@ module Dynamoid
             when :array
               !value.nil? ? value : nil
             when :datetime
-              !value.nil? ? value.to_time.to_f : nil
+              !value.nil? ? format_datetime(value, options) : nil
             when :date
-              !value.nil? ? (value.to_date - UNIX_EPOCH_DATE).to_i : nil
+              !value.nil? ? format_date(value, options) : nil
             when :serialized
               options[:serializer] ? options[:serializer].dump(value) : value.to_yaml
             when :raw
               !value.nil? ? value : nil
             when :boolean
-              !value.nil? ? value.to_s[0] : nil
+              if !value.nil?
+                if options[:store_as_native_boolean]
+                  !!value # native boolean type
+                else
+                  value.to_s[0] # => "f" or "t"
+                end
+              else
+                nil
+              end
             else
               raise ArgumentError, "Unknown type #{options[:type]}"
           end
@@ -207,6 +212,43 @@ module Dynamoid
         end
       end
 
+      # Creates several models at once.
+      # Neither callbacks nor validations run.
+      # It works efficiently because of using BatchWriteItem.
+      #
+      # Returns array of models
+      #
+      # Uses backoff specified by `Dynamoid::Config.backoff` config option
+      #
+      # @param [Array<Hash>] items
+      #
+      # @example
+      #   User.import([{ name: 'a' }, { name: 'b' }])
+      def import(objects)
+        documents = objects.map do |attrs|
+          self.build(attrs).tap do |item|
+            item.hash_key = SecureRandom.uuid if item.hash_key.blank?
+          end
+        end
+
+        unless Dynamoid.config.backoff
+          Dynamoid.adapter.batch_write_item(self.table_name, documents.map(&:dump))
+        else
+          backoff = nil
+          Dynamoid.adapter.batch_write_item(self.table_name, documents.map(&:dump)) do |has_unprocessed_items|
+            if has_unprocessed_items
+              backoff ||= Dynamoid.config.build_backoff
+              backoff.call
+            else
+              backoff = nil
+            end
+          end
+        end
+
+        documents.each { |d| d.new_record = false }
+        documents
+      end
+
       private
 
       def undump_hash(hash)
@@ -231,6 +273,77 @@ module Dynamoid
           val
         end
       end
+
+      def format_datetime(value, options)
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_datetime_as_string \
+          : options[:store_as_string]
+
+        if use_string_format
+          value.to_time.iso8601
+        else
+          unless value.respond_to?(:to_i) && value.respond_to?(:nsec)
+            value = value.to_time
+          end
+          BigDecimal("%d.%09d" % [value.to_i, value.nsec])
+        end
+      end
+
+      def format_date(value, options)
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_date_as_string \
+          : options[:store_as_string]
+
+        unless use_string_format
+          (value.to_date - UNIX_EPOCH_DATE).to_i
+        else
+          value.to_date.iso8601
+        end
+      end
+
+      def parse_datetime(value, options)
+        return value if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_datetime_as_string \
+          : options[:store_as_string]
+        value = DateTime.iso8601(value).to_time.to_i if use_string_format
+
+        case Dynamoid::Config.application_timezone
+          when :utc
+            ActiveSupport::TimeZone['UTC'].at(value).to_datetime
+          when :local
+            Time.at(value).to_datetime
+          when String
+            ActiveSupport::TimeZone[Dynamoid::Config.application_timezone].at(value).to_datetime
+        end
+      end
+
+      def parse_date(value, options)
+        use_string_format = options[:store_as_string].nil? \
+          ? Dynamoid.config.store_date_as_string \
+          : options[:store_as_string]
+
+        unless use_string_format
+          UNIX_EPOCH_DATE + value.to_i
+        else
+          Date.iso8601(value)
+        end
+      end
+
+      # Evaluates the default value given, this is used by undump
+      # when determining the value of the default given for a field options.
+      #
+      # @param [Object] :value the attribute's default value
+      def evaluate_default_value(val)
+        if val.respond_to?(:call)
+          val.call
+        elsif val.duplicable?
+          val.dup
+        else
+          val
+        end
+      end
     end
 
     # Set updated_at and any passed in field to current DateTime. Useful for things like last_login_at, etc.
@@ -256,15 +369,13 @@ module Dynamoid
       self.class.create_table
 
       if new_record?
-        conditions = { :unless_exists => [self.class.hash_key]}
+        conditions = { unless_exists: [self.class.hash_key]}
         conditions[:unless_exists] << range_key if(range_key)
 
         run_callbacks(:create) { persist(conditions) }
       else
         persist
       end
-
-      self
     end
 
     #
@@ -274,10 +385,10 @@ module Dynamoid
     #
     def update!(conditions = {}, &block)
       run_callbacks(:update) do
-        options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+        options = range_key ? {range_key: dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
 
         begin
-          new_attrs = Dynamoid.adapter.update_item(self.class.table_name, self.hash_key, options.merge(:conditions => conditions)) do |t|
+          new_attrs = Dynamoid.adapter.update_item(self.class.table_name, self.hash_key, options.merge(conditions: conditions)) do |t|
             if(self.class.attributes[:lock_version])
               t.add(lock_version: 1)
             end
@@ -316,11 +427,11 @@ module Dynamoid
     #
     # @since 0.2.0
     def delete
-      options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+      options = range_key ? {range_key: dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
 
       # Add an optimistic locking check if the lock_version column exists
       if(self.class.attributes[:lock_version])
-        conditions = {:if => {}}
+        conditions = {if: {}}
         conditions[:if][:lock_version] =
           if changes[:lock_version].nil?
             self.lock_version
@@ -360,7 +471,7 @@ module Dynamoid
     # @since 0.2.0
     def persist(conditions = nil)
       run_callbacks(:save) do
-        self.hash_key = SecureRandom.uuid if self.hash_key.nil? || self.hash_key.blank?
+        self.hash_key = SecureRandom.uuid if self.hash_key.blank?
 
         # Add an exists check to prevent overwriting existing records with new ones
         if(new_record?)
@@ -372,7 +483,7 @@ module Dynamoid
         if(self.class.attributes[:lock_version])
           conditions ||= {}
           self.lock_version = (lock_version || 0) + 1
-          #Uses the original lock_version value from ActiveModel::Dirty in case user changed lock_version manually
+          # Uses the original lock_version value from ActiveModel::Dirty in case user changed lock_version manually
           (conditions[:if] ||= {})[:lock_version] = changes[:lock_version][0] if(changes[:lock_version][0])
         end