ocean-dynamo 0.7.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f8f15f518a6ebd5f2641813c0dbdca6a2e08c22
-  data.tar.gz: 6cd1649181ef94bd8be00c988e7c54313d893721
+  metadata.gz: e59574397e111dc399d72b632fcd21fd73e9f114
+  data.tar.gz: b93297d296545f8a4f1626eaf8d6bd6936aa5be5
 SHA512:
-  metadata.gz: 348414c9d1533da6e0615f90ee510ef72c913b58b4eadc6696a74137189173b7e9a4cd77315563304c8ccbab220b5a9b254b93ad7da7474865f081627174ffd5
-  data.tar.gz: 5c4c8da288dacad52aeccf9cda01d4448a10f11fbad95234df98623a02ce75e3a72103ce4812da62f78857d59213e2a88f845cda159c6722de8b4905cc8ff165
+  metadata.gz: 61f93300975ddda2911f33da30761e9773d7a4c488148eb690618f1ec1286869e08ad1c50b25e0ca93ba6b14ddc4dc0989959c660b8d11b282eafaea97c00e03
+  data.tar.gz: b644c1ce1bf53bc1b55d67adcc7905f077502fddf8a6ad3770470a84d6800665c9c4cbdfaf9e73abae3a1cd9c6119e616efd8e9f85edf9cc45e4b2691f2daeab

data/README.rdoc

