dynamoid 0.7.1 → 1.0.0

data/lib/dynamoid/components.rb

@@ -25,7 +25,6 @@ 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

@@ -11,7 +11,7 @@ module Dynamoid
     include ActiveModel::Observing if defined?(ActiveModel::Observing)
 
     # All the default options.
-    option :adapter, :default => 'aws-sdk'
+    option :adapter, :default => 'aws_sdk_v2'
     option :namespace, :default => defined?(Rails) ? "dynamoid_#{Rails.application.class.parent_name}_#{Rails.env}" : "dynamoid"
     option :logger, :default => defined?(Rails)
     option :access_key
@@ -19,12 +19,9 @@ module Dynamoid
     option :read_capacity, :default => 100
     option :write_capacity, :default => 20
     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 :endpoint, :default => nil
     option :use_ssl, :default => true
     option :port, :default => '443'
-    option :included_models, :default => []
     option :identity_map, :default => false
 
     # 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, :limit, :start, :scan_index_forward].each do |meth|
+      [:where, :all, :first, :each, :eval_limit, :start, :scan_index_forward].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.
         #

data/lib/dynamoid/criteria/chain.rb

@@ -3,10 +3,9 @@ module Dynamoid #:nodoc:
   module Criteria
 
     # The criteria chain is equivalent to an ActiveRecord relation (and realistically I should change the name from
-    # 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.
+    # chain to relation). It is a chainable object that builds up a query and eventually executes it by a Query or Scan.
     class Chain
-      attr_accessor :query, :source, :index, :values, :limit, :start, :consistent_read
+      attr_accessor :query, :source, :values, :consistent_read
       include Enumerable
 
       # Create a new criteria chain.
@@ -43,82 +42,38 @@ module Dynamoid #:nodoc:
       # Returns all the records matching the criteria.
       #
       # @since 0.2.0
-      def all(opts = {})
-        batch opts[:batch_size] if opts.has_key? :batch_size
+      def all
         records
       end
-      
+
       # Destroys all the records matching the criteria.
       #
       def destroy_all
         ids = []
         
-        if range?
+        if key_present?
           ranges = []
-          Dynamoid::Adapter.query(source.table_name, range_query).collect do |hash| 
+          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})
-        elsif index
-          #TODO: test this throughly and find a way to delete all index table records for one source record
-          if index.range_key?
-            results = Dynamoid::Adapter.query(index.table_name, index_query.merge(consistent_opts))
-          else
-            results = Dynamoid::Adapter.read(index.table_name, index_query[:hash_value], consistent_opts)
-          end
-          
-          results.collect do |hash| 
-            ids << hash[source.hash_key.to_sym]
-            index_ranges << hash[source.range_key.to_sym]
-          end
-        
-          unless ids.nil? || ids.empty?
-            ids = ids.to_a
-  
-            if @start
-              ids = ids.drop_while { |id| id != @start.hash_key }.drop(1)
-              index_ranges = index_ranges.drop_while { |range| range != @start.hash_key }.drop(1) unless index_ranges.nil?
-            end
-  
-            if @limit           
-              ids = ids.take(@limit) 
-              index_ranges = index_ranges.take(@limit)
-            end
-            
-            Dynamoid::Adapter.delete(source.table_name, ids)
-            
-            if index.range_key?
-              Dynamoid::Adapter.delete(index.table_name, ids,{:range_key => index_ranges})
-            else
-              Dynamoid::Adapter.delete(index.table_name, ids)
-            end
-            
-          end
+          Dynamoid.adapter.delete(source.table_name, ids,{:range_key => ranges})
         else
-          Dynamoid::Adapter.scan(source.table_name, query, scan_opts).collect do |hash| 
+          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)
+          Dynamoid.adapter.delete(source.table_name, ids)
         end   
       end
 
-      # Returns the first record matching the criteria.
-      #
-      # @since 0.2.0
-      def first
-        limit(1).first
-      end
-
-      def limit(limit)
-        @limit = limit
-        records
+      def eval_limit(limit)
+        @eval_limit = limit
+        self
       end
 
       def batch(batch_size)
-        raise 'Cannot batch calls when using partitioning' if Dynamoid::Config.partitioning?
         @batch_size = batch_size
         self
       end
