ibm_db 0.4.6 → 0.6.0

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -260,13 +260,11 @@ module ActiveRecord
             when /DB2/i   
               case server_info.DBMS_VER
                 when /09/
-              @servertype = IBM_DB2_ZOS.new(@connection, self)
+                  @servertype = IBM_DB2_ZOS.new(@connection, self)
                 when /08/
                   @servertype = IBM_DB2_ZOS_8.new(@connection, self)
-                when /07/
-                  @servertype = IBM_DB2_ZOS_7.new(@connection, self)
                 else
-                  raise "Only DB2 z/OS version 7 and above are currently supported"
+                  raise "Only DB2 z/OS version 8 and above are currently supported"
               end
             # DB2 on i5
             when /AS/i  
@@ -290,7 +288,7 @@ module ActiveRecord
         unless name == @app_user
           option = {IBM_DB::SQL_ATTR_INFO_USERID => "#{name}"}
           if IBM_DB::set_option( @connection, option, 1 )
-            @app_user = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_USERID )
+            @app_user = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_USERID, 1 )
           end
         end
       end
@@ -300,7 +298,7 @@ module ActiveRecord
         unless name == @account
           option = {IBM_DB::SQL_ATTR_INFO_ACCTSTR => "#{name}"}
           if IBM_DB::set_option( @connection, option, 1 )
-            @account = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_ACCTSTR )
+            @account = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_ACCTSTR, 1 )
           end
         end
       end
@@ -310,7 +308,7 @@ module ActiveRecord
         unless name == @application
           option = {IBM_DB::SQL_ATTR_INFO_APPLNAME => "#{name}"}
           if IBM_DB::set_option( @connection, option, 1 )
-            @application = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_APPLNAME )
+            @application = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_APPLNAME, 1 )
           end
         end
       end
@@ -320,14 +318,16 @@ module ActiveRecord
         unless name == @workstation
           option = {IBM_DB::SQL_ATTR_INFO_WRKSTNNAME => "#{name}"}
           if IBM_DB::set_option( @connection, option, 1 )
-            @workstation = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_WRKSTNNAME )
+            @workstation = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_WRKSTNNAME, 1 )
           end
         end
       end
 
       # This adapter supports migrations.
-      # Current limitations: +remove_column+ is not currently supported
-      # while DB2 for zOS does not support +rename_column+
+      # Current limitations:
+      # +rename_column+ is not currently supported by the IBM data servers
+      # +remove_column+ is not currently supported by the DB2 for zOS data server
+      # Tables containing columns of XML data type do not support +remove_column+
       def supports_migrations?
         true
       end
@@ -404,13 +404,7 @@ module ActiveRecord
         # and get a IBM_DB::Statement from which is possible to fetch the results
         if stmt = execute(sql, name)
           begin
-            # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
-            # an hash for each single record.
-            # The loop stops when there aren't any more valid records to fetch
-            while single_hash = IBM_DB::fetch_assoc(stmt)
-              # Add the record to the +results+ array
-              results <<  single_hash
-            end
+            @servertype.select_all(sql, name, stmt, results)
           ensure
             # Ensures to free the resources associated with the statement
             IBM_DB::free_result stmt
@@ -450,20 +444,7 @@ module ActiveRecord
         # Logs and execute the sql instructions.
         # The +log+ method is defined in the parent class +AbstractAdapter+
         log(sql, name) do
-          begin
-            if stmt = IBM_DB::exec(@connection, sql)
-              stmt   # Return the statement object
-            else
-              raise IBM_DB::stmt_errormsg
-            end
-          rescue StandardError
-            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
-            if error_msg && !error_msg.empty?
-              raise "Failed to execute statement due to error: #{error_msg}"
-            else
-              raise
-            end
-          end
+          @servertype.execute(sql, name)
         end
       end
 
@@ -555,16 +536,7 @@ module ActiveRecord
       # Private method used by +add_limit_offset!+ to create a
       # sql query given an offset and a limit
       def query_offset_limit(sql, offset, limit)
