ibm_db 3.0.4 → 5.0.4

data/test/cases/log_subscriber_test.rb

@@ -7,6 +7,20 @@ require "active_support/log_subscriber/test_helper"
 class LogSubscriberTest < ActiveRecord::TestCase
   include ActiveSupport::LogSubscriber::TestHelper
   include ActiveSupport::Logger::Severity
+  REGEXP_CLEAR = Regexp.escape(ActiveRecord::LogSubscriber::CLEAR)
+  REGEXP_BOLD = Regexp.escape(ActiveRecord::LogSubscriber::BOLD)
+  REGEXP_MAGENTA = Regexp.escape(ActiveRecord::LogSubscriber::MAGENTA)
+  REGEXP_CYAN = Regexp.escape(ActiveRecord::LogSubscriber::CYAN)
+  SQL_COLORINGS = {
+      SELECT: Regexp.escape(ActiveRecord::LogSubscriber::BLUE),
+      INSERT: Regexp.escape(ActiveRecord::LogSubscriber::GREEN),
+      UPDATE: Regexp.escape(ActiveRecord::LogSubscriber::YELLOW),
+      DELETE: Regexp.escape(ActiveRecord::LogSubscriber::RED),
+      LOCK: Regexp.escape(ActiveRecord::LogSubscriber::WHITE),
+      ROLLBACK: Regexp.escape(ActiveRecord::LogSubscriber::RED),
+      TRANSACTION: REGEXP_CYAN,
+      OTHER: REGEXP_MAGENTA
+  }
 
   class TestDebugLogSubscriber < ActiveRecord::LogSubscriber
     attr_reader :debugs
@@ -46,31 +60,23 @@ class LogSubscriberTest < ActiveRecord::TestCase
     logger = TestDebugLogSubscriber.new
     assert_equal 0, logger.debugs.length
 
-    logger.sql(event.new(0, sql: 'hi mom!'))
+    logger.sql(event.new(0.9, sql: "hi mom!"))
     assert_equal 1, logger.debugs.length
 
-    logger.sql(event.new(0, sql: 'hi mom!', name: 'foo'))
+    logger.sql(event.new(0.9, sql: "hi mom!", name: "foo"))
     assert_equal 2, logger.debugs.length
 
-    logger.sql(event.new(0, sql: 'hi mom!', name: 'SCHEMA'))
+    logger.sql(event.new(0.9, sql: "hi mom!", name: "SCHEMA"))
     assert_equal 2, logger.debugs.length
   end
 
   def test_sql_statements_are_not_squeezed
     event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.sql(event.new(0, sql: 'ruby   rails'))
+    logger.sql(event.new(0.9, sql: "ruby   rails"))
     assert_match(/ruby   rails/, logger.debugs.first)
   end
 
-  def test_ignore_binds_payload_with_nil_column
-    event = Struct.new(:duration, :payload)
-
-    logger = TestDebugLogSubscriber.new
-    logger.sql(event.new(0, sql: 'hi mom!', binds: [[nil, 1]]))
-    assert_equal 1, logger.debugs.length
-  end
-
   def test_basic_query_logging
     Developer.all.load
     wait
@@ -79,6 +85,90 @@ class LogSubscriberTest < ActiveRecord::TestCase
     assert_match(/SELECT .*?FROM .?developers.?/i, @logger.logged(:debug).last)
   end
 