@@ -152,54 +107,17 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def records
-        results = if range?
-          records_with_range
-        elsif index
-          records_with_index
+        results = if key_present?
+          records_via_query
         else
-          records_without_index
+          records_via_scan
         end
         @batch_size ? results : Array(results)
       end
 
-      # If the query matches an index on the associated class, then this method will retrieve results from the index table.
-      #
-      # @return [Enumerator] an iterator of the found records.
-      #
-      # @since 0.2.0
-      def records_with_index
-        ids = ids_from_index
-        if ids.nil? || ids.empty?
-          Enumerator.new []
-        else
-          ids = ids.to_a
-
-          if @start
-            ids = ids.drop_while { |id| id != @start.hash_key }.drop(1)
-          end
-
-          ids = ids.take(@limit) if @limit
-          source.find(ids, consistent_opts)
-        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
+      def records_via_query
         Enumerator.new do |yielder|
-          Dynamoid::Adapter.query(source.table_name, range_query).each do |hash|
+          Dynamoid.adapter.query(source.table_name, range_query).each do |hash|
             yielder.yield source.from_database(hash)
           end
         end
@@ -210,7 +128,7 @@ module Dynamoid #:nodoc:
       # @return [Enumerator] an iterator of the found records.
       #
       # @since 0.2.0
-      def records_without_index
+      def records_via_scan
         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(', ')}]"
@@ -221,38 +139,18 @@ module Dynamoid #:nodoc:
         end
 
         Enumerator.new do |yielder|
-          Dynamoid::Adapter.scan(source.table_name, query, scan_opts).each do |hash|
+          Dynamoid.adapter.scan(source.table_name, query, scan_opts).each do |hash|
             yielder.yield source.from_database(hash)
           end
         end
       end
 
-      # 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
-      def index_query
-        values = index.values(query)
-        {}.tap do |hash|
-          hash[:hash_value] = values[:hash_value]
-          if index.range_key?
-            key = query.keys.find{|k| k.to_s.include?('.')}
-            if key
-              hash.merge!(range_hash(key))
-            else
-              raise Dynamoid::Errors::MissingRangeKey, 'This index requires a range key'
-            end
-          end
-        end
-      end
-
       def range_hash(key)
         val = query[key]
 
         return { :range_value => query[key] } if query[key].is_a?(Range)
 
-        case key.split('.').last
+        case key.to_s.split('.').last
         when 'gt'
           { :range_greater_than => val.to_f }
         when 'lt'
@@ -274,38 +172,27 @@ module Dynamoid #:nodoc:
         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
-      def index
-        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
 
-      # Use range query only when [hash_key] or [hash_key, range_key] is specified in query keys.
-      def range?
-        return false unless query_keys.include?(source.hash_key.to_s) or query_keys.include?(source.range_key.to_s)
+      # [hash_key] or [hash_key, range_key] is specified in query keys.
+      def key_present?
         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
- 	      hash_key_type = @start.class.attributes[@start.class.hash_key][:type] == :string ? 'S' : 'N'
-        key = { :hash_key_element => { hash_key_type => @start.hash_key.to_s } }
+        key = { :hash_key_element => @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).to_s } })
+          key.merge!({:range_key_element => @start.send(range_key) })
         end
         key
       end
 
       def query_opts
         opts = {}
-        opts[:limit] = @limit if @limit
+        opts[:select] = 'ALL_ATTRIBUTES'
+        opts[:limit] = @eval_limit if @eval_limit
         opts[:next_token] = start_key if @start
         opts[:scan_index_forward] = @scan_index_forward
         opts
@@ -313,7 +200,7 @@ module Dynamoid #:nodoc:
       
       def scan_opts
         opts = {}
-        opts[:limit] = @limit if @limit
+        opts[:limit] = @eval_limit if @eval_limit
         opts[:next_token] = start_key if @start
         opts[:batch_size] = @batch_size if @batch_size
         opts

data/lib/dynamoid/document.rb

@@ -13,7 +13,7 @@ module Dynamoid #:nodoc:
       self.read_only_attributes = []
       self.base_class = self
 
