dynamodb-api 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7fc7f62b75b2847e3b61765cffcc823b1af80a09f202cceef1a74d3a549de43
-  data.tar.gz: e1a80833c322c480c084fe33512db8012f25f683147de888e40f6a6d046677d9
+  metadata.gz: 884abb76fafa637862d01d8e3f75b0a49c34653d5aeb24a593f8865aae6d8011
+  data.tar.gz: fba9e304ecffb92392d602982d1f2e4f82c36b6b0dce4c702a378c4280d5c0a4
 SHA512:
-  metadata.gz: 4e3a874f279f32c37b16a77ba649aa9cfc83615103f5df9b58a64a06496e796d31396728e0e0e1c6d7bc6538ea0be5c02c49249933f6c4bfc830f71498b88a89
-  data.tar.gz: 9628ccc8dc2ff42c0ec495a5485546091f82e29ba1895e4345c1a7a31d7a2298f629a7e4370caeb51e6966c4076aba9cadc81e7500c0595c82a1c867d205b171
+  metadata.gz: 3c12330b1af83f9a73ba0965cc5c8189418825e26f98d3f859e5171666960e1f5d17c616534fb051d17e06e293234e4e1161182c5f3caa769e66e0d1842e7fbf
+  data.tar.gz: 1a2b02ae868c6392dd40863de0c864f69bd2501186b7aef53f0cd407be968f5f5490f2ac8b76919e2acb1bdded7f56b9ff68b664a607fbc0d85126cbb8871d55

data/bin/console

@@ -21,7 +21,7 @@ Aws.config.update(
 )
 
 Dynamodb::Api.config do |config|
-  config.endpoint = 'http://0.0.0.0:8000'
+  config.endpoint = 'http://dynamodb:8000'
 end
 
 IRB.start(__FILE__)

data/docker-compose.yml

@@ -7,6 +7,6 @@ services:
     volumes:
       - .:/app
   dynamodb:
-    image: cnadiminti/dynamodb-local:2018-04-11
+    image: amazon/dynamodb-local
     ports:
       - 8000:8000

data/lib/dynamodb/api/base.rb

@@ -12,9 +12,13 @@ module Dynamodb
         raise NotImplementedError, "You must implement #{self.class}##{__method__}"
       end
 
+      def next
+        raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+      end
+
       private
 
-      def build_query
+      def build_input
         raise NotImplementedError, "You must implement #{self.class}##{__method__}"
       end
 
@@ -30,20 +34,31 @@ module Dynamodb
         clause&.name ? clause.name : SelectClause.new.name
       end
 
-      def build_filter_clause
-        return {} if filter_clause&.expression.blank?
-        {
-          filter_expression: filter_clause.expression,
-          expression_attribute_values: filter_clause.values,
-        }
+      # Build filter clause.
+      # `filter_expression`: e.g. "Artist = :a"
+      # `expression_attribute_values`: e.g. { ":a" => "No One You Know" }
+      #
+      # @param input [Aws::DynamoDB::Types::ScanInput]
+      # @return [Aws::DynamoDB::Types::ScanInput]
+      def build_filter_clause(input)
+        return input if filter_clause&.expression.blank?
+        input[:filter_expression] = filter_clause.expression
+        if filter_clause.values.present?
+          if input[:expression_attribute_values].nil?
+            input[:expression_attribute_values] = {}
+          end
+          input[:expression_attribute_values].
+            merge!(filter_clause.values)
+        end
+        input
       end
 
-      def build_expression_attribute_names(params)
+      def build_expression_attribute_names(input)
         if filter_clause&.reserved_words.present?
           expression_attribute.add(filter_clause.reserved_words)
         end
         if expression_attribute.names.present?
-          params[:expression_attribute_names] = expression_attribute.names
+          input[:expression_attribute_names] = expression_attribute.names
         end
       end
     end

data/lib/dynamodb/api/config.rb

@@ -16,6 +16,8 @@ module Dynamodb
       option :table_name_prefix, default: ''
       option :index_name_prefix, default: ''
 
+      # @param value [String] the table name
+      # @return [String] the table name
       def build_table_name(value)
         return value unless table_name_prefix?
         "#{table_name_prefix}#{value}"

data/lib/dynamodb/api/map/operator.rb

@@ -4,21 +4,24 @@ module Dynamodb
   module Api
     module Map
       class Operator # :nodoc:
+        # Replace the Dynamodb Operators
+        # @param k [String] The Dynamodb Operator
+        # @return [String]
         def self.key(k)
           k = k.gsub(' ', '')
           case k
