dynamoid 0.3.2 → 0.4.0

data/lib/dynamoid/associations/single_association.rb

@@ -3,6 +3,7 @@ module Dynamoid #:nodoc:
 
   module Associations
     module SingleAssociation
+      include Association
 
       delegate :class, :to => :target
 
@@ -59,7 +60,7 @@ module Dynamoid #:nodoc:
       # @return [Dynamoid::Document] the found target (or nil if nothing)
       #
       # @since 0.2.0
-      def target
+      def find_target
         return if source_ids.empty?
         target_class.find(source_ids.first)
       end

data/lib/dynamoid/components.rb

@@ -16,6 +16,7 @@ module Dynamoid
       before_save :set_updated_at
     end
 
+    include ActiveModel::AttributeMethods
     include ActiveModel::Conversion
     include ActiveModel::Dirty
     include ActiveModel::MassAssignmentSecurity

data/lib/dynamoid/config.rb

@@ -21,6 +21,7 @@ module Dynamoid
     option :warn_on_scan, :default => true
     option :partitioning, :default => false
     option :partition_size, :default => 200
+    option :endpoint, :default => 'dynamodb.us-east-1.amazonaws.com'
     option :included_models, :default => []
     
     # The default logger for Dynamoid: either the Rails logger or just stdout.

data/lib/dynamoid/criteria.rb

@@ -9,7 +9,7 @@ module Dynamoid
     
     module ClassMethods
       
-      [:where, :all, :first, :each].each do |meth|
+      [:where, :all, :first, :each, :limit, :start].each do |meth|
         # Return a criteria chain in response to a method that will begin or end a chain. For more information, 
         # see Dynamoid::Criteria::Chain.
         #
@@ -26,4 +26,4 @@ module Dynamoid
     end
   end
   
-end
+end

data/lib/dynamoid/criteria/chain.rb

@@ -6,20 +6,21 @@ module Dynamoid #:nodoc:
     # chain to relation). It is a chainable object that builds up a query and eventually executes it either on an index
     # or by a full table scan.
     class Chain
-      attr_accessor :query, :source, :index, :values
+      attr_accessor :query, :source, :index, :values, :limit, :start, :consistent_read
       include Enumerable
-      
+
       # Create a new criteria chain.
       #
       # @param [Class] source the class upon which the ultimate query will be performed.
       def initialize(source)
         @query = {}
         @source = source
+        @consistent_read = false
       end
-      
-      # The workhorse method of the criteria chain. Each key in the passed in hash will become another criteria that the 
-      # ultimate query must match. A key can either be a symbol or a string, and should be an attribute name or 
-      # an attribute name with a range operator. 
+
+      # The workhorse method of the criteria chain. Each key in the passed in hash will become another criteria that the
+      # ultimate query must match. A key can either be a symbol or a string, and should be an attribute name or
+      # an attribute name with a range operator.
       #
       # @example A simple criteria
       #   where(:name => 'Josh')
@@ -32,7 +33,12 @@ module Dynamoid #:nodoc:
         args.each {|k, v| query[k] = v}
         self
       end
-      
+
+      def consistent
+        @consistent_read = true
+        self
+      end
+
       # Returns all the records matching the criteria.
       #
       # @since 0.2.0
@@ -42,40 +48,59 @@ module Dynamoid #:nodoc:
 
       # Returns the first record matching the criteria.
       #
-      # @since 0.2.0      
+      # @since 0.2.0
       def first
-        records.first
+        limit(1).first
+      end
+
+      def limit(limit)
+        @limit = limit
+        records
+      end
+
+      def start(start)
+        @start = start
+        self
       end
 
       # Allows you to use the results of a search as an enumerable over the results found.
       #
-      # @since 0.2.0            
+      # @since 0.2.0
       def each(&block)
         records.each(&block)
       end
-      
+
+      def consistent_opts
+        { :consistent_read => consistent_read }
+      end
+
       private
-      
+
       # The actual records referenced by the association.
       #
       # @return [Array] an array of the found records.
       #
       # @since 0.2.0
       def records
-        return records_with_index if index
-        records_without_index
+        if range?
+          records_with_range
+        elsif index
+          records_with_index
+        else
+          records_without_index
+        end
       end
 
       # If the query matches an index on the associated class, then this method will retrieve results from the index table.
       #
       # @return [Array] an array of the found records.
       #
-      # @since 0.2.0      
+      # @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])
+          results = Dynamoid::Adapter.read(index.table_name, index_query[:hash_value], consistent_opts)
           if results
             results[:ids]
           else
@@ -85,28 +110,40 @@ module Dynamoid #:nodoc:
         if ids.nil? || ids.empty?
           []
         else
-          Array(source.find(ids.to_a))
+          ids = ids.to_a
+
+          if @start
+            ids = ids.drop_while { |id| id != @start.hash_key }.drop(1)
+          end
+
+          ids = ids.take(@limit) if @limit
+          Array(source.find(ids, consistent_opts))
         end
       end
-      
-      # If the query does not match an index, we'll manually scan the associated table to manually find results.
+
+      def records_with_range
+        Dynamoid::Adapter.query(source.table_name, range_query).collect {|hash| source.new(hash).tap { |r| r.new_record = false } }
+      end
+
+      # If the query does not match an index, we'll manually scan the associated table to find results.
       #
       # @return [Array] an array of the found records.
       #
-      # @since 0.2.0      
+      # @since 0.2.0
       def records_without_index
         if Dynamoid::Config.warn_on_scan
           Dynamoid.logger.warn 'Queries without an index are forced to use scan and are generally much slower than indexed queries!'
           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).collect {|hash| source.new(hash).tap { |r| r.new_record = false } }
+
+        Dynamoid::Adapter.scan(source.table_name, query, query_opts).collect {|hash| source.new(hash).tap { |r| r.new_record = false } }
       end
-      
-      # Format the provided query so that it can be used to query results from DynamoDB. 
+
+      # Format the provided query so that it can be used to query results from DynamoDB.
       #
       # @return [Hash] a hash with keys of :hash_value and :range_value
       #
-      # @since 0.2.0      
+      # @since 0.2.0
       def index_query
         values = index.values(query)
         {}.tap do |hash|
@@ -114,21 +151,7 @@ module Dynamoid #:nodoc:
           if index.range_key?
             key = query.keys.find{|k| k.to_s.include?('.')}
             if key
-              if query[key].is_a?(Range)
-                hash[:range_value] = query[key]
-              else
-                val = query[key].to_f
-                case key.split('.').last
-                when 'gt'
-                  hash[:range_greater_than] = val
-                when 'lt'
-                  hash[:range_less_than] = val
-                when 'gte'
-                  hash[:range_gte] = val
-                when 'lte'
-                  hash[:range_lte] = val
-                end
-              end
+              hash.merge!(range_hash(key))
             else
               raise Dynamoid::Errors::MissingRangeKey, 'This index requires a range key'
             end
@@ -136,16 +159,68 @@ module Dynamoid #:nodoc:
         end
       end
 
+      def range_hash(key)
+        val = query[key]
+
+        return { :range_value => query[key] } if query[key].is_a?(Range)
+
+        case key.split('.').last
+        when 'gt'
+          { :range_greater_than => val.to_f }
+        when 'lt'
+          { :range_less_than  => val.to_f }
+        when 'gte'
+          { :range_gte  => val.to_f }
+        when 'lte'
+          { :range_lte => val.to_f }
+        when 'begins_with'
+          { :range_begins_with => val }
+        end
+      end
+
+      def range_query
+        opts = { :hash_value => query[source.hash_key] }
+        if key = query.keys.find { |k| k.to_s.include?('.') }
+          opts.merge!(range_key(key))
+        end
+        opts.merge(query_opts).merge(consistent_opts)
+      end
+
       # Return an index that fulfills all the attributes the criteria is querying, or nil if none is found.
       #
-      # @since 0.2.0            
+      # @since 0.2.0
       def index
-        index = source.find_index(query.keys.collect{|k| k.to_s.split('.').first})
+        index = source.find_index(query_keys)
         return nil if index.blank?
         index
       end
+
+      def query_keys
+        query.keys.collect{|k| k.to_s.split('.').first}
+      end
+
+      def range?
+        return false unless source.range_key
+        query_keys == ['id'] || (query_keys.to_set == ['id', source.range_key.to_s].to_set)
+      end
+
+      def start_key
+        key = { :hash_key_element => { 'S' => @start.hash_key } }
+        if range_key = @start.class.range_key
+          range_key_type = @start.class.attributes[range_key][:type] == :string ? 'S' : 'N'
+          key.merge!({:range_key_element => { range_key_type => @start.send(range_key) } })
+        end
+        key
+      end
+
+      def query_opts
+        opts = {}
+        opts[:limit] = @limit if @limit
+        opts[:next_token] = start_key if @start
+        opts
+      end
     end
