activerecord-postgresql-cursors 1.0.0 → 3.0.0

data/.rubocop_todo.yml

@@ -0,0 +1,26 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2024-08-06 02:41:08 UTC using RuboCop version 1.65.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
+Metrics/AbcSize:
+  Exclude:
+    - 'lib/activerecord-postgresql-cursors.rb'
+
+# Offense count: 1
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/PerceivedComplexity:
+  Max: 9
+
+# Offense count: 1
+# Configuration parameters: ExpectMatchingDefinition, CheckDefinitionPathHierarchy, CheckDefinitionPathHierarchyRoots, Regex, IgnoreExecutableScripts, AllowedAcronyms.
+# CheckDefinitionPathHierarchyRoots: lib, spec, test, src
+# AllowedAcronyms: CLI, DSL, ACL, API, ASCII, CPU, CSS, DNS, EOF, GUID, HTML, HTTP, HTTPS, ID, IP, JSON, LHS, QPS, RAM, RHS, RPC, SLA, SMTP, SQL, SSH, TCP, TLS, TTL, UDP, UI, UID, UUID, URI, URL, UTF8, VM, XML, XMPP, XSRF, XSS
+Naming/FileName:
+  Exclude:
+    - 'lib/activerecord-postgresql-cursors.rb'

data/FUNDING.yml

@@ -0,0 +1,2 @@
+github:
+  - dark-panda

data/Gemfile

@@ -1,21 +1,18 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
 
-if RUBY_PLATFORM == "java"
-  gem "activerecord-jdbcpostgresql-adapter"
-else
-  gem "pg"
-end
-
-gem "rdoc", "~> 3.12"
-gem "rake", "~> 10.0"
-gem "minitest", "~> 4.7"
-gem "minitest-reporters"
-gem "guard-minitest"
-gem "simplecov"
-
-if File.exists?('Gemfile.local')
-  instance_eval File.read('Gemfile.local')
-end
+gem 'guard'
+gem 'guard-minitest'
+gem 'minitest'
+gem 'minitest-reporters'
+gem 'pg'
+gem 'rake'
+gem 'rubocop', require: false
+gem 'rubocop-minitest', require: false
+gem 'simplecov', require: false
+gem 'simplecov_json_formatter', require: false
 
+instance_eval File.read('Gemfile.local') if File.exist?('Gemfile.local')

data/Guardfile

@@ -1,17 +1,15 @@
+# frozen_string_literal: true
 
-guard 'minitest', :test_folders => 'test', :test_file_patterns => '*_tests.rb' do
-  watch(%r|^test/(.+)_tests\.rb|)
+guard 'minitest', test_folders: 'test', test_file_patterns: '*_tests.rb' do
+  watch(%r{^test/(.+)_tests\.rb})
 
-  watch(%r|^lib/(.*)([^/]+)\.rb|) do |m|
-    "test/cursor_tests.rb"
+  watch(%r{^lib/(.*)([^/]+)\.rb}) do |_m|
+    'test/cursor_tests.rb'
   end
 
-  watch(%r|^test/test_helper\.rb|) do
-    "test"
+  watch(%r{^test/test_helper\.rb}) do
+    'test'
   end
 end
 
-if File.exists?('Guardfile.local')
-  instance_eval File.read('Guardfile.local')
-end
-
+instance_eval File.read('Guardfile.local') if File.exist?('Guardfile.local')

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2016 J Smith <dark.panda@gmail.com>
+Copyright (c) 2008-2024 J Smith <dark.panda@gmail.com>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
@@ -20,4 +20,3 @@ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
-

data/{README.rdoc → README.md}

@@ -1,4 +1,4 @@
-== ActiveRecord PostgreSQL Cursors
+# ActiveRecord PostgreSQL Cursors
 
 This extension allows you to loop through record sets using cursors in an
 Enumerable fashion. This allows you to cut down memory usage by only pulling
@@ -9,21 +9,24 @@ To use a cursor, just change the first parameter to an
 ActiveRecord::Base.find to :cursor instead of :first or :all or
 whatever or use the ActiveRecord::Base.cursor method directly.
 