-      Dynamoid::Config.included_models << self
+      Dynamoid.included_models << self
     end
 
     module ClassMethods
@@ -61,7 +61,7 @@ module Dynamoid #:nodoc:
       #
       # @since 0.6.1
       def count
-        Dynamoid::Adapter::AwsSdk.count(table_name)
+        Dynamoid.adapter.count(table_name)
       end
 
       # Initialize a new object and immediately save it to the database.

data/lib/dynamoid/errors.rb

@@ -1,22 +1,43 @@
 # encoding: utf-8
 module Dynamoid
   
-  # All the error specific to Dynamoid.
+  # All the errors specific to Dynamoid.  The goal is to mimic ActiveRecord.
   module Errors
     
-    # Generic error class.
+    # Generic Dynamoid error
     class Error < StandardError; end
     
-    # InvalidField is raised when an attribute is specified for an index, but the attribute does not exist.
-    class InvalidField < Error; end
-    
-    # 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
+    # This class is intended to be private to Dynamoid.
+    class ConditionalCheckFailedException < Error
+      attr_reader :inner_exception
+
+      def initialize(inner)
+        super
+        @inner_exception = inner
+      end
+    end
+
+    class RecordNotUnique < ConditionalCheckFailedException
+      attr_reader :original_exception
+
+      def initialize(original_exception, record)
+        super("Attempted to write record #{record} when its key already exists")
+        @original_exception = original_exception
+      end
+    end
+
+    class StaleObjectError < ConditionalCheckFailedException
+      attr_reader :record, :attempted_action
+
+      def initialize(record, attempted_action)
+        super("Attempted to #{attempted_action} a stale object #{record}")
+        @record = record
+        @attempted_action = attempted_action
+      end
+    end
 
-    # DocumentNotValid is raised when the document fails validation.
     class DocumentNotValid < Error
       def initialize(document)
         super("Validation failed: #{document.errors.full_messages.join(", ")}")

data/lib/dynamoid/fields.rb

@@ -20,16 +20,28 @@ module Dynamoid #:nodoc:
 
     module ClassMethods
 
-      # 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.
+      # Specify a field for a document.
+      #
+      # Its type determines how it is coerced when read in and out of the datastore.
+      # You can specify :integer, :number, :set, :array, :datetime, and :serialized,
+      # or specify a class that defines a serialization strategy.
+      #
+      # If you specify a class for field type, Dynamoid will serialize using
+      # `dynamoid_dump` or `dump` methods, and load using `dynamoid_load` or `load` methods.
+      #
+      # Default field type is :string.
       #
       # @param [Symbol] name the name of the field
-      # @param [Symbol] type the type of the field (one of :integer, :float, :set, :array, :datetime, or :serialized)
+      # @param [Symbol] type the type of the field (refer to method description for details)
       # @param [Hash] options any additional options for the field
       #
       # @since 0.2.0
       def field(name, type = :string, options = {})
         named = name.to_s
+        if type == :float
+          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))
 
         define_method(named) { read_attribute(named) }

data/lib/dynamoid/finders.rb

@@ -16,16 +16,17 @@ module Dynamoid
       #
       # @since 0.2.0
       def find(*ids)
-
         options = if ids.last.is_a? Hash
                     ids.slice!(-1)
                   else
                     {}
                   end
+        expects_array = ids.first.kind_of?(Array)
 
         ids = Array(ids.flatten.uniq)
         if ids.count == 1
-          self.find_by_id(ids.first, options)
+          result = self.find_by_id(ids.first, options)
+          expects_array ? Array(result) : result
         else
           find_all(ids)
         end
@@ -44,7 +45,7 @@ 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 = Dynamoid.adapter.read(self.table_name, ids, options)
         items ? items[self.table_name].map{|i| from_database(i)} : []
       end
 
@@ -56,7 +57,7 @@ module Dynamoid
       #
       # @since 0.2.0
       def find_by_id(id, options = {})
-        if item = Dynamoid::Adapter.read(self.table_name, id, options)
+        if item = Dynamoid.adapter.read(self.table_name, id, options)
           from_database(item)
         else
           nil
@@ -66,7 +67,7 @@ module Dynamoid
       # 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
+      # @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}))
@@ -94,7 +95,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