+  def test_basic_query_logging_coloration
+    event = Struct.new(:duration, :payload)
+    logger = TestDebugLogSubscriber.new
+    logger.colorize_logging = true
+    SQL_COLORINGS.each do |verb, color_regex|
+      logger.sql(event.new(0.9, sql: verb.to_s))
+      assert_match(/#{REGEXP_BOLD}#{color_regex}#{verb}#{REGEXP_CLEAR}/i, logger.debugs.last)
+    end
+  end
+
+  def test_basic_payload_name_logging_coloration_generic_sql
+    event = Struct.new(:duration, :payload)
+    logger = TestDebugLogSubscriber.new
+    logger.colorize_logging = true
+    SQL_COLORINGS.each do |verb, _|
+      logger.sql(event.new(0.9, sql: verb.to_s))
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+
+      logger.sql(event.new(0.9, sql: verb.to_s, name: "SQL"))
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA}SQL \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+    end
+  end
+
+  def test_basic_payload_name_logging_coloration_named_sql
+    event = Struct.new(:duration, :payload)
+    logger = TestDebugLogSubscriber.new
+    logger.colorize_logging = true
+    SQL_COLORINGS.each do |verb, _|
+      logger.sql(event.new(0.9, sql: verb.to_s, name: "Model Load"))
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Load \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+
+      logger.sql(event.new(0.9, sql: verb.to_s, name: "Model Exists"))
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Exists \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+
+      logger.sql(event.new(0.9, sql: verb.to_s, name: "ANY SPECIFIC NAME"))
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}ANY SPECIFIC NAME \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+    end
+  end
+
+  def test_query_logging_coloration_with_nested_select
+    event = Struct.new(:duration, :payload)
+    logger = TestDebugLogSubscriber.new
+    logger.colorize_logging = true
+    SQL_COLORINGS.slice(:SELECT, :INSERT, :UPDATE, :DELETE).each do |verb, color_regex|
+      logger.sql(event.new(0.9, sql: "#{verb} WHERE ID IN SELECT"))
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}#{verb} WHERE ID IN SELECT#{REGEXP_CLEAR}/i, logger.debugs.last)
+    end
+  end
+
+  def test_query_logging_coloration_with_multi_line_nested_select
+    event = Struct.new(:duration, :payload)
+    logger = TestDebugLogSubscriber.new
+    logger.colorize_logging = true
+    SQL_COLORINGS.slice(:SELECT, :INSERT, :UPDATE, :DELETE).each do |verb, color_regex|
+      sql = <<-EOS
+        #{verb}
+        WHERE ID IN (
+          SELECT ID FROM THINGS
+        )
+      EOS
+      logger.sql(event.new(0.9, sql: sql))
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}.*#{verb}.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
+    end
+  end
+
+  def test_query_logging_coloration_with_lock
+    event = Struct.new(:duration, :payload)
+    logger = TestDebugLogSubscriber.new
+    logger.colorize_logging = true
+    sql = <<-EOS
+      SELECT * FROM
+        (SELECT * FROM mytable FOR UPDATE) ss
+      WHERE col1 = 5;
+    EOS
+    logger.sql(event.new(0.9, sql: sql))
+    assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*FOR UPDATE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
+
+    sql = <<-EOS
+      LOCK TABLE films IN SHARE MODE;
+    EOS
+    logger.sql(event.new(0.9, sql: sql))
+    assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*LOCK TABLE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
+  end
+
   def test_exists_query_logging
     Developer.exists? 1
     wait
@@ -119,18 +209,17 @@ class LogSubscriberTest < ActiveRecord::TestCase
     Thread.new { assert_equal 0, ActiveRecord::LogSubscriber.runtime }.join
   end
 
-  unless current_adapter?(:Mysql2Adapter)
+  if ActiveRecord::Base.connection.prepared_statements
     def test_binary_data_is_not_logged
       Binary.create(data: 'some binary data')
       wait
       assert_match(/<16 bytes of binary data>/, @logger.logged(:debug).join)
     end
 
-    def test_nil_binary_data_is_logged
-      binary = Binary.create(data: "")
-      binary.update_attributes(data: nil)
+    def test_binary_data_hash
+      Binary.create(data: { a: 1 })
       wait
-      assert_match(/<NULL binary data>/, @logger.logged(:debug).join)
+      assert_match(/<7 bytes of binary data>/, @logger.logged(:debug).join)
     end
   end
 end

data/test/cases/migration/change_schema_test.rb

@@ -23,20 +23,14 @@ module ActiveRecord
         end
       end
 
-	  unless current_adapter?(:IBM_DBAdapter)
-      # For DB2: Cannot add a primary key to a table with some rows already in it as it violates the unique constraint
-      # Secondly GENERATED BY DEFAULT AS IDENTITY cannot be applied in a alter table command.
-      # as this will be wrong sql syntax for DB
-        def test_add_column_with_primary_key_attribute
-          testing_table_with_only_foo_attribute do
-            connection.add_column :testings, :id, :primary_key
-            assert_equal connection.columns(:testings).size, 2
-          end
+      def test_add_column_with_primary_key_attribute
+        testing_table_with_only_foo_attribute do
+          connection.add_column :testings, :id, :primary_key
+          assert_equal connection.columns(:testings).size, 2
         end
-	  end
+      end
 
       def test_create_table_adds_id
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :foo, :string
         end