@@ -73,8 +73,8 @@ value will return the empty string, <tt>""</tt>.
 +dynamo_schema+ takes args and many options. Here's the full syntax:
 
  dynamo_schema(
-   table_hash_key = :id,                   # The name of the hash key attribute
-   table_range_key = nil,                  # The name of the range key attribute (or nil)
+   table_hash_key: = :id,                  # The name of the hash key attribute
+   table_range_key: = nil,                 # The name of the range key attribute (or nil)
    table_name: compute_table_name,         # The basename of the DynamoDB table
    table_name_prefix: nil,                 # A basename prefix string or nil
    table_name_suffix: nil,                 # A basename suffix string or nil
@@ -214,9 +214,6 @@ to both the following locations in your project:
 Enter your AWS credentials in the latter file. Eventually, there
 will be a generator to copy these files for you, but for now you need to do it manually. 
 
-You also need +fake_dynamo+ to run DynamoDB locally: see below for installation instructions.
-NB: You do not need an Amazon AWS account to run OceanDynamo locally.
-
 
 == Documentation
 
@@ -228,6 +225,8 @@ See also Ocean, a Rails framework for creating highly scalable SOAs in the cloud
 OceanDynamo is used as a central component:
 * http://wiki.oceanframework.net
 
+* AWS Ruby SDK v2 for DynamoDB: http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB.html
+
 
 == Contributing
 
@@ -239,46 +238,48 @@ All contributed code must therefore also be exhaustively tested.
 
 == Running the specs
 
-To run the specs for the OceanDynamo gem, you must first install the bundle. It will download
-a gem called +fake_dynamo+, which runs a local, in-memory functional clone of Amazon DynamoDB.
-We use +fake_dynamo+ during development and testing.
+To run the specs for the OceanDynamo gem, you must first install DynamoDB Local. It's a local, 
+functional clone of Amazon DynamoDB. We use DynamoDB Local during development and testing.
+
+Starting with +ocean-dynamo+ 0.8.0, we're using v2 of the AWS SDK Ruby gem and the latest version
+of the DynamoDB API (2012-08-10). This means that we now have access to secondary indices, 
+amongst other things.
 
-First of all, copy the AWS configuration file from the template:
+Download DynamoDB Local from the following location: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html
+
+Next, copy the AWS configuration file from the template:
 
  cp spec/dummy/config/aws.yml.example spec/dummy/config/aws.yml
 
 NB: +aws.yml+ is excluded from source control. This allows you to enter your AWS credentials
 safely. Note that +aws.yml.example+ is under source control: don't edit it.
 
-Make sure your have version 0.1.3 of the +fake_dynamo+ gem. It implements the +2011-12-05+ version
-of the DynamoDB API. We're not using the +2012-08-10+ version, as the +aws-sdk+ ruby gem
-doesn't fully support it.
-
-Next, start +fake_dynamo+:
+You're now ready to start DynamoDB Local:
 
-  fake_dynamo --port 4567
+ java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
 
-If this returns errors, make sure that <tt>/usr/local/var/fake_dynamo</tt> exists and
-is writable:
+With DynamoDB Local running, you should now be able to do
 
- sudo mkdir -p /usr/local/var/fake_dynamo
- sudo chown peterb:staff /usr/local/var/fake_dynamo
+ rspec
 
-When +fake_dynamo+ runs normally, open another window and issue the following command:
+All tests should pass.
 
- curl -X DELETE http://localhost:4567
 
-This will reset the +fake_dynamo+ database. It's not a required operation when starting
-+fake_dynamo+; we're just using it here as a test that the installation works. It will
-be issued automatically as part of the test suite, so don't expect test data to survive
-between runs.
+=== Resetting the DynamoDB Local database
 
-With +fake_dynamo+ running, you should now be able to do
+You might want to add the following to your spec_helper.rb file, inside the +RSpec.configure+
+block:
 
- rspec
-
-All tests should pass.
+  # To clear the DB before and/or after each run, uncomment as desired:
+  config.before(:suite) { c = Aws::DynamoDB::Client.new
+                          c.list_tables.table_names.each { |t| c.delete_table({table_name: t}) }
+                        }
+  # config.after(:suite)  { c = Aws::DynamoDB::Client.new
+  #                         c.list_tables.table_names.each { |t| c.delete_table({table_name: t}) }
+  #                       }
 
+Just make sure you don't run the above code when running your tests against the live DynamoDB
+service on AWS, as it will erase all your DynamoDB tables.
 
 == Rails console
 
@@ -288,7 +289,7 @@ The Rails console is available from the built-in dummy application:
  rails console
 
 This will, amongst other things, also create the CloudModel table if it doesn't already
-exist. On Amazon, this will take a little while. With +fake_dynamo+, it's practically
+exist. On Amazon, this will take a little while. With DynamoDB Local, it's practically
 instant.
 
 When you leave the console, you must navigate back to the top directory (<tt>cd ../..</tt>)

data/lib/ocean-dynamo/associations/belongs_to.rb

@@ -26,7 +26,7 @@ module OceanDynamo
       #  end
       #  
       # class Topic < OceanDynamo::Table
-      #   dynamo_schema(:uuid) do
+      #   dynamo_schema(:guid) do
       #     attribute :title
       #   end
       #   belongs_to :forum
@@ -34,7 +34,7 @@ module OceanDynamo
       # end
       #  
       # class Post < OceanDynamo::Table
-      #   dynamo_schema(:uuid) do
+      #   dynamo_schema(:guid) do
       #     attribute :body
       #   end
       #   belongs_to :topic, composite_key: true

data/lib/ocean-dynamo/associations/has_many.rb

@@ -109,6 +109,13 @@ module OceanDynamo
 
     protected
 
+
+    def condition_options(child_class)
+      { key_condition_expression: "#{child_class.table_hash_key} = :hashval AND #{child_class.table_range_key} >= :rangeval",
+        expression_attribute_values: { ":hashval" => id, ":rangeval" => "0" }
+      }
+    end
+
     #
     # Reads all children of a has_many relation.
     #
@@ -118,10 +125,8 @@ module OceanDynamo
       else
         result = Array.new
         _late_connect?
-        child_items = child_class.dynamo_items
-        child_items.query(hash_value: id, range_gte: "0",
-                          batch_size: 1000, select: :all) do |item_data|
-          result << child_class.new._setup_from_dynamo(item_data)
+        child_class.in_batches :query, condition_options(child_class) do |attrs|
+          result << child_class.new._setup_from_dynamo(attrs)
         end
         result
       end
@@ -146,11 +151,8 @@ module OceanDynamo
     #
     def map_children(child_class)
       return if new_record?
-      child_items = child_class.dynamo_items
-      return if child_items.blank?
-      child_items.query(hash_value: id, range_gte: "0", 
-                        batch_size: 1000, select: :all) do |item_data|
-        yield child_class.new._setup_from_dynamo(item_data)
+      child_class.in_batches :query, condition_options(child_class) do |attrs|
+        yield child_class.new._setup_from_dynamo(attrs)
       end
     end
 
@@ -160,11 +162,9 @@ module OceanDynamo
     # 
     def delete_children(child_class)
       return if new_record?
-      child_items = child_class.dynamo_items
-      return if child_items.blank?
-      child_items.query(hash_value: id, range_gte: "0", 
-                        batch_size: 1000) do |item|
-        item.delete
+      child_class.in_batches :query, condition_options(child_class) do |attrs|
+        child_class.delete attrs[child_class.table_hash_key.to_s], 
+                           attrs[child_class.table_range_key.to_s]
       end
     end
 
@@ -176,14 +176,15 @@ module OceanDynamo
     #
     def nullify_children(child_class)
       return if new_record?
-      child_items = child_class.dynamo_items
-      return if child_items.blank?
-      child_items.query(hash_value: id, range_gte: "0", 
-                        batch_size: 1000, select: :all) do |item_data|
-        attrs = item_data.attributes
-        item_data.item.delete
-        attrs[child_class.table_hash_key.to_s] = "NULL"
-        child_items.create attrs
+      opts = condition_options(child_class)
+      child_class.in_batches :query, opts do |attrs|
+        child_hash_key = child_class.table_hash_key.to_s
+        child_range_key = child_class.table_range_key && child_class.table_range_key.to_s
+        # There is no way in the DynamoDB API to update a key attribute. Delete the child item.
+        child_class.delete attrs[child_hash_key], attrs[child_range_key]
+        # Create a new one with NULL for key
+        attrs[child_hash_key] = "NULL"
+        child_class.dynamo_table.put_item(item: attrs)
       end
     end
 

data/lib/ocean-dynamo/attributes.rb

@@ -54,7 +54,6 @@ module OceanDynamo
 
     attr_reader :destroyed      # :nodoc:
     attr_reader :new_record     # :nodoc:
-    attr_reader :dynamo_item    # :nodoc:
 
 
     def initialize(attrs={})

data/lib/ocean-dynamo/class_variables.rb

@@ -1,15 +1,15 @@
 module OceanDynamo
   class Table
 
+    class_attribute :dynamo_resource, instance_writer: false
+    self.dynamo_resource = nil
+
     class_attribute :dynamo_client, instance_writer: false
     self.dynamo_client = nil
 
     class_attribute :dynamo_table, instance_writer: false
     self.dynamo_table = nil
 
-    class_attribute :dynamo_items, instance_writer: false
-    self.dynamo_items = nil
-
     class_attribute :table_name, instance_writer: false
     self.table_name = nil
 

data/lib/ocean-dynamo/persistence.rb

@@ -30,27 +30,46 @@ module OceanDynamo
       end
 
 
+      #
+      # Class method to delete a record. Returns true if the record existed,
+      # false if it didn't.
+      #
       def delete(hash, range=nil)
-        item = dynamo_items[hash, range]
-        return false unless item.exists?
-        item.delete
-        true
+        _late_connect?
+        keys = { table_hash_key.to_s => hash }
+        keys[table_range_key] = range if table_range_key && range
+        options = { key: keys, 
+                    return_values: "ALL_OLD"
+                  }
+        dynamo_table.delete_item(options).attributes ? true : false
       end
 
 
+      #
+      # Deletes all records without instantiating them first.
+      #
       def delete_all
-        return nil unless dynamo_items
-        dynamo_items.each() do |item|
-          item.delete
+        options = {
+          consistent_read: true,
+          projection_expression: table_hash_key.to_s + (table_range_key ? ", " + table_range_key.to_s : "")
+        }
+        in_batches :scan, options do |attrs|
+          if table_range_key
+            delete attrs[table_hash_key.to_s], attrs[table_range_key.to_s]
+          else
+            delete attrs[table_hash_key.to_s]
+          end
         end
         nil
       end
 
 
+      #
+      # Destroys all records after first instantiating them.
+      #
       def destroy_all
-        return nil unless dynamo_items
-        dynamo_items.select() do |item_data|
-          new._setup_from_dynamo(item_data).destroy
+        in_batches :scan, { consistent_read: true } do |attrs|
+          new._setup_from_dynamo(attrs).destroy
         end
         nil
       end
@@ -217,12 +236,23 @@ module OceanDynamo
       _late_connect?
       run_callbacks :touch do
         begin
-          dynamo_item.attributes.update(_handle_locking) do |u|
-            set_timestamps(name).each do |k|
-              u.set(k => serialize_attribute(k, read_attribute(k)))
-            end
+          timestamps = set_timestamps(name)
+          update_expression = []
+          expression_attribute_values = {}
+          timestamps.each_with_index do |ts, i|
+            nomen = ":ts#{i}"
+            expression_attribute_values[nomen] = serialize_attribute(ts, read_attribute(ts))
+            update_expression << "#{ts} = #{nomen}"
           end
-        rescue AWS::DynamoDB::Errors::ConditionalCheckFailedException
+          update_expression = "SET " + update_expression.join(", ")
+          options = { 
+              key: serialized_key_attributes,
+              update_expression: update_expression
+          }.merge(_handle_locking)
+          options[:expression_attribute_values] = (options[:expression_attribute_values] || {}).merge(expression_attribute_values)
+          dynamo_table.update_item(options)
+        rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
+          write_attribute(lock_attribute, read_attribute(lock_attribute)-1) unless frozen?
           raise OceanDynamo::StaleObjectError.new(self)
         end
         self
@@ -231,36 +261,20 @@ module OceanDynamo
 
 
     #
-    # Sets the dynamo_item and deserialises and assigns all its defined 
-    # attributes. Skips undeclared attributes. 
-    #
-    # The arg may be either an Item or an ItemData. If Item, a request will be
-    # made for the attributes from DynamoDB. If ItemData, no DB access will
-    # be made and the existing data will be used.
-    #
-    # The :consistent keyword may only be used when the arg is an Item.
-    #
-    def _setup_from_dynamo(arg, consistent: false)
+    # Deserialises and assigns all defined attributes. Skips undeclared attributes. 
+    # Unlike its predecessor, this version never reads anything from DynamoDB, 
+    # it just processes the results from such reads. Thus, the implementation of 
+    # +consistent+ reads is up to the caller of this method.
+    #    
+    def _setup_from_dynamo(arg)
       case arg
-      when AWS::DynamoDB::Item
-        item = arg
-        item_data = nil
-      when AWS::DynamoDB::ItemData
-        item = arg.item
-        item_data = arg
-        raise ArgumentError, ":consistent may not be specified when passing an ItemData" if consistent
-      else
-        raise ArgumentError, "arg must be an AWS::DynamoDB::Item or an AWS::DynamoDB::ItemData"
-      end
-      
-      @dynamo_item = item
-
-      if !item_data
-        raw_attrs = item.attributes.to_hash(consistent_read: consistent)
+      when Aws::DynamoDB::Types::GetItemOutput
+        raw_attrs = arg.item
+      when Hash
+        raw_attrs = arg
       else
-        raw_attrs = item_data.attributes
+        raise ArgumentError, "arg must be an Aws::DynamoDB::Types::GetItemOutput or a Hash (was #{arg.class})"
       end
-
       dynamo_deserialize_attributes(raw_attrs)
       @new_record = false
       self
@@ -278,9 +292,13 @@ module OceanDynamo
     def dynamo_persist(lock: nil) # :nodoc:
       _late_connect?
       begin
-        options = _handle_locking(lock)
-        @dynamo_item = dynamo_items.put(serialized_attributes, options)
-      rescue AWS::DynamoDB::Errors::ConditionalCheckFailedException
+        options = _handle_locking(lock)                       # This might increment an attr...
+        options = options.merge(item: serialized_attributes)  # ... which we serialise here.
+        dynamo_table.put_item(options)
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
+        if lock
+          write_attribute(lock, read_attribute(lock)-1) unless frozen?
+        end
         raise OceanDynamo::StaleObjectError.new(self)
       end
       @new_record = false
@@ -291,9 +309,12 @@ module OceanDynamo
     def dynamo_delete(lock: nil) # :nodoc:
       _late_connect?
       begin
-        options = _handle_locking(lock)
-        @dynamo_item.delete(options)
-      rescue AWS::DynamoDB::Errors::ConditionalCheckFailedException
+        options = { key: serialized_key_attributes }.merge(_handle_locking(lock))
+        dynamo_table.delete_item(options)
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
+        if lock
+          write_attribute(lock, read_attribute(lock)-1) unless frozen?
+        end
         raise OceanDynamo::StaleObjectError.new(self)
       end
     end
@@ -309,18 +330,28 @@ module OceanDynamo
     end
 
 
-    def dynamo_deserialize_attributes(hash) # :nodoc:
+    def serialized_key_attributes
       result = Hash.new
-      fields.each do |attribute, metadata|
-        next if metadata['no_save']
-        result[attribute] = deserialize_attribute(hash[attribute], metadata)
+      # First the hash key
+      attribute = table_hash_key
+      metadata = fields[attribute]
+      serialized = serialize_attribute(attribute, read_attribute(attribute), metadata)
+      raise "Hash key may not be null" if serialized == nil
+      result[attribute] = serialized
+      # Then the range key, if any
+      if table_range_key
+        attribute = table_range_key
+        metadata = fields[attribute]
+        serialized = serialize_attribute(attribute, read_attribute(attribute), metadata)
+        raise "Range key may not be null" if serialized == nil
+        result[attribute] = serialized
       end
-      assign_attributes(result)
+      result
     end
 
 
     def serialize_attribute(attribute, value, metadata=fields[attribute],
-                            target_class: metadata['target_class'],
+                            target_class: metadata['target_class'],         # Remove?
                             type: metadata['type'])
       return nil if value == nil
       case type
@@ -345,6 +376,16 @@ module OceanDynamo
     end
 
 
+    def dynamo_deserialize_attributes(hash) # :nodoc:
+      result = Hash.new
+      fields.each do |attribute, metadata|
+        next if metadata['no_save']
+        result[attribute] = deserialize_attribute(hash[attribute], metadata)
+      end
+      assign_attributes(result)
+    end
+
+
     def deserialize_attribute(value, metadata, type: metadata[:type])
       case type
       when :reference
@@ -402,12 +443,24 @@ module OceanDynamo
     end
 
 
+    #
+    # Returns a hash with a condition expression which has to be satisfied 
+    # for the write or delete operation to succeed.
+    # Note that this method will increment the lock attribute. This means
+    # two things:
+    #   1. Collect the instance attributes after this method has been called.
+    #   2. Remember that care must be taken to decrement the lock attribute in
+    #      case the subsequent write/delete operation fails or throws an 
+    #      exception, such as +StaleObjectError+.
+    #
     def _handle_locking(lock=lock_attribute) # :nodoc:
       _late_connect?
       if lock
         current_v = read_attribute(lock)
         write_attribute(lock, current_v+1) unless frozen?
-        {if: {lock => current_v}}
+        { condition_expression: "#{lock} = :cv",
+          expression_attribute_values: { ":cv" => current_v }
+        }
       else
         {}
       end

data/lib/ocean-dynamo/queries.rb

@@ -12,11 +12,14 @@ module OceanDynamo
       _late_connect?
       hash = hash.id if hash.kind_of?(Table)    # TODO: We have (innocuous) leakage, fix!
       range = range.to_i if range.is_a?(Time)
-      item = dynamo_items[hash, range]
-      unless item.exists?
+      keys = { table_hash_key.to_s => hash }
+      keys[table_range_key] = range if table_range_key && range
+      options = { key: keys, consistent_read: consistent }
+      item = dynamo_table.get_item(options).item
+      unless item
         raise RecordNotFound, "can't find a #{self} with primary key ['#{hash}', #{range.inspect}]" 
       end
-      new._setup_from_dynamo(item, consistent: consistent)
+      new._setup_from_dynamo(item)
     end
 
 
@@ -29,11 +32,12 @@ module OceanDynamo
 
 
     #
-    # The number of records in the table.
+    # The number of records in the table. Updated every 6 hours or so;
+    # thus isn't a reliable real-time measure of the number of table items.
     #
     def count(**options)
       _late_connect?
-      dynamo_items.count(options)
+      dynamo_table.item_count
     end
 
 
@@ -42,17 +46,28 @@ module OceanDynamo
     #
     def all(consistent: false, **options)
       _late_connect?
-      result = []
-      if consistent
-        dynamo_items.each(options) do |item|
-          result << new._setup_from_dynamo(item, consistent: consistent)
-        end
-      else
-        dynamo_items.select(options) do |item_data| 
-          result << new._setup_from_dynamo(item_data)
+      records = []
+      in_batches :scan, { consistent_read: !!consistent } do |attrs|
+        records << new._setup_from_dynamo(attrs)
+      end
+      records
+    end
+
+
+    #
+    # This method takes a block and yields it to every record in a table.
+    # +message+ must be either :scan or :query.
+    # +options+ is the hash of options to 
+    #
+    def in_batches(message, options, &block)
+      loop do
+        result = dynamo_table.send message, options
+        result.items.each do |hash|
+          yield hash
         end
+        return true unless result.last_evaluated_key
+        options[:exclusive_start_key] = result.last_evaluated_key
       end
-      result
     end
 
 
@@ -64,19 +79,17 @@ module OceanDynamo
     # thereby greatly reducing memory consumption.
     #
     def find_each(limit: nil, batch_size: 1000, consistent: false)
-      if consistent
-        dynamo_items.each(limit: limit, batch_size: batch_size) do |item|
-          yield new._setup_from_dynamo(item, consistent: consistent)
-        end
-      else
-        dynamo_items.select(limit: limit, batch_size: batch_size) do |item_data|
-          yield new._setup_from_dynamo(item_data)
+      options = { consistent_read: consistent }
+      options[:limit] = batch_size if batch_size   
+      in_batches :scan, options do |attrs|
+        if limit
+          return true if limit <= 0
+          limit = limit - 1
         end
+        yield new._setup_from_dynamo(attrs)
       end
-      true
     end
 
-
     # #
     # # Yields each batch of records that was found by the find options as an array. The size of 
     # # each batch is set by the :batch_size option; the default is 1000.

data/lib/ocean-dynamo/tables.rb

@@ -26,8 +26,8 @@ module OceanDynamo
                         **keywords,
                         &block)
         self.dynamo_client = nil
