Remove :finder_sql, :counter_sql, :insert_sql, :delete_sql.

6 files changed, 3 insertions, 197 deletions

diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index 24bb4adf0a..90e5467f13 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -65,16 +65,6 @@ class DeveloperWithSymbolsForKeys < ActiveRecord::Base
     :foreign_key => "developer_id"
 end
 
-class DeveloperWithCounterSQL < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects,
-    :class_name => "DeveloperWithCounterSQL",
-    :join_table => "developers_projects",
-    :association_foreign_key => "project_id",
-    :foreign_key => "developer_id",
-    :counter_sql => proc { "SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}" }
-end
-
 class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects,
            :parrots, :pirates, :parrots_pirates, :treasures, :price_estimates, :tags, :taggings
@@ -361,31 +351,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 0, david.projects(true).size
   end
 
-  def test_deleting_with_sql
-    david = Developer.find(1)
-    active_record = Project.find(1)
-    active_record.developers.reload
-    assert_equal 3, active_record.developers_by_sql.size
-
-    active_record.developers_by_sql.delete(david)
-    assert_equal 2, active_record.developers_by_sql(true).size
-  end
-
-  def test_deleting_array_with_sql
-    active_record = Project.find(1)
-    active_record.developers.reload
-    assert_equal 3, active_record.developers_by_sql.size
-
-    active_record.developers_by_sql.delete(Developer.all)
-    assert_equal 0, active_record.developers_by_sql(true).size
-  end
-
-  def test_deleting_all_with_sql
-    project = Project.find(1)
-    project.developers_by_sql.delete_all
-    assert_equal 0, project.developers_by_sql.size
-  end
-
   def test_deleting_all
     david = Developer.find(1)
     david.projects.reload
@@ -534,25 +499,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert ! project.developers.include?(developer)
   end
 
-  def test_find_in_association_with_custom_finder_sql
-    assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id), "SQL find"
-
-    active_record = projects(:active_record)
-    active_record.developers_with_finder_sql.reload
-    assert_equal developers(:david), active_record.developers_with_finder_sql.find(developers(:david).id), "Ruby find"
-  end
-
-  def test_find_in_association_with_custom_finder_sql_and_multiple_interpolations
-    # interpolate once:
-    assert_equal [developers(:david), developers(:jamis), developers(:poor_jamis)], projects(:active_record).developers_with_finder_sql, "first interpolation"
-    # interpolate again, for a different project id
-    assert_equal [developers(:david)], projects(:action_controller).developers_with_finder_sql, "second interpolation"
-  end
-
-  def test_find_in_association_with_custom_finder_sql_and_string_id
-    assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id.to_s), "SQL find"
-  end
-
   def test_find_with_merged_options
     assert_equal 1, projects(:active_record).limited_developers.size
     assert_equal 1, projects(:active_record).limited_developers.all.size
@@ -788,21 +734,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, david.projects.count
   end
 
-  def test_count_with_counter_sql
-    developer  = DeveloperWithCounterSQL.create(:name => 'tekin')
-    developer.project_ids = [projects(:active_record).id]
-    developer.save
-    developer.reload
-    assert_equal 1, developer.projects.count
-  end
-
-  unless current_adapter?(:PostgreSQLAdapter)
-    def test_count_with_finder_sql
-      assert_equal 3, projects(:active_record).developers_with_finder_sql.count
-      assert_equal 3, projects(:active_record).developers_with_multiline_finder_sql.count
-    end
-  end
-
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
     Post.expects(:transaction)
     Category.first.posts.transaction do
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index bd850ce690..6e64a67761 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -20,43 +20,6 @@ require 'models/car'
 require 'models/bulb'
 require 'models/engine'
 
