ibm_db 0.10.0 → 1.0.0

data/test/cases/calculations_test.rb

@@ -1,6 +1,7 @@
 require "cases/helper"
 require 'models/company'
 require 'models/topic'
+require 'models/edge'
 
 Company.has_many :accounts
 
@@ -17,8 +18,8 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_average_field
     value = Account.average(:credit_limit)
-    assert_kind_of Float, value
-    assert_in_delta 53.0, value, 0.001
+    assert_kind_of BigDecimal, value
+    assert_equal BigDecimal.new('53.0'), value
   end
 
   def test_should_return_nil_as_average
@@ -99,6 +100,12 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_return_zero_if_sum_conditions_return_nothing
     assert_equal 0, Account.sum(:credit_limit, :conditions => '1 = 2')
+    assert_equal 0, companies(:rails_core).companies.sum(:id, :conditions => '1 = 2')
+  end
+
+  def test_sum_should_return_valid_values_for_decimals
+    NumericData.create(:bank_balance => 19.83)
+    assert_equal 19.83, NumericData.sum(:bank_balance)
   end
 
   def test_should_group_by_summed_field_with_conditions
@@ -269,7 +276,52 @@ class CalculationsTest < ActiveRecord::TestCase
     if current_adapter?(:IBM_DBAdapter) && !ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')
      assert_equal 636, Account.sum("2 * credit_limit")
     else
-     assert_equal "636", Account.sum("2 * credit_limit") 
+     assert_equal '636', Account.sum("2 * credit_limit") 
     end 
   end