+        self.dynamo_resource = nil
         self.dynamo_table = nil
-        self.dynamo_items = nil
         self.table_connected = false
         self.table_connect_policy = connect
         self.table_create_policy = create
@@ -45,85 +45,119 @@ module OceanDynamo
 
       def establish_db_connection
         setup_dynamo  
-        if dynamo_table.exists?
+        if table_exists?(dynamo_table)
           wait_until_table_is_active
           self.table_connected = true
+          update_table_if_required
         else
           raise(TableNotFound, table_full_name) unless table_create_policy
           create_table
         end
-        set_dynamo_table_keys
       end
 
 
       def setup_dynamo
-        self.dynamo_client ||= AWS::DynamoDB.new
-        self.dynamo_table = dynamo_client.tables[table_full_name]
-        self.dynamo_items = dynamo_table.items
+        self.dynamo_client ||= Aws::DynamoDB::Client.new
+        self.dynamo_resource ||= Aws::DynamoDB::Resource.new(client: dynamo_client)
+        self.dynamo_table = dynamo_resource.table(table_full_name)
+      end
+
+
+      def table_exists?(table)
+        return true if table.data_loaded?
+        begin
+          table.load
+        rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+          return false
+        end
+        true
       end
 
 
       def wait_until_table_is_active
         loop do
