postgresql_cursor 0.6.0 → 0.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8bd16d1710bfc6796d8410b99d01b17c085118df
-  data.tar.gz: 4ad5f707f0c96ddbf85fb57ed2935d7c6e2e1da6
+SHA256:
+  metadata.gz: 8aed2634af7f5f9be7ea31ff6a9b0757eadead1df98b48326e02716453b1a2ff
+  data.tar.gz: a6187a116e1f4e3151d39d834c9b00f665594fd94e80182eccbceb23fbce73e5
 SHA512:
-  metadata.gz: 69547256fbc79ab776b41a05729ead0eb05bc0c6cc94fb2da60a19922376e4ddbd3fa686f76f3ed0bd2e98e35e16a072828fdae0f29f687fc4e14ff0364bd8be
-  data.tar.gz: 90e5cda34d77577766143c53b26300696791298ac2c9f20ba09d204e9be443ccafa3c0bbbf70619679e829abaf2734ef271f59991352739dfcab54c63e6050f1
+  metadata.gz: 04fd5c71657bb4702af5d73efb7ae55c0f3e0e59b625d4331c0c202766faca9f2f3effcfc56bbb26e5aafc9cace30b719c2db7232413d600a3970b39d46393da
+  data.tar.gz: a3dff976f877302d6f0ffa8bfee195eb509c36c18ec3e8c4c81c07ec6bc57b0434d9fd9b63528b39da43ade976c61b47888d3a3451df9c1eedf24f8561e35aa0

data/.gitignore

@@ -15,6 +15,7 @@ tmtags
 
 ## IntelliJ/Rubymine
 .idea
+*.iml
 
 ## PROJECT::GENERAL
 coverage
@@ -22,4 +23,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
-Gemfile.lock
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,27 @@
+language: ruby
+rvm:
+  - 2.6.5
+  - 2.7.1
+before_install:
+  - sudo apt-get update
+  - sudo apt-get --yes remove postgresql\*
+  - sudo apt-get install -y postgresql-12 postgresql-client-12
+  - sudo cp /etc/postgresql/{9.6,12}/main/pg_hba.conf
+  - sudo service postgresql restart 12
+gemfile:
+  - gemfiles/activerecord_4.gemfile
+  - gemfiles/activerecord_5.gemfile
+  - gemfiles/activerecord_6.gemfile
+matrix:
+  exclude:
+    - rvm: 2.7.1
+      gemfile: gemfiles/activerecord_4.gemfile
+services:
+  - postgresql
+before_script:
+  - psql -c 'create database postgresql_cursor_test;' -U postgres
+  - psql -c 'CREATE ROLE travis SUPERUSER LOGIN CREATEDB;' -U postgres
+  - psql -c 'create table products ( id serial primary key, data varchar);' -U postgres -d postgresql_cursor_test
+  - psql -c 'create table prices ( id serial primary key, data varchar, product_id integer);' -U postgres -d postgresql_cursor_test
+addons:
+  postgresql: '12.3'

data/Appraisals

@@ -0,0 +1,12 @@
+appraise "activerecord-4" do
+  gem "activerecord", "4.2.11.1"
+  gem "pg", "~> 0.15"
+end
+
+appraise "activerecord-5" do
+  gem "activerecord", "5.2.3"
+end
+
+appraise "activerecord-6" do
+  gem "activerecord", "6.0.0"
+end

data/README.md