@@ -45,7 +39,6 @@ module ActiveRecord
       end
 
       def test_create_table_with_not_null_column
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :foo, :string, :null => false
         end
@@ -57,8 +50,8 @@ module ActiveRecord
 
       def test_create_table_with_defaults
         # MySQL doesn't allow defaults on TEXT or BLOB columns.
-        mysql = current_adapter?(:MysqlAdapter, :Mysql2Adapter, :IBM_DBAdapter)
-        connection.drop_table :testings rescue nil
+        mysql = current_adapter?(:Mysql2Adapter)
+
         connection.create_table :testings do |t|
           t.column :one, :string, :default => "hello"
           t.column :two, :boolean, :default => true
@@ -75,26 +68,24 @@ module ActiveRecord
         five = columns.detect { |c| c.name == "five" } unless mysql
 
         assert_equal "hello", one.default
-        assert_equal true, two.type_cast_from_database(two.default)
-        assert_equal false, three.type_cast_from_database(three.default)
+        assert_equal true, connection.lookup_cast_type_from_column(two).deserialize(two.default)
+        assert_equal false, connection.lookup_cast_type_from_column(three).deserialize(three.default)
         assert_equal '1', four.default
-        assert_equal "hello", five.default unless mysql		
+        assert_equal "hello", five.default unless mysql
       end
 
       if current_adapter?(:PostgreSQLAdapter)
         def test_add_column_with_array
-		  connection.drop_table :testings rescue nil
           connection.create_table :testings
           connection.add_column :testings, :foo, :string, :array => true
 
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array
+          assert array_column.array?
         end
 
         def test_create_table_with_array_column
-		  connection.drop_table :testings rescue nil
           connection.create_table :testings do |t|
             t.string :foo, :array => true
           end
@@ -102,12 +93,11 @@ module ActiveRecord
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array
+          assert array_column.array?
         end
       end
 
       def test_create_table_with_bigint
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.bigint :eight_int
         end
@@ -127,7 +117,6 @@ module ActiveRecord
       end
 
       def test_create_table_with_limits
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :foo, :string, :limit => 255
 
@@ -152,7 +141,7 @@ module ActiveRecord
           assert_equal 'smallint', one.sql_type
           assert_equal 'integer', four.sql_type
           assert_equal 'bigint', eight.sql_type
-        elsif current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+        elsif current_adapter?(:Mysql2Adapter)
           assert_match 'int(11)', default.sql_type
           assert_match 'tinyint', one.sql_type
           assert_match 'int', four.sql_type
@@ -167,7 +156,7 @@ module ActiveRecord
 
       def test_create_table_with_primary_key_prefix_as_table_name_with_underscore
         ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
-		connection.drop_table :testings rescue nil
+
         connection.create_table :testings do |t|
           t.column :foo, :string
         end
@@ -177,7 +166,7 @@ module ActiveRecord
 
       def test_create_table_with_primary_key_prefix_as_table_name
         ActiveRecord::Base.primary_key_prefix_type = :table_name
-		connection.drop_table :testings rescue nil
+
         connection.create_table :testings do |t|
           t.column :foo, :string
         end
@@ -185,23 +174,18 @@ module ActiveRecord
         assert_equal %w(testingid foo), connection.columns(:testings).map(&:name)
       end
 
-      def test_create_table_raises_when_redefining_primary_key_column	
-		
-		unless current_adapter?(:IBM_DBAdapter)
-		#DB2 instead of ArgumentError exception, thorws Class: <ActiveRecord::StatementInvalid> Message: <"RuntimeError: Failed to execute statement due to: [IBM][CLI Driver][DB2/NT64] SQL0612N  \"ID\" is a duplicate name.  SQLSTATE=42711\r SQLCODE=-612: CREATE TABLE testings (id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 10000) PRIMARY KEY, id varchar(255)) ">
-			error = assert_raise(ArgumentError) do	
-			  connection.drop_table :testings rescue nil
-			  connection.create_table :testings do |t|
-				t.column :id, :string
-			  end
-			end
-			assert_equal "you can't redefine the primary key column 'id'. To define a custom primary key, pass { id: false } to create_table.", error.message			
-		end
+      def test_create_table_raises_when_redefining_primary_key_column
+        error = assert_raise(ArgumentError) do
+          connection.create_table :testings do |t|
+            t.column :id, :string
+          end
+        end
+
+        assert_equal "you can't redefine the primary key column 'id'. To define a custom primary key, pass { id: false } to create_table.", error.message
       end
 
       def test_create_table_raises_when_redefining_custom_primary_key_column