-	MyModel.find(:cursor, :conditions => 'some_column = true').each do |r|
-		puts r.inspect
-	end
+```ruby
+MyModel.find(:cursor, :conditions => 'some_column = true').each do |r|
+  puts r.inspect
+end
 
-	MyModel.find(:cursor).collect { |r| r.foo / PI }.avg
+MyModel.find(:cursor).collect { |r| r.foo / PI }.avg
 
-	MyModel.cursor.each do |r|
-		puts r.inspect
-	end
+MyModel.cursor.each do |r|
+  puts r.inspect
+end
+```
 
 All ActiveRecord::Base.find options are available and should work as-is.
 As a bonus, the PostgreSQLCursor object returned includes Enumerable,
 so you can iterate to your heart's content.
 
-This extension should work in both Rails 2.3 as well as Rails 3.
+This extension should work with Rails 6.1+. For older versions of Rails, try
+out older versions of the gem.
 
 At the moment, this is a non-scrollable cursor -- it will only fetch
 forward. Also note that these cursors are non-updateable/insensitive to
@@ -48,5 +51,9 @@ while the first query is just used to build the larger joined query. This
 allows for a brief window between the point that the cursor query is
 created and the time it is executed. In these cases, it may be wise to wrap
 your use or cursors in your own transaction to ensure that changes made to
-the underlying data don't interfere with your cursor's visbility.
+the underlying data don't interfere with your cursor's visibility.
 
+## License
+
+This gem is licensed under an MIT-style license. See the +MIT-LICENSE+ file for
+details.

data/Rakefile

@@ -1,5 +1,4 @@
-
-# -*- ruby -*-
+# frozen_string_literal: true
 
 require 'rubygems'
 require 'rubygems/package_task'
@@ -7,22 +6,24 @@ require 'rake/testtask'
 require 'rdoc/task'
 require 'bundler/gem_tasks'
 
-$:.push File.expand_path(File.dirname(__FILE__), 'lib')
+$LOAD_PATH.push File.expand_path(File.dirname(__FILE__), 'lib')
 
 version = ActiveRecord::PostgreSQLCursors::VERSION
 
 desc 'Test PostgreSQL extensions'
 Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList['test/**/*_tests.rb']
+  t.libs << "#{File.dirname(__FILE__)}/test"
+  t.test_files = FileList['test/**/*_test.rb']
   t.verbose = !!ENV['VERBOSE_TESTS']
   t.warning = !!ENV['WARNINGS']
 end
 
+task default: :test
+
 desc 'Build docs'
 Rake::RDocTask.new do |t|
   t.title = "ActiveRecord PostgreSQL Cursors #{version}"
-  t.main = 'README.rdoc'
+  t.main = 'README.md'
   t.rdoc_dir = 'doc'
   t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
 end
-

data/activerecord-postgresql-cursors.gemspec

@@ -1,26 +1,26 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require File.expand_path('../lib/active_record/postgresql_cursors/version', __FILE__)
+require File.expand_path('lib/active_record/postgresql_cursors/version', __dir__)
 
 Gem::Specification.new do |s|
-  s.name = "activerecord-postgresql-cursors"
+  s.name = 'activerecord-postgresql-cursors'
   s.version = ActiveRecord::PostgreSQLCursors::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["J Smith"]
-  s.description = "Provides some support for PostgreSQL cursors in ActiveRecord."
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.required_ruby_version = '>= 3.0'
+  s.authors = ['J Smith']
+  s.description = 'Provides some support for PostgreSQL cursors in ActiveRecord.'
   s.summary = s.description
-  s.email = "dark.panda@gmail.com"
-  s.license = "MIT"
+  s.email = 'dark.panda@gmail.com'
+  s.license = 'MIT'
   s.extra_rdoc_files = [
-    "README.rdoc"
+    'README.md'
   ]
-  s.files = `git ls-files`.split($\)
+  s.files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
   s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  s.test_files = s.files.grep(%r{^(test|spec|features)/})
-  s.homepage = "http://github.com/dark-panda/activerecord-postgresql-cursors"
-  s.require_paths = ["lib"]
+  s.homepage = 'http://github.com/dark-panda/activerecord-postgresql-cursors'
+  s.require_paths = ['lib']
 
-  s.add_dependency("activerecord", [">= 2.3"])
+  s.add_dependency('activerecord', ['>= 6.1'])
+  s.metadata['rubygems_mfa_required'] = 'true'
 end