-    
+
   end
-  
+
 end

data/lib/dynamoid/document.rb

@@ -8,10 +8,47 @@ module Dynamoid #:nodoc:
     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 
+      # 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
+      # @option options [Integer] :read_capacity set the read capacity for the table; does not work on existing tables
+      # @option options [Integer] :write_capacity set the write capacity for the table; does not work on existing tables
+      #
+      # @since 0.4.0
+      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
+      def hash_key
+        options[:key] || :id
+      end
 
       # Initialize a new object and immediately save it to the database.
       #
@@ -66,13 +103,13 @@ module Dynamoid #:nodoc:
     #
     # @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 ||= {}
-      incoming_attributes = self.class.undump(attrs)
+      @associations ||= {}
 
-      self.class.attributes.keys.each do |attribute|
-        send "#{attribute}=", incoming_attributes[attribute]
-      end
+      self.class.undump(attrs).each {|key, value| send "#{key}=", value }
     end
 
     # An object is equal to another object if their ids are equal.
@@ -80,7 +117,7 @@ module Dynamoid #:nodoc:
     # @since 0.2.0    
     def ==(other)
       return false if other.nil?
-      other.respond_to?(:id) && other.id == self.id
+      other.respond_to?(:hash_key) && other.hash_key == self.hash_key
     end
 
     # Reload an object from the database -- if you suspect the object has changed in the datastore and you need those 
@@ -90,9 +127,24 @@ module Dynamoid #:nodoc:
     #
     # @since 0.2.0        
     def reload
-      self.attributes = self.class.find(self.id).attributes
+      self.attributes = self.class.find(self.hash_key).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)
+    end
   end
   
 end

data/lib/dynamoid/fields.rb

@@ -9,9 +9,10 @@ module Dynamoid #:nodoc:
     # Initialize the attributes we know the class has, in addition to our magic attributes: id, created_at, and updated_at.
     included do
       class_attribute :attributes
-      
+      class_attribute :range_key
+
       self.attributes = {}
-      field :id
+
       field :created_at, :datetime
       field :updated_at, :datetime
     end
@@ -34,7 +35,12 @@ module Dynamoid #:nodoc:
         define_method("#{named}?") { !read_attribute(named).nil? }
         define_method("#{named}=") {|value| write_attribute(named, value) }
 
-        define_attribute_method(name)
+        respond_to?(:define_attribute_method) ? define_attribute_method(name) : define_attribute_methods([name])
+      end
+
+      def range(name, type = :string)
+        field(name, type)
+        self.range_key = name
       end
     end
     
@@ -49,7 +55,16 @@ module Dynamoid #:nodoc:
     #
     # @since 0.2.0
     def write_attribute(name, value)
+      if (size = value.to_s.size) > MAX_ITEM_SIZE
+        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
+
       attributes[name.to_sym] = value
     end
     alias :[]= :write_attribute

data/lib/dynamoid/finders.rb

@@ -15,12 +15,19 @@ module Dynamoid
       # @return [Dynamoid::Document] one object or an array of objects, depending on whether the input was an array or not
       #
       # @since 0.2.0
-      def find(*id)
-        id = Array(id.flatten.uniq)
-        if id.count == 1
-          self.find_by_id(id.first)
+      def find(*ids)
+
+        options = if ids.last.is_a? Hash
+                    ids.slice!(-1)
+                  else
+                    {}
+                  end
+
+        ids = Array(ids.flatten.uniq)
+        if ids.count == 1
+          self.find_by_id(ids.first, options)
         else
-          items = Dynamoid::Adapter.read(self.table_name, id)
+          items = Dynamoid::Adapter.read(self.table_name, ids, options)
           items[self.table_name].collect{|i| self.build(i).tap { |o| o.new_record = false } }
         end
       end
@@ -32,8 +39,8 @@ module Dynamoid
       # @return [Dynamoid::Document] the found object, or nil if nothing was found
       #
       # @since 0.2.0      
-      def find_by_id(id)
-        if item = Dynamoid::Adapter.read(self.table_name, id)
+      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