dynamoid 0.4.1 → 0.5.0

data/lib/dynamoid/criteria/chain.rb

@@ -97,16 +97,7 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def records_with_index
-        ids = if index.range_key?
-          Dynamoid::Adapter.query(index.table_name, index_query).collect{|r| r[:ids]}.inject(Set.new) {|set, result| set + result}
-        else
-          results = Dynamoid::Adapter.read(index.table_name, index_query[:hash_value], consistent_opts)
-          if results
-            results[:ids]
-          else
-            []
-          end
-        end
+        ids = ids_from_index
         if ids.nil? || ids.empty?
           []
         else
@@ -121,8 +112,22 @@ module Dynamoid #:nodoc:
         end
       end
 
+      # Returns the Set of IDs from the index table.
+      #
+      # @return [Set] a Set containing the IDs from the index.
+      def ids_from_index
+        if index.range_key?
+          Dynamoid::Adapter.query(index.table_name, index_query.merge(consistent_opts)).inject(Set.new) do |all, record|
+            all + Set.new(record[:ids])
+          end
+        else
+          results = Dynamoid::Adapter.read(index.table_name, index_query[:hash_value], consistent_opts)
+          results ? results[:ids] : []
+        end
+      end
+
       def records_with_range
-        Dynamoid::Adapter.query(source.table_name, range_query).collect {|hash| source.new(hash).tap { |r| r.new_record = false } }
+        Dynamoid::Adapter.query(source.table_name, range_query).collect {|hash| source.from_database(hash) }
       end
 
       # If the query does not match an index, we'll manually scan the associated table to find results.
@@ -136,7 +141,11 @@ module Dynamoid #:nodoc:
           Dynamoid.logger.warn "You can index this query by adding this to #{source.to_s.downcase}.rb: index [#{source.attributes.sort.collect{|attr| ":#{attr}"}.join(', ')}]"
         end
 
-        Dynamoid::Adapter.scan(source.table_name, query, query_opts).collect {|hash| source.new(hash).tap { |r| r.new_record = false } }
+        if @consistent_read
+          raise Dynamoid::Errors::InvalidQuery, 'Consistent read is not supported by SCAN operation'
+        end
+
+        Dynamoid::Adapter.scan(source.table_name, query, query_opts).collect {|hash| source.from_database(hash) }
       end
 
       # Format the provided query so that it can be used to query results from DynamoDB.
@@ -201,7 +210,7 @@ module Dynamoid #:nodoc:
 
       def range?
         return false unless source.range_key
-        query_keys == ['id'] || (query_keys.to_set == ['id', source.range_key.to_s].to_set)
+        query_keys == [source.hash_key.to_s] || (query_keys.to_set == [source.hash_key.to_s, source.range_key.to_s].to_set)
       end
 
       def start_key

data/lib/dynamoid/dirty.rb

@@ -0,0 +1,41 @@
+module Dynamoid
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    module ClassMethods
+      def from_database(*)
+        super.tap { |d| d.changed_attributes.clear }
+      end
+    end
+
+    def save(*)
+      clear_changes { super }
+    end
+
+    def reload
+      super.tap { clear_changes }
+    end
+
+    def clear_changes
+      previous = changes
+      (block_given? ? yield : true).tap do |result|
+        unless result == false #failed validation; nil is OK.
+          @previously_changed = previous
+          changed_attributes.clear
+        end
+      end
+    end
+
+    def write_attribute(name, value)
+      attribute_will_change!(name) unless self.read_attribute(name) == value
+      super
+    end
+
+    protected
+
+    def attribute_method?(attr)
+      super || self.class.attributes.has_key?(attr.to_sym)
+    end
+  end
+end

data/lib/dynamoid/document.rb

@@ -6,18 +6,18 @@ module Dynamoid #:nodoc:
   module Document
     extend ActiveSupport::Concern
     include Dynamoid::Components
-    
+
     included do
       class_attribute :options
       self.options = {}
-      
+
       Dynamoid::Config.included_models << self
     end
-    
+
     module ClassMethods
-      # Set up table options, including naming it whatever you want, setting the id key, and manually overriding read and 
+      # Set up table options, including naming it whatever you want, setting the id key, and manually overriding read and
       # write capacity.
-      # 
+      #
       # @param [Hash] options options to pass for this table
       # @option options [Symbol] :name the name for the table; this still gets namespaced
       # @option options [Symbol] :id id column for the table
@@ -28,21 +28,21 @@ module Dynamoid #:nodoc:
       def table(options = {})
         self.options = options
       end
-      
+
       # Returns the read_capacity for this table.
       #
       # @since 0.4.0
       def read_capacity
         options[:read_capacity] || Dynamoid::Config.read_capacity
       end
-      
+
       # Returns the write_capacity for this table.
       #
       # @since 0.4.0
       def write_capacity
         options[:write_capacity] || Dynamoid::Config.write_capacity
       end