-

data/lib/active_record/postgresql_cursors/cursors.rb

@@ -1,15 +1,10 @@
+# frozen_string_literal: true
 
 module ActiveRecord
   module CursorExtensions
     extend ActiveSupport::Concern
 
-    included do
-      alias_method_chain :find, :cursors
-    end
-
-    # Override ActiveRecord::Base#find to allow for cursors in
-    # PostgreSQL. To use a cursor, set the first argument of
-    # find to :cursor. A PostgreSQLCursor object will be returned,
+    # Find using cursors. A PostgreSQLCursor object will be returned,
     # which can then be used as an Enumerable to loop through the
     # results.
     #
@@ -18,45 +13,30 @@ module ActiveRecord
     # is pretty unlikely to clash if you're using nested cursors.
     # Alternatively, you can supply a specific cursor name by
     # supplying a :cursor_name option.
-    def find_with_cursors(*args)
-      if args.first.to_s == 'cursor'
+    def cursor(*args)
+      find_with_cursor('cursor', *args)
+    end
+
+    private
+
+      def find_with_cursor(*args)
         options = args.extract_options!
         cursor_name = options.delete(:cursor_name)
         find_cursor(cursor_name, options)
-      else
-        find_without_cursors(*args)
       end
-    end
-
-    def cursor(*args)
-      find_with_cursors('cursor', *args)
-    end
 
-    private
       # Find method for using cursors. This works just like the regular
       # ActiveRecord::Base#find_every method, except it returns a
       # PostgreSQLCursor object that can be used to loop through records.
       def find_cursor(cursor_name, options)
-        unless connection.is_a? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-          raise CursorsNotSupported, "#{connection.class} doesn't support cursors"
-        end
-
-        relation = if ActiveRecord::VERSION::MAJOR >= 4
-          apply_finder_options(options, silence_deprecation = true)
-        else
-          apply_finder_options(options)
-        end
+        raise CursorsNotSupported, "#{connection.class} doesn't support cursors" unless connection.is_a? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
 
+        relation = merge(options.slice(:readonly, :references, :order, :limit, :joins, :group, :having, :offset, :select, :uniq))
         including = (relation.eager_load_values + relation.includes_values).uniq
 
         if including.present?
-          join_dependency = if ActiveRecord::VERSION::STRING >= '3.1'
-            ActiveRecord::Associations::JoinDependency.new(@klass, including, [])
-          else
-            ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, nil)
-          end
-
-          join_relation = relation.construct_relation_for_association_find(join_dependency)
+          join_dependency = construct_join_dependency(joins_values, nil)
+          join_relation = apply_join_dependency
 
           ActiveRecord::PostgreSQLCursor.new(self, cursor_name, join_relation, join_dependency)
         else
@@ -64,23 +44,6 @@ module ActiveRecord
         end
       end
   end
-
-  class PostgreSQLCursor
-    def initialize_with_rails(model, cursor_name, relation, join_dependency = nil)
-      @relation = relation
-
-      query = if ActiveRecord::VERSION::MAJOR >= 4
-        model.connection.unprepared_statement do
-          relation.to_sql
-        end
-      else
-        relation.to_sql
-      end
-
-      initialize_without_rails(model, cursor_name, query, join_dependency)
-    end
-    alias_method_chain :initialize, :rails
-  end
 end
 
 class ActiveRecord::Relation
@@ -89,10 +52,6 @@ end
 
 class ActiveRecord::Base
   class << self
-    if ActiveRecord::VERSION::MAJOR >= 4
-      delegate :cursor, :to => :all
-    else
-      delegate :cursor, :to => :scoped
-    end
+    delegate :cursor, to: :all
   end
 end

data/lib/active_record/postgresql_cursors/version.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 
 module ActiveRecord
   module PostgreSQLCursors
-    VERSION = '1.0.0'.freeze
+    VERSION = '3.0.0'
   end
 end
-

data/lib/activerecord-postgresql-cursors.rb

@@ -1,40 +1,28 @@
+# frozen_string_literal: true
 
 module ActiveRecord
   # Exception raised when database cursors aren't supported, which they
   # absolutely should be in our app.
   class CursorsNotSupported < ActiveRecordError; end
 