-class HasManyAssociationsTestForCountWithFinderSql < ActiveRecord::TestCase
-  class Invoice < ActiveRecord::Base
-    has_many :custom_line_items, :class_name => 'LineItem', :finder_sql => "SELECT line_items.* from line_items"
-  end
-  def test_should_fail
-    assert_raise(ArgumentError) do
-      Invoice.create.custom_line_items.count(:conditions => {:amount => 0})
-    end
-  end
-end
-
-class HasManyAssociationsTestForCountWithCountSql < ActiveRecord::TestCase
-  class Invoice < ActiveRecord::Base
-    has_many :custom_line_items, :class_name => 'LineItem', :counter_sql => "SELECT COUNT(*) line_items.* from line_items"
-  end
-  def test_should_fail
-    assert_raise(ArgumentError) do
-      Invoice.create.custom_line_items.count(:conditions => {:amount => 0})
-    end
-  end
-end
-
-class HasManyAssociationsTestForCountDistinctWithFinderSql < ActiveRecord::TestCase
-  class Invoice < ActiveRecord::Base
-    has_many :custom_line_items, :class_name => 'LineItem', :finder_sql => "SELECT DISTINCT line_items.amount from line_items"
-  end
-
-  def test_should_count_distinct_results
-    invoice = Invoice.new
-    invoice.custom_line_items << LineItem.new(:amount => 0)
-    invoice.custom_line_items << LineItem.new(:amount => 0)
-    invoice.save!
-
-    assert_equal 1, invoice.custom_line_items.count
-  end
-end
-
 class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase
   fixtures :authors, :posts, :comments
 
@@ -307,37 +270,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal "Summit", Firm.scoped(:order => "id").first.clients_using_primary_key.first.name
   end
 
-  def test_finding_using_sql
-    firm = Firm.scoped(:order => "id").first
-    first_client = firm.clients_using_sql.first
-    assert_not_nil first_client
-    assert_equal "Microsoft", first_client.name
-    assert_equal 1, firm.clients_using_sql.size
-    assert_equal 1, Firm.scoped(:order => "id").first.clients_using_sql.size
-  end
-
-  def test_finding_using_sql_take_into_account_only_uniq_ids
-    firm = Firm.scoped(:order => "id").first
-    client = firm.clients_using_sql.first
-    assert_equal client, firm.clients_using_sql.find(client.id, client.id)
-    assert_equal client, firm.clients_using_sql.find(client.id, client.id.to_s)
-  end
-
-  def test_counting_using_sql
-    assert_equal 1, Firm.scoped(:order => "id").first.clients_using_counter_sql.size
-    assert Firm.scoped(:order => "id").first.clients_using_counter_sql.any?
-    assert_equal 0, Firm.scoped(:order => "id").first.clients_using_zero_counter_sql.size
-    assert !Firm.scoped(:order => "id").first.clients_using_zero_counter_sql.any?
-  end
-
-  def test_counting_non_existant_items_using_sql
-    assert_equal 0, Firm.scoped(:order => "id").first.no_clients_using_counter_sql.size
-  end
-
-  def test_counting_using_finder_sql
-    assert_equal 2, Firm.find(4).clients_using_sql.count
-  end
-
   def test_belongs_to_sanity
     c = Client.new
     assert_nil c.firm
@@ -365,22 +297,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find(2, 99) }
   end
 
-  def test_find_string_ids_when_using_finder_sql
-    firm = Firm.scoped(:order => "id").first
-
-    client = firm.clients_using_finder_sql.find("2")
-    assert_kind_of Client, client
-
-    client_ary = firm.clients_using_finder_sql.find(["2"])
-    assert_kind_of Array, client_ary
-    assert_equal client, client_ary.first
-
-    client_ary = firm.clients_using_finder_sql.find("2", "3")
-    assert_kind_of Array, client_ary
-    assert_equal 2, client_ary.size
-    assert client_ary.include?(client)
-  end
-
   def test_find_all
     firm = Firm.scoped(:order => "id").first
     assert_equal 2, firm.clients.scoped(:where => "#{QUOTED_TYPE} = 'Client'").all.length
@@ -1208,13 +1124,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [readers(:michael_welcome).id], posts(:welcome).readers_with_person_ids
   end
 
-  def test_get_ids_for_unloaded_finder_sql_associations_loads_them
-    company = companies(:first_firm)
-    assert !company.clients_using_sql.loaded?
-    assert_equal [companies(:second_client).id], company.clients_using_sql_ids
-    assert company.clients_using_sql.loaded?
-  end
-
   def test_get_ids_for_ordered_association
     assert_equal [companies(:second_client).id, companies(:first_client).id], companies(:first_firm).clients_ordered_by_name_ids
   end
@@ -1275,17 +1184,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert ! firm.clients.loaded?
   end
 
-  def test_include_loads_collection_if_target_uses_finder_sql
-    firm = companies(:first_firm)
-    client = firm.clients_using_sql.first
-
-    firm.reload
-    assert ! firm.clients_using_sql.loaded?
-    assert firm.clients_using_sql.include?(client)
-    assert firm.clients_using_sql.loaded?
-  end
-
-
   def test_include_returns_false_for_non_matching_record_to_verify_scoping
     firm = companies(:first_firm)
     client = Client.create!(:name => 'Not Associated')
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 67e0c155c8..51f07b6a2f 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -165,8 +165,8 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_reflection_of_all_associations
     # FIXME these assertions bust a lot