@@ -1,4 +1,4 @@
-#PostgreSQLCursor for handling large Result Sets
+# PostgreSQLCursor for handling large Result Sets
 
 [![Gem Version](https://badge.fury.io/rb/postgresql_cursor.svg)](http://badge.fury.io/rb/postgresql_cursor)
 
@@ -13,16 +13,12 @@ set is exhausted. By fetching a smaller chunk of data, this reduces the
 amount of memory your application uses and prevents the potential crash
 of running out of memory.
 
-This extension is not intended to support the "FOR UPDATE / WHERE
-CURRENT OF" syntax to process and update each row in place. The primary
-goal is to read a large number of rows using buffering.
-
 Supports Rails/ActiveRecord v3.1 (v3.2 recommended) higher (including
 v5.0) and Ruby 1.9 and higher. Not all features work in ActiveRecord v3.1.
 Support for this gem will only be for officially supported versions of
 ActiveRecord and Ruby; others can try older versions of the gem.
 
-##Using Cursors
+## Using Cursors
 
 PostgreSQLCursor was developed to take advantage of PostgreSQL's cursors. Cursors allow the program
 to declare a cursor to run a given query returning "chunks" of rows to the application program while
@@ -71,6 +67,7 @@ All these methods take an options hash to control things more:
                       This library uses 1.0 (Optimize for 100% of the result set)
                       Do not override this value unless you understand it.
     with_hold:boolean Keep the cursor "open" even after a commit.
+    cursor_name:string Give your cursor a name.
 
 Notes:
 
@@ -79,7 +76,7 @@ Notes:
 * Aliases each_hash and each_hash_by_sql are provided for each_row and each_row_by_sql
   if you prefer to express what types are being returned.
 
-###PostgreSQLCursor is an Enumerable
+### PostgreSQLCursor is an Enumerable
 
 If you do not pass in a block, the cursor is returned, which mixes in the Enumerable
 libary. With that, you can pass it around, or chain in the awesome enumerable things
@@ -91,7 +88,7 @@ Product.each_row.map {|r| r["id"].to_i } #=> [1, 2, 3, ...]
 Product.each_instance.map {|r| r.id }.each {|id| p id } #=> [1, 2, 3, ...]
 Product.each_instance.lazy.inject(0) {|sum,r| sum +  r.quantity } #=> 499500
 ```
-###Hashes vs. Instances
+### Hashes vs. Instances
 
 The each_row method returns the Hash of strings for speed (as this allows you to process a lot of rows).
 Hashes are returned with String values, and you must take care of any type conversion.
@@ -103,7 +100,7 @@ If you find you need the types cast for your attributes, consider using each_ins
 insead. ActiveRecord's read casting algorithm will only cast the values you need and
 has become more efficient over time.
 
-###Select and Pluck
+### Select and Pluck
 
 To limit the columns returned to just those you need, use `.select(:id, :name)`
 query method.
@@ -128,7 +125,7 @@ Product.pluck_rows(:id) #=> ["1", "2", ...]
 Product.pluck_instances(:id, :quantity) #=> [[1, 503], [2, 932], ...]
 ```
 
-###Associations and Eager Loading
+### Associations and Eager Loading
 
 ActiveRecord performs some magic when eager-loading associated row. It
 will usually not join the tables, and prefers to load the data in
@@ -138,24 +135,50 @@ This library hooks onto the `to_sql` feature of the query builder. As a
 result, it can't do the join if ActiveRecord decided not to join, nor
 can it construct the association objects eagerly.
 
-##Background: Why PostgreSQL Cursors?
+## Locking and Updating Each Row (FOR UPDATE Queries)
+
+When you use the AREL `lock` method, a "FOR UPDATE" clause is added to
+the query. This causes the block of rows returned from each FETCH
+operation (see the `block_size` option) to be locked for you to update.
+The lock is released on those rows once the block is exhausted and the
+next FETCH or CLOSE statement is executed.
+
+This example will run through a large table and potentially update each
+row, locking only a set of rows at a time to allow concurrent use.
+
+```ruby
+Product.lock.each_instance(block_size:100) do |p|
+  p.update(price: p.price * 1.05)
+end
+```
+
+Also, pay attention to the `block_size` you request. Locking large
+blocks of rows for an extended time can cause deadlocks or other
+performance issues in your application. On a busy table, or if the
+processing of each row consumes a lot of time or resources, try a
+`block_size` <= 10.
+
+See the [PostgreSQL Select Documentation](https://www.postgresql.org/docs/current/static/sql-select.html)
+for more information and limitations when using "FOR UPDATE" locking.
+
+## Background: Why PostgreSQL Cursors?
 
 ActiveRecord is designed and optimized for web performance. In a web transaction, only a "page" of
 around 20 rows is returned to the user. When you do this
 
 ```ruby
-Product.find_each { |product| product.process }
+Product.where("id>0").each { |product| product.process }
 ```
 
 The database returns all matching result set rows to ActiveRecord, which instantiates each row with
 the data returned. This function returns an array of all these rows to the caller.
 
-Asyncronous, Background, or Offline processing may require processing a large amount of data.
+Asynchronous, Background, or Offline processing may require processing a large amount of data.
 When there is a very large number of rows, this requires a lot more memory to hold the data. Ruby
 does not return that memory after processing the array, and the causes your process to "bloat". If you
 don't have enough memory, it will cause an exception.
 
-###ActiveRecord.find_each and find_in_batches
+### ActiveRecord.find_each and find_in_batches
 
 To solve this problem, ActiveRecord gives us two alternative methods that work in "chunks" of your data:
 
@@ -179,7 +202,7 @@ There are drawbacks with these methods:
 ### How it works
 
 Under the covers, the library calls the PostgreSQL cursor operations
-with the psuedo-code:
+with the pseudo-code:
 
     SET cursor_tuple_fraction TO 1.0;
     DECLARE cursor_1 CURSOR WITH HOLD FOR select * from widgets;
@@ -189,17 +212,11 @@ with the psuedo-code:
     until rows.size < 100;
     CLOSE cursor_1;
 
-##Meta
-###Author
-Allen Fair, [@allenfair](https://twitter.com/allenfair), http://github.com/afair
-
-Thanks to:
-
-* Iulian Dogariu, http://github.com/iulianu (Fixes)
-* Julian Mehnle, julian@mehnle.net (Suggestions)
-* ...And all the other contributers!
+## Meta
+### Author
+Allen Fair, [@allenfair](https://twitter.com/allenfair), [github://afair](https://github.com/afair)
 
-###Note on Patches/Pull Requests
+### Note on Patches/Pull Requests
 
 * Fork the project.
 * Make your feature addition or bug fix.
@@ -209,11 +226,11 @@ Thanks to:
   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
-###Code of Conduct
+### Code of Conduct
 
 This project adheres to the [Open Code of Conduct](http://todogroup.org/opencodeofconduct/#postgresql_cursor/2016@allenfair.com).
 By participating, you are expected to honor this code.
 
-###Copyright
+### Copyright
 
-Copyright (c) 2010-2014 Allen Fair. See (MIT) LICENSE for details.
+Copyright (c) 2010-2017 Allen Fair. See (MIT) LICENSE for details.

data/Rakefile

@@ -11,7 +11,7 @@ end
 
 desc "Open and IRB Console with the gem and test-app loaded"
 task :console do
-  sh "bundle exec irb  -Ilib -I . -r postgresql_cursor -r test-app/app"
+  sh "bundle exec irb  -Ilib -I . -r pg -r postgresql_cursor -r test-app/app"
   #require 'irb'
   #ARGV.clear
   #IRB.start
@@ -21,4 +21,5 @@ desc "Setup testing database and table"
 task :setup do
   sh %q(createdb postgresql_cursor_test)
   sh %Q<echo "create table products ( id serial primary key, data varchar);" | psql postgresql_cursor_test>
+  sh %Q<echo "create table prices ( id serial primary key, data varchar, product_id integer);" | psql postgresql_cursor_test>
 end

data/gemfiles/activerecord_4.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "4.2.11.1"
+gem "pg", "~> 0.15"
+
+gemspec path: "../"

data/gemfiles/activerecord_5.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "5.2.3"
+
+gemspec path: "../"

data/gemfiles/activerecord_6.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "6.0.0"
+
+gemspec path: "../"

data/lib/postgresql_cursor/active_record/relation/cursor_iterators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Defines extension to ActiveRecord/AREL to use this library
 module PostgreSQLCursor
   module ActiveRecord
@@ -12,6 +14,7 @@ module PostgreSQLCursor
         #   block_size: 1..n      - The number of rows to fetch per db block fetch
         #   while: value          - Exits loop when block does not return this value.
         #   until: value          - Exits loop when block returns this value.
+        #   cursor_name: string   - Allows you to name your cursor.
         #
         # Example:
         #   Post.where(user_id:123).each_row { |hash| Post.process(hash) }
@@ -42,6 +45,47 @@ module PostgreSQLCursor
           cursor.iterate_type(self)
         end
 
+        # Public: Executes the query, yielding each batch of up to block_size
+        # rows where each row is a hash to the given block.
+        #
+        # Parameters: same as each_row
+        #
+        # Example:
+        #   Post.where(user_id:123).each_row_batch do |batch|
+        #     Post.process_batch(batch)
+        #   end
+        #   Post.each_row_batch.map { |batch| Post.transform_batch(batch) }
+        #
+        # Returns the number of rows yielded to the block
+        def each_row_batch(options={}, &block)
+          options = {:connection => self.connection}.merge(options)
+          cursor  = PostgreSQLCursor::Cursor.new(to_unprepared_sql, options)
+          return cursor.each_row_batch(&block) if block_given?
+          cursor.iterate_batched
+        end
+        alias :each_hash_batch :each_row_batch
+
+        # Public: Like each_row, but yields an array of instantiated model
+        # objects to the block
+        #
+        # Parameters: same as each_row
+        #
+        # Example:
+        #   Post.where(user_id:123).each_instance_batch do |batch|
+        #     Post.process_batch(batch)
+        #   end
+        #   Post.where(user_id:123).each_instance_batch.map do |batch|
+        #     Post.transform_batch(batch)
+        #   end
+        #
+        # Returns the number of rows yielded to the block
+        def each_instance_batch(options={}, &block)
+          options = {:connection => self.connection}.merge(options)
+          cursor = PostgreSQLCursor::Cursor.new(to_unprepared_sql, options)
+          return cursor.each_instance_batch(self, &block) if block_given?
+          cursor.iterate_type(self).iterate_batched
+        end
+
         # Plucks the column names from the rows, and return them in an array
         def pluck_rows(*cols)
           options = cols.last.is_a?(Hash) ? cols.pop : {}

data/lib/postgresql_cursor/active_record/sql_cursor.rb

@@ -74,7 +74,81 @@ module PostgreSQLCursor
         cursor.iterate_type(self)
       end
 
-      # Returns and array of the given column names. Use if you need cursors and don't expect
+      # Public: Executes the query, yielding an array of up to block_size rows
+      # where each row is a hash to the given block.
+      #
+      # Parameters: same as each_row
+      #
+      # Example:
+      #   Post.each_row_batch { |batch| Post.process_batch(batch) }
+      #
+      # Returns the number of rows yielded to the block
+      def each_row_batch(options={}, &block)
+        options = {:connection => self.connection}.merge(options)
+        all.each_row_batch(options, &block)
+      end
+      alias :each_hash_batch :each_row_batch
+
+      # Public: Like each_row_batch, but yields an array of instantiated model
+      # objects to the block
+      #
+      # Parameters: same as each_row
+      #
+      # Example:
+      #   Post.each_instance_batch { |batch| Post.process_batch(batch) }
+      #
+      # Returns the number of rows yielded to the block
+      def each_instance_batch(options={}, &block)
+        options = {:connection => self.connection}.merge(options)
+        all.each_instance_batch(options, &block)
+      end
+
+      # Public: Yields each batch of up to block_size rows as an array of rows
+      # where each row as a hash to the given block
+      #
+      # Parameters: see each_row_by_sql
+      #
+      # Example:
+      #   Post.each_row_batch_by_sql("select * from posts") do |batch|
+      #     Post.process_batch(batch)
+      #   end
+      #   Post.each_row_batch_by_sql("select * from posts").map do |batch|
+      #     Post.transform_batch(batch)
+      #   end
+      #
+      # Returns the number of rows yielded to the block
+      def each_row_batch_by_sql(sql, options={}, &block)
+        options = {:connection => self.connection}.merge(options)
+        cursor  = PostgreSQLCursor::Cursor.new(sql, options)
+        return cursor.each_row_batch(&block) if block_given?
+        cursor.iterate_batched
+      end
+      alias :each_hash_batch_by_sql :each_row_batch_by_sql
+
+      # Public: Yields each batch up to block_size of rows as model instances
+      # to the given block
+      #
+      # As this instantiates a model object, it is slower than each_row_batch_by_sql
+      #
+      # Paramaters: see each_row_by_sql
+      #
+      # Example:
+      #   Post.each_instance_batch_by_sql("select * from posts") do |batch|
+      #     Post.process_batch(batch)
+      #   end
+      #   Post.each_instance_batch_by_sql("select * from posts").map do |batch|
+      #     Post.transform_batch(batch)
+      #   end
+      #
+      # Returns the number of rows yielded to the block
+      def each_instance_batch_by_sql(sql, options={}, &block)
+        options = {:connection => self.connection}.merge(options)
+        cursor  = PostgreSQLCursor::Cursor.new(sql, options)
+        return cursor.each_instance_batch(self, &block) if block_given?
+        cursor.iterate_type(self).iterate_batched
+      end
+
+      # Returns an array of the given column names. Use if you need cursors and don't expect
       # this to comsume too much memory. Values are strings. Like ActiveRecord's pluck.
       def pluck_rows(*cols)
         options = cols.last.is_a?(Hash) ? cols.pop : {}
@@ -82,7 +156,7 @@ module PostgreSQLCursor
       end
       alias :pluck_row :pluck_rows
 
-      # Returns and array of the given column names. Use if you need cursors and don't expect
+      # Returns an array of the given column names. Use if you need cursors and don't expect
       # this to comsume too much memory. Values are instance types. Like ActiveRecord's pluck.
       def pluck_instances(*cols)
         options = cols.last.is_a?(Hash) ? cols.pop : {}

data/lib/postgresql_cursor/cursor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ################################################################################
 # PostgreSQLCursor: library class provides postgresql cursor for large result
 # set processing. Requires ActiveRecord, but can be adapted to other DBI/ORM libraries.
@@ -10,6 +12,7 @@
 #   while: value          - Exits loop when block does not return this value.
 #   until: value          - Exits loop when block returns this value.
 #   with_hold: boolean    - Allows the query to remain open across commit points.
+#   cursor_name: string   - Allows you to name your cursor.
 #
 # Exmaples:
 #   PostgreSQLCursor::Cursor.new("select ...").each { |hash| ... }
@@ -17,11 +20,11 @@
 #   ActiveRecordModel.each_row_by_sql("select ...") { |hash| ... }
 #   ActiveRecordModel.each_instance_by_sql("select ...") { |model| ... }
 #
+
 module PostgreSQLCursor
   class Cursor
     include Enumerable
     attr_reader :sql, :options, :connection, :count, :result
-    @@cursor_seq = 0
 
     # Public: Start a new PostgreSQL cursor query
     # sql     - The SQL statement with interpolated values
@@ -38,25 +41,36 @@ module PostgreSQLCursor
     #   PostgreSQLCursor::Cursor.new("select ....")
     #
     # Returns the cursor object when called with new.
-    def initialize(sql, options={})
-      @sql        = sql
-      @options    = options
+    def initialize(sql, options = {})
+      @sql = sql
+      @options = options
       @connection = @options.fetch(:connection) { ::ActiveRecord::Base.connection }
-      @count      = 0
-      @iterate    = options[:instances] ? :each_instance : :each_row
+      @count = 0
+      @iterate = options[:instances] ? :each_instance : :each_row
+      @batched = false
     end
 
-    # Specify the type to instantiate, or reset to return a Hash
-    def iterate_type(type=nil)
-      if type.nil? || type == Hash
+    # Specify the type to instantiate, or reset to return a Hash.
+    #
+    # Explicitly check for type class to prevent calling equality
+    # operator on active record relation, which will load it.
+    def iterate_type(type = nil)
+      if type.nil? || (type.instance_of?(Class) && type == Hash)
         @iterate = :each_row
+      elsif type.instance_of?(Class) && type == Array
+        @iterate = :each_array
       else
         @iterate = :each_instance
-        @type    = type
+        @type = type
       end
       self
     end
 
+    def iterate_batched(batched = true)
+      @batched = batched
+      self
+    end
+
     # Public: Yields each row of the result set to the passed block
     #
     # Yields the row to the block. The row is a hash with symbolized keys.
@@ -65,24 +79,39 @@ module PostgreSQLCursor
     # Returns the count of rows processed
     def each(&block)
       if @iterate == :each_row
-        self.each_row(&block)
+        @batched ? each_row_batch(&block) : each_row(&block)
+      elsif @iterate == :each_array
+        @batched ? each_array_batch(&block) : each_array(&block)
       else
-        self.each_instance(@type, &block)
+        @batched ? each_instance_batch(@type, &block) : each_instance(@type, &block)
       end
     end
 
     def each_row(&block)
-      self.each_tuple do |row|
+      each_tuple do |row|
         row = row.symbolize_keys if @options[:symbolize_keys]
         block.call(row)
       end
     end
 
-    def each_instance(klass=nil, &block)
+    def each_array(&block)
+      old_iterate = @iterate
+      @iterate = :each_array
+      begin
+        rv = each_tuple do |row|
+          block.call(row)
+        end
+      ensure
+        @iterate = old_iterate
+      end
+      rv
+    end
+
+    def each_instance(klass = nil, &block)
       klass ||= @type
-      self.each_tuple do |row|
+      each_tuple do |row|
         if ::ActiveRecord::VERSION::MAJOR < 4
-          model = klass.send(:instantiate,row)
+          model = klass.send(:instantiate, row)
         else
           @column_types ||= column_types
           model = klass.send(:instantiate, row, @column_types)
@@ -91,6 +120,41 @@ module PostgreSQLCursor
       end
     end
 
+    def each_row_batch(&block)
+      each_batch do |batch|
+        batch.map!(&:symbolize_keys) if @options[:symbolize_keys]
+        block.call(batch)
+      end
+    end
+
+    def each_array_batch(&block)
+      old_iterate = @iterate
+      @iterate = :each_array
+      begin
+        rv = each_batch do |batch|
+          block.call(batch)
+        end
+      ensure
+        @iterate = old_iterate
+      end
+      rv
+    end
+
+    def each_instance_batch(klass = nil, &block)
+      klass ||= @type
+      each_batch do |batch|
+        models = batch.map do |row|
+          if ::ActiveRecord::VERSION::MAJOR < 4
+            klass.send(:instantiate, row)
+          else
+            @column_types ||= column_types
+            klass.send(:instantiate, row, @column_types)
+          end
+        end
+        block.call(models)
+      end
+    end
+
     # Returns an array of columns plucked from the result rows.
     # Experimental function, as this could still use too much memory
     # and negate the purpose of this libarary.
@@ -99,11 +163,11 @@ module PostgreSQLCursor
       options = cols.last.is_a?(Hash) ? cols.pop : {}
       @options.merge!(options)
       @options[:symbolize_keys] = true
-      self.iterate_type(options[:class]) if options[:class]
-      cols    = cols.map {|c| c.to_sym }
-      result  = []
+      iterate_type(options[:class]) if options[:class]
+      cols = cols.map { |c| c.to_sym }
+      result = []
 
-      self.each() do |row|
+      each do |row|
         row = row.symbolize_keys if row.is_a?(Hash)
         result << cols.map { |c| row[c] }
       end
@@ -112,26 +176,44 @@ module PostgreSQLCursor
       result
     end
 
-    def each_tuple(&block) #:nodoc:
-      has_do_until  = @options.has_key?(:until)
-      has_do_while  = @options.has_key?(:while)
-      @count        = 0
+    def each_tuple(&block) # :nodoc:
+      has_do_until = @options.has_key?(:until)
+      has_do_while = @options.has_key?(:while)
+      @count = 0
       @column_types = nil
-      @connection.transaction do
-        begin
-          open
-          while (row = fetch) do
-            break if row.size==0
-            @count += 1
-            rc = block.call(row)
-            break if has_do_until && rc == @options[:until]
-            break if has_do_while && rc != @options[:while]
-          end
-        rescue Exception => e
-          raise e
-        ensure
-          close if @block
+      with_optional_transaction do
+        open
+        while (row = fetch)
+          break if row.size == 0
+          @count += 1
+          rc = block.call(row)
+          break if has_do_until && rc == @options[:until]
+          break if has_do_while && rc != @options[:while]
+        end
+      rescue => e
+        raise e
+      ensure
+        close if @block && connection.active?
+      end
+      @count
+    end
+
+    def each_batch(&block) # :nodoc:
+      has_do_until = @options.key?(:until)
+      has_do_while = @options.key?(:while)
+      @count = 0
+      @column_types = nil
+      with_optional_transaction do
+        open
+        while (batch = fetch_block)
+          break if batch.empty?
+          @count += 1
+          rc = block.call(batch)
+          break if has_do_until && rc == @options[:until]
+          break if has_do_while && rc != @options[:while]
         end
+      ensure
+        close if @block && connection.active?
       end
       @count
     end
@@ -148,11 +230,15 @@ module PostgreSQLCursor
       fields = @result.fields
       fields.each_with_index do |fname, i|
         ftype = @result.ftype i
-        fmod  = @result.fmod i
-        types[fname] = @connection.get_type_map.fetch(ftype, fmod) { |oid, mod|
+        fmod = @result.fmod i
+        types[fname] = @connection.get_type_map.fetch(ftype, fmod) do |oid, mod|
           warn "unknown OID: #{fname}(#{oid}) (#{sql})"
-          OID::Identity.new
-        }
+          if ::ActiveRecord::VERSION::MAJOR <= 4
+            ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::Identity.new
+          else
+            ::ActiveRecord::Type::Value.new
+          end
+        end
       end
 
       @column_types = types
@@ -161,41 +247,55 @@ module PostgreSQLCursor
     # Public: Opens (actually, "declares") the cursor. Call this before fetching
     def open
       set_cursor_tuple_fraction
-      @cursor = @@cursor_seq += 1
-      hold = @options[:with_hold] ? 'with hold ' : ''
-      @result = @connection.execute("declare cursor_#{@cursor} cursor #{hold}for #{@sql}")
+      @cursor = @options[:cursor_name] || ("cursor_" + SecureRandom.uuid.delete("-"))
+      hold = @options[:with_hold] ? "with hold " : ""
+      @result = @connection.execute("declare #{@cursor} no scroll cursor #{hold}for #{@sql}")
       @block = []
     end
 
     # Public: Returns the next row from the cursor, or empty hash if end of results
     #
     # Returns a row as a hash of {'colname'=>value,...}
-    def fetch(options={})
+    def fetch(options = {})
       open unless @block
-      fetch_block if @block.size==0
+      fetch_block if @block.size == 0
       row = @block.shift
       row = row.symbolize_keys if row && options[:symbolize_keys]
       row
     end
 
     # Private: Fetches the next block of rows into @block
-    def fetch_block(block_size=nil)
-      block_size ||= @block_size ||= @options.fetch(:block_size) { 1000 }
-      @result = @connection.execute("fetch #{block_size} from cursor_#{@cursor}")
-      @block = @result.collect {|row| row } # Make our own
+    def fetch_block(block_size = nil)
+      block_size ||= @block_size ||= @options.fetch(:block_size, 1000)
+      @result = @connection.execute("fetch #{block_size} from #{@cursor}")
+
+      @block = if @iterate == :each_array
+        @result.each_row.collect { |row| row }
+      else
+        @result.collect { |row| row }
+      end
     end
 
     # Public: Closes the cursor
     def close
-      @connection.execute("close cursor_#{@cursor}")
+      @connection.execute("close #{@cursor}")
+    end
+
+    # Private: Open transaction unless with_hold option, specified
+    def with_optional_transaction
+      if @options[:with_hold]
+        yield
+      else
+        @connection.transaction { yield }
+      end
     end
 
     # Private: Sets the PostgreSQL cursor_tuple_fraction value = 1.0 to assume all rows will be fetched
     # This is a value between 0.1 and 1.0 (PostgreSQL defaults to 0.1, this library defaults to 1.0)
     # used to determine the expected fraction (percent) of result rows returned the the caller.
     # This value determines the access path by the query planner.
-    def set_cursor_tuple_fraction(frac=1.0)
-      @cursor_tuple_fraction ||= @options.fetch(:fraction) { 1.0 }
+    def set_cursor_tuple_fraction(frac = 1.0)
+      @cursor_tuple_fraction ||= @options.fetch(:fraction, 1.0)
       return @cursor_tuple_fraction if frac == @cursor_tuple_fraction
       @cursor_tuple_fraction = frac
       @result = @connection.execute("set cursor_tuple_fraction to  #{frac}")

data/lib/postgresql_cursor/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PostgresqlCursor
-  VERSION = "0.6.0"
+  VERSION = "0.6.6"
 end

data/lib/postgresql_cursor.rb

@@ -1,12 +1,17 @@
+# frozen_string_literal: true
+
 require 'postgresql_cursor/version'
-require 'postgresql_cursor/cursor'
-require 'postgresql_cursor/active_record/relation/cursor_iterators'
-require 'postgresql_cursor/active_record/sql_cursor'
-require 'postgresql_cursor/active_record/connection_adapters/postgresql_type_map'
+require 'active_support'
+
+ActiveSupport.on_load :active_record do
+  require 'postgresql_cursor/cursor'
+  require 'postgresql_cursor/active_record/relation/cursor_iterators'
+  require 'postgresql_cursor/active_record/sql_cursor'
+  require 'postgresql_cursor/active_record/connection_adapters/postgresql_type_map'
 
-# ActiveRecord 4.x
-require 'active_record'
-require 'active_record/connection_adapters/postgresql_adapter'
-ActiveRecord::Base.extend(PostgreSQLCursor::ActiveRecord::SqlCursor)
-ActiveRecord::Relation.send(:include, PostgreSQLCursor::ActiveRecord::Relation::CursorIterators)
-ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include, PostgreSQLCursor::ActiveRecord::ConnectionAdapters::PostgreSQLTypeMap)
+  # ActiveRecord 4.x
+  require 'active_record/connection_adapters/postgresql_adapter'
+  ActiveRecord::Base.extend(PostgreSQLCursor::ActiveRecord::SqlCursor)
+  ActiveRecord::Relation.send(:include, PostgreSQLCursor::ActiveRecord::Relation::CursorIterators)
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include, PostgreSQLCursor::ActiveRecord::ConnectionAdapters::PostgreSQLTypeMap)
+end

data/postgresql_cursor.gemspec

@@ -1,32 +1,44 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'postgresql_cursor/version'
+require "postgresql_cursor/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "postgresql_cursor"
-  spec.version       = PostgresqlCursor::VERSION
-  spec.authors       = ["Allen Fair"]
-  spec.email         = ["allen.fair@gmail.com"]
-  spec.summary       = "ActiveRecord PostgreSQL Adapter extension for using a cursor to return a large result set"
-  spec.description   = "PostgreSQL Cursor is an extension to the ActiveRecord PostgreSQLAdapter for very large result sets. It provides a cursor open/fetch/close interface to access data without loading all rows into memory, and instead loads the result rows in \"chunks\" (default of 1_000 rows), buffers them, and returns the rows one at a time."
-  spec.homepage      = "http://github.com/afair/postgresql_cursor"
-  spec.license       = "MIT"
+  spec.name = "postgresql_cursor"
+  spec.version = PostgresqlCursor::VERSION
+  spec.authors = ["Allen Fair"]
+  spec.email = ["allen.fair@gmail.com"]
+  spec.summary = <<-SUMMARY
+  ActiveRecord PostgreSQL Adapter extension for using a cursor to return a
+  large result set
+  SUMMARY
+  spec.description = <<-DESCRIPTION
+  PostgreSQL Cursor is an extension to the ActiveRecord PostgreSQLAdapter for
+  very large result sets.  It provides a cursor open/fetch/close interface to
+  access data without loading all rows into memory, and instead loads the result
+  rows in 'chunks' (default of 1_000 rows), buffers them, and returns the rows
+  one at a time.
+  DESCRIPTION
+  spec.homepage = "http://github.com/afair/postgresql_cursor"
+  spec.license = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  #spec.add_dependency "pg" # Remove this for jruby, which should specify 'activerecord-jdbcpostgresql-adapter'
+  # Remove this for jruby which should use 'activerecord-jdbcpostgresql-adapter'
+  # spec.add_dependency 'pg'
+
   spec.add_dependency "activerecord", ">= 3.1.0"
-  #spec.add_dependency "activerecord", "~> 3.1.0"
-  # Tests don't run on 4.0.0 since AR/AS have an older version of minitest as a run-time dependency(!) than our tests support
-  #spec.add_dependency "activerecord", "~> 4.0.0";# spec.add_dependency "minitest", "~> 4.2.0"
-  #spec.add_dependency "activerecord", "~> 4.1.0"
-  #spec.add_dependency "activerecord", "~> 5.0.0.beta2"
+  # spec.add_dependency 'activerecord', '~> 3.1.0'
+  # spec.add_dependency 'activerecord', '~> 4.1.0'
+  # spec.add_dependency 'activerecord', '~> 5.0.0'
+  # spec.add_dependency 'activerecord', '~> 6.0.0'
 
+  spec.add_development_dependency "irb"
+  spec.add_development_dependency "minitest"
   spec.add_development_dependency "pg"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "appraisal"
 end

data/test/helper.rb

@@ -10,6 +10,8 @@ ActiveRecord::Base.establish_connection(adapter: 'postgresql',
   username: ENV['TEST_USER']     || ENV['USER'] || 'postgresql_cursor')
 
 class Product < ActiveRecord::Base
+  has_many :prices
+
   # create table records (id serial primary key);
   def self.generate(max=1_000)
     max.times do |i|
@@ -18,5 +20,9 @@ class Product < ActiveRecord::Base
   end
 end
 
+class Price < ActiveRecord::Base
+  belongs_to :product
+end
+
 Product.destroy_all
 Product.generate(1000)

data/test/test_postgresql_cursor.rb

@@ -3,16 +3,22 @@
 #     rake setup
 # or create the database manually if your environment doesn't permit
 ################################################################################
-require_relative 'helper'
-require 'minitest/autorun'
-require 'minitest/pride'
+require_relative "helper"
+require "minitest/autorun"
+require "minitest/pride"
 
 class TestPostgresqlCursor < Minitest::Test
-
   def test_each
     c = PostgreSQLCursor::Cursor.new("select * from products order by 1")
     nn = 0
-    n = c.each { nn += 1}
+    n = c.each { nn += 1 }
+    assert_equal nn, n
+  end
+
+  def test_each_batch
+    c = PostgreSQLCursor::Cursor.new("select * from products order by 1")
+    nn = 0
+    n = c.each_batch { |b| nn += 1 }
     assert_equal nn, n
   end
 
@@ -22,42 +28,137 @@ class TestPostgresqlCursor < Minitest::Test
   end
 
   def test_each_while_until
-    c = PostgreSQLCursor::Cursor.new("select * from products order by 1", until:true)
-    n = c.each { |r| r[:id].to_i > 100 }
-    assert_equal 1000, n
+    c = PostgreSQLCursor::Cursor.new("select * from products order by 1", until: true)
+    n = c.each { |r| r["id"].to_i > 100 }
+    assert_equal 101, n
 
-    c = PostgreSQLCursor::Cursor.new("select * from products order by 1", while:true)
-    n = c.each { |r| r[:id].to_i < 100 }
-    assert_equal 1000, n
+    c = PostgreSQLCursor::Cursor.new("select * from products order by 1", while: true)
+    n = c.each { |r| r["id"].to_i < 100 }
+    assert_equal 100, n
+  end
+
+  def test_each_batch_while_until
+    c = PostgreSQLCursor::Cursor.new("select * from products order by id asc", until: true, block_size: 50)
+    n = c.each_batch { |b| b.last["id"].to_i > 100 }
+    assert_equal 3, n
+
+    c = PostgreSQLCursor::Cursor.new("select * from products order by id asc", while: true, block_size: 50)
+    n = c.each_batch { |b| b.last["id"].to_i < 100 }
+    assert_equal 2, n
+  end
+
+  def test_each_array
+    c = PostgreSQLCursor::Cursor.new("select * from products where id = 1")
+    c.each_array do |ary|
+      assert_equal Array, ary.class
+      assert_equal 1, ary[0].to_i
+    end
+  end
+
+  def test_each_array_batch
+    c = PostgreSQLCursor::Cursor.new("select * from products where id = 1")
+    c.each_array_batch do |b|
+      assert_equal 1, b.size
+      ary = b.first
+      assert_equal Array, ary.class
+      assert_equal 1, ary[0].to_i
+    end
   end
 
   def test_relation
     nn = 0
-    Product.where("id>0").each_row {|r| nn += 1 }
+    Product.where("id>0").each_row { |r| nn += 1 }
     assert_equal 1000, nn
   end
 
+  def test_relation_batch
+    nn = 0
+    row = nil
+    Product.where("id>0").each_row_batch(block_size: 100) { |b|
+      row = b.last
+      nn += 1
+    }
+    assert_equal 10, nn
+    assert_equal Hash, row.class
+
+    nn = 0
+    row = nil
+    Product.where("id>0").each_instance_batch(block_size: 100) { |b|
+      row = b.last
+      nn += 1
+    }
+    assert_equal 10, nn
+    assert_equal Product, row.class
+  end
+
   def test_activerecord
     nn = 0
     row = nil
-    Product.each_row_by_sql("select * from products") {|r| row = r; nn += 1 }
+    Product.each_row_by_sql("select * from products") { |r|
+      row = r
+      nn += 1
+    }
     assert_equal 1000, nn
     assert_equal Hash, row.class
 
     nn = 0
-    Product.each_instance_by_sql("select * from products") {|r| row = r; nn += 1 }
+    Product.each_instance_by_sql("select * from products") { |r|
+      row = r
+      nn += 1
+    }
     assert_equal 1000, nn
     assert_equal Product, row.class
   end
 
+  def test_activerecord_batch
+    nn = 0
+    row = nil
+    Product.each_row_batch_by_sql("select * from products", block_size: 100) { |b|
+      row = b.last
+      nn += 1
+    }
+    assert_equal 10, nn
+    assert_equal Hash, row.class
+
+    nn = 0
+    Product.each_instance_batch_by_sql("select * from products", block_size: 100) { |b|
+      row = b.last
+      nn += 1
+    }
+    assert_equal 10, nn
+    assert_equal Product, row.class
+  end
+
   def test_exception
-    begin
-      Product.each_row_by_sql("select * from products") do |r|
-        raise "Oops"
-      end
-    rescue Exception => e
-      assert_equal e.message, 'Oops'
+    Product.each_row_by_sql("select * from products") do |r|
+      raise "Oops"
+    end
+  rescue => e
+    assert_equal e.message, "Oops"
+  end
+
+  def test_batch_exception
+    Product.each_row_batch_by_sql("select * from products") do |r|
+      raise "Oops"
+    end
+  rescue => e
+    assert_equal e.message, "Oops"
+  end
+
+  def test_exception_in_failed_transaction
+    Product.each_row_by_sql("select * from products") do |r|
+      Product.connection.execute("select kaboom")
+    end
+  rescue => e
+    assert_match(/PG::InFailedSqlTransaction/, e.message)
+  end
+
+  def test_batch_exception_in_failed_transaction
+    Product.each_row_batch_by_sql("select * from products") do |r|
+      Product.connection.execute("select kaboom")
     end
+  rescue => e
+    assert_match(/PG::InFailedSqlTransaction/, e.message)
   end
 
   def test_cursor
@@ -71,19 +172,30 @@ class TestPostgresqlCursor < Minitest::Test
     assert_equal 1000, r.size
   end
 
+  def test_batched_cursor
+    cursor = Product.all.each_row_batch(block_size: 100)
+    assert cursor.respond_to?(:each)
+    b = cursor.map { |batch| batch.map { |r| r["id"] } }
+    assert_equal 10, b.size
+    cursor = Product.each_row_batch_by_sql("select * from products", block_size: 100)
+    assert cursor.respond_to?(:each)
+    b = cursor.map { |batch| batch.map { |r| r["id"] } }
+    assert_equal 10, b.size
+  end
+
   def test_pluck
     r = Product.pluck_rows(:id)
     assert_equal 1000, r.size
     r = Product.all.pluck_instances(:id)
     assert_equal 1000, r.size
-    assert_equal Fixnum, r.first.class
+    assert_equal Integer, r.first.class
   end
 
   def test_with_hold
     items = 0
-    Product.where("id < 4") .each_instance(with_hold: true, block_size:1) do |row|
+    Product.where("id < 4").each_instance(with_hold: true, block_size: 1) do |row|
       Product.transaction do
-        row.update(data:Time.now.to_f.to_s)
+        row.update(data: Time.now.to_f.to_s)
         items += 1
       end
     end
@@ -92,22 +204,25 @@ class TestPostgresqlCursor < Minitest::Test
 
   def test_fetch_symbolize_keys
     Product.transaction do
-      #cursor = PostgreSQLCursor::Cursor.new("select * from products order by 1")
+      # cursor = PostgreSQLCursor::Cursor.new("select * from products order by 1")
       cursor = Product.all.each_row
       r = cursor.fetch
       assert r.has_key?("id")
-      r = cursor.fetch(symbolize_keys:true)
+      r = cursor.fetch(symbolize_keys: true)
       assert r.has_key?(:id)
       cursor.close
     end
   end
 
   def test_bad_sql
-    begin
-      ActiveRecord::Base.each_row_by_sql('select * from bad_table') { }
-      raise "Did Not Raise Expected Exception"
-    rescue Exception => e
-      assert_match(/bad_table/, e.message)
-    end
+    ActiveRecord::Base.each_row_by_sql("select * from bad_table") {}
+    raise "Did Not Raise Expected Exception"
+  rescue => e
+    assert_match(/bad_table/, e.message)
+  end
+
+  def test_relation_association_is_not_loaded
+    cursor = Product.first.prices.each_instance
+    refute cursor.instance_variable_get(:@type).loaded?
   end
 end

data/test-app/Gemfile

@@ -1,7 +1,7 @@
 # A sample Gemfile
 source "https://rubygems.org"
 
-gem 'activerecord', '~> 3.1.0'
+gem 'activerecord', '~> 5.2.0'
 #gem 'activerecord', '~> 3.2.0'
 #gem 'activerecord', '~> 4.0.0'
 #gem 'activerecord', '~> 4.1.0'
@@ -12,4 +12,4 @@ gem 'activerecord', '~> 3.1.0'
 #gem 'arel', github: 'rails/arel', branch: 'master'
 
 gem 'pg'
-gem 'postgresql_cursor', path:"#{ENV['HOME']}/src/postgresql_cursor"
+gem 'postgresql_cursor', path:"../"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: postgresql_cursor
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.6
 platform: ruby
 authors:
 - Allen Fair
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-22 00:00:00.000000000 Z
+date: 2022-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: irb
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,10 +94,12 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: PostgreSQL Cursor is an extension to the ActiveRecord PostgreSQLAdapter
-  for very large result sets. It provides a cursor open/fetch/close interface to access
-  data without loading all rows into memory, and instead loads the result rows in
-  "chunks" (default of 1_000 rows), buffers them, and returns the rows one at a time.
+description: |2
+    PostgreSQL Cursor is an extension to the ActiveRecord PostgreSQLAdapter for
+    very large result sets.  It provides a cursor open/fetch/close interface to
+    access data without loading all rows into memory, and instead loads the result
+    rows in 'chunks' (default of 1_000 rows), buffers them, and returns the rows
+    one at a time.
 email:
 - allen.fair@gmail.com
 executables: []
@@ -78,11 +108,15 @@ extra_rdoc_files: []
 files:
 - ".document"
 - ".gitignore"
+- ".travis.yml"
+- Appraisals
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
+- gemfiles/activerecord_4.gemfile
+- gemfiles/activerecord_5.gemfile
+- gemfiles/activerecord_6.gemfile
 - lib/postgresql_cursor.rb
 - lib/postgresql_cursor/active_record/connection_adapters/postgresql_type_map.rb
 - lib/postgresql_cursor/active_record/relation/cursor_iterators.rb
@@ -100,7 +134,7 @@ homepage: http://github.com/afair/postgresql_cursor
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -115,12 +149,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: ActiveRecord PostgreSQL Adapter extension for using a cursor to return a
   large result set
-test_files:
-- test/helper.rb
-- test/test_postgresql_cursor.rb
+test_files: []

data/Gemfile.lock

@@ -1,44 +0,0 @@
-PATH
-  remote: .
-  specs:
-    postgresql_cursor (0.6.0)
-      activerecord (>= 3.1.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activemodel (4.2.5.1)
-      activesupport (= 4.2.5.1)
-      builder (~> 3.1)
-    activerecord (4.2.5.1)
-      activemodel (= 4.2.5.1)
-      activesupport (= 4.2.5.1)
-      arel (~> 6.0)
-    activesupport (4.2.5.1)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    arel (6.0.3)
-    builder (3.2.2)
-    i18n (0.7.0)
-    json (1.8.3)
-    minitest (5.8.4)
-    pg (0.18.4)
-    rake (10.5.0)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  minitest
-  pg
-  postgresql_cursor!
-  rake
-
-BUNDLED WITH
-   1.11.2