-  module PostgreSQLCursors
-    module JoinDependency
-      # Extra method we can use to clear out a couple of things in
-      # JoinDependency so we can use some of the methods for our
-      # cursors code.
-      def clear_with_cursor
-        @reflections            = []
-        @base_records_hash      = {}
-        @base_records_in_order  = []
-      end
-    end
-  end
-
   # PostgreSQLCursor is an Enumerable class so you can use each, map,
   # any? and all of those nice Enumerable methods.
   #
   # At the moment, cursors aren't scrollable and are fetch forward-only
   # and read-only.
-  #
-  # This class isn't really meant to be used outside of the
-  # ActiveRecord::Base#find method.
   class PostgreSQLCursor
     include Enumerable
 
-    def initialize(model, cursor_name, query, join_dependency = nil)
+    def initialize(model, cursor_name, relation, join_dependency = nil)
       @model = model
-      @cursor_name = if cursor_name
-        @model.connection.quote_table_name(cursor_name.gsub(/"/, '\"'))
-      end
-      @query = query
+      @relation = relation
       @join_dependency = join_dependency
+
+      @cursor_name = (@model.connection.quote_table_name(cursor_name.gsub('"', '\"')) if cursor_name)
+
+      @query = model.connection.unprepared_statement do
+        relation.to_sql
+      end
     end
 
     def inspect
@@ -45,71 +33,67 @@ module ActiveRecord
     # record as a parameter.
     def each
       @model.transaction do
-        begin
-          declare_cursor
-          if @join_dependency
-            rows = Array.new
-            last_id = nil
-            while row = fetch_forward
-              current_id = row[@join_dependency.join_base.aliased_primary_key]
-              last_id ||= current_id
-              if last_id == current_id
-                rows << row
-                last_id = current_id
-              else
-                yield @join_dependency.instantiate(rows).first
-                @join_dependency.clear_with_cursor
-                rows = [ row ]
-              end
+        declare_cursor
+
+        if @join_dependency
+          rows = []
+          last_id = nil
+
+          until (row = fetch_forward).empty?
+            instantiated_row = @join_dependency.instantiate(row, true).first
+            current_id = instantiated_row[@join_dependency.send(:join_root).primary_key]
+            last_id ||= current_id
+
+            if last_id == current_id
+              rows << row.first.values
               last_id = current_id
-            end
+            else
+              result_set = ActiveRecord::Result.new(row.columns, rows, row.column_types)
 
-            if !rows.empty?
-              yield @join_dependency.instantiate(rows).first
-            end
-          else
-            while row = fetch_forward
-              yield row
+              yield @join_dependency.instantiate(result_set, true).first
+
+              rows = [row.first.values]
             end
+
+            last_id = current_id
+          end
+
+          unless rows.empty?
+            result_set = ActiveRecord::Result.new(row.columns, rows, row.column_types)
+
+            yield @join_dependency.instantiate(result_set, true).first
+          end
+        else
+          until (row = fetch_forward).empty?
+            yield @model.instantiate(row.first)
           end
-        ensure
-          close_cursor
         end
+      ensure
+        close_cursor
       end
       nil
     end
 
     private
+
       def cursor_name
-        @cursor_name ||= "cursor_#{(rand * 1000000).ceil}"
+        @cursor_name ||= "cursor_#{(rand * 1_000_000).ceil}"
       end
 
-      def fetch_forward #:nodoc:
-        @model.find_by_sql(%{FETCH FORWARD FROM #{cursor_name}}).first
+      def fetch_forward # :nodoc:
+        @relation.uncached do
+          @relation.connection.select_all(%{FETCH FORWARD FROM #{cursor_name}})
+        end
       end
 
-      def declare_cursor #:nodoc:
+      def declare_cursor # :nodoc:
         @model.connection.execute(%{DECLARE #{cursor_name} CURSOR FOR #{@query}})
       end
 
-      def close_cursor #:nodoc:
+      def close_cursor # :nodoc:
         @model.connection.execute(%{CLOSE #{cursor_name}})
       end
   end
 end
 
-if ActiveRecord::VERSION::STRING >= '3.1'
-  class ActiveRecord::Associations::JoinDependency
-    include ActiveRecord::PostgreSQLCursors::JoinDependency
-  end
-else
-  class ActiveRecord::Associations::ClassMethods::JoinDependency
-    include ActiveRecord::PostgreSQLCursors::JoinDependency
-  end
-end
-
-if ActiveRecord::VERSION::MAJOR >= 3
-  require File.join(File.dirname(__FILE__), *%w{ active_record postgresql_cursors cursors })
-else
-  require File.join(File.dirname(__FILE__), *%w{ active_record postgresql_cursors cursors_2 })
-end
+require File.join(File.dirname(__FILE__), *%w{ active_record postgresql_cursors cursors })

data/sonar-project.properties

@@ -0,0 +1,17 @@
+sonar.projectKey=dark-panda_activerecord-postgresql-cursors
+sonar.organization=dark-panda
+
+# This is the name and version displayed in the SonarCloud UI.
+sonar.projectName=activerecord-postgresql-cursors
+sonar.projectVersion=1.0
+
+# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
+sonar.sources=lib, test
+sonar.coverage.exclusions=test
+
+# Encoding of the source code. Default is default system encoding
+sonar.sourceEncoding=UTF-8
+
+# Additional reports
+sonar.ruby.rubocop.reportPaths=rubocop-report.json
+sonar.ruby.coverage.reportPaths=coverage/coverage.json

data/test/ci/github/database.yml

@@ -0,0 +1,10 @@
+
+arunit:
+  encoding: unicode
+  min_messages: WARNING
+  database: postgresql_cursors_unit_tests
+  adapter: postgresql
+  user: appuser
+  password: password
+  host: localhost
+  port: 5432

data/test/cursor_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class PostgreSQLCursorTests < Minitest::Test
+  include PostgreSQLCursorTestHelper
+
+  def test_cursor_scoped
+    cursor = Foo.cursor(order: 'id')
+
+    assert_kind_of(ActiveRecord::PostgreSQLCursor, cursor)
+
+    assert_equal(%w{ one two three four five }, cursor.collect(&:name))
+  end
+
+  def test_cursor_while_updating
+    cursor = Foo.cursor(order: 'id')
+
+    cursor.each do |row|
+      row.name = "#{row.name}_updated"
+
+      assert(row.save)
+    end
+
+    assert_equal(%w{ one_updated two_updated three_updated four_updated five_updated }, cursor.collect(&:name))
+  end
+
+  def test_with_associations
+    cursor = Foo.cursor(order: 'id')
+
+    cursor.each do |row|
+      assert_kind_of(Foo, row)
+      row.bars.each do |bar|
+        assert_kind_of(Bar, bar)
+      end
+    end
+  end
+
+  def test_with_associations_eager_loading
+    cursor = Foo.cursor(order: 'foos.id', include: :bars)
+
+    cursor.each do |row|
+      assert_kind_of(Foo, row)
+      row.bars.each do |bar|
+        assert_kind_of(Bar, bar)
+      end
+    end
+  end
+
+  def test_nested_cursors
+    cursor = Foo.cursor(order: 'foos.id')
+
+    cursor.each do |row|
+      bars_cursor = row.bars.cursor
+
+      assert_kind_of(ActiveRecord::PostgreSQLCursor, bars_cursor)
+
+      bars_cursor.each do |bar|
+        assert_kind_of(Bar, bar)
+      end
+    end
+  end
+
+  def test_as_relation
+    cursor = Foo.order('foos.id').where('foos.id >= 3').cursor
+
+    assert_equal(3, cursor.to_a.length)
+
+    cursor.each do |row|
+      assert_kind_of(Foo, row)
+      assert_equal(2, row.bars.length)
+      row.bars.each do |bar|
+        assert_kind_of(Bar, bar)
+      end
+    end
+  end
+
+  def test_as_relation_with_associations
+    cursor = Foo.includes(:bars).order('foos.id').where('foos.id >= 3').cursor
+
+    assert_equal(3, cursor.to_a.length)
+
+    cursor.each do |row|
+      assert_kind_of(Foo, row)
+      assert_equal(2, row.bars.length)
+      row.bars.each do |bar|
+        assert_kind_of(Bar, bar)
+      end
+    end
+  end
+end