toy-dynamo 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55543749d5aada53a2339255fecf85562746b958
-  data.tar.gz: ae3a9255c0d8d90187c4de0651ea3e262cf9c807
+  metadata.gz: 5a081dc7fc7b298bb5a17919dc56688f9aa504d4
+  data.tar.gz: 97616bc8ba2f9443c7915d9ea250ef5e50b0306c
 SHA512:
-  metadata.gz: 82d0ac9c53c7ec511df84d4afe592c946bf8567c5c1dce86c913b667937b033f9f408b71275c895a3a1889a03a1de7ecfc42ffea5345e2b006579c5a9e0c551f
-  data.tar.gz: 8e08548bbc6a408cc179d2f2c358e16f7b10eeef69aaf772ff14b1117a483a5d8f2fec85d26bf26a8a3efdd4595ffc89854f367255d35a0fb5ffe61eaece5983
+  metadata.gz: c6d12a4a8cbd03bbb98f8d1ba283d28771e1896b73c9b5480ef750c3b17865c9bb75ae32f654863aa3ee023a4816b37b9f34aead2bf55f29f92802c5a8daacc9
+  data.tar.gz: 8a345618f030321fc03c0695a35467d6e79166ba7bc22e06eb1f71079462b5d4ec882c4ab018f84b871d1d9bee9651d6d25ab579cde485b643fe9d40fe7d5069

data/lib/toy/dynamo/querying.rb

@@ -14,7 +14,7 @@ module Toy
         # Loop results in given batch size until limit is hit or no more results
         #   read_range("1", :range => { :varname.eq => "2"}, :batch => 10, :limit => 1000)
         def read_range(hash_value, options={})
-          raise ArgumentError, "no range_key specified for this table" if dynamo_table.range_keys.blank?
+          raise ArgumentError, "no range_key specified for this table" if dynamo_table.range_keys.blank? && global_secondary_indexes.blank?
           aggregated_results = []
 
           batch_size = options.delete(:batch) || DEFAULT_BATCH_SIZE

data/lib/toy/dynamo/schema.rb

@@ -50,6 +50,7 @@ module Toy
             :attribute_definitions => attribute_definitions
           }
           schema[:local_secondary_indexes] = local_secondary_indexes unless local_secondary_indexes.blank?
+          schema[:global_secondary_indexes] = global_secondary_indexes unless global_secondary_indexes.blank?
           schema
         end
 
@@ -94,6 +95,12 @@ module Toy
             keys << lsi[:key_schema].select{|h| h[:key_type] == "RANGE"}.first[:attribute_name]
           end
 
