dynamoid 1.1.0 → 1.2.0

data/lib/dynamoid/associations/association.rb

@@ -99,6 +99,17 @@ module Dynamoid #:nodoc:
         source.send(source_attribute) || Set.new
       end
 
+      # Create a new instance of the target class without trying to add it to the association. This creates a base, that caller can update before setting or adding it.
+      #
+      # @param [Hash] attribute hash for the new object
+      #
+      # @return [Dynamoid::Document] the newly-created object
+      #
+      # @since 1.1.1
+      def build(attributes = {})
+        target_class.build(attributes)
+      end
+
     end
   end
 

data/lib/dynamoid/associations/many_association.rb

@@ -145,8 +145,10 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def where(args)
-        args.each {|k, v| query[k] = v}
-        self
+        filtered = clone
+        filtered.query = query.clone
+        args.each {|k, v| filtered.query[k] = v}
+        filtered
       end
 
       # Is this array equal to the association's records?

data/lib/dynamoid/associations/single_association.rb

@@ -25,7 +25,7 @@ module Dynamoid #:nodoc:
       end
 
       def create(attributes = {})
-        setter(target_class.create!(attributes))
+        setter(target_class.create(attributes))
       end
 
 

data/lib/dynamoid/components.rb

@@ -25,6 +25,7 @@ module Dynamoid
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml
     include Dynamoid::Fields
+    include Dynamoid::Indexes
     include Dynamoid::Persistence
     include Dynamoid::Finders
     include Dynamoid::Associations

data/lib/dynamoid/config.rb

@@ -23,6 +23,9 @@ module Dynamoid
     option :use_ssl, :default => true
     option :port, :default => '443'
     option :identity_map, :default => false
+    option :timestamps, :default => true
+    option :sync_retry_max_times, :default => 60 # a bit over 2 minutes
+    option :sync_retry_wait_seconds, :default => 2
 
     # The default logger for Dynamoid: either the Rails logger or just stdout.
     #

data/lib/dynamoid/criteria/chain.rb

@@ -50,22 +50,22 @@ module Dynamoid #:nodoc:
       #
       def destroy_all
         ids = []
-        
+
         if key_present?
           ranges = []
           Dynamoid.adapter.query(source.table_name, range_query).collect do |hash|
             ids << hash[source.hash_key.to_sym]
             ranges << hash[source.range_key.to_sym]
           end
-          
+
           Dynamoid.adapter.delete(source.table_name, ids,{:range_key => ranges})
         else
           Dynamoid.adapter.scan(source.table_name, query, scan_opts).collect do |hash|
             ids << hash[source.hash_key.to_sym]
           end
-          
+
           Dynamoid.adapter.delete(source.table_name, ids)
-        end   
+        end
       end
 
       def eval_limit(limit)
@@ -152,13 +152,15 @@ module Dynamoid #:nodoc:
 
         case key.to_s.split('.').last
         when 'gt'
-          { :range_greater_than => val.to_f }
+          { :range_greater_than => val }
         when 'lt'
-          { :range_less_than  => val.to_f }
+          { :range_less_than  => val }
         when 'gte'
-          { :range_gte  => val.to_f }
+          { :range_gte  => val }
         when 'lte'
-          { :range_lte => val.to_f }
+          { :range_lte => val }
+        when 'between'
+          { :range_between => val }
         when 'begins_with'
           { :range_begins_with => val }
         end
@@ -166,7 +168,7 @@ module Dynamoid #:nodoc:
 
       def range_query
         opts = { :hash_value => query[source.hash_key] }
-        if key = query.keys.find { |k| k.to_s.include?('.') }
+        query.keys.select { |k| k.to_s.include?('.') }.each do |key|
           opts.merge!(range_hash(key))
         end
         opts.merge(query_opts).merge(consistent_opts)
@@ -197,7 +199,7 @@ module Dynamoid #:nodoc:
         opts[:scan_index_forward] = @scan_index_forward
         opts
       end