+
+  def test_count_with_from_option
+    assert_equal Company.count(:all), Company.count(:all, :from => 'companies')
+    assert_equal Account.count(:all, :conditions => "credit_limit = 50"),
+        Account.count(:all, :from => 'accounts', :conditions => "credit_limit = 50")
+    assert_equal Company.count(:type, :conditions => {:type => "Firm"}),
+        Company.count(:type, :conditions => {:type => "Firm"}, :from => 'companies')
+  end
+
+  def test_sum_with_from_option
+    assert_equal Account.sum(:credit_limit), Account.sum(:credit_limit, :from => 'accounts')
+    assert_equal Account.sum(:credit_limit, :conditions => "credit_limit > 50"),
+        Account.sum(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+  end
+
+  def test_average_with_from_option
+    assert_equal Account.average(:credit_limit), Account.average(:credit_limit, :from => 'accounts')
+    assert_equal Account.average(:credit_limit, :conditions => "credit_limit > 50"),
+        Account.average(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+  end
+
+  def test_minimum_with_from_option
+    assert_equal Account.minimum(:credit_limit), Account.minimum(:credit_limit, :from => 'accounts')
+    assert_equal Account.minimum(:credit_limit, :conditions => "credit_limit > 50"),
+        Account.minimum(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+  end
+
+  def test_maximum_with_from_option
+    assert_equal Account.maximum(:credit_limit), Account.maximum(:credit_limit, :from => 'accounts')
+    assert_equal Account.maximum(:credit_limit, :conditions => "credit_limit > 50"),
+        Account.maximum(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+  end
+
+  def test_from_option_with_specified_index
+    if Edge.connection.adapter_name == 'MySQL'
+      assert_equal Edge.count(:all), Edge.count(:all, :from => 'edges USE INDEX(unique_edge_index)')
+      assert_equal Edge.count(:all, :conditions => 'sink_id < 5'),
+          Edge.count(:all, :from => 'edges USE INDEX(unique_edge_index)', :conditions => 'sink_id < 5')
+    end
+  end
+
+  def test_from_option_with_table_different_than_class
+    assert_equal Account.count(:all), Company.count(:all, :from => 'accounts')
+  end
+
 end

data/test/cases/finder_test.rb

@@ -1,5 +1,6 @@
 require "cases/helper"
 require 'models/author'
+require 'models/categorization'
 require 'models/comment'
 require 'models/company'
 require 'models/topic'
@@ -51,11 +52,11 @@ class FinderTest < ActiveRecord::TestCase
   def test_exists_with_aggregate_having_three_mappings_with_one_difference
     existing_address = customers(:david).address
     assert !Customer.exists?(:address =>
-                             Address.new(existing_address.street, existing_address.city, existing_address.country + "1"))
+      Address.new(existing_address.street, existing_address.city, existing_address.country + "1"))
     assert !Customer.exists?(:address =>
-                             Address.new(existing_address.street, existing_address.city + "1", existing_address.country))
+      Address.new(existing_address.street, existing_address.city + "1", existing_address.country))
     assert !Customer.exists?(:address =>
-                             Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
+      Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
   end
   
   def test_find_by_array_of_one_id
@@ -323,7 +324,7 @@ class FinderTest < ActiveRecord::TestCase
       Company.find(:first, :conditions => ["id=? AND name = ?", 2])
     }
     assert_raises(ActiveRecord::PreparedStatementInvalid) {
-      Company.find(:first, :conditions => ["id=?", 2, 3, 4])
+     Company.find(:first, :conditions => ["id=?", 2, 3, 4])
     }
   end
   
@@ -385,7 +386,15 @@ class FinderTest < ActiveRecord::TestCase
   def test_bind_string
     assert_equal ActiveRecord::Base.connection.quote(''), bind('?', '')
   end
-  
+
+  def test_bind_string_with_nl
+    assert_equal ActiveRecord::Base.connection.quote("a\nb"), bind('?', "a\nb")
+  end
+
+  def test_bind_mb_string_with_nl
+    assert_equal ActiveRecord::Base.connection.quote("a\nb"), bind('?', "a\nb".chars)
+  end
+
   def test_bind_record
     o = Struct.new(:quoted_id).new(1)
     assert_equal '1', bind('?', o)
@@ -393,7 +402,13 @@ class FinderTest < ActiveRecord::TestCase
     os = [o] * 3
     assert_equal '1,1,1', bind('?', os)
   end
-  
+
+  def test_named_bind_with_postgresql_type_casts
+    l = Proc.new { bind(":a::integer '2009-01-01'::date", :a => '10') }
+    assert_nothing_raised(&l)
+    assert_equal "#{ActiveRecord::Base.quote_value('10')}::integer '2009-01-01'::date", l.call
+  end
+
   def test_string_sanitation
     assert_not_equal "#{ActiveRecord::Base.connection.quoted_string_prefix}'something ' 1=1'", ActiveRecord::Base.sanitize("something ' 1=1")
     assert_equal "#{ActiveRecord::Base.connection.quoted_string_prefix}'something; select table'", ActiveRecord::Base.sanitize("something; select table")
@@ -419,467 +434,467 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_by_one_attribute_caches_dynamic_finder
     # ensure this test can run independently of order
     class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
-      assert !Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
-      t = Topic.find_by_title("The First Topic")
-      assert Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
+    assert !Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
+    t = Topic.find_by_title("The First Topic")
+    assert Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
+  end
+
+  def test_dynamic_finder_returns_same_results_after_caching
+    # ensure this test can run independently of order
+    class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.public_method_defined?(:find_by_title)
+    t = Topic.find_by_title("The First Topic")
+    assert_equal t, Topic.find_by_title("The First Topic") # find_by_title has been cached
+  end
+
+  def test_find_by_one_attribute_with_order_option
+    assert_equal accounts(:signals37), Account.find_by_credit_limit(50, :order => 'id')
+    assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :order => 'id DESC')
+  end
+
+  def test_find_by_one_attribute_with_conditions
+    assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
+  end
+
+  def test_find_by_one_attribute_that_is_an_aggregate
+    address = customers(:david).address
+    assert_kind_of Address, address
+    found_customer = Customer.find_by_address(address)
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_find_by_one_attribute_that_is_an_aggregate_with_one_attribute_difference
+    address = customers(:david).address
+    assert_kind_of Address, address
+    missing_address = Address.new(address.street, address.city, address.country + "1")
+    assert_nil Customer.find_by_address(missing_address)
+    missing_address = Address.new(address.street, address.city + "1", address.country)
+    assert_nil Customer.find_by_address(missing_address)
+    missing_address = Address.new(address.street + "1", address.city, address.country)
+    assert_nil Customer.find_by_address(missing_address)
+  end
+
+  def test_find_by_two_attributes_that_are_both_aggregates
+    balance = customers(:david).balance
+    address = customers(:david).address
+    assert_kind_of Money, balance
+    assert_kind_of Address, address
+    found_customer = Customer.find_by_balance_and_address(balance, address)
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_find_by_two_attributes_with_one_being_an_aggregate
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customer = Customer.find_by_balance_and_name(balance, customers(:david).name)
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_dynamic_finder_on_one_attribute_with_conditions_caches_method
+    # ensure this test can run independently of order
+    class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
+    assert !Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
+    a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
+    assert Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
+  end
+
+  def test_dynamic_finder_on_one_attribute_with_conditions_returns_same_results_after_caching
+    # ensure this test can run independently of order
+    class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
+    a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
+    assert_equal a, Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6]) # find_by_credit_limit has been cached
+  end
+
+  def test_find_by_one_attribute_with_several_options
+    assert_equal accounts(:unknown), Account.find_by_credit_limit(50, :order => 'id DESC', :conditions => ['id != ?', 3])
+  end
+
+  def test_find_by_one_missing_attribute
+    assert_raises(NoMethodError) { Topic.find_by_undertitle("The First Topic!") }
+  end
+
+  def test_find_by_invalid_method_syntax
+    assert_raises(NoMethodError) { Topic.fail_to_find_by_title("The First Topic") }
+    assert_raises(NoMethodError) { Topic.find_by_title?("The First Topic") }
+    assert_raises(NoMethodError) { Topic.fail_to_find_or_create_by_title("Nonexistent Title") }
+    assert_raises(NoMethodError) { Topic.find_or_create_by_title?("Nonexistent Title") }
+  end
+
+  def test_find_by_two_attributes
+    assert_equal topics(:first), Topic.find_by_title_and_author_name("The First Topic", "David")
+    assert_nil Topic.find_by_title_and_author_name("The First Topic", "Mary")
+  end
+
+  def test_find_all_by_one_attribute
+    topics = Topic.find_all_by_content("Have a nice day")
+    assert_equal 2, topics.size
+    assert topics.include?(topics(:first))
+
+    assert_equal [], Topic.find_all_by_title("The First Topic!!")
+  end
+
+  def test_find_all_by_one_attribute_that_is_an_aggregate
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customers = Customer.find_all_by_balance(balance)
+    assert_equal 1, found_customers.size
+    assert_equal customers(:david), found_customers.first
+  end
+
+  def test_find_all_by_two_attributes_that_are_both_aggregates
+    balance = customers(:david).balance
+    address = customers(:david).address
+    assert_kind_of Money, balance
+    assert_kind_of Address, address
+    found_customers = Customer.find_all_by_balance_and_address(balance, address)
+    assert_equal 1, found_customers.size
+    assert_equal customers(:david), found_customers.first
+  end
+
+  def test_find_all_by_two_attributes_with_one_being_an_aggregate
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customers = Customer.find_all_by_balance_and_name(balance, customers(:david).name)
+    assert_equal 1, found_customers.size
+    assert_equal customers(:david), found_customers.first
+  end
+
+  def test_find_all_by_one_attribute_with_options
+    topics = Topic.find_all_by_content("Have a nice day", :order => "id DESC")
+    assert topics(:first), topics.last
+
+    topics = Topic.find_all_by_content("Have a nice day", :order => "id")
+    assert topics(:first), topics.first
+  end
+
+  def test_find_all_by_array_attribute
+    assert_equal 2, Topic.find_all_by_title(["The First Topic", "The Second Topic of the day"]).size
+  end
+
+  def test_find_all_by_boolean_attribute
+    topics = Topic.find_all_by_approved(false)
+    assert_equal 1, topics.size
+    assert topics.include?(topics(:first))
+
+    topics = Topic.find_all_by_approved(true)
+    assert_equal 3, topics.size
+    assert topics.include?(topics(:second))
+  end
+
+  def test_find_by_nil_attribute
+    topic = Topic.find_by_last_read nil
+    assert_not_nil topic
+    assert_nil topic.last_read
+  end
+
+  def test_find_all_by_nil_attribute
+    topics = Topic.find_all_by_last_read nil
+    assert_equal 3, topics.size
+    assert topics.collect(&:last_read).all?(&:nil?)
+  end
+
+  def test_find_by_nil_and_not_nil_attributes
+    topic = Topic.find_by_last_read_and_author_name nil, "Mary"
+    assert_equal "Mary", topic.author_name
+  end
+
+  def test_find_all_by_nil_and_not_nil_attributes
+    topics = Topic.find_all_by_last_read_and_author_name nil, "Mary"
+    assert_equal 1, topics.size
+    assert_equal "Mary", topics[0].author_name
+  end
+
+  def test_find_or_create_from_one_attribute
+    number_of_companies = Company.count
+    sig38 = Company.find_or_create_by_name("38signals")
+    assert_equal number_of_companies + 1, Company.count
+    assert_equal sig38, Company.find_or_create_by_name("38signals")
+    assert !sig38.new_record?
+  end
+
+  def test_find_or_create_from_two_attributes
+    number_of_topics = Topic.count
+    another = Topic.find_or_create_by_title_and_author_name("Another topic","John")
+    assert_equal number_of_topics + 1, Topic.count
+    assert_equal another, Topic.find_or_create_by_title_and_author_name("Another topic", "John")
+    assert !another.new_record?
+  end
+
+  def test_find_or_create_from_two_attributes_with_one_being_an_aggregate
+    number_of_customers = Customer.count
+    created_customer = Customer.find_or_create_by_balance_and_name(Money.new(123), "Elizabeth")
+    assert_equal number_of_customers + 1, Customer.count
+    assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123), "Elizabeth")
+    assert !created_customer.new_record?
+  end
+
+  def test_find_or_create_from_one_attribute_and_hash
+    number_of_companies = Company.count
+    sig38 = Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
+    assert_equal number_of_companies + 1, Company.count
+    assert_equal sig38, Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
+    assert !sig38.new_record?
+    assert_equal "38signals", sig38.name
+    assert_equal 17, sig38.firm_id
+    assert_equal 23, sig38.client_of
+  end
+
+  def test_find_or_create_from_one_aggregate_attribute
+    number_of_customers = Customer.count
+    created_customer = Customer.find_or_create_by_balance(Money.new(123))
+    assert_equal number_of_customers + 1, Customer.count
+    assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123))
+    assert !created_customer.new_record?
+  end
+
+  def test_find_or_create_from_one_aggregate_attribute_and_hash
+    number_of_customers = Customer.count
+    balance = Money.new(123)
+    name = "Elizabeth"
+    created_customer = Customer.find_or_create_by_balance({:balance => balance, :name => name})
+    assert_equal number_of_customers + 1, Customer.count
+    assert_equal created_customer, Customer.find_or_create_by_balance({:balance => balance, :name => name})
+    assert !created_customer.new_record?
+    assert_equal balance, created_customer.balance
+    assert_equal name, created_customer.name
+  end
+
+  def test_find_or_initialize_from_one_attribute
+    sig38 = Company.find_or_initialize_by_name("38signals")
+    assert_equal "38signals", sig38.name
+    assert sig38.new_record?
+  end
+
+  def test_find_or_initialize_from_one_aggregate_attribute
+    new_customer = Customer.find_or_initialize_by_balance(Money.new(123))
+    assert_equal 123, new_customer.balance.amount
+    assert new_customer.new_record?
+  end
+
+  def test_find_or_initialize_from_one_attribute_should_not_set_attribute_even_when_protected
+    c = Company.find_or_initialize_by_name({:name => "Fortune 1000", :rating => 1000})
+    assert_equal "Fortune 1000", c.name
+    assert_not_equal 1000, c.rating
+    assert c.valid?
+    assert c.new_record?
+  end
+
+  def test_find_or_create_from_one_attribute_should_set_not_attribute_even_when_protected
+    c = Company.find_or_create_by_name({:name => "Fortune 1000", :rating => 1000})
+    assert_equal "Fortune 1000", c.name
+    assert_not_equal 1000, c.rating
+    assert c.valid?
+    assert !c.new_record?
+  end
+
+  def test_find_or_initialize_from_one_attribute_should_set_attribute_even_when_protected
+    c = Company.find_or_initialize_by_name_and_rating("Fortune 1000", 1000)
+    assert_equal "Fortune 1000", c.name
+    assert_equal 1000, c.rating
+    assert c.valid?
+    assert c.new_record?
+  end
+
+  def test_find_or_create_from_one_attribute_should_set_attribute_even_when_protected
+    c = Company.find_or_create_by_name_and_rating("Fortune 1000", 1000)
+    assert_equal "Fortune 1000", c.name
+    assert_equal 1000, c.rating
+    assert c.valid?
+    assert !c.new_record?
+  end
+
+  def test_find_or_initialize_should_set_protected_attributes_if_given_as_block
+    c = Company.find_or_initialize_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
+    assert_equal "Fortune 1000", c.name
+    assert_equal 1000.to_f, c.rating.to_f
+    assert c.valid?
+    assert c.new_record?
+  end
+
+  def test_find_or_create_should_set_protected_attributes_if_given_as_block
+    c = Company.find_or_create_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
+    assert_equal "Fortune 1000", c.name
+    assert_equal 1000.to_f, c.rating.to_f
+    assert c.valid?
+    assert !c.new_record?
+  end
+  
+  def test_dynamic_find_or_initialize_from_one_attribute_caches_method
+    class << Company; self; end.send(:remove_method, :find_or_initialize_by_name) if Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
+    assert !Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
+    sig38 = Company.find_or_initialize_by_name("38signals")
+    assert Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
+  end
+
+  def test_find_or_initialize_from_two_attributes
+    another = Topic.find_or_initialize_by_title_and_author_name("Another topic","John")
+    assert_equal "Another topic", another.title
+    assert_equal "John", another.author_name
+    assert another.new_record?
+  end
+
+  def test_find_or_initialize_from_one_aggregate_attribute_and_one_not
+    new_customer = Customer.find_or_initialize_by_balance_and_name(Money.new(123), "Elizabeth")
+    assert_equal 123, new_customer.balance.amount
+    assert_equal "Elizabeth", new_customer.name
+    assert new_customer.new_record?
+  end
+
+  def test_find_or_initialize_from_one_attribute_and_hash
+    sig38 = Company.find_or_initialize_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
+    assert_equal "38signals", sig38.name
+    assert_equal 17, sig38.firm_id
+    assert_equal 23, sig38.client_of
+    assert sig38.new_record?
+  end
+
+  def test_find_or_initialize_from_one_aggregate_attribute_and_hash
+    balance = Money.new(123)
+    name = "Elizabeth"
+    new_customer = Customer.find_or_initialize_by_balance({:balance => balance, :name => name})
+    assert_equal balance, new_customer.balance
+    assert_equal name, new_customer.name
+    assert new_customer.new_record?
+  end
+
+  def test_find_with_bad_sql
+    assert_raises(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
+  end
+
+  def test_find_with_invalid_params
+    assert_raises(ArgumentError) { Topic.find :first, :join => "It should be `joins'" }
+    assert_raises(ArgumentError) { Topic.find :first, :conditions => '1 = 1', :join => "It should be `joins'" }
+  end
+
+  def test_dynamic_finder_with_invalid_params
+    assert_raises(ArgumentError) { Topic.find_by_title 'No Title', :join => "It should be `joins'" }
+  end
+
+  def test_find_all_with_limit
+    first_five_developers = Developer.find :all, :order => 'id ASC', :limit =>  5
+    assert_equal 5, first_five_developers.length
+    assert_equal 'David', first_five_developers.first.name
+    assert_equal 'fixture_5', first_five_developers.last.name
+
+    no_developers = Developer.find :all, :order => 'id ASC', :limit => 0
+    assert_equal 0, no_developers.length
+  end
+
+  def test_find_all_with_limit_and_offset
+    first_three_developers = Developer.find :all, :order => 'id ASC', :limit => 3, :offset => 0
+    second_three_developers = Developer.find :all, :order => 'id ASC', :limit => 3, :offset => 3
+    last_two_developers = Developer.find :all, :order => 'id ASC', :limit => 2, :offset => 8
+
+    assert_equal 3, first_three_developers.length
+    assert_equal 3, second_three_developers.length
+    assert_equal 2, last_two_developers.length
+
+    assert_equal 'David', first_three_developers.first.name
+    assert_equal 'fixture_4', second_three_developers.first.name
+    assert_equal 'fixture_9', last_two_developers.first.name
+  end
+
+  def test_find_all_with_limit_and_offset_and_multiple_order_clauses
+    first_three_posts = Post.find :all, :order => 'author_id, id', :limit => 3, :offset => 0
+    second_three_posts = Post.find :all, :order => ' author_id,id ', :limit => 3, :offset => 3
+    last_posts = Post.find :all, :order => ' author_id, id  ', :limit => 3, :offset => 6
+
+    assert_equal [[0,3],[1,1],[1,2]], first_three_posts.map { |p| [p.author_id, p.id] }
+    assert_equal [[1,4],[1,5],[1,6]], second_three_posts.map { |p| [p.author_id, p.id] }
+    assert_equal [[2,7]], last_posts.map { |p| [p.author_id, p.id] }
+  end
+
+  def test_find_all_with_join
+    developers_on_project_one = Developer.find(
+      :all,
+      :joins => 'LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id',
+      :conditions => 'project_id=1'
+    )
+    assert_equal 3, developers_on_project_one.length
+    developer_names = developers_on_project_one.map { |d| d.name }
+    assert developer_names.include?('David')
+    assert developer_names.include?('Jamis')
+  end
+
+  def test_joins_dont_clobber_id
+    first = Firm.find(
+      :first,
+      :joins => 'INNER JOIN companies AS clients ON clients.firm_id = companies.id',
+      :conditions => 'companies.id = 1'
+    )
+    assert_equal 1, first.id
+  end
+
+  def test_find_by_id_with_conditions_with_or
+    assert_nothing_raised do
+      Post.find([1,2,3],
+        :conditions => "posts.id <= 3 OR posts.#{QUOTED_TYPE} = 'Post'")
     end
-    
-    def test_dynamic_finder_returns_same_results_after_caching
-      # ensure this test can run independently of order
-      class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.public_method_defined?(:find_by_title)
-        t = Topic.find_by_title("The First Topic")
-        assert_equal t, Topic.find_by_title("The First Topic") # find_by_title has been cached
-      end
-      
-      def test_find_by_one_attribute_with_order_option
-        assert_equal accounts(:signals37), Account.find_by_credit_limit(50, :order => 'id')
-        assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :order => 'id DESC')
-      end
-      
-      def test_find_by_one_attribute_with_conditions
-        assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
-      end
-      
-      def test_find_by_one_attribute_that_is_an_aggregate
-        address = customers(:david).address
-        assert_kind_of Address, address
-        found_customer = Customer.find_by_address(address)
-        assert_equal customers(:david), found_customer
-      end
-      
-      def test_find_by_one_attribute_that_is_an_aggregate_with_one_attribute_difference
-        address = customers(:david).address
-        assert_kind_of Address, address
-        missing_address = Address.new(address.street, address.city, address.country + "1")
-        assert_nil Customer.find_by_address(missing_address)
-        missing_address = Address.new(address.street, address.city + "1", address.country)
-        assert_nil Customer.find_by_address(missing_address)
-        missing_address = Address.new(address.street + "1", address.city, address.country)
-        assert_nil Customer.find_by_address(missing_address)
-      end
-      
-      def test_find_by_two_attributes_that_are_both_aggregates
-        balance = customers(:david).balance
-        address = customers(:david).address
-        assert_kind_of Money, balance
-        assert_kind_of Address, address
-        found_customer = Customer.find_by_balance_and_address(balance, address)
-        assert_equal customers(:david), found_customer
-      end
-      
-      def test_find_by_two_attributes_with_one_being_an_aggregate
-        balance = customers(:david).balance
-        assert_kind_of Money, balance
-        found_customer = Customer.find_by_balance_and_name(balance, customers(:david).name)
-        assert_equal customers(:david), found_customer
+  end
+
+  # http://dev.rubyonrails.org/ticket/6778
+  def test_find_ignores_previously_inserted_record
+    post = Post.create!(:title => 'test', :body => 'it out')
+    assert_equal [], Post.find_all_by_id(nil)
+  end
+
+  def test_find_by_empty_ids
+    assert_equal [], Post.find([])
+  end
+
+  def test_find_by_empty_in_condition
+    assert_equal [], Post.find(:all, :conditions => ['id in (?)', []])
+  end
+
+  def test_find_by_records
+    p1, p2 = Post.find(:all, :limit => 2, :order => 'id asc')
+    assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2]], :order => 'id asc')
+    assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2.id]], :order => 'id asc')
+  end
+
+  def test_select_value
+    assert_equal "37signals", Company.connection.select_value("SELECT name FROM companies WHERE id = 1")
+    assert_nil Company.connection.select_value("SELECT name FROM companies WHERE id = -1")
+    # make sure we didn't break count...
+    assert_equal 0, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = 'Halliburton'")
+    assert_equal 1, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = '37signals'")
+  end
+
+  def test_select_values
+    assert_equal ["1","2","3","4","5","6","7","8","9"], Company.connection.select_values("SELECT id FROM companies ORDER BY id").map! { |i| i.to_s }
+    assert_equal ["37signals","Summit","Microsoft", "Flamboyant Software", "Ex Nihilo", "RailsCore", "Leetsoft", "Jadedpixel", "Odegy"], Company.connection.select_values("SELECT name FROM companies ORDER BY id")
+  end
+
+  def test_select_rows
+    assert_equal(
+      [["1", nil, nil, "37signals"],
+       ["2", "1", "2", "Summit"],
+       ["3", "1", "1", "Microsoft"]],
+      Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}})
+    assert_equal [["1", "37signals"], ["2", "Summit"], ["3", "Microsoft"]],
+      Company.connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}}
+  end
+
+  unless current_adapter?(:IBM_DBAdapter)
+    def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
+      assert_equal 2, Post.find(:all, :include => { :authors => :author_address }, :order => ' author_addresses.id DESC ', :limit => 2).size
+
+      assert_equal 3, Post.find(:all, :include => { :author => :author_address, :authors => :author_address},
+                              :order => ' author_addresses_authors.id DESC ', :limit => 3).size
+    end
+  end 
+
+  def test_with_limiting_with_custom_select
+    posts = Post.find(:all, :include => :author, :select => ' posts.*, authors.id as "author_id"', :limit => 3, :order => 'posts.id')
+    assert_equal 3, posts.size
+    assert_equal [0, 1, 1], posts.map(&:author_id).sort
+  end
+
+  protected
+    def bind(statement, *vars)
+      if vars.first.is_a?(Hash)
+        ActiveRecord::Base.send(:replace_named_bind_variables, statement, vars.first)
+      else
+        ActiveRecord::Base.send(:replace_bind_variables, statement, vars)
       end