-        # Defines what will be the last record
-        last_record = offset + limit
-        # Transforms the SELECT query in order to retrieve/fetch only
-        # a number of records after the specified offset.
-        # 'select' or 'SELECT' is replaced with the partial query below that adds the sys_row_num column
-        # to select with the condition of this column being between offset+1 and the offset+limit
-        sql.gsub!(/SELECT/i,"SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (SELECT")
-        # The final part of the query is appended to include a WHERE...BETWEEN...AND condition,
-        # and retrieve only a LIMIT number of records starting from the OFFSET+1
-        sql << ") AS I) AS O WHERE sys_row_num BETWEEN #{offset+1} AND #{last_record}"
+        @servertype.query_offset_limit(sql, offset, limit)
       end
       private :query_offset_limit
 
@@ -600,7 +572,7 @@ module ActiveRecord
                 "BLOB('?')"
               else
                 # Quoting required for the default value of a column
-                "BLOB('#{value}')"
+                @servertype.set_blob_default(value)
               end
             elsif column && column.type == :text
                 unless caller[0] =~ /add_column_options/i
@@ -678,13 +650,14 @@ module ActiveRecord
         }
       end
 
-      # DB2 does not support limits on the integer and double data types
-      # unlike MySQL. It does support limits on float and decimal/numeric
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil)   
-        if type == :integer && (!limit.nil? && limit > 0)
-          return 'integer'       
-        elsif type == :double && (!limit.nil? && limit > 0)
-          return 'double'
+      # IBM data servers do not support limits on certain data types (unlike MySQL)
+      # Limit is supported for the {float, decimal, numeric, varchar, clob, blob} data types.
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+        return super if limit.nil?
+
+        # strip off limits on data types not supporting them
+        if [:integer, :double, :date, :time, :timestamp, :xml].include? type
+          return type.to_s
         else
           return super
         end
@@ -938,37 +911,54 @@ module ActiveRecord
         @caller = caller
       end
 
-      # Implemented by concrete DataServer if applicable
       def last_generated_id 
       end
 
-      # Implemented by concrete DataServer if applicable
       def create_index_after_table (table_name, caller)
       end
 
-      # Implemented by concrete DataServer if applicable
       def setup_for_lob_table ()
       end
 
-      # Implemented by concrete DataServer if applicable
       def reorg_table(table_name)
       end
 
-      # Implemented by concrete DataServer if applicable
       def check_reserved_words(col_name)
         col_name
       end
 
-      # This is supported by LUW and i5
+      # This is supported by the DB2 for Linux, UNIX, Windows data servers
+      # and by the DB2 for i5 data servers
       def remove_column(table_name, column_name)
-        @caller.execute "ALTER TABLE #{table_name} DROP #{column_name}"
-        reorg_table(table_name)
+        begin
+          @caller.execute "ALTER TABLE #{table_name} DROP #{column_name}"
+          reorg_table(table_name)
+        rescue StandardError => exec_err
+          # Provide details on the current XML columns support
+          if exec_err.message.include?('SQLCODE=-1242') && exec_err.message.include?('42997')
+            raise StatementInvalid, "A column that is part of a table containing an XML column cannot be dropped.  To remove the column, the table must be dropped and recreated without the #{column_name} column: #{exec_err}"
+          else
+            raise
+          end
+        end
       end
 
       def set_schema(schema)
         @caller.execute("SET SCHEMA #{schema}")
       end
 
+      def select_all(sql, name, stmt, results)
+      end
+
+      def execute(sql, name)
+      end
+
+      def query_offset_limit(sql, offset, limit)
+      end
+      
+      def set_blob_default(value)
+        "BLOB('#{value}')"
+      end
     end # class IBM_DataServer
 
     class IBM_DB2 < IBM_DataServer
@@ -1009,6 +999,105 @@ module ActiveRecord
           @caller.change_column_default(table_name, column_name, options[:default])
         end
       end
+
+      # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
+      # an hash for each single record.
+      # The loop stops when there aren't any more valid records to fetch
+      def select_all(sql, name, stmt, results)
+        if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
+          # We know at this point that there is an offset and/or a limit
+          # Check if the cursor type is set correctly
+          cursor_type = IBM_DB::get_option stmt, IBM_DB::SQL_ATTR_CURSOR_TYPE, 0
+          if (cursor_type == IBM_DB::SQL_CURSOR_STATIC)
+            index = 0
+            # Get @limit rows starting at @offset
+            while (index < @limit)
+              # We increment the offset by 1 because for DB2 the offset of the initial row is 1 instead of 0
+              if single_hash = IBM_DB::fetch_assoc(stmt, @offset + index + 1)
+                # Add the record to the +results+ array
+                results <<  single_hash
+                index = index + 1
+              else
+                # break from the while loop
+                break 
+              end
+            end
+          else # cursor != IBM_DB::SQL_CURSOR_STATIC
+            # If the result set contains a LOB, the cursor type will never be SQL_CURSOR_STATIC
+            # because DB2 does not allow this. We can't use the offset mechanism because the cursor 
+            # is not scrollable. In this case, ignore first @offset rows and return rows starting 
+            # at @offset to @offset + @limit
+            index = 0
+            while (index < @offset + @limit)
+              if single_hash = IBM_DB::fetch_assoc(stmt)
+                # Add the record to the +results+ array only from row @offset to @offset + @limit
+                if (index >= @offset)
+                  results <<  single_hash
+                end
+                index = index + 1
+              else
+                # break from the while loop
+                break
+              end
+            end
+          end
+        # This is the case where limit is set to zero
+        # Simply return an empty +results+
+        elsif (!@limit.nil? && @limit == 0)
+          results
+        # No limits or offsets specified
+        else
+          while single_hash = IBM_DB::fetch_assoc(stmt)
+            # Add the record to the +results+ array
+            results <<  single_hash
+          end
+        end
+        # Assign the instance variables to nil. We will not be using them again
+        @offset = nil
+        @limit = nil
+      end
+
+      def execute(sql, name)
+        # Check if there is a limit and/or an offset
+        # If so then make sure and use a static cursor type
+        if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
+          begin
+            # Set the cursor type to static so we can later utilize the offset and limit correctly
+            if stmt = IBM_DB::exec(@connection, sql, {IBM_DB::SQL_ATTR_CURSOR_TYPE => IBM_DB::SQL_CURSOR_STATIC})
+              stmt   # Return the statement object
+            else
+              raise StatementInvalid, IBM_DB::stmt_errormsg
+            end
+          rescue StandardError
+            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+            if error_msg && !error_msg.empty?
+              raise "Failed to execute statement due to error: #{error_msg}"
+            else
+              raise
+            end
+          end
+        else
+          begin
+            if stmt = IBM_DB::exec(@connection, sql)
+              stmt   # Return the statement object
+            else
+              raise StatementInvalid, IBM_DB::stmt_errormsg
+            end
+          rescue StandardError
+            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+            if error_msg && !error_msg.empty?
+              raise "Failed to execute statement due to error: #{error_msg}"
+            else
+              raise
+            end
+          end
+        end
+      end
+
+      def query_offset_limit(sql, offset, limit)
+        @limit = limit
+        @offset = offset
+      end
     end # class IBM_DB2
 
     class IBM_DB2_LUW < IBM_DB2
@@ -1016,6 +1105,46 @@ module ActiveRecord
       def reorg_table(table_name)
         @caller.execute("CALL ADMIN_CMD('REORG TABLE #{table_name}')")
       end
+
+      def select_all(sql, name, stmt, results)
+        # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
+        # an hash for each single record.
+        # The loop stops when there aren't any more valid records to fetch
+        while single_hash = IBM_DB::fetch_assoc(stmt)
+          # Add the record to the +results+ array
+          results <<  single_hash
+        end
+      end
+
+      def execute(sql, name)
+        begin
+          if stmt = IBM_DB::exec(@connection, sql)
+            stmt   # Return the statement object
+          else
+            raise StatementInvalid, IBM_DB::stmt_errormsg
+          end
+        rescue StandardError
+          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          if error_msg && !error_msg.empty?
+            raise "Failed to execute statement due to error: #{error_msg}"
+          else
+            raise
+          end
+        end
+      end
+
+      def query_offset_limit(sql, offset, limit)
+        # Defines what will be the last record
+        last_record = offset + limit
+        # Transforms the SELECT query in order to retrieve/fetch only
+        # a number of records after the specified offset.
+        # 'select' or 'SELECT' is replaced with the partial query below that adds the sys_row_num column
+        # to select with the condition of this column being between offset+1 and the offset+limit
+        sql.gsub!(/SELECT/i,"SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (SELECT")
+        # The final part of the query is appended to include a WHERE...BETWEEN...AND condition,
+        # and retrieve only a LIMIT number of records starting from the OFFSET+1
+        sql << ") AS I) AS O WHERE sys_row_num BETWEEN #{offset+1} AND #{last_record}"
+      end
     end # class IBM_DB2_LUW
 
     module HostedDataServer
@@ -1042,37 +1171,39 @@ module ActiveRecord
         caller.add_index(table_name, "id", :unique => true) 
       end
 
-      # This call is needed on DB2 z/OS v8 and earlier for the creation of tables
-      # with LOBs.  When issued, this call does the following:
-      #   DB2 creates LOB table spaces, auxiliary tables, and indexes on auxiliary
-      #   tables for LOB columns.
-      def setup_for_lob_table()
-        @caller.execute "SET CURRENT RULES = 'STD'"
-      end
-
       def remove_column(table_name, column_name)
-        raise NotImplementedError, "remove_column is not supported for DB2/zOS server"
-      end
+        raise NotImplementedError, "remove_column is not supported by the DB2 for zOS data server"
+      end  
       
-      # Setting the SQLID on z/OS will also update the CURRENT SCHEMA
-      # special register, but not vice versa
-      def set_schema(schema)
-        @caller.execute("SET CURRENT SQLID ='#{schema}'")
+      # DB2 z/OS only allows a "null" or an empty binary string 
+      # as a default for a BLOB column
+      # if value is not empty or equivalent to the string "null",
+      # the server will complain
+      def set_blob_default(value)
+        "#{value}"
       end
-  
     end # class IBM_DB2_ZOS
 
     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)
+        @caller.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:
+      #   DB2 creates LOB table spaces, auxiliary tables, and indexes on auxiliary
+      #   tables for LOB columns.
+      def setup_for_lob_table()
+        @caller.execute "SET CURRENT RULES = 'STD'"
+      end
     end # class IBM_DB2_ZOS_8
     
-    class IBM_DB2_ZOS_7 < IBM_DB2_ZOS
-      include HostedDataServer
-    end # class IBM_DB2_ZOS_7
-
     class IBM_DB2_I5 < IBM_DB2
       include HostedDataServer
     end # class IBM_DB2_I5
 
   end # module ConnectionAdapters
-end # module ActiveRecord
+end # module ActiveRecord

data/test/associations/eager_test.rb

@@ -0,0 +1,445 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+require 'fixtures/company'
+require 'fixtures/person'
+require 'fixtures/reader'
+
+class EagerAssociationTest < Test::Unit::TestCase
+  fixtures :posts, :comments, :authors, :categories, :categories_posts,
+            :companies, :accounts, :tags, :people, :readers
+
+  def test_loading_with_one_association
+    posts = Post.find(:all, :include => :comments)
+    post = posts.find { |p| p.id == 1 }
+    assert_equal 2, post.comments.size
+    assert post.comments.include?(comments(:greetings))
+
+    post = Post.find(:first, :include => :comments, :conditions => "posts.title = 'Welcome to the weblog'")
+    assert_equal 2, post.comments.size
+    assert post.comments.include?(comments(:greetings))
+  end
+
+  def test_loading_conditions_with_or
+    posts = authors(:david).posts.find(:all, :include => :comments, :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE} = 'SpecialComment'")
+    assert_nil posts.detect { |p| p.author_id != authors(:david).id },
+      "expected to find only david's posts"
+  end
+
+  def test_with_ordering
+    list = Post.find(:all, :include => :comments, :order => "posts.id DESC")
+    [:eager_other, :sti_habtm, :sti_post_and_comments, :sti_comments,
+     :authorless, :thinking, :welcome
+    ].each_with_index do |post, index|
+      assert_equal posts(post), list[index]
+    end
+  end
+
+  def test_loading_with_multiple_associations
+    posts = Post.find(:all, :include => [ :comments, :author, :categories ], :order => "posts.id")
+    assert_equal 2, posts.first.comments.size
+    assert_equal 2, posts.first.categories.size
+    assert posts.first.comments.include?(comments(:greetings))
+  end
+
+  def test_loading_from_an_association
+    posts = authors(:david).posts.find(:all, :include => :comments, :order => "posts.id")
+    assert_equal 2, posts.first.comments.size
+  end
+
+  def test_loading_with_no_associations
+    assert_nil Post.find(posts(:authorless).id, :include => :author).author
+  end
+
+  def test_eager_association_loading_with_belongs_to
+    comments = Comment.find(:all, :include => :post)
+    assert_equal 10, comments.length
+    titles = comments.map { |c| c.post.title }
+    assert titles.include?(posts(:welcome).title)
+    assert titles.include?(posts(:sti_post_and_comments).title)
+  end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit
+    comments = Comment.find(:all, :include => :post, :limit => 5, :order => 'comments.id')
+    assert_equal 5, comments.length
+    assert_equal [1,2,3,5,6], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :order => 'comments.id')
+    assert_equal 3, comments.length
+    assert_equal [5,6,7], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset
+    comments = Comment.find(:all, :include => :post, :limit => 3, :offset => 2, :order => 'comments.id')
+    assert_equal 3, comments.length
+    assert_equal [3,5,6], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :offset => 1, :order => 'comments.id')
+    assert_equal 3, comments.length
+    assert_equal [6,7,8], comments.collect { |c| c.id }
+  end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array
+    comments = Comment.find(:all, :include => :post, :conditions => ['post_id = ?',4], :limit => 3, :offset => 1, :order => 'comments.id')
+    assert_equal 3, comments.length
+    assert_equal [6,7,8], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
+    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :order => 'posts.id')
+    assert_equal 1, posts.length
+    assert_equal [1], posts.collect { |p| p.id }
+  end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
+    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id')
+    assert_equal 1, posts.length
+    assert_equal [2], posts.collect { |p| p.id }
+  end
+  
+  def test_eager_with_has_many_through
+    posts_with_comments = people(:michael).posts.find(:all, :include => :comments)
+    posts_with_author = people(:michael).posts.find(:all, :include => :author )
+    posts_with_comments_and_author = people(:michael).posts.find(:all, :include => [ :comments, :author ])
+    assert_equal 2, posts_with_comments.inject(0) { |sum, post| sum += post.comments.size }
+    assert_equal authors(:david), assert_no_queries { posts_with_author.first.author }
+    assert_equal authors(:david), assert_no_queries { posts_with_comments_and_author.first.author }
+  end
+
+  def test_eager_with_has_many_through_an_sti_join_model
+    author = Author.find(:first, :include => :special_post_comments, :order => 'authors.id')
+    assert_equal [comments(:does_it_hurt)], assert_no_queries { author.special_post_comments }
+  end
+  
+  def test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both
+    author = Author.find(:first, :include => :special_nonexistant_post_comments, :order => 'authors.id')
+    assert_equal [], author.special_nonexistant_post_comments
+  end
+
+  def test_eager_with_has_many_through_join_model_with_conditions
+    assert_equal Author.find(:first, :include => :hello_post_comments,
+                             :order => 'authors.id').hello_post_comments.sort_by(&:id),
+                 Author.find(:first, :order => 'authors.id').hello_post_comments.sort_by(&:id)
+  end
+
+  def test_eager_with_has_many_and_limit
+    posts = Post.find(:all, :order => 'posts.id asc', :include => [ :author, :comments ], :limit => 2)
+    assert_equal 2, posts.size
+    assert_equal 3, posts.inject(0) { |sum, post| sum += post.comments.size }
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.body = 'hello'", :order => "posts.id")
+    assert_equal 2, posts.size
+    assert_equal [4,5], posts.collect { |p| p.id }
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions_array
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "posts.body = ?", 'hello' ], :order => "posts.id")
+    assert_equal 2, posts.size
+    assert_equal [4,5], posts.collect { |p| p.id }    
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ])
+    assert_equal 2, posts.size
+    
+    count = Post.count(:include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ])
+    assert_equal count, posts.size
+  end
+
+  def test_eager_with_has_many_and_limit_ond_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
+    posts = Post.count(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => [ "authors.name = ?", 'David' ])
+    assert_equal 0, posts
+  end
+
+  def test_eager_with_has_many_and_limit_with_no_results
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.title = 'magic forest'")
+    assert_equal 0, posts.size
+  end
+
+  def test_eager_with_has_and_belongs_to_many_and_limit
+    posts = Post.find(:all, :include => :categories, :order => "posts.id", :limit => 3)
+    assert_equal 3, posts.size
+    assert_equal 2, posts[0].categories.size
+    assert_equal 1, posts[1].categories.size
+    assert_equal 0, posts[2].categories.size
+    assert posts[0].categories.include?(categories(:technology))
+    assert posts[1].categories.include?(categories(:general))
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions_on_the_eagers
+    posts = authors(:david).posts.find(:all, 
+      :include    => :comments, 
+      :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
+      :limit      => 2
+    )
+    assert_equal 2, posts.size
+    
+    count = Post.count(
+      :include    => [ :comments, :author ], 
+      :conditions => "authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')",
+      :limit      => 2
+    )
+    assert_equal count, posts.size
+  end
+
+  def test_eager_with_has_many_and_limit_and_scoped_conditions_on_the_eagers
+    posts = nil
+    Post.with_scope(:find => {
+      :include    => :comments, 
+      :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'"
+    }) do
+      posts = authors(:david).posts.find(:all, :limit => 2)
+      assert_equal 2, posts.size
+    end
+    
+    Post.with_scope(:find => {
+      :include    => [ :comments, :author ], 
+      :conditions => "authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')"
+    }) do
+      count = Post.count(:limit => 2)
+      assert_equal count, posts.size
+    end
+  end
+
+  def test_eager_with_has_many_and_limit_and_scoped_and_explicit_conditions_on_the_eagers
+    Post.with_scope(:find => { :conditions => "1=1" }) do
+      posts = authors(:david).posts.find(:all, 
+        :include    => :comments, 
+        :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
+        :limit      => 2
+      )
+      assert_equal 2, posts.size
+      
+      count = Post.count(
+        :include    => [ :comments, :author ], 
+        :conditions => "authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')",
+        :limit      => 2
+      )
+      assert_equal count, posts.size
+    end
+  end
+  def test_eager_association_loading_with_habtm
+    posts = Post.find(:all, :include => :categories, :order => "posts.id")
+    assert_equal 2, posts[0].categories.size
+    assert_equal 1, posts[1].categories.size
+    assert_equal 0, posts[2].categories.size
+    assert posts[0].categories.include?(categories(:technology))
+    assert posts[1].categories.include?(categories(:general))
+  end
+
+  def test_eager_with_inheritance
+    posts = SpecialPost.find(:all, :include => [ :comments ])
+  end
+
+  def test_eager_has_one_with_association_inheritance
+    post = Post.find(4, :include => [ :very_special_comment ])
+    assert_equal "VerySpecialComment", post.very_special_comment.class.to_s
+  end
+
+  def test_eager_has_many_with_association_inheritance
+    post = Post.find(4, :include => [ :special_comments ])
+    post.special_comments.each do |special_comment|
+      assert_equal "SpecialComment", special_comment.class.to_s
+    end
+  end
+
+  def test_eager_habtm_with_association_inheritance
+    post = Post.find(6, :include => [ :special_categories ])
+    assert_equal 1, post.special_categories.size
+    post.special_categories.each do |special_category|
+      assert_equal "SpecialCategory", special_category.class.to_s
+    end
+  end
+
+  def test_eager_with_has_one_dependent_does_not_destroy_dependent
+    assert_not_nil companies(:first_firm).account
+    f = Firm.find(:first, :include => :account,
+            :conditions => ["companies.name = ?", "37signals"])
+    assert_not_nil f.account
+    assert_equal companies(:first_firm, :reload).account, f.account
+  end
+
+  def test_eager_with_invalid_association_reference
+    assert_raises(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") {
+      post = Post.find(6, :include=>[ :monkeys ])
+    }
+    assert_raises(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") {
+      post = Post.find(6, :include=>[ :monkeys, :elephants ])
+    }
+  end
+  
+  def find_all_ordered(className, include=nil)
+    className.find(:all, :order=>"#{className.table_name}.#{className.primary_key}", :include=>include)
+  end
+  
+  def test_limited_eager_with_order
+    unless current_adapter?(:IBM_DBAdapter)
+      assert_equal [posts(:thinking), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title)', :limit => 2, :offset => 1)
+      assert_equal [posts(:sti_post_and_comments), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title) DESC', :limit => 2, :offset => 1)
+    else
+      # LUW:     [IBM][CLI Driver][DB2/LINUX] SQL0214N  
+      # An expression in the ORDER BY clause in the following position, 
+      # or starting with "UPPER..." in the "ORDER BY" clause is not valid.  
+      # Reason code = "2".  SQLSTATE=42822 SQLCODE=-214: 
+      #     SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num 
+      #       FROM (SELECT DISTINCT posts.id FROM posts  
+      #       LEFT OUTER JOIN authors ON authors.id = posts.author_id  
+      #       LEFT OUTER JOIN comments ON comments.post_id = posts.id 
+      #       WHERE (authors.name = 'David') 
+      #       ORDER BY UPPER(posts.title)) AS I) AS O WHERE sys_row_num BETWEEN 2 AND 3
+      # 
+      # i5:      ActiveRecord::RecordNotFound: Couldn't find Post with ID=2
+      # 
+      # zOS v9:  ActiveRecord::RecordNotFound: Couldn't find Post with ID=2
+      # 
+    end
+  end
+  
+  def test_limited_eager_with_multiple_order_columns
+    unless current_adapter?(:IBM_DBAdapter)
+      assert_equal [posts(:thinking), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title), posts.id', :limit => 2, :offset => 1)
+      assert_equal [posts(:sti_post_and_comments), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title) DESC, posts.id', :limit => 2, :offset => 1)
+    else
+      # LUW:   [IBM][CLI Driver][DB2/LINUX] SQL0214N  
+      # An expression in the ORDER BY clause in the following position, 
+      # or starting with "UPPER..." in the "ORDER BY" clause is not valid.  
+      # Reason code = "2".  SQLSTATE=42822 SQLCODE=-214: 
+      #   SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num 
+      #     FROM (SELECT DISTINCT posts.id FROM posts  
+      #     LEFT OUTER JOIN authors ON authors.id = posts.author_id  
+      #     LEFT OUTER JOIN comments ON comments.post_id = posts.id 
+      #       WHERE (authors.name = 'David') 
+      #       ORDER BY UPPER(posts.title), posts.id) AS I) AS O WHERE sys_row_num BETWEEN 2 AND 3
+      # 
+      # i5:    [IBM][CLI Driver][AS] SQL0214N  
+      # An expression in the ORDER BY clause in the following position, 
+      # or starting with "1" in the "   OBY0002" clause is not valid.  
+      # Reason code = "2".  SQLSTATE=42822 SQLCODE=-214:
+      #   SELECT DISTINCT posts.id FROM posts  
+      #     LEFT OUTER JOIN authors ON authors.id = posts.author_id  
+      #     LEFT OUTER JOIN comments ON comments.post_id = posts.id 
+      #       WHERE (authors.name = 'David') 
+      #       ORDER BY UPPER(posts.title), posts.id
+      # 
+      # zOS 9: [IBM][CLI Driver][DB2] SQL0214N  
+      # An expression in the ORDER BY clause in the following position, 
+      # or starting with "1" in the "ORDER BY" clause is not valid.  
+      # Reason code = "2".  SQLSTATE=42822 SQLCODE=-214: 
+      #   SELECT DISTINCT posts.id FROM posts  
+      #     LEFT OUTER JOIN authors ON authors.id = posts.author_id  
+      #     LEFT OUTER JOIN comments ON comments.post_id = posts.id 
+      #       WHERE (authors.name = 'David') 
+      #       ORDER BY UPPER(posts.title), posts.id
+      # 
+    end
+  end
+
+  def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
+    # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
+    def assert_equal_after_sort(item1, item2, item3 = nil)
+      assert_equal(item1.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id})
+      assert_equal(item3.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id}) if item3
+    end
+    # Test regular association, association with conditions, association with
+    # STI, and association with conditions assured not to be true
+    post_types = [:posts, :other_posts, :special_posts]
+    # test both has_many and has_and_belongs_to_many
+    [Author, Category].each do |className|
+      d1 = find_all_ordered(className)
+      # test including all post types at once
+      d2 = find_all_ordered(className, post_types) 
+      d1.each_index do |i| 
+        assert_equal(d1[i], d2[i])
+        assert_equal_after_sort(d1[i].posts, d2[i].posts)
+        post_types[1..-1].each do |post_type|
+          # test including post_types together
+          d3 = find_all_ordered(className, [:posts, post_type])
+          assert_equal(d1[i], d3[i])
+          assert_equal_after_sort(d1[i].posts, d3[i].posts)
+          assert_equal_after_sort(d1[i].send(post_type), d2[i].send(post_type), d3[i].send(post_type))
+        end
+      end
+    end
+  end
+  
+  def test_eager_with_multiple_associations_with_same_table_has_one
+    d1 = find_all_ordered(Firm)
+    d2 = find_all_ordered(Firm, :account)
+    d1.each_index do |i| 
+      assert_equal(d1[i], d2[i])
+      assert_equal(d1[i].account, d2[i].account)
+    end
+  end
+  
+  def test_eager_with_multiple_associations_with_same_table_belongs_to
+    firm_types = [:firm, :firm_with_basic_id, :firm_with_other_name, :firm_with_condition]
+    d1 = find_all_ordered(Client)
+    d2 = find_all_ordered(Client, firm_types)
+    d1.each_index do |i| 
+      assert_equal(d1[i], d2[i])
+      firm_types.each { |type| assert_equal(d1[i].send(type), d2[i].send(type)) }
+    end
+  end
+  def test_eager_with_valid_association_as_string_not_symbol
+    assert_nothing_raised { Post.find(:all, :include => 'comments') }
+  end
+
+  def test_preconfigured_includes_with_belongs_to
+    author = posts(:welcome).author_with_posts
+    assert_equal 5, author.posts.size
+  end
+
+  def test_preconfigured_includes_with_has_one
+    comment = posts(:sti_comments).very_special_comment_with_post
+    assert_equal posts(:sti_comments), comment.post
+  end
+
+  def test_preconfigured_includes_with_has_many
+    posts = authors(:david).posts_with_comments
+    one = posts.detect { |p| p.id == 1 }
+    assert_equal 5, posts.size
+    assert_equal 2, one.comments.size
+  end
+
+  def test_preconfigured_includes_with_habtm
+    posts = authors(:david).posts_with_categories
+    one = posts.detect { |p| p.id == 1 }
+    assert_equal 5, posts.size
+    assert_equal 2, one.categories.size
+  end
+
+  def test_preconfigured_includes_with_has_many_and_habtm
+    posts = authors(:david).posts_with_comments_and_categories
+    one = posts.detect { |p| p.id == 1 }
+    assert_equal 5, posts.size
+    assert_equal 2, one.comments.size
+    assert_equal 2, one.categories.size
+  end
+  
+  def test_count_with_include
+    if current_adapter?(:SQLServerAdapter, :SybaseAdapter)
+      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "len(comments.body) > 15")
+    else
+      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "length(comments.body) > 15")
+    end
+  end
+end