ocean-dynamo 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d36ffc88503b1fb28acf30eb86d8b5e709561e72
-  data.tar.gz: 126589875287f2df88701c60aea134918e0b6c55
+  metadata.gz: f6249788253589b08c22ba6f39f134b14ac986b5
+  data.tar.gz: 1d170f9c05448c3136fe7df37de6f6f43f56666f
 SHA512:
-  metadata.gz: 54c12079e7262327235bd3bae2fd40151c817ea7950ecbd1a22a61ac11f288c9bdec67a31f1e256b39aef30699aa56a1de14211ca29b2588f6a789d75a4e0d2a
-  data.tar.gz: 67e51cfa1e840deca03e0119b897b20a2a5de29b3f4b23df8b2669b375493efa728c914172820f1e160ff902cb0e4253bb2fe3b84384e049475fb76348db94b7
+  metadata.gz: 84d2847bba2ae68f2c29aa52844081bab0a0e61976b8b9b5fc25cb185f8eb039481418b501ce36db628a8912bfbc95fce488121abe766de45cca39525f5fc433
+  data.tar.gz: 238e095ec0105f540326430af4e0445c02cdf9ee557780e87c6e10284f53aa6e97aa43be57c29747e343b4051a51c1f3bdfef782abea06e60f8164a5a7a3511b

data/README.rdoc