+          global_secondary_indexes.each do |lsi|
+            lsi[:key_schema].each do |a|
+              keys << a[:attribute_name]
+            end
+          end
+
           definitions = keys.uniq.collect do |k|
             attr = self.attributes[k.to_s]
             {
@@ -197,6 +204,66 @@ module Toy
           end
         end
 
+        def global_secondary_indexes
+          @global_secondary_indexes ||= []
+        end
+
+        # { hash_key: :hash_key_here, range_key: :optional_range_key_here }
+        # :name
+        # :projection
+        # :read_provision
+        # :write_provision
+        def global_secondary_index(index_name, options={})
+          options[:projection] ||= :keys_only
+          global_secondary_index_hash = {
+            :projection => {},
+            :provisioned_throughput => {
+              :read_capacity_units => options[:read_provision] || read_provision,
+              :write_capacity_units => options[:write_provision] || write_provision
+            }
+          }
+          if options[:projection].is_a?(Array) && options[:projection].size > 0
+            options[:projection].each do |non_key_attr|
+              attr = self.attributes[non_key_attr.to_s]
+              raise(ArgumentError, "Could not find attribute definition for projection on #{non_key_attr}") unless attr
+              (global_secondary_index_hash[:projection][:non_key_attributes] ||= []) << attr.name
+            end
+            global_secondary_index_hash[:projection][:projection_type] = PROJECTION_TYPE[:include]
+          else
+            raise(ArgumentError, 'projection must be :all, :keys_only, Array (or attrs)') unless options[:projection] == :keys_only || options[:projection] == :all
+            global_secondary_index_hash[:projection][:projection_type] = PROJECTION_TYPE[options[:projection]]
+          end
+
+          if !options.has_key?(:hash_key) || self.attributes[options[:hash_key].to_s].blank?
+            raise(ArgumentError, "Could not find attribute definition for global secondary index on hash_key specified")
+          end
+          hash_key_attr = self.attributes[options[:hash_key].to_s]
+
+          if options.has_key?(:range_key) && self.attributes[options[:range_key].to_s].blank?
+            raise(ArgumentError, "Could not find attribute definition for global secondary index on range_key specified")
+          end
+          range_key_attr = nil
+          range_key_attr = self.attributes[options[:range_key].to_s] if options.has_key?(:range_key)
+
+          ## Force naming of index_name for lookup later
+          #global_secondary_index_hash[:index_name] = (index_name.to_s || "#{hash_key_attr.name}#{"_#{range_key_attr.name}" if range_key_attr}_gsi_index".camelcase)
+          global_secondary_index_hash[:index_name] = index_name.to_s
+
+          global_secondary_index_hash[:key_schema] = [
+            {
+              :attribute_name => hash_key_attr.name,
+              :key_type => KEY_TYPE[:hash]
+            }
+          ]
+          global_secondary_index_hash[:key_schema] << {
+            :attribute_name => range_key_attr.name,
+            :key_type => KEY_TYPE[:range]
+          } if range_key_attr
+
+          return false if (@global_secondary_indexes ||= []).select {|i| i[:index_name] == global_secondary_index_hash[:index_name] }.present? # Do not add if we already have a range key set for this attr
+          (@global_secondary_indexes ||= []) << global_secondary_index_hash
+        end
+
         def local_secondary_indexes
           @local_secondary_indexes ||= []
         end
@@ -226,7 +293,7 @@ module Toy
 
           range_attr = self.attributes[range_key_attr.to_s]
           raise(ArgumentError, "Could not find attribute definition for local secondary index on #{range_key_attr}") unless range_attr
-          local_secondary_index_hash[:index_name] = (options[:name] || "#{range_attr.name}_index".camelcase)
+          local_secondary_index_hash[:index_name] = (options[:name] || options[:index_name] || "#{range_attr.name}_index".camelcase)
 
           hash_key_attr = self.attributes[hash_key[:attribute_name].to_s]
           raise(ArgumentError, "Could not find attribute definition for hash_key") unless hash_key_attr

data/lib/toy/dynamo/table.rb

@@ -74,14 +74,15 @@ module Toy
           end
         end
 
-        if @schema_loaded_from_dynamo[:table][:local_secondary_indexes]
-          @schema_loaded_from_dynamo[:table][:local_secondary_indexes].each do |key|
-            lsi_range_key = key[:key_schema].find{|h| h[:key_type] == "RANGE" }
-            lsi_range_attribute = @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == lsi_range_key[:attribute_name]}
-            next if lsi_range_attribute.nil?
+        if @schema_loaded_from_dynamo[:table][:local_secondary_indexes] || @schema_loaded_from_dynamo[:table][:global_secondary_indexes]
+          ((@schema_loaded_from_dynamo[:table][:local_secondary_indexes] || []) + (@schema_loaded_from_dynamo[:table][:global_secondary_indexes] || [])).each do |key|
+            si_range_key = key[:key_schema].find{|h| h[:key_type] == "RANGE" }
+            next if si_range_key.nil?
+            si_range_attribute = @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == si_range_key[:attribute_name]}
+            next if si_range_attribute.nil?
             (@range_keys ||= []) << {
-              :attribute_name => lsi_range_key[:attribute_name],
-              :attribute_type => lsi_range_attribute[:attribute_type],
+              :attribute_name => si_range_key[:attribute_name],
+              :attribute_type => si_range_attribute[:attribute_type],
               :index_name => key[:index_name]
             }
           end
@@ -96,8 +97,7 @@ module Toy
         { hash_key => { hash_key_type => value } }
       end
 