-      
+
       def scan_opts
         opts = {}
         opts[:limit] = @eval_limit if @eval_limit

data/lib/dynamoid/document.rb

@@ -72,7 +72,7 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def create(attrs = {})
-        attrs[:type] ? attrs[:type].constantize.new(attrs).tap(&:save) : new(attrs).tap(&:save)
+        build(attrs).tap(&:save)
       end
 
       # Initialize a new object and immediately save it to the database. Raise an exception if persistence failed.
@@ -83,7 +83,7 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def create!(attrs = {})
-        attrs[:type] ? attrs[:type].constantize.new(attrs).tap(&:save!) : new(attrs).tap(&:save!)
+        build(attrs).tap(&:save!)
       end
 
       # Initialize a new object.
@@ -130,7 +130,9 @@ module Dynamoid #:nodoc:
     end
 
     def load(attrs)
-      self.class.undump(attrs).each {|key, value| send "#{key}=", value }
+      self.class.undump(attrs).each do |key, value|
+        send("#{key}=", value) if self.respond_to?("#{key}=")
+      end
     end
 
     # An object is equal to another object if their ids are equal.

data/lib/dynamoid/errors.rb

@@ -1,14 +1,28 @@
 # encoding: utf-8
 module Dynamoid
-  
+
   # All the errors specific to Dynamoid.  The goal is to mimic ActiveRecord.
   module Errors
-    
+
     # Generic Dynamoid error
     class Error < StandardError; end
-    
+
     class MissingRangeKey < Error; end
 
+    class MissingIndex < Error; end
+
+    # InvalidIndex is raised when an invalid index is specified, for example if
+    # specified key attribute(s) or projected attributes do not exist.
+    class InvalidIndex < Error
+      def initialize(item)
+        if (item.is_a? String)
+          super(item)
+        else
+          super("Validation failed: #{item.errors.full_messages.join(", ")}")
+        end
+      end
+    end
+
     # This class is intended to be private to Dynamoid.
     class ConditionalCheckFailedException < Error
       attr_reader :inner_exception

data/lib/dynamoid/fields.rb

@@ -1,11 +1,17 @@
 # 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
   # specified with field, then they will be ignored.
   module Fields
     extend ActiveSupport::Concern
 
+    PERMITTED_KEY_TYPES = [
+      :number,
+      :integer,
+      :string,
+      :datetime
+    ]
+
     # 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
@@ -45,7 +51,15 @@ module Dynamoid #:nodoc:
         self.attributes = attributes.merge(name => {:type => type}.merge(options))
 
         define_method(named) { read_attribute(named) }
-        define_method("#{named}?") { !read_attribute(named).nil? }
+        define_method("#{named}?") do
+          value = read_attribute(named)
+          case value
+          when true        then true
+          when false, nil  then false
+          else
+            !value.nil?
+          end
+        end
         define_method("#{named}=") {|value| write_attribute(named, value) }
       end
 
@@ -131,14 +145,14 @@ module Dynamoid #:nodoc:
     #
     # @since 0.2.0
     def set_created_at
-      self.created_at = DateTime.now
+      self.created_at = DateTime.now if Dynamoid::Config.timestamps
     end
 
     # Automatically called during the save callback to set the updated_at time.
     #
     # @since 0.2.0
     def set_updated_at
-      self.updated_at = DateTime.now
+      self.updated_at = DateTime.now if Dynamoid::Config.timestamps
     end
 
     def set_type
@@ -147,4 +161,4 @@ module Dynamoid #:nodoc:
 
   end
 
-end
+end

data/lib/dynamoid/finders.rb

@@ -6,6 +6,16 @@ module Dynamoid
   module Finders
     extend ActiveSupport::Concern
 
+    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
+    }
+
     module ClassMethods
 
       # Find one or many objects, specified by one id or an array of ids.
@@ -100,6 +110,61 @@ module Dynamoid
         end
       end
 
+      # Find all objects by using local secondary or global secondary index
+      #
+      # @example
+      #   class User
+      #     include Dynamoid::Document
+      #     field :email,          :string
+      #     field :age,            :integer
+      #     field :gender,         :string
+      #     field :rank            :number
+      #     table :key => :email
+      #     global_secondary_index :hash_key => :age, :range_key => :rank
+      #   end
+      #   # NOTE: the first param and the second param are both hashes,
+      #   #       so curly braces must be used on first hash param if sending both params
+      #   User.find_all_by_secondary_index({:age => 5}, :range => {"rank.lte" => 10})
+      #
+      # @param [Hash] eg: {:age => 5}
+      # @param [Hash] eg: {"rank.lte" => 10}
+      # @param [Hash] options - @TODO support more options in future such as
+      #               query filter, projected keys etc
+      # @return [Array] an array of all matching items
+      def find_all_by_secondary_index(hash, options = {})
+        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
+          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
+
+        # Find the index
+        index = self.find_index(hash_key_field, range_key_field)
+        raise Dynamoid::Errors::MissingIndex if index.nil?
+
+        # query
+        opts = {
+          :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
+          opts[range_op_mapped] = range_key_value
+        end
+        Dynamoid.adapter.query(self.table_name, opts).map do |item|
+          from_database(item)
+        end
+      end
+
       # Find using exciting method_missing finders attributes. Uses criteria chains under the hood to accomplish this neatness.
       #
       # @example find a user by a first name

data/lib/dynamoid/indexes.rb

@@ -0,0 +1,273 @@
+module Dynamoid
+  module Indexes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :local_secondary_indexes
+      class_attribute :global_secondary_indexes
+      self.local_secondary_indexes = {}
+      self.global_secondary_indexes = {}
+    end
+
+    module ClassMethods
+      # Defines a Global Secondary index on a table. Keys can be specified as
+      # hash-only, or hash & range.
+      #
+      # @param [Hash] options options to pass for this table
+      # @option options [Symbol] :name the name for the index; this still gets
+      #         namespaced.  If not specified, will use a default name.
+      # @option options [Symbol] :hash_key the index hash key column.
+      # @option options [Symbol] :range_key the index range key column (if
+      #         applicable).
+      # @option options [Symbol, Array<Symbol>] :projected_attributes table
+      #         attributes to project for this index. Can be :keys_only, :all
+      #         or an array of included fields. If not specified, defaults to
+      #         :keys_only.
+      # @option options [Integer] :read_capacity set the read capacity for the
+      #         index; does not work on existing indexes.
+      # @option options [Integer] :write_capacity set the write capacity for
+      #         the index; does not work on existing indexes.
+      def global_secondary_index(options={})
+        unless options.present?
+          raise Dynamoid::Errors::InvalidIndex.new('empty index definition')
+        end
+
+        unless options[:hash_key].present?
+          raise Dynamoid::Errors::InvalidIndex.new(
+            'A global secondary index requires a :hash_key to be specified'
+          )
+        end
+
+        index_opts = {
+            :read_capacity => Dynamoid::Config.read_capacity,
+            :write_capacity => Dynamoid::Config.write_capacity
+        }.merge(options)
+
+        index_opts[:dynamoid_class] = self
+        index_opts[:type] = :global_secondary
+
+        index = Dynamoid::Indexes::Index.new(index_opts)
+        gsi_key = index_key(options[:hash_key], options[:range_key])
+        self.global_secondary_indexes[gsi_key] = index
+        self
+      end
+
+
+      # Defines a local secondary index on a table. Will use the same primary
+      # hash key as the table.
+      #
+      # @param [Hash] options options to pass for this index.
+      # @option options [Symbol] :name the name for the index; this still gets
+      #         namespaced. If not specified, a name is automatically generated.
+      # @option options [Symbol] :range_key the range key column for the index.
+      # @option options [Symbol, Array<Symbol>] :projected_attributes table
+      #         attributes to project for this index. Can be :keys_only, :all
+      #         or an array of included fields. If not specified, defaults to
+      #         :keys_only.
+      def local_secondary_index(options={})
+        unless options.present?
+          raise Dynamoid::Errors::InvalidIndex.new('empty index definition')
+        end
+
+        primary_hash_key = self.hash_key
+        primary_range_key = self.range_key
+        index_range_key = options[:range_key]
+
+        unless index_range_key.present?
+          raise Dynamoid::Errors::InvalidIndex.new('A local secondary index '\
+            'requires a :range_key to be specified')
+        end
+
+        if primary_range_key.present? && index_range_key == primary_range_key
+          raise Dynamoid::Errors::InvalidIndex.new('A local secondary index'\
+            ' 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 = Dynamoid::Indexes::Index.new(index_opts)
+        key = index_key(primary_hash_key, index_range_key)
+        self.local_secondary_indexes[key] = index
+        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.
+      #
+      # @param [Symbol] hash hash key name.
+      # @param [Symbol] range range key name.
+      # @return [Boolean] true iff provided keys correspond to a local
+      #         secondary index.
+      def is_local_secondary_index?(hash, range=nil)
+        self.local_secondary_indexes[index_key(hash, range)].present?
+      end
+
+
+      # Returns true iff the provided hash[,range] key combo is a global
+      # secondary index.
+      #
+      # @param [Symbol] hash hash key name.
+      # @param [Symbol] range range key name.
+      # @return [Boolean] true iff provided keys correspond to a global
+      #         secondary index.
+      def is_global_secondary_index?(hash, range=nil)
+        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.
+      #
+      # @param [Symbol] hash hash key name.
+      # @param [Symbol] range range key name.
+      # @return [String] returns "hash" if hash only, "hash_range" otherwise.
+      def index_key(hash, range=nil)
+        name = hash.to_s
+        if range.present?
+          name += "_#{range.to_s}"
+        end
+        name
+      end
+
+
+      # Generates a default index name.
+      #
+      # @param [Symbol] hash hash key name.
+      # @param [Symbol] range range key name.
+      # @return [String] index name of the form "table_name_index_index_key".
+      def index_name(hash, range=nil)
+        "#{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
+      #         secondary indexes.
+      def indexes
+        self.local_secondary_indexes.merge(self.global_secondary_indexes)
+      end
+
+      def indexed_hash_keys
+        self.global_secondary_indexes.map do |name, index|
+          index.hash_key.to_s
+        end
+      end
+    end
+
+
+    # Represents the attributes of a DynamoDB index.
+    class Index
+      include ActiveModel::Validations
+
+      PROJECTION_TYPES = [:keys_only, :all].to_set
+      DEFAULT_PROJECTION_TYPE = :keys_only
+
+      attr_accessor :name, :dynamoid_class, :type, :hash_key, :range_key,
+          :hash_key_schema, :range_key_schema, :projected_attributes,
+          :read_capacity, :write_capacity
+
+
+      validate do
+        validate_index_type
+        validate_hash_key
+        validate_range_key
+        validate_projected_attributes
+      end
+
+
+      def initialize(attrs={})
+        unless attrs[:dynamoid_class].present?
+          raise Dynamoid::Errors::InvalidIndex.new(':dynamoid_class is required')
+        end
+
+        @dynamoid_class = attrs[:dynamoid_class]
+        @type = attrs[:type]
+        @hash_key = attrs[:hash_key]
+        @range_key = attrs[:range_key]
+        @name = attrs[:name] || @dynamoid_class.index_name(@hash_key, @range_key)
+        @projected_attributes =
+            attrs[:projected_attributes] || DEFAULT_PROJECTION_TYPE
+        @read_capacity = attrs[:read_capacity]
+        @write_capacity = attrs[:write_capacity]
+
+        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.
+      #
+      # @return [Symbol] the projection type.
+      def projection_type
+        if @projected_attributes.is_a? Array
+          :include
+        else
+          @projected_attributes
+        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
+        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
+            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
+          else
+            errors.add(:hash_key, "No such field #{@hash_key} defined on table")
+          end
+        end
+    end
+  end
+end