-      
-      def test_dynamic_finder_on_one_attribute_with_conditions_caches_method
-        # ensure this test can run independently of order
-        class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
-          assert !Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
-          a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
-          assert Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
-        end
-        
-        def test_dynamic_finder_on_one_attribute_with_conditions_returns_same_results_after_caching
-          # ensure this test can run independently of order
-          class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
-            a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
-            assert_equal a, Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6]) # find_by_credit_limit has been cached
-          end
-          
-          def test_find_by_one_attribute_with_several_options
-            assert_equal accounts(:unknown), Account.find_by_credit_limit(50, :order => 'id DESC', :conditions => ['id != ?', 3])
-          end
-          
-          def test_find_by_one_missing_attribute
-            assert_raises(NoMethodError) { Topic.find_by_undertitle("The First Topic!") }
-          end
-          
-          def test_find_by_invalid_method_syntax
-            assert_raises(NoMethodError) { Topic.fail_to_find_by_title("The First Topic") }
-            assert_raises(NoMethodError) { Topic.find_by_title?("The First Topic") }
-            assert_raises(NoMethodError) { Topic.fail_to_find_or_create_by_title("Nonexistent Title") }
-            assert_raises(NoMethodError) { Topic.find_or_create_by_title?("Nonexistent Title") }
-          end
-          
-          def test_find_by_two_attributes
-            assert_equal topics(:first), Topic.find_by_title_and_author_name("The First Topic", "David")
-            assert_nil Topic.find_by_title_and_author_name("The First Topic", "Mary")
-          end
-          
-          def test_find_all_by_one_attribute
-            topics = Topic.find_all_by_content("Have a nice day")
-            assert_equal 2, topics.size
-            assert topics.include?(topics(:first))
-            
-            assert_equal [], Topic.find_all_by_title("The First Topic!!")
-          end
-          
-          def test_find_all_by_one_attribute_that_is_an_aggregate
-            balance = customers(:david).balance
-            assert_kind_of Money, balance
-            found_customers = Customer.find_all_by_balance(balance)
-            assert_equal 1, found_customers.size
-            assert_equal customers(:david), found_customers.first
-          end
-          
-          def test_find_all_by_two_attributes_that_are_both_aggregates
-            balance = customers(:david).balance
-            address = customers(:david).address
-            assert_kind_of Money, balance
-            assert_kind_of Address, address
-            found_customers = Customer.find_all_by_balance_and_address(balance, address)
-            assert_equal 1, found_customers.size
-            assert_equal customers(:david), found_customers.first
-          end
-          
-          def test_find_all_by_two_attributes_with_one_being_an_aggregate
-            balance = customers(:david).balance
-            assert_kind_of Money, balance
-            found_customers = Customer.find_all_by_balance_and_name(balance, customers(:david).name)
-            assert_equal 1, found_customers.size
-            assert_equal customers(:david), found_customers.first
-          end
-          
-          def test_find_all_by_one_attribute_with_options
-            topics = Topic.find_all_by_content("Have a nice day", :order => "id DESC")
-            assert topics(:first), topics.last
-            
-            topics = Topic.find_all_by_content("Have a nice day", :order => "id")
-            assert topics(:first), topics.first
-          end
-          
-          def test_find_all_by_array_attribute
-            assert_equal 2, Topic.find_all_by_title(["The First Topic", "The Second Topic of the day"]).size
-          end
-          
-          def test_find_all_by_boolean_attribute
-            topics = Topic.find_all_by_approved(false)
-            assert_equal 1, topics.size
-            assert topics.include?(topics(:first))
-            
-            topics = Topic.find_all_by_approved(true)
-            assert_equal 3, topics.size
-            assert topics.include?(topics(:second))
-          end
-          
-          def test_find_by_nil_attribute
-            topic = Topic.find_by_last_read nil
-            assert_not_nil topic
-            assert_nil topic.last_read
-          end
-          
-          def test_find_all_by_nil_attribute
-            topics = Topic.find_all_by_last_read nil
-            assert_equal 3, topics.size
-            assert topics.collect(&:last_read).all?(&:nil?)
-          end
-          
-          def test_find_by_nil_and_not_nil_attributes
-            topic = Topic.find_by_last_read_and_author_name nil, "Mary"
-            assert_equal "Mary", topic.author_name
-          end
-          
-          def test_find_all_by_nil_and_not_nil_attributes
-            topics = Topic.find_all_by_last_read_and_author_name nil, "Mary"
-            assert_equal 1, topics.size
-            assert_equal "Mary", topics[0].author_name
-          end
-          
-          def test_find_or_create_from_one_attribute
-            number_of_companies = Company.count
-            sig38 = Company.find_or_create_by_name("38signals")
-            assert_equal number_of_companies + 1, Company.count
-            assert_equal sig38, Company.find_or_create_by_name("38signals")
-            assert !sig38.new_record?
-          end
-          
-          def test_find_or_create_from_two_attributes
-            number_of_topics = Topic.count
-            another = Topic.find_or_create_by_title_and_author_name("Another topic","John")
-            assert_equal number_of_topics + 1, Topic.count
-            assert_equal another, Topic.find_or_create_by_title_and_author_name("Another topic", "John")
-            assert !another.new_record?
-          end
-          
-          def test_find_or_create_from_two_attributes_with_one_being_an_aggregate
-            number_of_customers = Customer.count
-            created_customer = Customer.find_or_create_by_balance_and_name(Money.new(123), "Elizabeth")
-            assert_equal number_of_customers + 1, Customer.count
-            assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123), "Elizabeth")
-            assert !created_customer.new_record?
-          end
-          
-          def test_find_or_create_from_one_attribute_and_hash
-            number_of_companies = Company.count
-            sig38 = Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
-            assert_equal number_of_companies + 1, Company.count
-            assert_equal sig38, Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
-            assert !sig38.new_record?
-            assert_equal "38signals", sig38.name
-            assert_equal 17, sig38.firm_id
-            assert_equal 23, sig38.client_of
-          end
-          
-          def test_find_or_create_from_one_aggregate_attribute
-            number_of_customers = Customer.count
-            created_customer = Customer.find_or_create_by_balance(Money.new(123))
-            assert_equal number_of_customers + 1, Customer.count
-            assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123))
-            assert !created_customer.new_record?
-          end
-          
-          def test_find_or_create_from_one_aggregate_attribute_and_hash
-            number_of_customers = Customer.count
-            balance = Money.new(123)
-            name = "Elizabeth"
-            created_customer = Customer.find_or_create_by_balance({:balance => balance, :name => name})
-            assert_equal number_of_customers + 1, Customer.count
-            assert_equal created_customer, Customer.find_or_create_by_balance({:balance => balance, :name => name})
-            assert !created_customer.new_record?
-            assert_equal balance, created_customer.balance
-            assert_equal name, created_customer.name
-          end
-          
-          def test_find_or_initialize_from_one_attribute
-            sig38 = Company.find_or_initialize_by_name("38signals")
-            assert_equal "38signals", sig38.name
-            assert sig38.new_record?
-          end
-          
-          def test_find_or_initialize_from_one_aggregate_attribute
-            new_customer = Customer.find_or_initialize_by_balance(Money.new(123))
-            assert_equal 123, new_customer.balance.amount
-            assert new_customer.new_record?
-          end
-          
-          def test_find_or_initialize_from_one_attribute_should_not_set_attribute_even_when_protected
-            c = Company.find_or_initialize_by_name({:name => "Fortune 1000", :rating => 1000})
-            assert_equal "Fortune 1000", c.name
-            assert_not_equal 1000, c.rating
-            assert c.valid?
-            assert c.new_record?
-          end
-          
-          def test_find_or_create_from_one_attribute_should_set_not_attribute_even_when_protected
-            c = Company.find_or_create_by_name({:name => "Fortune 1000", :rating => 1000})
-            assert_equal "Fortune 1000", c.name
-            assert_not_equal 1000, c.rating
-            assert c.valid?
-            assert !c.new_record?
-          end
-          
-          def test_find_or_initialize_from_one_attribute_should_set_attribute_even_when_protected
-            c = Company.find_or_initialize_by_name_and_rating("Fortune 1000", 1000)
-            assert_equal "Fortune 1000", c.name
-            assert_equal 1000, c.rating
-            assert c.valid?
-            assert c.new_record?
-          end
-          
-          def test_find_or_create_from_one_attribute_should_set_attribute_even_when_protected
-            c = Company.find_or_create_by_name_and_rating("Fortune 1000", 1000)
-            assert_equal "Fortune 1000", c.name
-            assert_equal 1000, c.rating
-            assert c.valid?
-            assert !c.new_record?
-          end
-          
-          def test_find_or_initialize_should_set_protected_attributes_if_given_as_block
-            c = Company.find_or_initialize_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
-            assert_equal "Fortune 1000", c.name
-            assert_equal 1000.to_f, c.rating.to_f
-            assert c.valid?
-            assert c.new_record?
-          end
-          
-          def test_find_or_create_should_set_protected_attributes_if_given_as_block
-            c = Company.find_or_create_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
-            assert_equal "Fortune 1000", c.name
-            assert_equal 1000.to_f, c.rating.to_f
-            assert c.valid?
-            assert !c.new_record?
-          end
-          
-          def test_dynamic_find_or_initialize_from_one_attribute_caches_method
-            class << Company; self; end.send(:remove_method, :find_or_initialize_by_name) if Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
-              assert !Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
-              sig38 = Company.find_or_initialize_by_name("38signals")
-              assert Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
-            end
-            
-            def test_find_or_initialize_from_two_attributes
-              another = Topic.find_or_initialize_by_title_and_author_name("Another topic","John")
-              assert_equal "Another topic", another.title
-              assert_equal "John", another.author_name
-              assert another.new_record?
-            end
-            
-            def test_find_or_initialize_from_one_aggregate_attribute_and_one_not
-              new_customer = Customer.find_or_initialize_by_balance_and_name(Money.new(123), "Elizabeth")
-              assert_equal 123, new_customer.balance.amount
-              assert_equal "Elizabeth", new_customer.name
-              assert new_customer.new_record?
-            end
-            
-            def test_find_or_initialize_from_one_attribute_and_hash
-              sig38 = Company.find_or_initialize_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
-              assert_equal "38signals", sig38.name
-              assert_equal 17, sig38.firm_id
-              assert_equal 23, sig38.client_of
-              assert sig38.new_record?
-            end
-            
-            def test_find_or_initialize_from_one_aggregate_attribute_and_hash
-              balance = Money.new(123)
-              name = "Elizabeth"
-              new_customer = Customer.find_or_initialize_by_balance({:balance => balance, :name => name})
-              assert_equal balance, new_customer.balance
-              assert_equal name, new_customer.name
-              assert new_customer.new_record?
-            end
-            
-            def test_find_with_bad_sql
-              assert_raises(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
-            end
-            
-            def test_find_with_invalid_params
-              assert_raises(ArgumentError) { Topic.find :first, :join => "It should be `joins'" }
-              assert_raises(ArgumentError) { Topic.find :first, :conditions => '1 = 1', :join => "It should be `joins'" }
-            end
-            
-            def test_dynamic_finder_with_invalid_params
-              assert_raises(ArgumentError) { Topic.find_by_title 'No Title', :join => "It should be `joins'" }
-            end
-            
-            def test_find_all_with_limit
-              first_five_developers = Developer.find :all, :order => 'id ASC', :limit =>  5
-              assert_equal 5, first_five_developers.length
-              assert_equal 'David', first_five_developers.first.name
-              assert_equal 'fixture_5', first_five_developers.last.name
-              
-              no_developers = Developer.find :all, :order => 'id ASC', :limit => 0
-              assert_equal 0, no_developers.length
-            end
-            
-            def test_find_all_with_limit_and_offset
-              first_three_developers = Developer.find :all, :order => 'id ASC', :limit => 3, :offset => 0
-              second_three_developers = Developer.find :all, :order => 'id ASC', :limit => 3, :offset => 3
-              last_two_developers = Developer.find :all, :order => 'id ASC', :limit => 2, :offset => 8
-              
-              assert_equal 3, first_three_developers.length
-              assert_equal 3, second_three_developers.length
-              assert_equal 2, last_two_developers.length
-              
-              assert_equal 'David', first_three_developers.first.name
-              assert_equal 'fixture_4', second_three_developers.first.name
-              assert_equal 'fixture_9', last_two_developers.first.name
-            end
-            
-            def test_find_all_with_limit_and_offset_and_multiple_order_clauses
-              first_three_posts = Post.find :all, :order => 'author_id, id', :limit => 3, :offset => 0
-              second_three_posts = Post.find :all, :order => ' author_id,id ', :limit => 3, :offset => 3
-              last_posts = Post.find :all, :order => ' author_id, id  ', :limit => 3, :offset => 6
-              
-              assert_equal [[0,3],[1,1],[1,2]], first_three_posts.map { |p| [p.author_id, p.id] }
-              assert_equal [[1,4],[1,5],[1,6]], second_three_posts.map { |p| [p.author_id, p.id] }
-              assert_equal [[2,7]], last_posts.map { |p| [p.author_id, p.id] }
-            end
-            
-            def test_find_all_with_join
-              developers_on_project_one = Developer.find(
-                                                         :all,
-                                                         :joins => 'LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id',
-              :conditions => 'project_id=1'
-              )
-              assert_equal 3, developers_on_project_one.length
-              developer_names = developers_on_project_one.map { |d| d.name }
-              assert developer_names.include?('David')
-              assert developer_names.include?('Jamis')
-            end
-            
-            def test_joins_dont_clobber_id
-              first = Firm.find(
-                                :first,
-                                :joins => 'INNER JOIN companies AS clients ON clients.firm_id = companies.id',
-              :conditions => 'companies.id = 1'
-              )
-              assert_equal 1, first.id
-            end
-            
-            def test_find_by_id_with_conditions_with_or
-              assert_nothing_raised do
-                Post.find([1,2,3],
-                          :conditions => "posts.id <= 3 OR posts.#{QUOTED_TYPE} = 'Post'")
-              end
-            end
-            
-            # http://dev.rubyonrails.org/ticket/6778
-            def test_find_ignores_previously_inserted_record
-              post = Post.create!(:title => 'test', :body => 'it out')
-              assert_equal [], Post.find_all_by_id(nil)
-            end
-            
-            def test_find_by_empty_ids
-              assert_equal [], Post.find([])
-            end
-            
-            def test_find_by_empty_in_condition
-              assert_equal [], Post.find(:all, :conditions => ['id in (?)', []])
-            end
-            
-            def test_find_by_records
-              p1, p2 = Post.find(:all, :limit => 2, :order => 'id asc')
-              assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2]], :order => 'id asc')
-              assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2.id]], :order => 'id asc')
-            end
-            
-            def test_select_value
-              assert_equal "37signals", Company.connection.select_value("SELECT name FROM companies WHERE id = 1")
-              assert_nil Company.connection.select_value("SELECT name FROM companies WHERE id = -1")
-              # make sure we didn't break count...
-              assert_equal 0, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = 'Halliburton'")
-              assert_equal 1, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = '37signals'")
-            end
-            
-            def test_select_values
-              assert_equal ["1","2","3","4","5","6","7","8","9"], Company.connection.select_values("SELECT id FROM companies ORDER BY id").map! { |i| i.to_s }
-              assert_equal ["37signals","Summit","Microsoft", "Flamboyant Software", "Ex Nihilo", "RailsCore", "Leetsoft", "Jadedpixel", "Odegy"], Company.connection.select_values("SELECT name FROM companies ORDER BY id")
-            end
-            
-            def test_select_rows
-              assert_equal(
-                           [["1", nil, nil, "37signals"],
-              ["2", "1", "2", "Summit"],
-              ["3", "1", "1", "Microsoft"]],
-              Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}})
-              assert_equal [["1", "37signals"], ["2", "Summit"], ["3", "Microsoft"]],
-              Company.connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}}
-            end
-            
-            unless current_adapter?(:IBM_DBAdapter) 
-              def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
-                assert_equal 2, Post.find(:all, :include => { :authors => :author_address }, :order => ' author_addresses.id DESC ', :limit => 2).size
-                
-                assert_equal 3, Post.find(:all, :include => { :author => :author_address, :authors => :author_address},
-                :order => ' author_addresses_authors.id DESC ', :limit => 3).size
-              end
-            end 
-            
-            def test_with_limiting_with_custom_select
-              posts = Post.find(:all, :include => :author, :select => ' posts.*, authors.id as "author_id"', :limit => 3, :order => 'posts.id')
-              assert_equal 3, posts.size
-              assert_equal [0, 1, 1], posts.map(&:author_id).sort
-            end
-            
-            protected
-            def bind(statement, *vars)
-              if vars.first.is_a?(Hash)
-                ActiveRecord::Base.send(:replace_named_bind_variables, statement, vars.first)
-              else
-                ActiveRecord::Base.send(:replace_bind_variables, statement, vars)
-              end
-            end
-          end
+    end
+end