-          case dynamo_table.status
-          when :active
-            set_dynamo_table_keys
+          case dynamo_table.table_status
+          when "ACTIVE"
+            update_table_if_required
             return
-          when :updating, :creating
+          when "UPDATING", "CREATING"
             sleep 1
             next
-          when :deleting
-            sleep 1 while dynamo_table.exists?
+          when "DELETING"
+            sleep 1 while table_exists?(dynamo_table)
             create_table
             return
           else
-            raise UnknownTableStatus.new("Unknown DynamoDB table status '#{dynamo_table.status}'")
+            raise UnknownTableStatus.new("Unknown DynamoDB table status '#{dynamo_table.table_status}'")
           end
         end
       end
 
 
-      def set_dynamo_table_keys
-        hash_key_type = fields[table_hash_key][:type]
-        hash_key_type = :string if hash_key_type == :reference
-        dynamo_table.hash_key = [table_hash_key, hash_key_type]
+       def create_table
+        attrs = table_attribute_definitions
+        keys = table_key_schema
+        options = {
+          table_name: table_full_name,
+          provisioned_throughput: {
+            read_capacity_units: table_read_capacity_units,
+            write_capacity_units: table_write_capacity_units
+          },
+          attribute_definitions: attrs,
+          key_schema: keys
+        }
+        dynamo_resource.create_table(options)
+        sleep 1 until dynamo_table.table_status == "ACTIVE"
+        setup_dynamo
+        true
+      end
 