-      def hash_key_condition_param(value)
-        hash_key = @table_schema[:key_schema].find{|h| h[:key_type] == "HASH"}[:attribute_name]
+      def hash_key_condition_param(hash_key, value)
         hash_key_type = @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == hash_key}[:attribute_type]
         {
           hash_key => {
@@ -142,7 +142,17 @@ module Toy
         #options[:exclusive_start_key]
 
         key_conditions = {}
-        key_conditions.merge!(hash_key_condition_param(hash_key_value))
+        gsi = nil
+        if options[:global_secondary_index]
+          # TODO
+          gsi = @table_schema[:global_secondary_indexes].select{ |gsi| gsi[:index_name].to_s == options[:global_secondary_index].to_s}.first
+          raise ArgumentError, "Could not find Global Secondary Index '#{options[:global_secondary_index]}'" unless gsi
+          gsi_hash_key = gsi[:key_schema].find{|h| h[:key_type] == "HASH"}[:attribute_name]
+          key_conditions.merge!(hash_key_condition_param(gsi_hash_key, hash_key_value))
+        else
+          hash_key = @table_schema[:key_schema].find{|h| h[:key_type] == "HASH"}[:attribute_name]
+          key_conditions.merge!(hash_key_condition_param(hash_key, hash_key_value))
+        end
 
         query_request = {
           :table_name => options[:table_name] || self.table_name,
@@ -153,14 +163,24 @@ module Toy
         }
 
         if options[:range] 
-          raise ArgumentError, "Expected a 1 element Hash for :range (ex {:age.gt => 13})" unless options[:range].is_a?(Hash) && options[:range].keys.size == 1
+          raise ArgumentError, "Expected a 1 element Hash for :range (ex {:age.gt => 13})" unless options[:range].is_a?(Hash) && options[:range].keys.size == 1 && options[:range].keys.first.is_a?(String)
           range_key_name, comparison_operator = options[:range].keys.first.split(".")
           raise ArgumentError, "Comparison operator must be one of (#{(COMPARISON_OPERATOR.keys - COMPARISON_OPERATOR_SCAN_ONLY).join(", ")})" unless COMPARISON_OPERATOR.keys.include?(comparison_operator.to_sym)
-          range_key = @range_keys.find{|k| k[:attribute_name] == range_key_name}
+          range_key = nil
+          #[{:attribute_name=>"health_check_guid", :attribute_type=>"S", :primary_range_key=>true}]
+          #raise @range_keys.inspect
+          #if options[:global_secondary_index]
+            #raise @table_schema.inspect
+            #hash_key_type = @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == hash_key}[:attribute_type]
+            #raise gsi[:key_schema].inspect
+            ##range_key = gsi.find{|k| k[:attribute_name] == range_key_name}
+          #else
+            range_key = @range_keys.find{|k| k[:attribute_name] == range_key_name}
+          #end
           raise ArgumentError, ":range key must be a valid Range attribute" unless range_key
           raise ArgumentError, ":range key must be a Range if using the operator BETWEEN" if comparison_operator == "between" && !options[:range].values.first.is_a?(Range)
 
-          if range_key.has_key?(:index_name) # Local Secondary Index
+          if range_key.has_key?(:index_name) # Local/Global Secondary Index
             #options[:select] = :projected unless options[:select].present?
             query_request.merge!(:index_name => range_key[:index_name])
           end
@@ -183,6 +203,10 @@ module Toy
           })
         end
 
+        if options[:global_secondary_index] # Override index_name if using GSI
+          query_request.merge!(:index_name => gsi[:index_name])
+        end
+
         # Default if not already set
         options[:select] ||= :all # :all, :projected, :count, []
         if options[:select].is_a?(Array)

data/lib/toy/dynamo/version.rb

@@ -1,5 +1,5 @@
 module Toy
   module Dynamo
-    VERSION = "0.1.3"
+    VERSION = "0.1.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toy-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Cary Dunn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-04 00:00:00.000000000 Z
+date: 2013-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler