dynamoid 0.6.1 → 0.7.0

data/lib/dynamoid/dirty.rb

@@ -13,6 +13,12 @@ module Dynamoid
       clear_changes { super }
     end
 
+    def update!(*)
+      ret = super
+      clear_changes #update! completely reloads all fields on the class, so any extant changes are wiped out
+      ret
+    end
+
     def reload
       super.tap { clear_changes }
     end

data/lib/dynamoid/document.rb

@@ -8,9 +8,10 @@ module Dynamoid #:nodoc:
     include Dynamoid::Components
 
     included do
-      class_attribute :options, :read_only_attributes
+      class_attribute :options, :read_only_attributes, :base_class
       self.options = {}
       self.read_only_attributes = []
+      self.base_class = self
 
       Dynamoid::Config.included_models << self
     end
@@ -28,6 +29,7 @@ module Dynamoid #:nodoc:
       # @since 0.4.0
       def table(options = {})
         self.options = options
+        super if defined? super
       end
 
       def attr_readonly(*read_only_attributes)
@@ -55,6 +57,13 @@ module Dynamoid #:nodoc:
         options[:key] || :id
       end
 
+      # Returns the number of items for this class.
+      #
+      # @since 0.6.1
+      def count
+        Dynamoid::Adapter::AwsSdk.count(table_name)
+      end
+
       # Initialize a new object and immediately save it to the database.
       #
       # @param [Hash] attrs Attributes with which to create the object.
@@ -63,7 +72,7 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def create(attrs = {})
-        new(attrs).tap(&:save)
+        attrs[:type] ? attrs[:type].constantize.new(attrs).tap(&:save) : new(attrs).tap(&:save)
       end
 
       # Initialize a new object and immediately save it to the database. Raise an exception if persistence failed.
@@ -74,7 +83,7 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def create!(attrs = {})
-        new(attrs).tap(&:save!)
+        attrs[:type] ? attrs[:type].constantize.new(attrs).tap(&:save!) : new(attrs).tap(&:save!)
       end
 
       # Initialize a new object.
@@ -85,18 +94,21 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def build(attrs = {})
-        new(attrs)
+        attrs[:type] ? attrs[:type].constantize.new(attrs) : new(attrs)
       end
 
       # Does this object exist?
       #
-      # @param [String] id the id of the object
+      # @param [Mixed] id_or_conditions the id of the object or a hash with the options to filter from.
       #
       # @return [Boolean] true/false
       #
       # @since 0.2.0
-      def exists?(id)
-        !! find(id)
+      def exists?(id_or_conditions = {})
+        case id_or_conditions
+          when Hash then ! where(id_or_conditions).all.empty?
+          else !! find(id_or_conditions)
+        end
       end
     end
 
@@ -109,8 +121,6 @@ module Dynamoid #:nodoc:
     # @since 0.2.0
     def initialize(attrs = {})
       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 ||= {}
@@ -131,18 +141,27 @@ module Dynamoid #:nodoc:
         super
       else
         return false if other.nil?
-        other.respond_to?(:hash_key) && other.hash_key == self.hash_key
+        other.is_a?(Dynamoid::Document) && self.hash_key == other.hash_key && self.range_value == other.range_value
       end
     end
 
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      hash_key.hash ^ range_value.hash
+    end
+
     # 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.
+    # changes to be reflected immediately, you would call this method. This is a consistent read.
     #
     # @return [Dynamoid::Document] the document this method was called on
     #
     # @since 0.2.0
     def reload
-      self.attributes = self.class.find(hash_key, :range_key => range_value).attributes
+      range_key_value = range_value ? dumped_range_value : nil
+      self.attributes = self.class.find(hash_key, :range_key => range_key_value, :consistent_read => true).attributes
       @associations.values.each(&:reset)
       self
     end
@@ -171,14 +190,10 @@ module Dynamoid #:nodoc:
       self.send("#{self.class.range_key}=", value)
     end
 
-    def range_value
-      if range_key = self.class.range_key
-        self.send(range_key)
-      end
-    end
+    private
 
