activerecord-postgresql-cursors 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c1248c91950e3c8ebb2828659ee1a14082c8fe1
-  data.tar.gz: 2900adb67d660cacefebf47d1705c99f826ca7a7
+  metadata.gz: 4664b822d630c82374f56ca318d69c736c9ad819
+  data.tar.gz: 7318a45c89b1b76dcb8d79fecb6a499bac1a7a48
 SHA512:
-  metadata.gz: 7c43c972a3b16f104c29231e98c1e1e4728cb6528a21b97305701aa4671ba9f11f99feed4bb928cc588f89951d4a9be4988f237d972ac5958b07ff1c59501d0c
-  data.tar.gz: 3bae3a25d88449eac8054c46a24c4e7bc36e3d7908ce4b4b6e5edffad0afc3ad19517cfddfbe96beb4fb5b0ae61ec02584febb981647a8cbe5ff2c819e43e280
+  metadata.gz: '053952a5bcc975b0bc7652e652d0f8029fda8a1dd470adbfc0a081d1095f0a0ec601ee4c633250930b16c7e089e8f175d4753d2580d3bb4c796f6f0ff67671b0'
+  data.tar.gz: a67bb236338e87143a8d0827edbbb847371b132f9fbc7dae09c9b39ce5a02129ece6fa8b809b2b8ca4a9cd989994203935c79a1d0b73a4a705d7cfc5b07afdd3

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - 2.5.0
+  - 2.4.3
+  - 2.3.6
+  - 2.2.9
+  - jruby
+env:
+  - RAILS_VERSION=5.1
+  - RAILS_VERSION=4.2
+matrix:
+  allow_failures:
+    - rvm: jruby
+before_install:
+- gem update --system
+- gem install bundler
+before_script:
+- psql -c 'create database postgresql_cursors_unit_tests;' -U postgres

data/Gemfile

@@ -5,12 +5,12 @@ gemspec
 if RUBY_PLATFORM == "java"
   gem "activerecord-jdbcpostgresql-adapter"
 else
-  gem "pg"
+  gem "pg", '~> 0.21'
 end
 
-gem "rdoc", "~> 3.12"
-gem "rake", "~> 10.0"
-gem "minitest", "~> 4.7"
+gem "rdoc"
+gem "rake"
+gem "minitest"
 gem "minitest-reporters"
 gem "guard-minitest"
 gem "simplecov"

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2016 J Smith <dark.panda@gmail.com>
+Copyright (c) 2008-2018 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

data/README.rdoc

@@ -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,22 @@ 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
+  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 4.2+. 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 +49,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

@@ -13,11 +13,14 @@ version = ActiveRecord::PostgreSQLCursors::VERSION
 
 desc 'Test PostgreSQL extensions'
 Rake::TestTask.new(:test) do |t|