@@ -8,34 +8,6 @@ OceanDynamo requires Ruby 2.0 and Ruby on Rails 4.0.0 or later.
 {<img src="https://badge.fury.io/rb/ocean-dynamo.png" alt="Gem Version" />}[http://badge.fury.io/rb/ocean-dynamo]
 
 
-==== Installation
-
- gem install ocean-dynamo
-
-Then, locate the gem's directory and copy 
-
- spec/dummy/config/initializers/aws.rb
-
-to your project's
-
- config/initializers/aws.rb
-
-Also copy 
-
- spec/dummy/config/aws.yml.example
-
-to both the following locations in your project:
-
- config/aws.yml.example
- config/aws.yml
-
-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.
-
-
 ==== Features
 
 As one important use case for OceanDynamo is to facilitate the conversion of SQL based
@@ -45,18 +17,17 @@ callbacks, exceptions and support methods. Ocean-dynamo follows this pattern clo
 is of course based on ActiveModel.
 
 The attribute and persistence layer of OceanDynamo is modeled on that of ActiveRecord:
-there's +save+, +save!+, +create+, +update+, +update!+, +update_attributes+ and all the other
-methods you're used to. The design goal is always to implement as much as possible of the
-ActiveRecord interface, without sacrificing scalability. This makes the task of switching 
-from SQL to no-SQL much easier.
+there's +save+, +save!+, +create+, +update+, +update!+, +update_attributes+, +find_each+,
+and all the other methods you're used to. The design goal is always to implement as much 
+as possible of the ActiveRecord interface, without sacrificing scalability. This makes the 
+task of switching from SQL to no-SQL much easier.
 
 Thanks to its structural similarity to ActiveRecord, OceanDynamo works with FactoryGirl.
 To facilitate testing, future versions will keep track of and delete instances after tests.
 
-OceanDynamo will use primary and secondary indices to retrieve related table items, 
+OceanDynamo uses primary and secondary indices to retrieve related table items, 
 which means it will scale without limits.
 
-
 ==== Example
 
 The following example shows the syntax. 
@@ -115,22 +86,61 @@ Also, dynamo_schema takes args and many options. Here's the full syntax:
  end
 
 
-== Current State
+=== Current State
 
 At the moment, OceanDynamo is fully usable as an ActiveModel and can be used by Rails
 controllers. Furthermore, OceanDynamo implements much of the infrastructure of ActiveRecord;
 for instance, +read_attribute+, +write_attribute+, and much of the control logic and
 parameters.
 
-Relations are underway. Assocations will use secondary
-indices, up to the DynamoDB maximum of 5 secondary keys per table. At the moment,
-only find with a single id is implemented. Collections can not yet be obtained.
-Work has begun on the +has_many+ / +belongs_to+ association which requires only a primary index.
-After that, the +has_and_belongs_to_many+ association will be added.
+At the moment, Model.find only takes a single id. Model.all and Model.count work as
+expected. Model.find_each and Model.find_in_batches are also available.
+
+Work has begun on the +has_many+ / +belongs_to+ association which requires only a primary 
+index. This association is even more efficient than its ActiveRecord counterpart.
+
+
+=== Future milestones
+
+After the +has_many+ / +belongs_to+ association, the +has_and_belongs_to_many+ assocation
+will be implemented. This will require secondary indices. This, and other associations will 
+use secondary indices. OceanDynamo will use association proxies to achieve the same kind of
+interface as ActiveRecord, e.g.: <code>blog_entry.comments.build(body: "Cool!").save!</code>
+
+
+=== Current use
 
 OceanDynamo is currently used in the Ocean framework (http://wiki.oceanframework.net)
 e.g. to implement critical job queues. It will be used increasingly as features are
-added to OceanDynamo and will eventually replace all ActiveRecord tables.
+added to OceanDynamo and will eventually replace all ActiveRecord tables in Ocean.
+
+
+==== Installation
+
+ gem install ocean-dynamo
+
+Then, locate the gem's directory and copy 
+
+ spec/dummy/config/initializers/aws.rb
+
+to your project's
+
+ config/initializers/aws.rb
+
+Also copy 
+
+ spec/dummy/config/aws.yml.example
+
+to both the following locations in your project:
+
+ config/aws.yml.example
+ config/aws.yml
+
+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

data/lib/ocean-dynamo/persistence.rb

@@ -32,6 +32,22 @@ module OceanDynamo
     end
 
 
+    def self.delete_all
+      dynamo_items.each() do |item|
+        item.delete
+      end
+      nil
+    end
+
+
+    def self.destroy_all
+      dynamo_items.select() do |item_data|
+        new._setup_from_dynamo(item_data).destroy
+      end
+      nil
+    end
+
+
     # ---------------------------------------------------------
     #
     #  Instance variables and methods

data/lib/ocean-dynamo/queries.rb

@@ -42,5 +42,33 @@ module OceanDynamo
       result
     end
 
+
+    #
+    # Looping through a collection of records from the database (using the +all+ method, 
+    # for example) is very inefficient since it will try to instantiate all the objects at once.
+    #
+    # In that case, batch processing methods allow you to work with the records in batches, 
+    # thereby greatly reducing memory consumption.
+    #
+    def self.find_each(limit: nil, batch_size: 1000)
+      dynamo_items.select(limit: limit, batch_size: 1000) do |item_data|
+        yield new._setup_from_dynamo(item_data)
+      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.
+    # #
+    # # You can control the starting point for the batch processing by supplying the :start option. 
+    # # This is especially useful if you want multiple workers dealing with the same processing queue. You can make worker 1 handle all the records between id 0 and 10,000 and worker 2 handle from 10,000 and beyond (by setting the :start option on that worker).
+    # #
+    # # It’s not possible to set the order.
+    # #
+    # def self.find_in_batches(start: nil, batch_size: 1000)
+    #   []
+    # end
   end
 end

data/lib/ocean-dynamo/version.rb

@@ -1,3 +1,3 @@
 module OceanDynamo
-  VERSION = "0.3.9"
+  VERSION = "0.3.10"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
 platform: ruby
 authors:
 - Peter Bengtson
@@ -144,15 +144,15 @@ description: "== OceanDynamo\n\nOceanDynamo is a massively scalable Amazon Dynam
   and support methods. Ocean-dynamo follows this pattern closely and\nis of course
   based on ActiveModel.\n\nThe attribute and persistence layer of OceanDynamo is modeled
   on that of ActiveRecord:\nthere's +save+, +save!+, +create+, +update+, +update!+,
-  +update_attributes+ and all the other\nmethods you're used to. The design goal is
-  always to implement as much as possible of the\nActiveRecord interface, without
-  sacrificing scalability. This makes the task of switching from\nSQL to no-SQL much
-  easier.\n\nOceanDynamo will use secondary indices to retrieve related table items,
-  \nwhich means OceanDynamo tables will scale without limits.\n\nThanks to its structural
-  similarity to ActiveRecord, OceanDynamo works with FactoryGirl.\nTo facilitate testing,
-  future versions will keep track of and delete instances after tests.\n\nSee also
-  Ocean, a Rails framework for creating highly scalable SOAs in the cloud, in which\nocean-dynamo
-  is used as a central component: http://wiki.oceanframework.net"
+  +update_attributes+, +find_each+,\nand all the other methods you're used to. The
+  design goal is always to implement as much \nas possible of the ActiveRecord interface,
+  without sacrificing scalability. This makes the \ntask of switching from SQL to
+  no-SQL much easier.\n\nThanks to its structural similarity to ActiveRecord, OceanDynamo
+  works with FactoryGirl.\nTo facilitate testing, future versions will keep track
+  of and delete instances after tests.\n\nOceanDynamo uses primary and secondary indices
+  to retrieve related table items, \nwhich means it will scale without limits.\n\nSee
+  also Ocean, a Rails framework for creating highly scalable SOAs in the cloud, in
+  which\nocean-dynamo is used as a central component: http://wiki.oceanframework.net"
 email:
 - peter@peterbengtson.com
 executables: []