-		connection.drop_table :testings rescue nil	  
-        error = assert_raise(ArgumentError) do		  
+        error = assert_raise(ArgumentError) do
           connection.create_table :testings, primary_key: :testing_id do |t|
             t.column :testing_id, :string
           end
@@ -211,46 +195,39 @@ module ActiveRecord
       end
 
       def test_create_table_with_timestamps_should_create_datetime_columns
-        # FIXME: Remove the silence when we change the default `null` behavior
-        ActiveSupport::Deprecation.silence do
-		  connection.drop_table :testings rescue nil
-          connection.create_table table_name do |t|
-            t.timestamps
-          end
+        connection.create_table table_name do |t|
+          t.timestamps
         end
         created_columns = 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
+        assert !created_at_column.null
+        assert !updated_at_column.null
       end
 
       def test_create_table_with_timestamps_should_create_datetime_columns_with_options
-	    connection.drop_table :testings rescue nil
         connection.create_table table_name do |t|
-          t.timestamps :null => false
+          t.timestamps null: true
         end
         created_columns = 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
+        assert created_at_column.null
+        assert updated_at_column.null
       end
 
       def test_create_table_without_a_block
-	    connection.drop_table :testings rescue nil
         connection.create_table table_name
       end
 
-      # Sybase, and SQLite3 will not allow you to add a NOT NULL
+      # SQLite3 will not allow you to add a NOT NULL
       # column to a table without a default value.
-      unless current_adapter?(:SybaseAdapter, :SQLite3Adapter, :IBM_DBAdapter)
+      unless current_adapter?(:SQLite3Adapter)
         def test_add_column_not_null_without_default
-		  connection.drop_table :testings rescue nil
           connection.create_table :testings do |t|
             t.column :foo, :string
           end
@@ -263,36 +240,39 @@ module ActiveRecord
       end
 
       def test_add_column_not_null_with_default
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :foo, :string
         end
 
         con = connection
-        connection.enable_identity_insert("testings", true) if current_adapter?(:SybaseAdapter)
         connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}) values (1, 'hello')"
-        connection.enable_identity_insert("testings", false) if current_adapter?(:SybaseAdapter)
         assert_nothing_raised {connection.add_column :testings, :bar, :string, :null => false, :default => "default" }
 
         assert_raises(ActiveRecord::StatementInvalid) do
-          unless current_adapter?(:OpenBaseAdapter)
-            connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)"
-          else
-            connection.insert("INSERT INTO testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) VALUES (2, 'hello', NULL)",
-                                     "Testing Insert","id",2)
-          end
+          connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)"
+        end
+      end
+
+      def test_add_column_with_timestamp_type
+        connection.create_table :testings do |t|
+          t.column :foo, :timestamp
+        end
+
+        klass = Class.new(ActiveRecord::Base)
+        klass.table_name = 'testings'
+
+        assert_equal :datetime, klass.columns_hash['foo'].type
+
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_equal 'timestamp without time zone', klass.columns_hash['foo'].sql_type
+        else
+          assert_equal klass.connection.type_to_sql('datetime'), klass.columns_hash['foo'].sql_type
         end
       end
 
       def test_change_column_quotes_column_names
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
-          unless current_adapter?(:IBM_DBAdapter)
-            t.column :select, :string
-          else
-            # If no limit specified by default column of length 255 is created, which later cannot be scaled down to 10
-            t.column :select, :string, :limit => 5
-          end
+          t.column :select, :string
         end
 
         connection.change_column :testings, :select, :string, :limit => 10
@@ -306,7 +286,6 @@ module ActiveRecord
       end
 
       def test_keeping_default_and_notnull_constraints_on_change
-	   connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :title, :string
         end
@@ -315,7 +294,7 @@ module ActiveRecord
 
         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 99, person_klass.column_defaults["wealth"]
         assert_equal false, person_klass.columns_hash["wealth"].null
         # Oracle needs primary key value from sequence
         if current_adapter?(:OracleAdapter)
@@ -327,70 +306,40 @@ module ActiveRecord
         # 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 100, person_klass.column_defaults["wealth"]
         assert_equal false, person_klass.columns_hash["wealth"].null
 