+  t.libs << "#{File.dirname(__FILE__)}/test"
   t.test_files = FileList['test/**/*_tests.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}"
@@ -25,4 +28,3 @@ Rake::RDocTask.new do |t|
   t.rdoc_dir = 'doc'
   t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
 end
-

data/lib/active_record/postgresql_cursors/cursors.rb

@@ -3,13 +3,7 @@ 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,21 +12,18 @@ 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.
@@ -41,22 +32,15 @@ module ActiveRecord
           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
-
+        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_dependency = construct_join_dependency(joins_values)
 
-          join_relation = relation.construct_relation_for_association_find(join_dependency)
+          aliases = join_dependency.aliases
+          join_relation = select(aliases.columns)
+          join_relation = apply_join_dependency(join_relation, join_dependency)
 
           ActiveRecord::PostgreSQLCursor.new(self, cursor_name, join_relation, join_dependency)
         else
@@ -64,23 +48,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 +56,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 @@
 
 module ActiveRecord
   module PostgreSQLCursors
-    VERSION = '1.0.0'.freeze
+    VERSION = '2.0.0'.freeze
   end
 end
 

data/lib/activerecord-postgresql-cursors.rb

@@ -4,37 +4,26 @@ module ActiveRecord
   # 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
+      @relation = relation
+      @join_dependency = join_dependency
+
       @cursor_name = if cursor_name
         @model.connection.quote_table_name(cursor_name.gsub(/"/, '\"'))
       end
-      @query = query
-      @join_dependency = join_dependency
+
+      @query = model.connection.unprepared_statement do
+        relation.to_sql
+      end
     end
 
     def inspect
@@ -50,26 +39,28 @@ module ActiveRecord
           if @join_dependency
             rows = Array.new
             last_id = nil
+
             while row = fetch_forward
-              current_id = row[@join_dependency.join_base.aliased_primary_key]
+              instantiated_row = @join_dependency.instantiate([row], @join_dependency.aliases).first
+
+              current_id = instantiated_row[@join_dependency.join_root.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
+                yield @join_dependency.instantiate(rows, @join_dependency.aliases).first
                 rows = [ row ]
               end
               last_id = current_id
             end
 
             if !rows.empty?
-              yield @join_dependency.instantiate(rows).first
+              yield @join_dependency.instantiate(rows, @join_dependency.aliases).first
             end
           else
             while row = fetch_forward
-              yield row
+              yield @model.instantiate(row)
             end
           end
         ensure
@@ -80,12 +71,13 @@ module ActiveRecord
     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
+        @relation.connection.select_all(%{FETCH FORWARD FROM #{cursor_name}}).first
       end
 
       def declare_cursor #:nodoc:
@@ -98,18 +90,4 @@ module ActiveRecord
   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/test/cursor_tests.rb

@@ -1,20 +1,11 @@
 
-$: << File.dirname(__FILE__)
 require 'test_helper'
 
-class PostgreSQLCursorTests < MiniTest::Unit::TestCase
+class PostgreSQLCursorTests < Minitest::Test
   include PostgreSQLCursorTestHelper
 
-  def test_find_cursor
-    cursor = Foo.find(:cursor, :order => 'id')
-
-    assert(cursor.is_a?(ActiveRecord::PostgreSQLCursor))
-
-    assert_equal(%w{ one two three four five }, cursor.collect(&:name))
-  end
-
   def test_cursor_scoped
-    cursor = Foo.cursor(:order => 'id')
+    cursor = Foo.cursor(order: 'id')
 
     assert(cursor.is_a?(ActiveRecord::PostgreSQLCursor))
 
@@ -22,7 +13,7 @@ class PostgreSQLCursorTests < MiniTest::Unit::TestCase
   end
 
   def test_cursor_while_updating
-    cursor = Foo.cursor(:order => 'id')
+    cursor = Foo.cursor(order: 'id')
 
     cursor.each do |row|
       row.name = "#{row.name}_updated"
@@ -33,7 +24,7 @@ class PostgreSQLCursorTests < MiniTest::Unit::TestCase
   end
 
   def test_with_associations
-    cursor = Foo.cursor(:order => 'id')
+    cursor = Foo.cursor(order: 'id')
 
     cursor.each do |row|
       assert(row.is_a?(Foo))
@@ -44,7 +35,7 @@ class PostgreSQLCursorTests < MiniTest::Unit::TestCase
   end
 
   def test_with_associations_eager_loading
-    cursor = Foo.cursor(:order => 'foos.id', :include => :bars)
+    cursor = Foo.cursor(order: 'foos.id', include: :bars)
 
     cursor.each do |row|
       assert(row.is_a?(Foo))
@@ -55,7 +46,7 @@ class PostgreSQLCursorTests < MiniTest::Unit::TestCase
   end
 
   def test_nested_cursors
-    cursor = Foo.cursor(:order => 'foos.id')
+    cursor = Foo.cursor(order: 'foos.id')
 
     cursor.each do |row|
       bars_cursor = row.bars.cursor
@@ -67,30 +58,28 @@ class PostgreSQLCursorTests < MiniTest::Unit::TestCase
     end
   end
 
-  if ActiveRecord::VERSION::MAJOR >= 3
-    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(row.is_a?(Foo))
-        assert_equal(2, row.bars.length)
-        row.bars.each do |bar|
-          assert(bar.is_a?(Bar))
-        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(row.is_a?(Foo))
+      assert_equal(2, row.bars.length)
+      row.bars.each do |bar|
+        assert(bar.is_a?(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)
+  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(row.is_a?(Foo))
-        assert_equal(2, row.bars.length)
-        row.bars.each do |bar|
-          assert(bar.is_a?(Bar))
-        end
+    cursor.each do |row|
+      assert(row.is_a?(Foo))
+      assert_equal(2, row.bars.length)
+      row.bars.each do |bar|
+        assert(bar.is_a?(Bar))
       end
     end
   end

data/test/test_helper.rb

@@ -1,11 +1,9 @@
 
-if RUBY_VERSION >= '1.9'
-  require 'simplecov'
+require 'simplecov'
 
-  SimpleCov.command_name('Unit Tests')
-  SimpleCov.start do
-    add_filter '/test/'
-  end
+SimpleCov.command_name('Unit Tests')
+SimpleCov.start do
+  add_filter '/test/'
 end
 
 require 'rubygems'
@@ -14,14 +12,11 @@ require 'active_support/core_ext/module/aliasing'
 require 'active_record'
 require 'logger'
 require 'minitest/autorun'
-
-if RUBY_VERSION >= '1.9'
-  require 'minitest/reporters'
-end
+require 'minitest/reporters'
 
 require File.join(File.dirname(__FILE__), *%w{ .. lib activerecord-postgresql-cursors })
 
-ActiveRecord::Base.logger = Logger.new("debug.log") if ENV['ENABLE_LOGGER']
+ActiveRecord::Base.logger = Logger.new('debug.log') if ENV['ENABLE_LOGGER']
 ActiveRecord::Base.configurations = {
   'arunit' => {}
 }
@@ -32,12 +27,12 @@ ActiveRecord::Base.configurations = {
 }.each do |file|
   file = File.join('test', file)
 
-  next unless File.exists?(file)
+  next unless File.exist?(file)
 
-  configuration = YAML.load(File.read(file))
+  configuration = YAML.safe_load(File.read(file))
 
   if configuration['arunit']
-    ActiveRecord::Base.configurations['arunit'].merge!(configuration['arunit'])
+    ActiveRecord::Base.configurations['arunit'] = configuration['arunit']
   end
 
   if defined?(JRUBY_VERSION) && configuration['jdbc']
@@ -45,29 +40,31 @@ ActiveRecord::Base.configurations = {
   end
 end
 
-ActiveRecord::Base.establish_connection 'arunit'
+ActiveRecord::Base.establish_connection :arunit
 ARBC = ActiveRecord::Base.connection
 
 puts "Ruby version #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
-puts "Testing against ActiveRecord #{Gem.loaded_specs['activerecord'].version.to_s}"
-if postgresql_version = ARBC.select_rows('SELECT version()').flatten.to_s
+puts "Testing against ActiveRecord #{Gem.loaded_specs['activerecord'].version}"
+
+postgresql_version = ARBC.select_rows('SELECT version()').flatten.to_s
+
+if postgresql_version
   puts "PostgreSQL info from version(): #{postgresql_version}"
 end
 
-if !ARBC.table_exists?('foos')
+unless ARBC.data_source_exists?('foos')
   ActiveRecord::Migration.create_table(:foos) do |t|
     t.text :name
   end
 end
 
-if !ARBC.table_exists?('bars')
+unless ARBC.data_source_exists?('bars')
   ActiveRecord::Migration.create_table(:bars) do |t|
     t.text :name
     t.integer :foo_id
   end
 end
 
-
 class Bar < ActiveRecord::Base
   belongs_to :foo
 end
@@ -84,18 +81,15 @@ module PostgreSQLCursorTestHelper
     ARBC.execute(%{select setval('bars_id_seq', 1, false)})
 
     %w{ six seven eight nine ten eleven twelve thirteen fourteen fifteen }.each do |name|
-      Bar.create(:name => name)
+      Bar.create(name: name)
     end
 
     %w{ one two three four five }.each_with_index do |name, i|
-      foo = Foo.new(:name => name)
+      foo = Foo.new(name: name)
       foo.bar_ids = [ i + 1, i + 6 ]
       foo.save
     end
   end
 end
 
-if RUBY_VERSION >= '1.9'
-  MiniTest::Reporters.use!(MiniTest::Reporters::SpecReporter.new)
-end
-
+Minitest::Reporters.use!(MiniTest::Reporters::SpecReporter.new)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgresql-cursors
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - J Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2018-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -32,6 +32,7 @@ extra_rdoc_files:
 - README.rdoc
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - MIT-LICENSE
@@ -39,7 +40,6 @@ files:
 - Rakefile
 - activerecord-postgresql-cursors.gemspec
 - lib/active_record/postgresql_cursors/cursors.rb
-- lib/active_record/postgresql_cursors/cursors_2.rb
 - lib/active_record/postgresql_cursors/version.rb
 - lib/activerecord-postgresql-cursors.rb
 - test/cursor_tests.rb
@@ -65,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Provides some support for PostgreSQL cursors in ActiveRecord.

data/lib/active_record/postgresql_cursors/cursors_2.rb

@@ -1,75 +0,0 @@
-
-module ActiveRecord
-  class Base
-    class << self
-      # 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,
-      # which can then be used as an Enumerable to loop through the
-      # results.
-      #
-      # By default, cursor names are generated automatically using
-      # "cursor_#{rand}", where rand is a big ol' random number that
-      # 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'
-          options = args.extract_options!
-          cursor_name = options.delete(:cursor_name)
-          validate_find_options(options)
-          set_readonly_option!(options)
-          find_cursor(cursor_name, options)
-        else
-          find_without_cursors(*args)
-        end
-      end
-      alias_method_chain :find, :cursors
-
-      def cursor(*args)
-        find(:cursor, *args)
-      end
-    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 self.find_cursor(cursor_name, options)
-        unless connection.is_a? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-          raise CursorsNotSupported, "#{connection.class} doesn't support cursors"
-        end
-
-        catch :invalid_query do
-          if options[:include]
-            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
-            return ActiveRecord::PostgreSQLCursor.new(
-              self,
-              cursor_name,
-              construct_finder_sql_with_included_associations(
-                options,
-                join_dependency
-              ),
-              join_dependency
-            )
-          else
-            return ActiveRecord::PostgreSQLCursor.new(
-              self,
-              cursor_name,
-              construct_finder_sql(
-                options
-              )
-            )
-          end
-        end
-        nil
-      end
-  end
-
-  class PostgreSQLCursor
-    def initialize_with_rails_2(model, cursor_name, query, join_dependency = nil)
-      initialize_without_rails_2(model, cursor_name, query, join_dependency)
-    end
-    alias_method_chain :initialize, :rails_2
-  end
-end