-    assert_equal 39, Firm.reflect_on_all_associations.size
-    assert_equal 29, Firm.reflect_on_all_associations(:has_many).size
+    assert_equal 34, Firm.reflect_on_all_associations.size
+    assert_equal 24, Firm.reflect_on_all_associations(:has_many).size
     assert_equal 10, Firm.reflect_on_all_associations(:has_one).size
     assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
   end
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index 4c57cf1050..ff6b7d085f 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -36,9 +36,7 @@ module Namespaced
 end
 
 class Firm < Company
-  has_many :clients, -> { order "id" }, :dependent => :destroy, :counter_sql =>
-      "SELECT COUNT(*) FROM companies WHERE firm_id = 1 " +
-      "AND (#{QUOTED_TYPE} = 'Client' OR #{QUOTED_TYPE} = 'SpecialClient' OR #{QUOTED_TYPE} = 'VerySpecialClient' )",
+  has_many :clients, -> { order "id" }, :dependent => :destroy,
       :before_remove => :log_before_remove,
       :after_remove  => :log_after_remove
   has_many :unsorted_clients, :class_name => "Client"
@@ -53,17 +51,6 @@ class Firm < Company
   has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, :class_name => "Client"
   has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
   has_many :clients_like_ms_with_hash_conditions, -> { where(:name => 'Microsoft').order("id") }, :class_name => "Client"
-  has_many :clients_using_sql, :class_name => "Client", :finder_sql => proc { "SELECT * FROM companies WHERE client_of = #{id}" }
-  has_many :clients_using_counter_sql, :class_name => "Client",
-           :finder_sql  => proc { "SELECT * FROM companies WHERE client_of = #{id} " },
-           :counter_sql => proc { "SELECT COUNT(*) FROM companies WHERE client_of = #{id}" }
-  has_many :clients_using_zero_counter_sql, :class_name => "Client",
-           :finder_sql  => proc { "SELECT * FROM companies WHERE client_of = #{id}" },
-           :counter_sql => proc { "SELECT 0 FROM companies WHERE client_of = #{id}" }
-  has_many :no_clients_using_counter_sql, :class_name => "Client",
-           :finder_sql  => 'SELECT * FROM companies WHERE client_of = 1000',
-           :counter_sql => 'SELECT COUNT(*) FROM companies WHERE client_of = 1000'
-  has_many :clients_using_finder_sql, :class_name => "Client", :finder_sql => 'SELECT * FROM companies WHERE 1=1'
   has_many :plain_clients, :class_name => 'Client'
   has_many :readonly_clients, -> { readonly }, :class_name => 'Client'
   has_many :clients_using_primary_key, :class_name => 'Client',
diff --git a/activerecord/test/models/company_in_module.rb b/activerecord/test/models/company_in_module.rb
index e5ceda2928..0d14fa1be1 100644
--- a/activerecord/test/models/company_in_module.rb
+++ b/activerecord/test/models/company_in_module.rb
@@ -11,7 +11,6 @@ module MyApplication
       has_many :clients_sorted_desc, -> { order("id DESC") }, :class_name => "Client"
       has_many :clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client"
       has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
-      has_many :clients_using_sql, :class_name => "Client", :finder_sql => 'SELECT * FROM companies WHERE client_of = #{id}'
 
       has_one :account, :class_name => 'MyApplication::Billing::Account', :dependent => :destroy
     end
diff --git a/activerecord/test/models/project.rb b/activerecord/test/models/project.rb
index 98129bcd4f..c31750688b 100644
--- a/activerecord/test/models/project.rb
+++ b/activerecord/test/models/project.rb
@@ -7,15 +7,6 @@ class Project < ActiveRecord::Base
   has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").uniq }, :class_name => "Developer"
   has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(:name => 'David').uniq }, :class_name => "Developer"
   has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => proc { "SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id" }
-  has_and_belongs_to_many :developers_with_multiline_finder_sql, :class_name => "Developer", :finder_sql => proc {
-    "SELECT
-       t.*, j.*
-     FROM
-       developers_projects j,
-       developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id"
-  }
-  has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => proc { |record| "DELETE FROM developers_projects WHERE project_id = #{id} AND developer_id = #{record.id}" }
   has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
                             :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
                             :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},