ibm_db 1.0.2 → 1.0.5

data/CHANGES

@@ -1,5 +1,13 @@
 Change Log
 ==============
+2009/03/24 (IBM_DB adapter 1.0.5, driver 1.0.5) :
+  - Support for Ruby-1.9.1
+  - Support for SQLRowcount in driver
+  - Support for Activerecord-2.3.2 [test suite updated]
+  - Fixed bug [24663] --> Fixed pre-mature clearing of the sql array in handle_lobs
+  - Fixed bug [23115] --> Fixed truncation of a nested query during update
+  - Fixed wrong setting of SQLID for schema on zOS 8 dataserver when schema is explicitly specified.
+  
 2009/03/06 (IBM_DB adapter 1.0.2, driver 1.0.1) :
   - Support for specifying connection timeout in adapter
   - Fixed Bug [23317] --> Fixed assumption of id as the primary key while updation/insertion of lob fields

data/README

@@ -1,5 +1,5 @@
 =====================================================================
-README for the IBM_DB Adapter (1.0.2) and Driver (1.0.1) (2009/03/06)
+README for the IBM_DB Adapter (1.0.5) and Driver (1.0.5) (2009/03/24)
 For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 

data/ext/ibm_db.c

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   |  Licensed Materials - Property of IBM                                |
   |                                                                      |
-  | (C) Copyright IBM Corporation 2006, 2007,2008                            |
+  | (C) Copyright IBM Corporation 2006, 2007,2008, 2009                  |
   +----------------------------------------------------------------------+
   | Authors: Sushant Koduru, Lynh Nguyen, Kanchana Padmanabhan,          |
   |          Dan Scott, Helmut Tessarek, Sam Ruby, Kellen Bombardier,    |
@@ -12,7 +12,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "1.0.1"
+#define MODULE_RELEASE "1.0.5"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -579,6 +579,10 @@ void ruby_init_ibm_db()
   rb_define_const(mDB, "SQL_ATTR_INFO_APPLNAME", INT2NUM(SQL_ATTR_INFO_APPLNAME));
   /* String used to identify the client accounting string sent to the host database */
   rb_define_const(mDB, "SQL_ATTR_INFO_ACCTSTR", INT2NUM(SQL_ATTR_INFO_ACCTSTR));
+  /* Enabling Prefetching of Rowcount - Available from V95FP3 onwards */
+  rb_define_const(mDB, "SQL_ATTR_ROWCOUNT_PREFETCH", INT2NUM(SQL_ATTR_ROWCOUNT_PREFETCH));
+  rb_define_const(mDB, "SQL_ROWCOUNT_PREFETCH_ON", INT2NUM(SQL_ROWCOUNT_PREFETCH_ON));
+  rb_define_const(mDB, "SQL_ROWCOUNT_PREFETCH_OFF", INT2NUM(SQL_ROWCOUNT_PREFETCH_OFF));
   rb_global_variable(&persistent_list);
 
   /* REGISTER_INI_ENTRIES(); */
@@ -831,7 +835,7 @@ static int _ruby_ibm_db_parse_options ( VALUE options, int type, void *handle )
 
   if ( !NIL_P(options) ) {
     keys = rb_funcall(options, id_keys, 0);
-    numOpts = RARRAY(keys)->len;
+    numOpts = RARRAY_LEN(keys);
 
     for ( i = 0; i < numOpts; i++) {
       key = rb_ary_entry(keys,i);
@@ -3140,11 +3144,10 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
     Data_Get_Struct(stmt, stmt_handle, stmt_res);
     if ( stmt_res->hstmt ) {
       /* Free any cursors that might have been allocated in a previous call to SQLExecute */
-      rc = SQLFreeHandle( SQL_HANDLE_STMT, stmt_res->hstmt);
+      rc = SQLFreeStmt( stmt_res->hstmt, SQL_CLOSE);
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors(stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1);
       }
-      stmt_res->hstmt = 0;
     }
     _ruby_ibm_db_free_result_struct(stmt_res);
   } else {
@@ -3653,7 +3656,7 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
           return Qfalse;
         }
 
-        numOpts = RARRAY(parameters_array)->len;
+        numOpts = RARRAY_LEN(parameters_array);
 
         if (numOpts > num) {
           /* More are passed in -- Warning - Use the max number present */

data/ext/ruby_ibm_db.h

@@ -2,10 +2,11 @@
   +----------------------------------------------------------------------+
   |  Licensed Materials - Property of IBM                                |
   |                                                                      |
-  | (C) Copyright IBM Corporation 2006, 2007.                            |
+  | (C) Copyright IBM Corporation 2006, 2007, 2008, 2009                 |
   +----------------------------------------------------------------------+
   | Authors: Sushant Koduru, Lynh Nguyen, Kanchana Padmanabhan,          |
   |          Dan Scott, Helmut Tessarek, Kellen Bombardier, Sam Ruby     |
+  |          Ambrish Bhargava, Tarun Pasrija                             |
   +----------------------------------------------------------------------+
 */
 
@@ -26,6 +27,13 @@
 #define SQL_DECFLOAT -360
 #endif
 
+/* needed for backward compatibility (SQL_ATTR_ROWCOUNT_PREFETCH not defined prior to DB2 9.5.0.3) */
+#ifndef SQL_ATTR_ROWCOUNT_PREFETCH
+#define SQL_ATTR_ROWCOUNT_PREFETCH 2592
+#define SQL_ROWCOUNT_PREFETCH_OFF   0
+#define SQL_ROWCOUNT_PREFETCH_ON    1
+#endif
+
 /* SQL_ATTR_USE_TRUSTED_CONTEXT,
  * SQL_ATTR_TRUSTED_CONTEXT_USERID and
  * SQL_ATTR_TRUSTED_CONTEXT_PASSWORD

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -86,7 +86,7 @@ module ActiveRecord
             end
           end # if clob_sql
         end #connection.sql.each
-        connection.sql = []
+        connection.handle_lobs_triggered = true
       end # if connection.kind_of?
     end # handle_lobs
     private :handle_lobs
@@ -362,7 +362,7 @@ module ActiveRecord
         if options[:limit]
           column.limit   = options[:limit]
         elsif @base.native_database_types[type.to_sym]
-          column.limit   = @base.native_database_types[type.to_sym][:limit]
+          column.limit   = @base.native_database_types[type.to_sym][:limit] if @base.native_database_types[type.to_sym].has_key? :limit
         end
 
         unless @columns.include? column
@@ -400,7 +400,7 @@ module ActiveRecord
     # 
     class IBM_DBAdapter < AbstractAdapter
       attr_reader :connection, :servertype
-      attr_accessor :sql
+      attr_accessor :sql,:handle_lobs_triggered
       attr_reader :schema, :app_user, :account, :application, :workstation
 
       # Name of the adapter
@@ -431,6 +431,7 @@ module ActiveRecord
         @workstation      = conn_options[:workstation]  if conn_options.has_key?(:workstation)
         
         @sql = []
+        @handle_lobs_triggered = false
 
         # Calls the parent class +ConnectionAdapters+' initializer
         # which sets @connection, @logger, @runtime and @last_verification
@@ -674,8 +675,9 @@ module ActiveRecord
         column_list = columns(table_name)
         fixture.each do |item|
           col = nil
-          column_list.each do |col|
-            if col.name == item.at(0)
+          column_list.each do |column|
+            if column.name.downcase == item.at(0).downcase
+              col= column
               break
             end
           end
@@ -723,6 +725,11 @@ module ActiveRecord
       # This can be the ID passed to the method or the one auto-generated by the database,
       # and retrieved by the +last_generated_id+ method.
       def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
+          @sql = []
+          @handle_lobs_triggered = false
+        end
+        
         if stmt = execute(sql, name)
           begin
             @sql << sql
@@ -746,11 +753,24 @@ module ActiveRecord
 
       # Executes an "UPDATE" SQL statement
       def update(sql, name = nil)
+        if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
+          @sql = []
+          @handle_lobs_triggered = false
+        end
+        
         # Make sure the WHERE clause handles NULL's correctly
         sqlarray = sql.split(/\s*WHERE\s*/)
-        if !sqlarray[1].nil?
-          sqlarray[1].gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
-          sql = sqlarray[0] + " WHERE " + sqlarray[1]
+        size = sqlarray.size
+        if size > 1
+          sql = sqlarray[0] + " WHERE "
+          if size > 2
+            1.upto size-2 do |index|
+              sqlarray[index].gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" ) unless sqlarray[index].nil?
+              sql = sql + sqlarray[index] + " WHERE "
+            end
+          end
+          sqlarray[size-1].gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" ) unless sqlarray[size-1].nil?
+          sql = sql + sqlarray[size-1]
         end
 
         # Logs and execute the given sql query.
@@ -927,7 +947,7 @@ module ActiveRecord
       # database types
       def native_database_types
         {
-          :primary_key => @servertype.primary_key,
+          :primary_key => { :name => @servertype.primary_key},
           :string      => { :name => "varchar", :limit => 255 },
           :text        => { :name => "clob" },
           :integer     => { :name => "integer" },
@@ -1034,7 +1054,7 @@ module ActiveRecord
             while ( pk_index_row = IBM_DB.fetch_array(stmt) )
               if pk_index_row[5] 
                 pk_index_name = pk_index_row[5].downcase
-                pk_index_columns = pk_index_row[3].map{|c| c.downcase}           # COLUMN_NAME
+                pk_index_columns = [pk_index_row[3].downcase]           # COLUMN_NAME
                 if pk_index 
                   pk_index.columns = pk_index.columns + pk_index_columns
                 else
@@ -1070,7 +1090,7 @@ module ActiveRecord
             if index_stats[5]             # INDEX_NAME
               index_name = index_stats[5].downcase
               index_unique = (index_stats[3] == 0)
-              index_columns = index_stats[8].map{|c| c.downcase}     # COLUMN_NAME
+              index_columns = [index_stats[8].downcase]     # COLUMN_NAME
               index_qualifier = index_stats[4].downcase             #Index_Qualifier
               # Create an IndexDefinition object and add to the indexes array
               i = 0;
@@ -1228,6 +1248,7 @@ module ActiveRecord
         @servertype.change_column(table_name, column_name, type, options)
       end
 
+=begin
       #overrides the abstract adapter method to generate proper sql
       #specifying the column options, like default value and nullability clause
       def add_column_options!(sql,options={})
@@ -1251,6 +1272,7 @@ module ActiveRecord
           end
         end   
       end
+=end
       
       # Sets a new default value for a column. This does not set the default
       # value to +NULL+, instead, it needs DatabaseStatements#execute which
@@ -1764,11 +1786,6 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
 
     class IBM_DB2_ZOS_8 < IBM_DB2_ZOS
       include HostedDataServer
-      # Setting the SQLID on z/OS will also update the CURRENT SCHEMA
-      # special register, but not vice versa
-      def set_schema(schema)
-        execute("SET CURRENT SQLID ='#{schema.upcase}'")
-      end
       
       # This call is needed on DB2 z/OS v8 for the creation of tables
       # with LOBs.  When issued, this call does the following:

data/test/cases/associations/cascaded_eager_loading_test.rb

@@ -106,6 +106,14 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
       authors.first.posts.first.special_comments.first.post.very_special_comment
     end
   end
+  
+  def test_eager_association_loading_where_first_level_returns_nil
+    authors = Author.find(:all, :include => {:post_about_thinking => :comments}, :order => 'authors.id DESC')
+    assert_equal [authors(:mary), authors(:david)], authors
+    assert_no_queries do
+      authors[1].post_about_thinking.comments.first
+    end
+  end
 end
 
 require 'models/vertex'

data/test/cases/associations/eager_test.rb

@@ -1,6 +1,7 @@
 require "cases/helper"
 require 'models/post'
 require 'models/tagging'
+require 'models/tag'
 require 'models/comment'
 require 'models/author'
 require 'models/category'
@@ -145,7 +146,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_finding_with_includes_on_null_belongs_to_association_with_same_include_includes_only_once
     post = posts(:welcome)
     post.update_attributes!(:author => nil)
-    post = assert_queries(2) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author which is null so no query for the address
+    post = assert_queries(1) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author which is null so no query for the author or address
     assert_no_queries do
       assert_equal nil, post.author_with_address
     end
@@ -387,12 +388,28 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal count, posts.size
   end
 
-  def test_eager_with_has_many_and_limit_ond_high_offset
+  def test_eager_with_has_many_and_limit_and_high_offset
     posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => [ "authors.name = ?", 'David' ])
     assert_equal 0, posts.size
   end
 
-  def test_count_eager_with_has_many_and_limit_ond_high_offset
+  def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions
+    assert_queries(1) do
+      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
+        :conditions => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ])
+      assert_equal 0, posts.size
+    end
+  end
+
+  def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
+    assert_queries(1) do
+      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
+        :conditions => { 'authors.name' => 'David', 'comments.body' => 'go crazy' })
+      assert_equal 0, posts.size
+    end
+  end
+
+  def test_count_eager_with_has_many_and_limit_and_high_offset
     posts = Post.count(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => [ "authors.name = ?", 'David' ])
     assert_equal 0, posts
   end
@@ -534,16 +551,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_invalid_association_reference
-    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       post = Post.find(6, :include=> :monkeys )
     }
-    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       post = Post.find(6, :include=>[ :monkeys ])
     }
-    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       post = Post.find(6, :include=>[ 'monkeys' ])
     }
-    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
+    assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
       post = Post.find(6, :include=>[ :monkeys, :elephants ])
     }
   end
@@ -694,5 +711,120 @@ class EagerAssociationTest < ActiveRecord::TestCase
     def test_order_on_join_table_with_include_and_limit
       assert_equal 5, Developer.find(:all, :include => 'projects', :order => 'developers_projects.joined_on DESC', :limit => 5).size
     end
-  end 
+  end
+  
+  def test_eager_loading_with_order_on_joined_table_preloads
+    posts = assert_queries(2) do
+      Post.find(:all, :joins => :comments, :include => :author, :order => 'comments.id DESC')
+    end
+    assert_equal posts(:eager_other), posts[0]
+    assert_equal authors(:mary), assert_no_queries { posts[0].author}
+  end
+
+  def test_eager_loading_with_conditions_on_joined_table_preloads
+    posts = assert_queries(2) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+
+    posts = assert_queries(2) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+
+    posts = assert_queries(2) do
+      Post.find(:all, :include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id')
+    end
+    assert_equal posts(:welcome, :thinking), posts
+
+    posts = assert_queries(2) do
+      Post.find(:all, :include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id')
+    end
+    assert_equal posts(:welcome, :thinking), posts
+
+  end
+
+  def test_eager_loading_with_conditions_on_string_joined_table_preloads
+    posts = assert_queries(2) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+
+    posts = assert_queries(2) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+
+  end
+
+  def test_eager_loading_with_select_on_joined_table_preloads
+    posts = assert_queries(2) do
+      Post.find(:all, :select => 'posts.*, authors.name as author_name', :include => :comments, :joins => :author, :order => 'posts.id')
+    end
+    assert_equal 'David', posts[0].author_name
+    assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments}
+  end
+
+  def test_eager_loading_with_conditions_on_join_model_preloads
+    authors = assert_queries(2) do
+      Author.find(:all, :include => :author_address, :joins => :comments, :conditions => "posts.title like 'Welcome%'")
+    end
+    assert_equal authors(:david), authors[0]
+    assert_equal author_addresses(:david_address), authors[0].author_address
+  end
+
+  def test_preload_belongs_to_uses_exclusive_scope
+    people = Person.males.find(:all, :include => :primary_contact)
+    assert_not_equal people.length, 0
+    people.each do |person|
+      assert_no_queries {assert_not_nil person.primary_contact}
+      assert_equal Person.find(person.id).primary_contact, person.primary_contact
+    end
+  end
+
+  def test_preload_has_many_uses_exclusive_scope
+    people = Person.males.find :all, :include => :agents
+    people.each do |person|
+      assert_equal Person.find(person.id).agents, person.agents
+    end
+  end
+
+  def test_preload_has_many_using_primary_key
+    expected = Firm.find(:first).clients_using_primary_key.to_a
+    firm = Firm.find :first, :include => :clients_using_primary_key
+    assert_no_queries do
+      assert_equal expected, firm.clients_using_primary_key
+    end
+  end
+
+  def test_include_has_many_using_primary_key
+    expected = Firm.find(1).clients_using_primary_key.sort_by &:name
+    firm = Firm.find 1, :include => :clients_using_primary_key, :order => 'clients_using_primary_keys_companies.name'
+    assert_no_queries do
+      assert_equal expected, firm.clients_using_primary_key
+    end
+  end
+  
+  def test_preload_has_one_using_primary_key
+    expected = Firm.find(:first).account_using_primary_key
+    firm = Firm.find :first, :include => :account_using_primary_key
+    assert_no_queries do
+      assert_equal expected, firm.account_using_primary_key
+    end
+  end
+
+  unless current_adapter?(:IBM_DBAdapter)
+    def test_include_has_one_using_primary_key
+      expected = Firm.find(1).account_using_primary_key
+      firm = Firm.find(:all, :include => :account_using_primary_key, :order => 'accounts.id').detect {|f| f.id == 1}
+      assert_no_queries do
+        assert_equal expected, firm.account_using_primary_key
+      end
+    end
+  end
+  
 end

data/test/cases/associations/has_and_belongs_to_many_associations_test.rb

@@ -429,6 +429,33 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_date_from_db Date.new(2004, 10, 10), Developer.find(1).projects.first.joined_on.to_date
   end
 
+  def test_destroying
+    david = Developer.find(1)
+    active_record = Project.find(1)
+    david.projects.reload
+    assert_equal 2, david.projects.size
+    assert_equal 3, active_record.developers.size
+
+    assert_difference "Project.count", -1 do
+      david.projects.destroy(active_record)
+    end
+
+    assert_equal 1, david.reload.projects.size
+    assert_equal 1, david.projects(true).size
+  end
+
+  def test_destroying_array
+    david = Developer.find(1)
+    david.projects.reload
+
+    assert_difference "Project.count", -Project.count do
+      david.projects.destroy(Project.find(:all))
+    end
+
+    assert_equal 0, david.reload.projects.size
+    assert_equal 0, david.projects(true).size
+  end
+
   def test_destroy_all
     david = Developer.find(1)
     david.projects.reload
@@ -664,7 +691,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_updating_attributes_on_rich_associations
     david = projects(:action_controller).developers.first
     david.name = "DHH"
-    assert_raises(ActiveRecord::ReadOnlyRecord) { david.save! }
+    assert_raise(ActiveRecord::ReadOnlyRecord) { david.save! }
   end
 
   def test_updating_attributes_on_rich_associations_with_limited_find_from_reflection
@@ -706,6 +733,11 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, categories(:technology).posts_gruoped_by_title.size
   end
 
+  def test_find_scoped_grouped_having
+    assert_equal 2, projects(:active_record).well_payed_salary_groups.size
+    assert projects(:active_record).well_payed_salary_groups.all? { |g| g.salary > 10000 }
+  end
+
   def test_get_ids
     assert_equal projects(:active_record, :action_controller).map(&:id).sort, developers(:david).project_ids.sort
     assert_equal [projects(:active_record).id], developers(:jamis).project_ids
@@ -785,41 +817,58 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal developer, project.developers.find(:first)
     assert_equal project, developer.projects.find(:first)
   end
+  
+  def test_self_referential_habtm_without_foreign_key_set_should_raise_exception
+    assert_raise(ActiveRecord::HasAndBelongsToManyAssociationForeignKeyNeeded) {
+      Member.class_eval do
+        has_and_belongs_to_many :friends, :class_name => "Member", :join_table => "member_friends"
+      end
+    }
+  end
 
-  unless current_adapter?(:IBM_DBAdapter)#refer SQL0214N
+  unless current_adapter?(:IBM_DBAdapter) #refer SQL214n
     def test_dynamic_find_should_respect_association_include
       # SQL error in sort clause if :include is not included
       # due to Unknown column 'authors.id'
       assert Category.find(1).posts_with_authors_sorted_by_author_id.find_by_title('Welcome to the weblog')
     end
-    
-    def test_counting_on_habtm_association_and_not_array
-      david = Developer.find(1)
-      # Extra parameter just to make sure we aren't falling back to
-      # Array#count in Ruby >=1.8.7, which would raise an ArgumentError
-      assert_nothing_raised { david.projects.count(:all, :conditions => '1=1') }
-    end
+  end
 
-    def test_count
-      david = Developer.find(1)
-      assert_equal 2, david.projects.count
-    end
+  def test_counting_on_habtm_association_and_not_array
+    david = Developer.find(1)
+    # Extra parameter just to make sure we aren't falling back to
+    # Array#count in Ruby >=1.8.7, which would raise an ArgumentError
+    assert_nothing_raised { david.projects.count(:all, :conditions => '1=1') }
+  end
+
+  def test_count
+    david = Developer.find(1)
+    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
+  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
+
+  def test_association_proxy_transaction_method_starts_transaction_in_association_class
+    Post.expects(:transaction)
+    Category.find(:first).posts.transaction do
+      # nothing
     end
+  end
 
-    uses_mocha 'mocking Post.transaction' do
-      def test_association_proxy_transaction_method_starts_transaction_in_association_class
-        Post.expects(:transaction)
-        Category.find(:first).posts.transaction do
-          # nothing
-        end
-      end
-    end 
+  def test_caching_of_columns
+    david = Developer.find(1)
+    # clear cache possibly created by other tests
+    david.projects.reset_column_information
+    assert_queries(0) { david.projects.columns; david.projects.columns }
+    # and again to verify that reset_column_information clears the cache correctly
+    david.projects.reset_column_information
+    assert_queries(0) { david.projects.columns; david.projects.columns }
   end
-end
+
+end