dynamoid-edge 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f852381ddc94efb1130d84cdfe4aa714a72ff097
-  data.tar.gz: 20bee710a9e4312738469f91c980607304788734
+  metadata.gz: 80ef1eaf479540803590814d5cf4d531faa12cf2
+  data.tar.gz: 901734ae300344fd6294f83818781216ad3f3425
 SHA512:
-  metadata.gz: 8be902d06c5ed5ba977338c577877fe8561bee4207e9ab09e5d752d5625ceb80db89d97e34cb248ff96c4ea2be4341626848199fb57c4e891ddd8b461d6f3e94
-  data.tar.gz: a45f9b3bcc175054b02437e294b237f1e5440b0e35f553371e84dd2da06c357cd8dd698489d1e1058cadf4cb6c97eeb7ab57d10ff43e9ab944b26fb4f408e2b5
+  metadata.gz: 3fde56e03afd236911cd55022d3581dc9974248cf2b4b5656bef9fb9de32c631fd9962bbad637da971b52c54531aec3f028e7c34541a29ff7df862b4dad9ae51
+  data.tar.gz: 7bfe7c2c91508f757b2018a6d9459cc5f306a0ef2d84eadfd004c534ce5c68cd763cbec842cce3055117c60deb9174604cff845ec40ccf9c46afec07fec6fde1

data/dynamoid-edge.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = "dynamoid-edge"
-  s.version = "1.1.0"
+  s.version = "1.1.1"
 
   # Keep in sync with README
   s.authors = [
@@ -51,6 +51,7 @@ Gem::Specification.new do |s|
     lib/dynamoid/fields.rb
     lib/dynamoid/finders.rb
     lib/dynamoid/identity_map.rb
+    lib/dynamoid/indexes.rb
     lib/dynamoid/middleware/identity_map.rb
     lib/dynamoid/persistence.rb
     lib/dynamoid/validations.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamoid-edge
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Josh Symonds
@@ -196,6 +196,7 @@ files:
 - lib/dynamoid/fields.rb
 - lib/dynamoid/finders.rb
 - lib/dynamoid/identity_map.rb
+- lib/dynamoid/indexes.rb
 - lib/dynamoid/middleware/identity_map.rb
 - lib/dynamoid/persistence.rb
 - lib/dynamoid/validations.rb
@@ -219,8 +220,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Dynamoid is an ORM for Amazon's DynamoDB
 test_files: []
+has_rdoc: