postgresql_cursor 0.3.1 → 0.4.0

data/README.rdoc

@@ -1,76 +1,75 @@
-= PostgreSQLCursor
+= PostgreSQLCursor for handling large Result Sets
 
-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 10_000 rows), buffers them, and returns the
-rows one at a time.
+PostgreSQLCursor extends ActiveRecord to allow for efficient processing of queries
+returning a large number of rows.
 
-For web pages, an application would not want to process a large amount of data, usually employing a 
-Pagination scheme to present it to the users. Background processes sometimes need to generate a large 
-amount of data, and the ActiveRecord approach to load all data into memory is not the best fit here.
+== Why use this?
 
-Previous solutions employ pagination to fetch each block, then re-running the query for the next "page". 
-This gem avoids re-executing the query by using PostgreSQL's cursor feature.
+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
 
-The ActiveRecord methods for the cursor return instances of the model class by default, however you 
-can pass in a block to override this strategy. For instance, returning Hashes instead of AR instances
-is faster. Julian's benchmarks showed returning instances was a factor of 4 slower than returning a hash.
+  Model.find(:all, :conditions=>["id>0"]
 
-ActiveRecord v3 has initial support in this release. It is deprecating using the conditions in the find()
-method in favor of Arel scopes and usage. I added a method to Arel for iterate over the results in a buffered
-way. 
-  Model.scope_methods.each_row { |hash| puts hash.inspect }
+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. 
 
-NOTE: This gem is intended to replace the 'postgresql-cursor' (with hyphen, not underscore) library. 
+Asyncronous, 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.
 
-==Installation
- [sudo] gem install postgresql_cursor
+== Enter find_each
 
-This does not require Rails to work, just ActiveRecord < 3.0.0 and the 'pg' gem. Rails 3 support is forthcoming.
+To solve this problem, ActiveRecord gives us two alternative methods that work in "chunks" of your data:
 
-You can then configure your Rails application by adding to the config/environment.rb file
-  config.gem 'postgresql_cursor'
-or require the gem on your non-rails application
-  require 'rubygems'
-  require 'postgresql_cursor'
+  Model.where("id>0").find_each { |model| model.process! }
 
-==Usage
+  Model.where("id>0").find_in_batches do |batch|
+    batch.each { |model| model.process! }
+  end
 
-This library is intended to be used via ActiveRecord. It provides two methods on ActiveRecord::Base
-like the find() method, that will return cursor objects instead of an array of model instances. 
+Optionally, you can specify a :batch_size option as the size of the "chunk", and defaults to 1000.
 
-Calling each() the returned cursor will yield a record to the block for each row. It handles a transaction
-block, open, buffering, and closing the cursor. In this way, it operates like an Array object. Note that
-it does not implement Enumerable, so no other methods are available.
+There are drawbacks with these methods:
 
-* *find_with_cursor*( <i>find options</i>, :cursor=>{<i>cursor options</i>}, &block) returns a cursor for the data matching the find options. It takes an optional block accepting a column=>value hash which returns the object desired via each or next, instead of an instance of the model.
+* You cannot specify the order, it will be ordered by the primary key (usually id)
+* The primary key must be numeric
+* The query is rerun for each chunk (1000 rows), starting at the next id sequence.
+* You cannot use overly complex queries as that will be rerun and incur more overhead.
 
-* *find_by_sql_with_cursor*(<i>select statement</i>, <i>cursor options</i>, &block) takes a custom SQL statement and returns each row as above.
+== PostgreSQLCursor FTW!
 
-==Examples
+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
+retaining the position of the full result set in the database. This overcomes all the disadvantages
+of using find_each and find_in_batches.
 
- # Active Record v3 with Arel scopes. This is the new, preferred method of use
- Account.active.each_row { |hash| puts hash.inspect }
+Also, with PostgreSQL, you have on option to have raw hashes of the row returned instead of the 
+instantiated models. An informal benchmark showed that returning instances is a factor of 4 times
+slower than returning hashes. If you are can work with the data in this form, you will find better
+performance.
 
- Account.find_with_cursor(:conditions=>["status = ?", 'good']).each do |row|
-   puts row.to_json
- end
- 
- Account.find_by_sql_with_cursor("select ...", :buffer_size=>1000).each do |row|
-   row.process
- end
-
- Account.transaction do 
-   cursor = Account.find_with_cursor(...) { |record| record.symbolize_keys }
-   while record = cursor.next do
-     record.process # => {:column=>value, ...}
-     cursor.close if cursor.count > 1000 # Halts loop after 1000 records
-   end
- end
-
- Account.find_with_cursor(...) { |record| record.symbolize_keys }.each do |row|
-   row.process
- end
+With PostgreSQL, you can work with cursors as follows:
+
+  Model.where("id>0").each_row { |hash| Model.process(hash) }
+
+  Model.where("id>0").each_instance { |model| model.process! }
+  Model.where("id>0").each_instance(buffer_size:100000) { |model| model.process! }
+
+  Model.each_row_by_sql("select * from models") { |hash| Model.process(hash) }
+
+  Model.each_instance_by_sql("select * from models") { |model| model.process }
+
+All these methods take an options hash to control things more:
+
+  buffer_size:n     The number of rows to fetch from the database each time (default 1000)
+  while:value       Continue looping as long as the block returns this value
+  until:value       Continue looping until the block returns this value
+  connection:conn   Use this connection instead of the current model connection
+  fraction:float    A value to set for the cursor_tuple_fraction variable.
+                    PostgreSQL uses 0.1 (optimize for 10% of result set)
+                    This library uses 1.0 (Optimize for 100% of the result set)
+                    Do not override this value unless you understand it.
 
 ==Authors
 Allen Fair, allen.fair@gmail.com, http://github.com/afair

data/Rakefile

@@ -43,7 +43,7 @@ task :test => :check_dependencies
 
 task :default => :test
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/lib/postgresql_cursor.rb

@@ -1,135 +1,176 @@
-require 'active_record'
-
-# Class to operate a PostgreSQL cursor to buffer a set of rows, and return single rows for processing.
-# Use this class when processing a very large number of records, which would otherwise all be instantiated
-# in memory by find(). This also adds helpers to ActiveRecord::Base for *find_with_cursor()* and 
-# *find_by_sql_with_cursor()* to return instances of the cursor ready to fetch. 
+# PostgreSQLCursor: library class provides postgresql cursor for large result
+# set processing. Requires ActiveRecord, but can be adapted to other DBI/ORM libraries.
+# If you don't use AR, this assumes #connection and #instantiate methods are available.
+#
+# options     - Hash to control operation and loop breaks
+#   connection: instance  - ActiveRecord connection to use
+#   fraction: 0.1..1.0    - The cursor_tuple_fraction (default 1.0)
+#   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.
 #
-# Use each() with a block to accept an instance of the Model (or whatever you define with a block on 
-# initialize()). It will open, buffer, yield each row, then close the cursor.
+# Exmaples: 
+#   PostgreSQLCursor.new("select ...").each { |hash| ... }
+#   ActiveRecordModel.where(...).each_row { |hash| ... }
+#   ActiveRecordModel.each_row_by_sql("select ...") { |hash| ... }
+#   ActiveRecordModel.each_instance_by_sql("select ...") { |model| ... }
 #
-# PostgreSQL requires that a cursor is executed within a transaction block, which you must provide unless
-# you use each() to run through the result set.
 class PostgreSQLCursor
-  attr_reader :count, :buffer_reads
-  @@counter=0
-  
-  # Define a new cursor, with a SQL statement, as a string with parameters already replaced, and options for 
-  # the cursor
-  # * :buffer_size=>number of records to buffer, default 10000.
-  # Pass a optional block which takes a Hash of "column"=>"value", and returns an object to be yielded for each row.
-  def initialize(sql,*args, &block)
-    @options = args.last.is_a?(Hash) ? args.pop : {}
-    @@counter += 1
-    @instantiator = block || lambda {|r| r }
-    @sql = sql
-    @name = "pgcursor_#{@@counter}"
-    @connection = ActiveRecord::Base.connection
-    @buffer_size = @options[:buffer_size] || 10_000 
-    @count = 0
-    @state = :ready
+  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
+  # options - hash of processing controls
+  #   while: value    - Exits loop when block does not return this value.
+  #   until: value    - Exits loop when block returns this value.
+  #   fraction: 0.1..1.0    - The cursor_tuple_fraction (default 1.0)
+  #   block_size: 1..n      - The number of rows to fetch per db block fetch
+  #                           Defaults to 1000
+  #
+  # Examples
+  #
+  #   PostgreSQLCursor.new("select ....")
+  #
+  # Returns the cursor object when called with new.
+  def initialize(sql, options={})
+    @sql        = sql
+    @options    = options
+    @connection = @options.fetch(:connection) { ActiveRecord::Base.connection }
+    @count      = 0
   end
-  
-  # Iterates through the rows, yields them to the block. It wraps the processing in a transaction 
-  # (required by PostgreSQL), opens the cursor, buffers the results, returns each row, and closes the cursor.
-  def each
+
+  # 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.
+  #   {colname: value, ....}
+  #
+  # Returns the count of rows processed
+  def each(&block)
+    has_do_until = @options.has_key?(:until)
+    has_do_while = @options.has_key?(:while)
+    @count      = 0
     @connection.transaction do
-      @result = open 
-      while (row = fetch ) do
-        yield row
+      begin
+        open
+        while (row = fetch) do
+          break if row.size==0
+          @count += 1
+          row = row.symbolize_keys
+          rc = yield row
+          # TODO: Handle exceptions raised within block
+          break if has_do_until && rc == @options[:until]
+          break if has_do_while && rc != @options[:while]
+        end
+      rescue e
+        close
+        raise e
       end
-      close 
-      @count
     end
+    @count
   end
-  
-  # Starts buffered result set processing for a given SQL statement. The DB
+
+  # Public: Opens (actually, "declares") the cursor. Call this before fetching
   def open
-    raise "Open Cursor state not ready" unless @state == :ready
-    @result = @connection.execute("declare #{@name} cursor for #{@sql}")
-    @state = :empty
-    @buffer_reads = 0
-    @buffer = nil
+    set_cursor_tuple_fraction
+    @cursor = @@cursor_seq += 1
+    @result = @connection.execute("declare cursor_#{@cursor} cursor for #{@sql}")
+    @block = []
   end
 
-  # Returns a string of the current status
-  def status #:nodoc:
-    "row=#{@count} buffer=#{@buffer.size} state=#{@state} buffer_size=#{@buffer_size} reads=#{@buffer_reads}"
+  # 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
+    fetch_block if @block.size==0
+    @block.shift
   end
 
-  # Fetches the next block of rows into memory
-  def fetch_buffer #:nodoc:
-    return unless @state == :empty
-    @result = @connection.execute("fetch #{@buffer_size} from #{@name}")
-    @buffer = @result.collect {|row| row }
-    @state  = @buffer.size > 0 ? :buffered : :eof
-    @buffer_reads += 1
-    @buffer
+  # 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
   end
 
-  # Returns the next row from the cursor, or nil when end of data.
-  # The row returned is a hash[:colname]
-  def fetch
-    open         if @state == :ready
-    fetch_buffer if @state == :empty
-    return nil   if @state == :eof || @state == :closed
-    @state = :empty if @buffer.size <= 1
-    @count+= 1
-    row = @buffer.shift
-    @instantiator.call(row)
+  # Public: Closes the cursor
+  def close
+    @connection.execute("close cursor_#{@cursor}")
   end
-  
-  alias_method :next, :fetch 
-  
-  # Closes the cursor to clean up resources. Call this method during process of each() to 
-  # exit the loop
-  def close 
-    pg_result = @connection.execute("close #{@name}")
-    @state = :closed
+
+  # 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 }
+    return @cursor_tuple_fraction if frac == @cursor_tuple_fraction
+    @cursor_tuple_fraction = frac
+    @result = @connection.execute("set cursor_tuple_fraction to  #{frac}")
+    frac
   end
-  
+ 
 end
 
+# Defines extension to ActiveRecord to use this library
 class ActiveRecord::Base
-  class <<self
   
-    # Returns a PostgreSQLCursor instance to access the results, on which you are able to call
-    # each (though the cursor is not Enumerable and no other methods are available).
-    # No :all argument is needed, and other find() options can be specified.
-    # Specify the :cursor=>{...} option to override options for the cursor such has :buffer_size=>n.
-    # Pass an optional block that takes a Hash of the record and returns what you want to return.
-    # For example, return the Hash back to process a Hash instead of a table instance for better speed.
-    def find_with_cursor(*args, &block)
-      find_options = args.last.is_a?(Hash) ? args.pop : {}
-      options = find_options.delete(:cursor) || {}
-      #validate_find_options(find_options)
-      #set_readonly_option!(find_options)
-      #sql = construct_finder_sql(find_options)
-      
-      sql = ActiveRecord::SpawnMethods.apply_finder_options(args.first).to_sql
-      puts sql
-
-      PostgreSQLCursor.new(sql, options) { |r| block_given? ? yield(r) : instantiate(r) }
-    end
+  # Public: Returns each row as a hash to the given block
+  #
+  # sql         - Full SQL statement, variables interpolated
+  # options     - Hash to control 
+  #   fraction: 0.1..1.0    - The cursor_tuple_fraction (default 1.0)
+  #   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.
+  #
+  # Returns the number of rows yielded to the block
+  def self.each_row_by_sql(sql, options={}, &block)
+    PostgreSQLCursor.new(sql, options).each(&block)
+  end
 
-    # Returns a PostgreSQLCursor instance to access the results of the sql
-    # Specify the :cursor=>{...} option to override options for the cursor such has :buffer_size=>n.
-    # Pass an optional block that takes a Hash of the record and returns what you want to return.
-    # For example, return the Hash back to process a Hash instead of a table instance for better speed.
-    def find_by_sql_with_cursor(sql, options={})
-      PostgreSQLCursor.new(sql, options) { |r| block_given? ? yield(r) : instantiate(r) }
+  # Public: Returns each row as a model instance to the given block
+  # As this instantiates a model object, it is slower than each_row_by_sql 
+  #
+  # Paramaters: see each_row_by_sql
+  #
+  # Returns the number of rows yielded to the block
+  def self.each_instance_by_sql(sql, options={}, &block)
+    PostgreSQLCursor.new(sql, options).each do |row|
+      model = instantiate(row)
+      yield model
     end
-
   end
 end
 
-#Rails 3: add method to use PostgreSQL cursors
+# Defines extension to ActiveRecord/AREL to use this library
 class ActiveRecord::Relation
-  @@relation_each_row_seq = 0 
-
+  
+  # Public: Executes the query, returning each row as a hash
+  # to the given block.
+  #
+  # options     - Hash to control 
+  #   fraction: 0.1..1.0    - The cursor_tuple_fraction (default 1.0)
+  #   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.
+  #
+  # Returns the number of rows yielded to the block
   def each_row(options={}, &block)
-    @@relation_each_row_seq += 1
-    PostgreSQLCursor.new( to_sql, options).each { |r| block_given? ? yield(r) : instantiate(r) }
-  end 
+    PostgreSQLCursor.new(to_sql).each(&block)
+  end
 
+  # Public: Like each_row, but returns an instantiated model object to the block
+  #
+  # Paramaters: same as each_row 
+  #
+  # Returns the number of rows yielded to the block
+  def each_instance(options={}, &block)
+    PostgreSQLCursor.new(to_sql, options).each do |row|
+      model = instantiate(row)
+      yield model
+    end
+  end
 end

data/postgresql_cursor.gemspec

@@ -1,45 +1,38 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{postgresql_cursor}
-  s.version = "0.3.1"
+  s.name = "postgresql_cursor"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Allen Fair"]
-  s.date = %q{2010-08-06}
-  s.description = %q{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 10_000 rows), buffers them, and returns the rows one at a time.}
-  s.email = %q{allen.fair@gmail.com}
+  s.date = "2012-07-21"
+  s.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 10_000 rows), buffers them, and returns the rows one at a time."
+  s.email = "allen.fair@gmail.com"
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+    "README.rdoc"
   ]
   s.files = [
     ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/postgresql_cursor.rb",
-     "postgresql_cursor.gemspec",
-     "test/helper.rb",
-     "test/test_postgresql_cursor.rb"
-  ]
-  s.homepage = %q{http://github.com/afair/postgresql_cursor}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{ActiveRecord PostgreSQL Adapter extension for using a cursor to return a large result set}
-  s.test_files = [
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/postgresql_cursor.rb",
+    "postgresql_cursor.gemspec",
     "test/helper.rb",
-     "test/test_postgresql_cursor.rb"
+    "test/test_postgresql_cursor.rb"
   ]
+  s.homepage = "http://github.com/afair/postgresql_cursor"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.16"
+  s.summary = "ActiveRecord PostgreSQL Adapter extension for using a cursor to return a large result set"
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/test/helper.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'test/unit'
+require 'active_record'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -7,7 +8,8 @@ require 'postgresql_cursor'
 
 ActiveRecord::Base.establish_connection :database=>'allen_test', :adapter=>'postgresql', :username=>'allen'
 class Model < ActiveRecord::Base
-  set_table_name "records"
+  #set_table_name "records"
+  self.table_name = "records"
 
   # create table records (id serial primary key);
   def self.generate(max=1_000_000)

data/test/test_postgresql_cursor.rb

@@ -1,44 +1,45 @@
 require 'helper'
 
 class TestPostgresqlCursor < Test::Unit::TestCase
-  
-  def test_cursor
-    c = Model.find_with_cursor(:conditions=>["id>?",0], :cursor=>{:buffer_size=>10})
-    mycount=0
-    count = c.each { |r| mycount += 1 } 
-    assert_equal mycount, count
-  end
 
-  def test_empty_set
-    c = Model.find_with_cursor(:conditions=>["id<?",0])
-    count = c.each { |r| puts r.class }
-    assert_equal count, 0
+  def test_each
+    c = PostgreSQLCursor.new("select * from records order by 1")
+    nn = 0
+    n = c.each { nn += 1}
+    assert_equal nn, n
   end
 
-  def test_block
-    Model.transaction do
-      c = Model.find_with_cursor(:conditions=>["id<?",10]) { |r| r }
-      r = c.next
-      assert_equal r.class, Hash
-    end
+  def test_enumerables
+    assert_equal true, PostgreSQLCursor.new("select * from records order by 1").any?
+    assert_equal false, PostgreSQLCursor.new("select * from records where id<0").any?
   end
 
-  def test_sql
-    c = Model.find_by_sql_with_cursor("select * from #{Model.table_name}")
-    mycount=0
-    count = c.each { |r| mycount += 1 } 
-    assert_equal mycount, count
+  def test_each_while_until
+    c = PostgreSQLCursor.new("select * from records order by 1", until:true)
+    n = c.each { |r| r[:id].to_i > 100 }
+    assert_equal 101, n
+
+    c = PostgreSQLCursor.new("select * from records order by 1", while:true)
+    n = c.each { |r| r[:id].to_i < 100 }
+    assert_equal 100, n
   end
 
-  def test_loop
-   Model.transaction do 
-     cursor = Model.find_with_cursor() { |record| record.symbolize_keys }
-     while record = cursor.next do
-       assert record[:id].class, Fixnum
-       cursor.close if cursor.count >= 10 
-     end
-     assert_equal cursor.count, 10
-   end
+  def test_relation
+    nn = 0
+    Model.where("id>0").each_row {|r| nn += 1 }
+    assert_equal 1000, nn
   end
 
+  def test_activerecord
+    nn = 0
+    Model.each_row_by_sql("select * from records") {|r| nn += 1 }
+    assert_equal 1000, nn
+
+    nn = 0
+    row = nil
+    Model.each_instance_by_sql("select * from records") {|r| row = r; nn += 1 }
+    assert_equal 1000, nn
+    assert_equal Model, row.class
+  end
+  
 end

metadata

@@ -1,63 +1,50 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: postgresql_cursor
-version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 1
-  version: 0.3.1
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Allen Fair
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-08-06 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2164034600 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: pg
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2164034600
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &2164034040 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
-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 10_000 rows), buffers them, and returns the rows one at a time.
+  prerelease: false
+  version_requirements: *2164034040
+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 10_000 rows), buffers them, and returns the rows one at a time.
 email: allen.fair@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README.rdoc
-files: 
+files:
 - .document
-- .gitignore
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -66,40 +53,29 @@ files:
 - postgresql_cursor.gemspec
 - test/helper.rb
 - test/test_postgresql_cursor.rb
-has_rdoc: true
 homepage: http://github.com/afair/postgresql_cursor
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
-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
+summary: ActiveRecord PostgreSQL Adapter extension for using a cursor to return a
+  large result set
+test_files: []

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC