ibm_db 0.10.0 → 1.0.0

data/test/cases/migration_test.rb

@@ -3,6 +3,7 @@ require 'bigdecimal/util'
 
 require 'models/person'
 require 'models/topic'
+require 'models/developer'
 
 require MIGRATIONS_ROOT + "/valid/1_people_have_last_names"
 require MIGRATIONS_ROOT + "/valid/2_we_need_reminders"
@@ -48,8 +49,8 @@ if ActiveRecord::Base.connection.supports_migrations?
         Person.connection.remove_column('people', column) rescue nil
       end
       Person.connection.remove_column("people", "first_name") rescue nil
-    Person.connection.remove_column("people", "middle_name") rescue nil
-    Person.connection.add_column("people", "first_name", :string, :limit => 40)
+      Person.connection.remove_column("people", "middle_name") rescue nil
+      Person.connection.add_column("people", "first_name", :string, :limit => 40)
       Person.reset_column_information
     end
 
@@ -124,7 +125,7 @@ if ActiveRecord::Base.connection.supports_migrations?
     def test_create_table_with_defaults
       # MySQL doesn't allow defaults on TEXT or BLOB columns.
       mysql = current_adapter?(:MysqlAdapter)
-    ibm_ids_zOS = ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')||
+      ibm_ids_zOS = ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')||
         ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_DB2_ZOS')
     
       Person.connection.create_table :testings do |t|
@@ -153,39 +154,48 @@ if ActiveRecord::Base.connection.supports_migrations?
     end
 
   if current_adapter?(:IBM_DBAdapter)
-      def test_no_limits_datatypes_IBM_DB
-        clasz = Class.new(ActiveRecord::Base)
-        clasz.table_name = 'test_no_limits_datatypes_IBM_DB'
-        assert_nothing_raised do
-          clasz.connection.create_table clasz.table_name do |t|
-            t.column "test_varchar", :string,    :limit => 10
-            t.column "test_integer", :integer,   :limit => 5
-            t.column "test_boolean", :boolean,   :limit => 5
-            t.column "test_double",  :double,    :limit => 10
-            t.column "test_date",    :date,      :limit => 10
-            t.column "test_time",    :time,      :limit => 10
-            t.column "test_tstamp",  :timestamp, :limit => 10
-            t.column "test_xml",     :xml,       :limit => 10
-            t.column "test_clob",    :text,      :limit => 10000
-          end
+    def test_no_limits_datatypes_IBM_DB
+      ibm_ids = ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')
+      clasz = Class.new(ActiveRecord::Base)
+      clasz.table_name = 'test_no_limits_datatypes_IBM_DB'
+      assert_nothing_raised do
+        clasz.connection.create_table clasz.table_name do |t|
+          t.column "test_varchar", :string,    :limit => 10
+          t.column "test_integer", :integer,   :limit => 5
+          t.column "test_boolean", :boolean,   :limit => 5
+          t.column "test_double",  :double,    :limit => 10
+          t.column "test_date",    :date,      :limit => 10
+          t.column "test_time",    :time,      :limit => 10
+          t.column "test_tstamp",  :timestamp, :limit => 10
+          t.column "test_xml",     :xml,       :limit => 10  unless ibm_ids
+          t.column "test_clob",    :text,      :limit => 10000
         end
-      ensure
-        clasz.connection.drop_table(clasz.table_name) rescue nil
       end
+    ensure
+      clasz.connection.drop_table(clasz.table_name) rescue nil
+    end
       
-      #Sexy migration test for column of type xml
-      def test_new_xml_migrations
-        clasz = Class.new(ActiveRecord::Base)
-        clasz.table_name = 'test_new_xml_migrations'
-        assert_nothing_raised do
-          clasz.connection.create_table clasz.table_name do |t|
-                t.xml     :xml_col
-          end
+    #Sexy migration test for column of type xml and char
+    def test_short_hand_char_xml_migrations
+      ibm_ids = ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')
+      clasz = Class.new(ActiveRecord::Base)
+      clasz.table_name = 'test_short_hand_migrations'
+      assert_nothing_raised do
+        clasz.connection.create_table clasz.table_name do |t|
+          t.xml     :xml_col  unless ibm_ids
+          t.char    :char_col, :limit=>10
         end
-      ensure
-        clasz.connection.drop_table(clasz.table_name) rescue nil
       end
+      assert_nothing_raised do
+        clasz.connection.change_table clasz.table_name do |t|
+          t.xml     :xml_col1  unless ibm_ids
+          t.char    :char_col1, :limit=>50 
+        end
+      end
+    ensure
+      clasz.connection.drop_table(clasz.table_name) rescue nil
     end
+  end
   
     def test_create_table_with_limits
       assert_nothing_raised do
@@ -194,9 +204,10 @@ if ActiveRecord::Base.connection.supports_migrations?
 
           t.column :default_int, :integer
 
-          t.column :one_int,   :integer, :limit => 1
-          t.column :four_int,  :integer, :limit => 4
-          t.column :eight_int, :integer, :limit => 8
+          t.column :one_int,    :integer, :limit => 1
+          t.column :four_int,   :integer, :limit => 4
+          t.column :eight_int,  :integer, :limit => 8
+          t.column :eleven_int, :integer, :limit => 11
         end
       end
 
@@ -208,12 +219,20 @@ if ActiveRecord::Base.connection.supports_migrations?
       one     = columns.detect { |c| c.name == "one_int"     }
       four    = columns.detect { |c| c.name == "four_int"    }
       eight   = columns.detect { |c| c.name == "eight_int"   }
+      eleven  = columns.detect { |c| c.name == "eleven_int"   }
 
       if current_adapter?(:PostgreSQLAdapter)
         assert_equal 'integer', default.sql_type
         assert_equal 'smallint', one.sql_type
         assert_equal 'integer', four.sql_type
         assert_equal 'bigint', eight.sql_type
+        assert_equal 'integer', eleven.sql_type
+      elsif current_adapter?(:MysqlAdapter)
+        assert_match 'int(11)', default.sql_type
+        assert_match 'tinyint', one.sql_type
+        assert_match 'int', four.sql_type
+        assert_match 'bigint', eight.sql_type
+        assert_match 'int(11)', eleven.sql_type
       elsif current_adapter?(:OracleAdapter)
         assert_equal 'NUMBER(38)', default.sql_type
         assert_equal 'NUMBER(1)', one.sql_type
@@ -268,6 +287,39 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
+    def test_create_table_with_timestamps_should_create_datetime_columns
+      table_name = :testings
+
+      Person.connection.create_table table_name do |t|
+        t.timestamps
+      end
+      created_columns = Person.connection.columns(table_name)
+
+      created_at_column = created_columns.detect {|c| c.name == 'created_at' }
+      updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
+
+      assert created_at_column.null
+      assert updated_at_column.null
+    ensure
+      Person.connection.drop_table table_name rescue nil
+    end
+
+    def test_create_table_with_timestamps_should_create_datetime_columns_with_options
+      table_name = :testings
+
+      Person.connection.create_table table_name do |t|
+        t.timestamps :null => false
+      end
+      created_columns = Person.connection.columns(table_name)
+
+      created_at_column = created_columns.detect {|c| c.name == 'created_at' }
+      updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
+
+      assert !created_at_column.null
+      assert !updated_at_column.null
+    ensure
+      Person.connection.drop_table table_name rescue nil
+    end
 
     # SQL Server, Sybase, and SQLite3 will not allow you to add a NOT NULL
     # column to a table without a default value.
@@ -440,10 +492,7 @@ if ActiveRecord::Base.connection.supports_migrations?
 
         ActiveRecord::Migration.add_column :people, :intelligence_quotient, :tinyint
         Person.reset_column_information
-        Person.create :intelligence_quotient => 300
-        jonnyg = Person.find(:first)
-        assert_equal 127, jonnyg.intelligence_quotient
-        jonnyg.destroy
+        assert_match /tinyint/, Person.columns_hash['intelligence_quotient'].sql_type
       ensure
         ActiveRecord::Migration.remove_column :people, :intelligence_quotient rescue nil
       end
@@ -525,6 +574,37 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
+    def test_rename_column_preserves_default_value_not_null
+      begin
+        default_before = Developer.connection.columns("developers").find { |c| c.name == "salary" }.default
+        assert_equal 70000, default_before
+        Developer.connection.rename_column "developers", "salary", "anual_salary"
+        Developer.reset_column_information
+        assert Developer.column_names.include?("anual_salary")
+        default_after = Developer.connection.columns("developers").find { |c| c.name == "anual_salary" }.default
+        assert_equal 70000, default_after
+      ensure
+        Developer.connection.rename_column "developers", "anual_salary", "salary"
+        Developer.reset_column_information
+      end
+    end
+
+    def test_rename_nonexistent_column
+      ActiveRecord::Base.connection.create_table(:hats) do |table|
+        table.column :hat_name, :string, :default => nil
+      end
+      exception = if current_adapter?(:PostgreSQLAdapter)
+        ActiveRecord::StatementInvalid
+      else
+        ActiveRecord::ActiveRecordError
+      end
+      assert_raises(exception) do
+        Person.connection.rename_column "hats", "nonexistent", "should_fail"
+      end
+    ensure
+      ActiveRecord::Base.connection.drop_table(:hats)
+    end
+
     def test_rename_column_with_sql_reserved_word
       begin
         assert_nothing_raised { Person.connection.rename_column "people", "first_name", "group" }
@@ -613,14 +693,14 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.add_column "people", "funny", :boolean
       Person.reset_column_information
       assert Person.columns_hash["funny"].null, "Column 'funny' must initially allow nulls"
-    unless current_adapter?(:IBM_DBAdapter) # incompatible types changes  
-    Person.connection.change_column "people", "funny", :boolean, :null => false, :default => true
-    Person.reset_column_information
-    assert !Person.columns_hash["funny"].null, "Column 'funny' must *not* allow nulls at this point"
-    Person.connection.change_column "people", "funny", :boolean, :null => true
-    Person.reset_column_information
-    assert Person.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point"
-    end 
+      unless current_adapter?(:IBM_DBAdapter) # incompatible types changes  
+        Person.connection.change_column "people", "funny", :boolean, :null => false, :default => true
+        Person.reset_column_information
+        assert !Person.columns_hash["funny"].null, "Column 'funny' must *not* allow nulls at this point"
+        Person.connection.change_column "people", "funny", :boolean, :null => true
+        Person.reset_column_information
+        assert Person.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point"
+      end 
     end
 
     def test_rename_table_with_an_index
@@ -705,7 +785,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.create_table :testings do |t|
         t.column :select, :string
       end
-      unless current_adapter?(:IBM_DBAdapter) # altering a string column to size  
+      unless current_adapter?(:IBM_DBAdapter) # altering a string column to smaller size  
         assert_nothing_raised { Person.connection.change_column :testings, :select, :string, :limit => 10 }
       end 
 
@@ -714,6 +794,81 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.drop_table :testings rescue nil
     end
 
+    def test_keeping_default_and_notnull_constaint_on_change
+      Person.connection.create_table :testings do |t|
+        t.column :title, :string
+      end
+      person_klass = Class.new(Person)
+      person_klass.set_table_name 'testings'
+
+      person_klass.connection.add_column "testings", "wealth", :integer, :null => false, :default => 99
+      person_klass.reset_column_information
+      assert_equal 99, person_klass.columns_hash["wealth"].default
+      assert_equal false, person_klass.columns_hash["wealth"].null
+      assert_nothing_raised {person_klass.connection.execute("insert into testings (title) values ('tester')")}
+
+      # change column default to see that column doesn't lose its not null definition
+      person_klass.connection.change_column_default "testings", "wealth", 100
+      person_klass.reset_column_information
+      assert_equal 100, person_klass.columns_hash["wealth"].default
+      assert_equal false, person_klass.columns_hash["wealth"].null
+
+      # rename column to see that column doesn't lose its not null and/or default definition
+      unless current_adapter?(:IBM_DBAdapter) #rename_column is not implemented in IBM_DBAdapetr
+        person_klass.connection.rename_column "testings", "wealth", "money"
+        person_klass.reset_column_information
+        assert_nil person_klass.columns_hash["wealth"]
+        assert_equal 100, person_klass.columns_hash["money"].default
+        assert_equal false, person_klass.columns_hash["money"].null
+      end 
+
+      # change column
+      unless current_adapter?(:IBM_DBAdapter)
+        person_klass.connection.change_column "testings", "money", :integer, :null => false, :default => 1000
+        person_klass.reset_column_information
+        assert_equal 1000, person_klass.columns_hash["money"].default
+        assert_equal false, person_klass.columns_hash["money"].null
+      else
+        person_klass.connection.change_column "testings", "wealth", :decimal, :precision => 15, :scale => 1,:null => false, :default => 1000
+        person_klass.reset_column_information
+        assert_equal 1000, person_klass.columns_hash["wealth"].default
+        assert_equal false, person_klass.columns_hash["wealth"].null
+      end   
+
+      # change column, make it nullable and clear default
+      unless current_adapter?(:IBM_DBAdapter)
+        person_klass.connection.change_column "testings", "money", :integer, :null => true, :default => nil
+        person_klass.reset_column_information
+        assert_nil person_klass.columns_hash["money"].default
+        assert_equal true, person_klass.columns_hash["money"].null
+      else
+        person_klass.connection.change_column "testings", "wealth", :decimal, :precision => 20, :scale => 2,  :null => true, :default => nil
+        person_klass.reset_column_information
+        assert_nil person_klass.columns_hash["wealth"].default
+        assert_equal true, person_klass.columns_hash["wealth"].null
+      end   
+
+      # change_column_null, make it not nullable and set null values to a default value
+      unless current_adapter?(:IBM_DBAdapter)
+        person_klass.connection.execute('UPDATE testings SET money = NULL')
+        person_klass.connection.change_column_null "testings", "money", false, 2000
+        person_klass.reset_column_information
+        assert_nil person_klass.columns_hash["money"].default
+        assert_equal false, person_klass.columns_hash["money"].null
+        assert_equal [2000], Person.connection.select_values("SELECT money FROM testings").map { |s| s.to_i }.sort
+      else
+        # Trying to set the value of the column wealth to NULL and 
+        # in the next statement a not null constraint is being applied which is wrong.
+        #person_klass.connection.execute('UPDATE testings SET wealth = NULL')
+        person_klass.connection.change_column_null "testings", "wealth", false, 2000
+        person_klass.reset_column_information
+        assert_equal false, person_klass.columns_hash["wealth"].null
+        assert_equal 2000, person_klass.columns_hash["wealth"].default
+      end
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
     def test_change_column_default_to_null
       Person.connection.change_column_default "people", "first_name", nil
       Person.reset_column_information
@@ -863,6 +1018,21 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert !Reminder.table_exists?
     end
 
+    def test_migrator_double_up
+      assert_equal(0, ActiveRecord::Migrator.current_version)
+      ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT + "/valid", 1)
+      assert_nothing_raised { ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT + "/valid", 1) }
+      assert_equal(1, ActiveRecord::Migrator.current_version)
+    end
+
+    def test_migrator_double_down
+      assert_equal(0, ActiveRecord::Migrator.current_version)
+      ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT + "/valid", 1)
+      ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT + "/valid", 1)
+      assert_nothing_raised { ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT + "/valid", 1) }
+      assert_equal(0, ActiveRecord::Migrator.current_version)
+    end
+
     def test_finds_migrations
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/valid").migrations
       [['1', 'people_have_last_names'],
@@ -952,16 +1122,6 @@ if ActiveRecord::Base.connection.supports_migrations?
       ActiveRecord::Migrator.rollback(MIGRATIONS_ROOT + "/valid")
       assert_equal(0, ActiveRecord::Migrator.current_version)
     end
-    
-    def test_migrator_run
-      assert_equal(0, ActiveRecord::Migrator.current_version)
-      ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT + "/valid", 3)
-      assert_equal(0, ActiveRecord::Migrator.current_version)
-
-      assert_equal(0, ActiveRecord::Migrator.current_version)
-      ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT + "/valid", 3)
-      assert_equal(0, ActiveRecord::Migrator.current_version)
-    end
 
     def test_schema_migrations_table_name
       ActiveRecord::Base.table_name_prefix = "prefix_"
@@ -1141,8 +1301,8 @@ if ActiveRecord::Base.connection.supports_migrations?
 
       def test_timestamps_creates_updated_at_and_created_at
         with_new_table do |t|
-          t.expects(:column).with(:created_at, :datetime)
-          t.expects(:column).with(:updated_at, :datetime)
+          t.expects(:column).with(:created_at, :datetime, kind_of(Hash))
+          t.expects(:column).with(:updated_at, :datetime, kind_of(Hash))
           t.timestamps
         end
       end
@@ -1270,10 +1430,10 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
 
       def integer_column
-        if current_adapter?(:SQLite3Adapter) || current_adapter?(:SQLiteAdapter) || current_adapter?(:PostgreSQLAdapter)
-          "integer"
-        else
+        if current_adapter?(:MysqlAdapter)
           'int(11)'
+        else
+          'integer'
         end
       end
 

data/test/cases/query_cache_test.rb

@@ -8,120 +8,121 @@ require 'models/post'
 
 unless current_adapter?(:IBM_DBAdapter)
   class QueryCacheTest < ActiveRecord::TestCase
-  fixtures :tasks, :topics, :categories, :posts, :categories_posts
+    fixtures :tasks, :topics, :categories, :posts, :categories_posts
 
-  def test_find_queries
-    assert_queries(2) { Task.find(1); Task.find(1) }
-  end
-
-  def test_find_queries_with_cache
-    Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+    def test_find_queries
+      assert_queries(2) { Task.find(1); Task.find(1) }
     end
-  end
 
-  def test_count_queries_with_cache
-    Task.cache do
-      assert_queries(1) { Task.count; Task.count }
+    def test_find_queries_with_cache
+      Task.cache do
+        assert_queries(1) { Task.find(1); Task.find(1) }
+      end
     end
-  end
 
-  def test_query_cache_dups_results_correctly
-    Task.cache do
-      now  = Time.now.utc
-      task = Task.find 1
-      assert_not_equal now, task.starting
-      task.starting = now
-      task.reload
-      assert_not_equal now, task.starting
+    def test_count_queries_with_cache
+      Task.cache do
+        assert_queries(1) { Task.count; Task.count }
+      end
     end
-  end
 
-  def test_cache_is_flat
-    Task.cache do
-      Topic.columns # don't count this query
-      assert_queries(1) { Topic.find(1); Topic.find(1); }
+    def test_query_cache_dups_results_correctly
+      Task.cache do
+        now  = Time.now.utc
+        task = Task.find 1
+        assert_not_equal now, task.starting
+        task.starting = now
+        task.reload
+        assert_not_equal now, task.starting
+      end
     end
 
-    ActiveRecord::Base.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+    def test_cache_is_flat
+      Task.cache do
+        Topic.columns # don't count this query
+        assert_queries(1) { Topic.find(1); Topic.find(1); }
+      end
+
+      ActiveRecord::Base.cache do
+        assert_queries(1) { Task.find(1); Task.find(1) }
+      end
     end
-  end
 
-  def test_cache_does_not_wrap_string_results_in_arrays
-    Task.cache do
-      assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
+    def test_cache_does_not_wrap_string_results_in_arrays
+      Task.cache do
+        assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
+      end
     end
   end
-  end
 
-uses_mocha 'QueryCacheExpiryTest' do
+  uses_mocha 'QueryCacheExpiryTest' do
 
   class QueryCacheExpiryTest < ActiveRecord::TestCase
-    fixtures :tasks
-
-  def test_find
-    Task.connection.expects(:clear_query_cache).times(1)
-
-    assert !Task.connection.query_cache_enabled
-    Task.cache do
-      assert Task.connection.query_cache_enabled
-      Task.find(1)
-  
-      Task.uncached do
-        assert !Task.connection.query_cache_enabled
+    fixtures :tasks, :posts, :categories, :categories_posts
+
+    def test_find
+      Task.connection.expects(:clear_query_cache).times(1)
+
+      assert !Task.connection.query_cache_enabled
+      Task.cache do
+        assert Task.connection.query_cache_enabled
         Task.find(1)
+
+        Task.uncached do
+          assert !Task.connection.query_cache_enabled
+          Task.find(1)
+        end
+
+        assert Task.connection.query_cache_enabled
       end
-  
-      assert Task.connection.query_cache_enabled
+      assert !Task.connection.query_cache_enabled
     end
-    assert !Task.connection.query_cache_enabled
-  end
 
-  def test_update
-    Task.connection.expects(:clear_query_cache).times(2)
+    def test_update
+      Task.connection.expects(:clear_query_cache).times(2)
 
-    Task.cache do
-      task = Task.find(1)
-      task.starting = Time.now.utc
-      task.save!
+      Task.cache do
+        task = Task.find(1)
+        task.starting = Time.now.utc
+        task.save!
+      end
     end
-  end
 
-  def test_destroy
-    Task.connection.expects(:clear_query_cache).times(2)
+    def test_destroy
+      Task.connection.expects(:clear_query_cache).times(2)
 
-    Task.cache do
-      Task.find(1).destroy
+      Task.cache do
+        Task.find(1).destroy
+      end
     end
-  end
 
-  def test_insert
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
+    def test_insert
+      ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
 
-    Task.cache do
-      Task.create!
+      Task.cache do
+        Task.create!
+      end
     end
-  end
 
-  def test_cache_is_expired_by_habtm_update
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
+    def test_cache_is_expired_by_habtm_update
+      ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
       ActiveRecord::Base.cache do
         c = Category.find(:first)
         p = Post.find(:first)
         p.categories << c
       end
-  end
+    end
 
-  def test_cache_is_expired_by_habtm_delete
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
+    def test_cache_is_expired_by_habtm_delete
+      ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
       ActiveRecord::Base.cache do
-        c = Category.find(:first)
-        p = Post.find(:first)
+        c = Category.find(1)
+        p = Post.find(1)
+        assert p.categories.any?
         p.categories.delete_all
       end
     end
   end
-  
+
   end
-end
+end