-          when '='
-            'EQ'
-          when '!='
-            'NE'
-          when '<='
-            'LE'
-          when '<'
-            'LT'
-          when '>='
-            'GE'
-          when '>'
-            'GT'
+          when 'EQ'
+            '='
+          when 'NE'
+            '!='
+          when 'LE'
+            '<='
+          when 'LT'
+            '<'
+          when 'GE'
+            '>='
+          when 'GT'
+            '>'
           else
             k
           end

data/lib/dynamodb/api/query.rb

@@ -6,16 +6,16 @@ module Dynamodb
   module Api
     class Query < Base # :nodoc:
       def all
-        result = Adapter.client.query(build_query)
+        result = Adapter.client.query(build_input)
         @last_evaluated_key = result.last_evaluated_key
         result
       end
 
       def next
         return nil if @last_evaluated_key.blank?
-        result = Adapter.client.query(
-          build_query.merge(exclusive_start_key: @last_evaluated_key)
-        )
+        input = build_input
+        input[:exclusive_start_key] = @last_evaluated_key
+        result = Adapter.client.query(input)
         @last_evaluated_key = result.last_evaluated_key
         return nil if result.count.zero?
         result
@@ -23,21 +23,34 @@ module Dynamodb
 
       private
 
-      def build_query
-        build_params = base_params.merge(build_filter_clause)
-        build_params[:scan_index_forward] = order_direct(order_clause)
-        build_params[:select] = select_name(select_clause)
-        build_expression_attribute_names(build_params)
-        build_params[:limit] = limit_clause.number if limit_clause&.number
-        build_params
+      # Build options.
+      #
+      # @return [Aws::DynamoDB::Types::ScanInput]
+      def build_input
+        input = Aws::DynamoDB::Types::QueryInput.new
+        input[:expression_attribute_values] = {}
+        input = base_input(input)
+        input = build_filter_clause(input)
+        input[:scan_index_forward] = order_direct(order_clause)
+        input[:select] = select_name(select_clause)
+        build_expression_attribute_names(input)
+        input[:limit] = limit_clause.number if limit_clause&.number
+        input
       end
 
-      def base_params
-        {
-          table_name: from_clause.name,
-          index_name: index_clause.name,
-          key_conditions: where_clause.key_conditions,
-        }
+      # Build required options.
+      # `key_condition_expression`: e.g. "Artist = :a"
+      # `expression_attribute_values`: e.g. { ":a" => "No One You Know" }
+      #
+      # @param input [Aws::DynamoDB::Types::ScanInput]
+      # @return [Aws::DynamoDB::Types::ScanInput]
+      def base_input(input)
+        input[:table_name] = from_clause.name
+        input[:index_name] = index_clause.name
+        input[:key_condition_expression] = where_clause.key_condition
+        input[:expression_attribute_values].
+          merge!(where_clause.attribute_values)
+        input
       end
     end
   end

data/lib/dynamodb/api/relation/query_methods.rb

@@ -24,8 +24,8 @@ module Dynamodb
           self
         end
 
-        def where(key_conditions)
-          self.where_clause = Relation::WhereClause.new(key_conditions)
+        def where(expression)
+          self.where_clause = Relation::WhereClause.new(expression)
           self
         end
 

data/lib/dynamodb/api/relation/where_clause.rb

@@ -4,24 +4,89 @@ module Dynamodb
   module Api
     module Relation
       class WhereClause # :nodoc:
-        attr_reader :key_conditions
+        attr_reader :key_condition
+        attr_reader :attribute_values
 
         KEY = 0
         VALUE = 2
         OPERATOR = 1
+        FROM = 0
+        TO = 1
 
-        def initialize(key_conditions)
-          @key_conditions = build(key_conditions)
+        # @param conditions [Array]
+        def initialize(conditions)
+          built_conditions = build(conditions)
+          @key_condition = built_conditions[:key_conditions]
+          @attribute_values = built_conditions[:attribute_values]
         end
 
         private
 