-    def range_value=(value)
-      self.send("#{self.class.range_key}=", value)
+    def dumped_range_value
+      dump_field(range_value, self.class.attributes[self.class.range_key])
     end
   end
 end

data/lib/dynamoid/fields.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 module Dynamoid #:nodoc:
 
-  # All fields on a Dynamoid::Document must be explicitly defined -- if you have fields in the database that are not 
+  # All fields on a Dynamoid::Document must be explicitly defined -- if you have fields in the database that are not
   # specified with field, then they will be ignored.
   module Fields
     extend ActiveSupport::Concern
@@ -14,11 +14,13 @@ module Dynamoid #:nodoc:
       self.attributes = {}
       field :created_at, :datetime
       field :updated_at, :datetime
+
+      field :id #Default primary key
     end
-    
+
     module ClassMethods
-      
-      # Specify a field for a document. Its type determines how it is coerced when read in and out of the datastore: 
+
+      # Specify a field for a document. Its type determines how it is coerced when read in and out of the datastore:
       # default is string, but you can also specify :integer, :float, :set, :array, :datetime, and :serialized.
       #
       # @param [Symbol] name the name of the field
@@ -28,7 +30,7 @@ module Dynamoid #:nodoc:
       # @since 0.2.0
       def field(name, type = :string, options = {})
         named = name.to_s
-        self.attributes[name] = {:type => type}.merge(options)
+        self.attributes = attributes.merge(name => {:type => type}.merge(options))
 
         define_method(named) { read_attribute(named) }
         define_method("#{named}?") { !read_attribute(named).nil? }
@@ -39,8 +41,24 @@ module Dynamoid #:nodoc:
         field(name, type)
         self.range_key = name
       end
+
+      def table(options)
+        #a default 'id' column is created when Dynamoid::Document is included
+        unless(attributes.has_key? hash_key)
+          remove_field :id
+          field(hash_key)
+        end
+      end
+
+      def remove_field(field)
+        field = field.to_sym
+        attributes.delete(field) or raise "No such field"
+        remove_method field
+        remove_method :"#{field}="
+        remove_method :"#{field}?"
+      end
     end
-    
+
     # You can access the attributes of an object directly on its attributes method, which is by default an empty hash.
     attr_accessor :attributes
     alias :raw_attributes :attributes
@@ -80,24 +98,8 @@ module Dynamoid #:nodoc:
     #
     # @since 0.2.0
     def update_attributes(attributes)
-      attributes.each {|attribute, value| self.write_attribute(attribute, value)}
-      if self.new_record # if never saved save.
-        save
-      else # update attributes if we have saved.
-        # next if self.read_only_attributes.include? attribute.to_s put this back in.
-        run_callbacks(:save) do
-          update! do |u|
-            attributes.each do |attribute, value|
-              u.set attribute => dump_field(
-                self.read_attribute(attribute),
-                self.class.attributes[attribute.to_sym]
-              )
-            end
-          end
-        end
-        
-        save
-      end
+      attributes.each {|attribute, value| self.write_attribute(attribute, value)} unless attributes.nil? || attributes.empty?
+      save
     end
 
     # Update a single attribute, saving the object afterwards.
@@ -110,9 +112,9 @@ module Dynamoid #:nodoc:
       write_attribute(attribute, value)
       save
     end
-    
+
     private
-    
+
     # Automatically called during the created callback to set the created_at time.
     #
     # @since 0.2.0
@@ -122,11 +124,15 @@ module Dynamoid #:nodoc:
 
     # Automatically called during the save callback to set the updated_at time.
     #
-    # @since 0.2.0    
+    # @since 0.2.0
     def set_updated_at
       self.updated_at = DateTime.now
     end
-    
+
+    def set_type
+      self.type ||= self.class.to_s if self.class.attributes[:type]
+    end
+
   end
-  
-end
+
+end

data/lib/dynamoid/finders.rb

@@ -31,19 +31,21 @@ module Dynamoid
         end
       end
 
-      # Find all object by hash key or hash and range key
+      # Return objects found by the given array of ids, either hash keys, or hash/range key combinations using BatchGet.
+      # Returns empty array if no results found.
       #
       # @param [Array<ID>] ids
+      # @param [Hash] options: Passed to the underlying query.
       #
       # @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)
+      #   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[self.table_name].collect{|i| from_database(i) }
+        items ? items[self.table_name].map{|i| from_database(i)} : []
       end
 
       # Find one object directly by id.

data/lib/dynamoid/persistence.rb

@@ -13,11 +13,8 @@ module Dynamoid
 
     module ClassMethods
 
-      # Returns the name of the table the class is for.
-      #
-      # @since 0.2.0
       def table_name
-        "#{Dynamoid::Config.namespace}_#{options[:name] ? options[:name] : self.name.split('::').last.downcase.pluralize}"
+        @table_name ||= "#{Dynamoid::Config.namespace}_#{options[:name] || base_class.name.split('::').last.downcase.pluralize}"
       end
 
       # Creates a table.
@@ -57,7 +54,8 @@ module Dynamoid
       end
 
       def from_database(attrs = {})
-        new(attrs).tap { |r| r.new_record = false }
+        clazz = attrs[:type] ? obj = attrs[:type].constantize : self
+        clazz.new(attrs).tap { |r| r.new_record = false }
       end
 
       # Undump an object into a hash, converting each type from a string representation of itself into the type specified by the field.
@@ -170,10 +168,24 @@ module Dynamoid
       self
     end
 
+    #
+    # update!() will increment the lock_version if the table has the column, but will not check it. Thus, a concurrent save will 
+    # never cause an update! to fail, but an update! may cause a concurrent save to fail. 
+    #
+    #
     def update!(conditions = {}, &block)
-      options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
-      new_attrs = Dynamoid::Adapter.update_item(self.class.table_name, self.hash_key, options.merge(:conditions => conditions), &block)
-      load(new_attrs)
+      run_callbacks(:update) do
+        options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+        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])
+            raise "Optimistic locking cannot be used with Partitioning" if(Dynamoid::Config.partitioning)
+            t.add(lock_version: 1)
+          end
+
+          yield t
+        end
+        load(new_attrs)
+      end
     end
 
     def update(conditions = {}, &block)
@@ -245,7 +257,7 @@ module Dynamoid
         raise ArgumentError, "Unknown type #{options[:type]}"
       end
     end
-
+    
     # Persist the object into the datastore. Assign it an id first if it doesn't have one; then afterwards,
     # save its indexes.
     #
@@ -253,13 +265,28 @@ module Dynamoid
     def persist(conditions = nil)
       run_callbacks(:save) do
         self.hash_key = SecureRandom.uuid if self.hash_key.nil? || self.hash_key.blank?
+        
+        # Add an exists check to prevent overwriting existing records with new ones
+        if(new_record?)
+          conditions ||= {}
+          (conditions[:unless_exists] ||= []) << self.class.hash_key
+        end
+
+        # Add an optimistic locking check if the lock_version column exists
+        if(self.class.attributes[:lock_version])
+          conditions ||= {}
+          raise "Optimistic locking cannot be used with Partitioning" if(Dynamoid::Config.partitioning)
+          self.lock_version = (lock_version || 0) + 1 
+          #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
+
         Dynamoid::Adapter.write(self.class.table_name, self.dump, conditions)
         save_indexes
         @new_record = false
         true
       end
     end
-
   end
 
 end

data/spec/app/models/address.rb

@@ -4,6 +4,8 @@ class Address
   field :city
   field :options, :serialized
   field :deliverable, :boolean
+  
+  field :lock_version, :integer #Provides Optimistic Locking
 
   def zip_code=(zip_code)
     self.city = "Chicago"

data/spec/app/models/camel_case.rb

@@ -10,6 +10,8 @@ class CamelCase
   
   before_create :doing_before_create
   after_create :doing_after_create
+  before_update :doing_before_update
+  after_update :doing_after_update
   
   private
   