-        if table_range_key
-          range_key_type = generalise_range_key_type
-          dynamo_table.range_key = [table_range_key, range_key_type]
+
+     def update_table_if_required
+        attrs = table_attribute_definitions
+        active_attrs = []
+        dynamo_table.attribute_definitions.each do |k| 
+          active_attrs << { attribute_name: k.attribute_name, attribute_type: k.attribute_type }
         end
+        return false if active_attrs == attrs
+        options = { attribute_definitions: attrs }
+        dynamo_table.update(options)
+        true
       end
 
 
-      def create_table
-        hash_key_type = fields[table_hash_key][:type]
-        hash_key_type = :string if hash_key_type == :reference
-        range_key_type = generalise_range_key_type
+      def table_attribute_definitions
+        attrs = []
+        attrs << { attribute_name: table_hash_key.to_s, attribute_type: attribute_type(table_hash_key) }
+        attrs << { attribute_name: table_range_key.to_s, attribute_type: attribute_type(table_range_key) }  if table_range_key
+        attrs
+      end
 
-        self.dynamo_table = dynamo_client.tables.create(table_full_name, 
-          table_read_capacity_units, table_write_capacity_units,
-          hash_key: { table_hash_key => hash_key_type},
-          range_key: table_range_key && { table_range_key => range_key_type }
-        )
-        sleep 1 until dynamo_table.status == :active
-        setup_dynamo
-        true
+      def table_key_schema
+        keys = []
+        keys << { attribute_name: table_hash_key.to_s, key_type: "HASH" }
+        keys << { attribute_name: table_range_key.to_s, key_type: "RANGE" } if table_range_key
+        keys
       end
 
 