-		if (!current_adapter?(:IBM_DBAdapter))
-          # rename column to see that column doesn't lose its not null and/or default definition
-          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
+        # rename column to see that column doesn't lose its not null and/or default definition
+        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.column_defaults["money"]
+        assert_equal false, person_klass.columns_hash["money"].null
 
         # 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
+        person_klass.connection.change_column "testings", "money", :integer, :null => false, :default => 1000
+        person_klass.reset_column_information
+        assert_equal 1000, person_klass.column_defaults["money"]
+        assert_equal false, person_klass.columns_hash["money"].null
 
         # 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
+        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
 
         # 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 money = NULL')
-          person_klass.connection.change_column_null "testings", "wealth", false, 2000
-          person_klass.reset_column_information
-          #assert_nil person_klass.columns_hash["wealth"].default #Setting default to 2000 and expecting nil is nor correct
-          assert_not_nil person_klass.columns_hash["wealth"].default
-          assert_equal false, person_klass.columns_hash["wealth"].null
-          #Changing default does not change the already inserted value. Hence expecting 2000 is wrong.
-          #assert_equal [99], Person.connection.select_values("SELECT wealth FROM testings").map { |s| s.to_i }.sort
-		  assert_equal [99], person_klass.connection.select_values("SELECT wealth FROM testings").map { |s| s.to_i }.sort
-        end
+        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, connection.select_values("SELECT money FROM testings").first.to_i
       end
 
       def test_change_column_null
         testing_table_with_only_foo_attribute do
-          notnull_migration = Class.new(ActiveRecord::Migration) do
+          notnull_migration = Class.new(ActiveRecord::Migration::Current) do
             def change
               change_column_null :testings, :foo, false
             end
@@ -405,7 +354,6 @@ module ActiveRecord
       end
 
       def test_column_exists
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :foo, :string
         end
@@ -415,7 +363,6 @@ module ActiveRecord
       end
 
       def test_column_exists_with_type
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :foo, :string
           t.column :bar, :decimal, :precision => 8, :scale => 2
@@ -429,7 +376,6 @@ module ActiveRecord
       end
 
       def test_column_exists_with_definition
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings do |t|
           t.column :foo, :string, limit: 100
           t.column :bar, :decimal, precision: 8, scale: 2
@@ -448,8 +394,7 @@ module ActiveRecord
       end
 
       def test_column_exists_on_table_with_no_options_parameter_supplied
-        connection.drop_table :testings rescue nil
-		connection.create_table :testings do |t|
+        connection.create_table :testings do |t|
           t.string :foo
         end
         connection.change_table :testings do |t|
@@ -458,9 +403,19 @@ module ActiveRecord
         end
       end
 
+      def test_drop_table_if_exists
+        connection.create_table(:testings)
+        ActiveSupport::Deprecation.silence { assert connection.table_exists?(:testings) }
+        connection.drop_table(:testings, if_exists: true)
+        ActiveSupport::Deprecation.silence { assert_not connection.table_exists?(:testings) }
+      end
+
+      def test_drop_table_if_exists_nothing_raised
+        assert_nothing_raised { connection.drop_table(:nonexistent, if_exists: true) }
+      end
+
       private
       def testing_table_with_only_foo_attribute
-	    connection.drop_table :testings rescue nil
         connection.create_table :testings, :id => false do |t|
           t.column :foo, :string
         end
@@ -468,5 +423,36 @@ module ActiveRecord
         yield
       end
     end
+
+    if ActiveRecord::Base.connection.supports_foreign_keys?
+      class ChangeSchemaWithDependentObjectsTest < ActiveRecord::TestCase
+        self.use_transactional_tests = false
+
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table :trains
+          @connection.create_table(:wagons) { |t| t.references :train }
+          @connection.add_foreign_key :wagons, :trains
+        end
+
+        teardown do
+          [:wagons, :trains].each do |table|
+            @connection.drop_table table, if_exists: true
+          end
+        end
+
+        def test_create_table_with_force_cascade_drops_dependent_objects
+          skip "MySQL > 5.5 does not drop dependent objects with DROP TABLE CASCADE" if current_adapter?(:Mysql2Adapter)
+          # can't re-create table referenced by foreign key
+          assert_raises(ActiveRecord::StatementInvalid) do
+            @connection.create_table :trains, force: true
+          end
+
+          # can recreate referenced table with force: :cascade
+          @connection.create_table :trains, force: :cascade
+          assert_equal [], @connection.foreign_keys(:wagons)
+        end
+      end
+    end
   end
 end