@@ -21,4 +23,12 @@ class CamelCase
     true
   end
 
+  def doing_before_update
+    true
+  end
+
+  def doing_after_update
+    true
+  end
+
 end

data/spec/app/models/car.rb

@@ -0,0 +1,6 @@
+require_relative 'vehicle'
+
+class Car < Vehicle
+  
+  field :power_locks, :boolean
+end

data/spec/app/models/nuclear_submarine.rb

@@ -0,0 +1,5 @@
+require_relative 'vehicle'
+class NuclearSubmarine < Vehicle
+  
+  field :torpedoes, :integer
+end

data/spec/app/models/subscription.rb

@@ -1,8 +1,8 @@
 class Subscription
   include Dynamoid::Document
-  
+
   field :length, :integer
-  
+
   belongs_to :magazine
   has_and_belongs_to_many :users
 

data/spec/app/models/vehicle.rb

@@ -0,0 +1,7 @@
+class Vehicle
+  include Dynamoid::Document
+  
+  field :type
+  
+  field :description
+end

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -50,23 +50,27 @@ describe Dynamoid::Adapter::AwsSdk do
     end
 
     it 'performs query on a table with a range and selects items in a range' do
-      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_value => 0.0..3.0).to_a.should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+    end
+
+    it 'performs query on a table with a range and selects items in a range with :select option' do
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_value => 0.0..3.0, :select => :all).to_a.should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
     end
 
     it 'performs query on a table with a range and selects items greater than' do
-      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_greater_than => 1.0).to_a.should =~ [{:id => '1', :range => BigDecimal.new(3)}]
     end
 
     it 'performs query on a table with a range and selects items less than' do
-      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_less_than => 2.0).to_a.should =~ [{:id => '1', :range => BigDecimal.new(1)}]
     end
 
     it 'performs query on a table with a range and selects items gte' do
-      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_gte => 1.0).to_a.should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
     end
 
     it 'performs query on a table with a range and selects items lte' do
-      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_lte => 3.0).to_a.should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
     end
   end
   
@@ -85,7 +89,7 @@ describe Dynamoid::Adapter::AwsSdk do
     end
 
     it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
-      query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
+      query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true).to_a
       query[0].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
       query[1].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
       query[2].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
@@ -95,7 +99,7 @@ describe Dynamoid::Adapter::AwsSdk do
     end
     
     it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
-      query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
+      query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false).to_a
       query[5].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
       query[4].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
       query[3].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
@@ -157,6 +161,11 @@ describe Dynamoid::Adapter::AwsSdk do
     end
 
     # BatchGetItem
+    it 'passes options to underlying BatchGet call' do
+      AWS::DynamoDB::BatchGet.any_instance.expects(:table).with(test_table1, :all, ['1', '2'], :consistent_read => true)
+      described_class.batch_get_item({test_table1 => ['1', '2']}, :consistent_read => true)
+    end
+
     it "performs BatchGetItem with singular keys" do
       Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item(test_table2, {:id => '1', :name => 'Justin'})
@@ -259,14 +268,14 @@ describe Dynamoid::Adapter::AwsSdk do
     it 'performs query on a table and returns items' do
       Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
 
-      Dynamoid::Adapter.query(test_table1, :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+      Dynamoid::Adapter.query(test_table1, :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
     end
 
     it 'performs query on a table and returns items if there are multiple items' do
       Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
 
-      Dynamoid::Adapter.query(test_table1, :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+      Dynamoid::Adapter.query(test_table1, :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
     end
     
     it_behaves_like 'range queries'
@@ -275,14 +284,14 @@ describe Dynamoid::Adapter::AwsSdk do
     it 'performs scan on a table and returns items' do
       Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
 
-      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').to_a.should == [{ :id=> '1', :name=>"Josh" }]
     end
 
     it 'performs scan on a table and returns items if there are multiple items but only one match' do
       Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
 
-      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').to_a.should == [{ :id=> '1', :name=>"Josh" }]
     end
 
     it 'performs scan on a table and returns multiple items if there are multiple matches' do