-      def generalise_range_key_type
-        return false unless table_range_key
-        t = fields[table_range_key][:type]
-        return :string if t == :string
-        return :number if t == :integer
-        return :number if t == :float
-        return :number if t == :datetime
-        raise "Unsupported range key type: #{t}"
+      def attribute_type(name)
+        vals = fields[name][:type]
+        case vals
+        when :string, :serialized, :reference
+          return "S"
+        when :integer, :float, :datetime
+          return "N"
+        when :boolean
+          return "B"
+        else
+          raise "Unknown OceanDynamo type: #{name} - #{vals.inspect}"
+        end
       end
 
 
       def delete_table
-        return false unless dynamo_table.exists? && dynamo_table.status == :active
+        return false unless dynamo_table.data_loaded? && dynamo_table.table_status == "ACTIVE"
         dynamo_table.delete
         true
       end
@@ -138,7 +172,6 @@ module OceanDynamo
     # ---------------------------------------------------------
 
     def initialize(*)
-      @dynamo_item = nil
       super
     end
 

data/lib/ocean-dynamo/version.rb

@@ -1,3 +1,3 @@
 module OceanDynamo
-  VERSION = "0.7.5"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Peter Bengtson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-10 00:00:00.000000000 Z
+date: 2015-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -16,28 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: aws-sdk-core
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: ocean-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "== OceanDynamo\n\nOceanDynamo is a massively scalable Amazon DynamoDB
   near drop-in replacement for \nActiveRecord.\n\nAs one important use case for OceanDynamo
   is to facilitate the conversion of SQL\ndatabases to no-SQL DynamoDB databases,