-      
+
       # Returns the id field for this class.
       #
       # @since 0.4.0
@@ -71,7 +71,7 @@ module Dynamoid #:nodoc:
       def create!(attrs = {})
         new(attrs).tap(&:save!)
       end
-      
+
       # Initialize a new object.
       #
       # @param [Hash] attrs Attributes with which to create the object.
@@ -101,50 +101,79 @@ module Dynamoid #:nodoc:
     #
     # @return [Dynamoid::Document] the new document
     #
-    # @since 0.2.0    
+    # @since 0.2.0
     def initialize(attrs = {})
-      self.class.send(:field, self.class.hash_key) unless self.respond_to?(self.class.hash_key)
-      
-      @new_record = true
-      @attributes ||= {}
-      @associations ||= {}
+      run_callbacks :initialize do
+        self.class.send(:field, self.class.hash_key) unless self.respond_to?(self.class.hash_key)
+
+        @new_record = true
+        @attributes ||= {}
+        @associations ||= {}
+
+        load(attrs)
+      end
+    end
 
+    def load(attrs)
       self.class.undump(attrs).each {|key, value| send "#{key}=", value }
     end
 
     # An object is equal to another object if their ids are equal.
     #
-    # @since 0.2.0    
+    # @since 0.2.0
     def ==(other)
-      return false if other.nil?
-      other.respond_to?(:hash_key) && other.hash_key == self.hash_key
+      if self.class.identity_map_on?
+        super
+      else
+        return false if other.nil?
+        other.respond_to?(:hash_key) && other.hash_key == self.hash_key
+      end
     end
 
-    # Reload an object from the database -- if you suspect the object has changed in the datastore and you need those 
+    # Reload an object from the database -- if you suspect the object has changed in the datastore and you need those
     # changes to be reflected immediately, you would call this method.
     #
     # @return [Dynamoid::Document] the document this method was called on
     #
-    # @since 0.2.0        
+    # @since 0.2.0
     def reload
-      self.attributes = self.class.find(self.hash_key).attributes
+      self.attributes = self.class.find(hash_key, :range_key => range_value).attributes
       @associations.values.each(&:reset)
       self
     end
-    
+
     # Return an object's hash key, regardless of what it might be called to the object.
     #
     # @since 0.4.0
     def hash_key
       self.send(self.class.hash_key)
     end
-    
+
     # Assign an object's hash key, regardless of what it might be called to the object.
     #
     # @since 0.4.0
-    def hash_key=(key)
-      self.send("#{self.class.hash_key}=".to_sym, key)
+    def hash_key=(value)
+      self.send("#{self.class.hash_key}=", value)
+    end
+
+    def range_value
+      if range_key = self.class.range_key
+        self.send(range_key)
+      end
+    end
+
+    def range_value=(value)
+      self.send("#{self.class.range_key}=", value)
+    end
+
+    def range_value
+      if range_key = self.class.range_key
+        self.send(range_key)
+      end
+    end
+
+    def range_value=(value)
+      self.send("#{self.class.range_key}=", value)
     end
   end
-  
 end

data/lib/dynamoid/errors.rb

@@ -13,11 +13,16 @@ module Dynamoid
     # MissingRangeKey is raised when a table that requires a range key is quieried without one.
     class MissingRangeKey < Error; end
 
+    # raised when the conditional check failed during update operation
+    class ConditionalCheckFailedException < Error; end
+
     # DocumentNotValid is raised when the document fails validation.
     class DocumentNotValid < Error
       def initialize(document)
         super("Validation failed: #{document.errors.full_messages.join(", ")}")
       end
     end
+
+    class InvalidQuery < Error; end
   end
 end

data/lib/dynamoid/fields.rb

@@ -12,7 +12,6 @@ module Dynamoid #:nodoc:
       class_attribute :range_key
 
       self.attributes = {}
-
       field :created_at, :datetime
       field :updated_at, :datetime
     end
@@ -34,8 +33,6 @@ module Dynamoid #:nodoc:
         define_method(named) { read_attribute(named) }
         define_method("#{named}?") { !read_attribute(named).nil? }
         define_method("#{named}=") {|value| write_attribute(named, value) }
-
-        respond_to?(:define_attribute_method) ? define_attribute_method(name) : define_attribute_methods([name])
       end
 
       def range(name, type = :string)
@@ -59,8 +56,6 @@ module Dynamoid #:nodoc:
         Dynamoid.logger.warn "DynamoDB can't store items larger than #{MAX_ITEM_SIZE} and the #{name} field has a length of #{size}."
       end
 
-      attribute_will_change!(name) unless self.read_attribute(name) == value
-
       if association = @associations[name]
         association.reset
       end

data/lib/dynamoid/finders.rb

@@ -5,9 +5,9 @@ module Dynamoid
   # class level, like find, find_by_id, and the method_missing style finders.
   module Finders
     extend ActiveSupport::Concern
-    
+
     module ClassMethods
-      
+
       # Find one or many objects, specified by one id or an array of ids.
       #
       # @param [Array/String] *id an array of ids or one single id
@@ -27,25 +27,73 @@ module Dynamoid
         if ids.count == 1
           self.find_by_id(ids.first, options)
         else
-          items = Dynamoid::Adapter.read(self.table_name, ids, options)
-          items[self.table_name].collect{|i| self.build(i).tap { |o| o.new_record = false } }
+          find_all(ids)
         end
       end
 
+      # Find all object by hash key or hash and range key
+      #
+      # @param [Array<ID>] ids
+      #
+      # @example
+      #   find all the user with hash key
+      #   User.find_all(['1', '2', '3'])
+      #
+      #   find all the tweets using hash key and range key
+      #   Tweet.find_all([['1', 'red'], ['1', 'green'])
+      def find_all(ids)
+        items = Dynamoid::Adapter.read(self.table_name, ids, options)
+        items[self.table_name].collect{|i| from_database(i) }
+      end
+
       # Find one object directly by id.
       #
       # @param [String] id the id of the object to find
       #
       # @return [Dynamoid::Document] the found object, or nil if nothing was found
       #
-      # @since 0.2.0      
+      # @since 0.2.0
       def find_by_id(id, options = {})
         if item = Dynamoid::Adapter.read(self.table_name, id, options)
-          obj = self.new(item)
-          obj.new_record = false
-          return obj
+          from_database(item)
         else
-          return nil
+          nil
+        end
+      end
+
+      # Find one object directly by hash and range keys
+      #
+      # @param [String] hash_key of the object to find
+      # @param [String/Integer/Float] 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}))
+      end
+
+      # Find all objects by hash and range keys.
+      #
+      # @example find all ChamberTypes whose level is greater than 1
+      #   class ChamberType
+      #     include Dynamoid::Document
+      #     field :chamber_type,            :string
+      #     range :level,                   :integer
+      #     table :key => :chamber_type
+      #   end
+      #   ChamberType.find_all_by_composite_key('DustVault', range_greater_than: 1)
+      #
+      # @param [String] hash_key of the objects to find
+      # @param [Hash] options the options for the range key
+      # @option options [Range] :range_value 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
+      #
+      # @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|
+          from_database(item)
         end
       end
 
@@ -59,7 +107,7 @@ module Dynamoid
       #
       # @return [Dynamoid::Document/Array] the found object, or an array of found objects if all was somewhere in the method
       #
-      # @since 0.2.0            
+      # @since 0.2.0
       def method_missing(method, *args)
         if method =~ /find/
           finder = method.to_s.split('_by_').first
@@ -67,7 +115,7 @@ module Dynamoid
 
           chain = Dynamoid::Criteria::Chain.new(self)
           chain.query = Hash.new.tap {|h| attributes.each_with_index {|attr, index| h[attr.to_sym] = args[index]}}
-          
+
           if finder =~ /all/
             return chain.all
           else
@@ -79,5 +127,5 @@ module Dynamoid
       end
     end
   end
-  
+
 end

data/lib/dynamoid/identity_map.rb

@@ -0,0 +1,96 @@
+module Dynamoid
+  module IdentityMap
+    extend ActiveSupport::Concern
+
+    def self.clear
+      models.each { |m| m.identity_map.clear }
+    end
+
+    def self.models
+      Dynamoid::Config.included_models
+    end
+
+    module ClassMethods
+      def identity_map
+        @identity_map ||= {}
+      end
+
+      def from_database(attrs = {})
+        return super if identity_map_off?
+
+        key = identity_map_key(attrs)
+        document = identity_map[key]
+
+        if document.nil?
+          document = super
+          identity_map[key] = document
+        else
+          document.load(attrs)
+        end
+
+        document
+      end
+
+      def find_by_id(id, options = {})
+        return super if identity_map_off?
+
+        key = id.to_s
+
+        if range_key = options[:range_key]
+          key += "::#{range_key}"
+        end
+
+        if identity_map[key]
+          identity_map[key]
+        else
+          super
+        end
+      end
+
+      def identity_map_key(attrs)
+        key = attrs[hash_key].to_s
+        if range_key
+          key += "::#{attrs[range_key]}"
+        end
+        key
+      end
+
+      def identity_map_on?
+        Dynamoid::Config.identity_map
+      end
+
+      def identity_map_off?
+        !identity_map_on?
+      end
+    end
+
+    def identity_map
+      self.class.identity_map
+    end
+
+    def save(*args)
+      return super if self.class.identity_map_off?
+
+      if result = super
+        identity_map[identity_map_key] = self
+      end
+      result
+    end
+
+    def delete
+      return super if self.class.identity_map_off?
+
+      identity_map.delete(identity_map_key)
+      super
+    end
+
+
+    def identity_map_key
+      key = hash_key.to_s
+      if self.class.range_key
+        key += "::#{range_value}"
+      end
+      key
+    end
+  end
+end