-        def build(key_conditions)
-          conditions = format_conditions(key_conditions)
-          conditions.each_with_object({}) do |c, h|
-            h[c[KEY]] = {
-              attribute_value_list: format_value(c[VALUE]),
-              comparison_operator: Map::Operator.key(c[OPERATOR]),
+        # Build where clause.
+        #
+        # @param conditions [Array]
+        def build(conditions)
+          init = { key_conditions: [], attribute_values: {} }
+          conditions = format_conditions(conditions)
+          built = conditions.each_with_object(init) do |c, h|
+            h[:key_conditions] <<
+              format_key_condition(c[KEY], c[OPERATOR])
+            h[:attribute_values].
+              merge!(format_values(c[KEY], c[OPERATOR], c[VALUE]))
+          end
+          built[:key_conditions] =
+            built[:key_conditions].join(' AND ')
+          built
+        end
+
+        # Format to the `key_condition_expression`.
+        # e.g.
+        #   `format_key_condition("Artist", "=")` =>
+        #     `"Artist = :Artist"`
+        #
+        #   `format_key_condition("Artist", "begins_with")` =>
+        #     `"begins_with(Artist, :Artist)"`
+        #
+        #   `format_key_condition("Year", "between")` =>
+        #     `"Year between :from_Year and :to_Year"`
+        #
+        # @param key [String] a attribute name
+        # @param operator [String] a operator
+        # @return [String] Formatted expression.
+        def format_key_condition(key, operator)
+          case operator.downcase
+          when 'begins_with'
+            "#{operator.downcase}(#{key}, :#{key})"
+          when 'between'
+            "#{key} #{operator.downcase}" \
+              " :from_#{key} AND :to_#{key}"
+          else
+            "#{key} #{Map::Operator.key(operator)} :#{key}"
+          end
+        end
+
+        # Format to the `expression_attribute_values`
+        # e.g.
+        #   `format_values("Artist", "=", "blue")` =>
+        #     `{ ":Artist" => "blue" }`
+        #
+        #   `format_values("Year", "between", [1999, 2020])` =>
+        #     `{ ":from_Year" => 1999, ":to_Year" => 2020 }`
+        #
+        # @param key [String] a attribute name
+        # @param operator [String] a operator
+        # @param values [Object] values
+        # @return [Hash<Object>] Formatted expression.
+        def format_values(key, operator, values)
+          case operator.downcase
+          when 'between'
+            {
+              ":from_#{key}" => values[FROM],
+              ":to_#{key}" => values[TO],
+            }
+          else
+            {
+              ":#{key}" => values.is_a?(Array) ? values[0] : values,
             }
           end
         end
@@ -30,11 +95,6 @@ module Dynamodb
           return [conditions] unless conditions[0].is_a?(Array)
           conditions
         end
-
-        def format_value(value)
-          return [value] unless value.is_a?(Array)
-          value
-        end
       end
     end
   end

data/lib/dynamodb/api/scan.rb

@@ -6,36 +6,36 @@ module Dynamodb
   module Api
     class Scan < Base # :nodoc:
       def all
-        result = Adapter.client.scan(build_query)
+        result = Adapter.client.scan(build_input)
         @last_evaluated_key = result.last_evaluated_key
         result
       end
 
       def next
         return nil if @last_evaluated_key.blank?
-        result = Adapter.client.scan(
-          build_query.merge(exclusive_start_key: @last_evaluated_key)
-        )
+        input = build_input
+        input[:exclusive_start_key] = @last_evaluated_key
+        result = Adapter.client.scan(input)
         @last_evaluated_key = result.last_evaluated_key
         result
       end
 
       private
 
-      def build_query
-        build_params = base_params.merge(build_filter_clause)
-        build_params[:index_name] = index_clause.name if index_clause&.name
-        build_params[:key_conditions] = where_clause.key_conditions if where_clause&.key_conditions
-        build_params[:select] = select_name(select_clause)
-        build_expression_attribute_names(build_params)
-        build_params[:limit] = limit_clause.number if limit_clause&.number
-        build_params
+      def build_input
+        input = Aws::DynamoDB::Types::ScanInput.new
+        input = base_input(input)
+        input = build_filter_clause(input)
+        input[:index_name] = index_clause.name if index_clause&.name
+        input[:select] = select_name(select_clause)
+        build_expression_attribute_names(input)
+        input[:limit] = limit_clause.number if limit_clause&.number
+        input
       end
 
-      def base_params
-        {
-          table_name: from_clause.name,
-        }
+      def base_input(input)
+        input[:table_name] = from_clause.name
+        input
       end
     end
   end

data/lib/dynamodb/api/version.rb

@@ -1,5 +1,5 @@
 module Dynamodb
   module Api
-    VERSION = '0.8.1'.freeze
+    VERSION = '0.9.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamodb-api
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - WalkerSumida
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-05 00:00:00.000000000 Z
+date: 2020-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -193,8 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: aws dynamodb api