ibm_db 3.0.5-x86-mingw32 → 5.0.5-x86-mingw32

data/test/cases/result_test.rb

@@ -22,6 +22,16 @@ module ActiveRecord
       ], result.to_hash
     end
 
+    test "first returns first row as a hash" do
+      assert_equal(
+        {'col_1' => 'row 1 col 1', 'col_2' => 'row 1 col 2'}, result.first)
+    end
+
+    test "last returns last row as a hash" do
+      assert_equal(
+        {'col_1' => 'row 3 col 1', 'col_2' => 'row 3 col 2'}, result.last)
+    end
+
     test "each with block returns row hashes" do
       result.each do |row|
         assert_equal ['col_1', 'col_2'], row.keys

data/test/cases/sanitize_test.rb

@@ -7,24 +7,13 @@ class SanitizeTest < ActiveRecord::TestCase
   def setup
   end
 
-  def test_sanitize_sql_hash_handles_associations
-    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
-    quoted_column_name = ActiveRecord::Base.connection.quote_column_name("name")
-    quoted_table_name = ActiveRecord::Base.connection.quote_table_name("adorable_animals")
-    expected_value = "#{quoted_table_name}.#{quoted_column_name} = #{quoted_bambi}"
-
-    assert_deprecated do
-      assert_equal expected_value, Binary.send(:sanitize_sql_hash, {adorable_animals: {name: 'Bambi'}})
-    end
-  end
-
   def test_sanitize_sql_array_handles_string_interpolation
     quoted_bambi = ActiveRecord::Base.connection.quote_string("Bambi")
-    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=%s", "Bambi"])
-    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=%s", "Bambi".mb_chars])
+    assert_equal "name='#{quoted_bambi}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi"])
+    assert_equal "name='#{quoted_bambi}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi".mb_chars])
     quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote_string("Bambi\nand\nThumper")
-    assert_equal "name=#{quoted_bambi_and_thumper}",Binary.send(:sanitize_sql_array, ["name=%s", "Bambi\nand\nThumper"])
-    assert_equal "name=#{quoted_bambi_and_thumper}",Binary.send(:sanitize_sql_array, ["name=%s", "Bambi\nand\nThumper".mb_chars])
+    assert_equal "name='#{quoted_bambi_and_thumper}'",Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper"])
+    assert_equal "name='#{quoted_bambi_and_thumper}'",Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper".mb_chars])
   end
 
   def test_sanitize_sql_array_handles_bind_variables
@@ -36,6 +25,16 @@ class SanitizeTest < ActiveRecord::TestCase
     assert_equal "name=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi\nand\nThumper".mb_chars])
   end
 
+  def test_sanitize_sql_array_handles_named_bind_variables
+    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
+    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=:name", name: "Bambi"])
+    assert_equal "name=#{quoted_bambi} AND id=1", Binary.send(:sanitize_sql_array, ["name=:name AND id=:id", name: "Bambi", id: 1])
+
+    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=:name", name: "Bambi\nand\nThumper"])
+    assert_equal "name=#{quoted_bambi_and_thumper} AND name2=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=:name AND name2=:name", name: "Bambi\nand\nThumper"])
+  end
+
   def test_sanitize_sql_array_handles_relations
     david = Author.create!(name: 'David')
     david_posts = david.posts.select(:id)
@@ -80,4 +79,98 @@ class SanitizeTest < ActiveRecord::TestCase
       searchable_post.search("20% _reduction_!").to_a
     end
   end
+
+  def test_bind_arity
+    assert_nothing_raised                                { bind '' }
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind '', 1 }
+
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind '?' }
+    assert_nothing_raised                                { bind '?', 1 }
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind '?', 1, 1 }
+  end
+
+  def test_named_bind_variables
+    assert_equal '1', bind(':a', :a => 1) # ' ruby-mode
+    assert_equal '1 1', bind(':a :a', :a => 1)  # ' ruby-mode
+
+    assert_nothing_raised { bind("'+00:00'", :foo => "bar") }
+  end
+
+  def test_named_bind_arity
+    assert_nothing_raised                                { bind "name = :name", { name: "37signals" } }
+    assert_nothing_raised                                { bind "name = :name", { name: "37signals", id: 1 } }
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind "name = :name", { id: 1 } }
+  end
+
+  class SimpleEnumerable
+    include Enumerable
+
+    def initialize(ary)
+      @ary = ary
+    end
+
+    def each(&b)
+      @ary.each(&b)
+    end
+  end
+
+  def test_bind_enumerable
+    quoted_abc = %(#{ActiveRecord::Base.connection.quote('a')},#{ActiveRecord::Base.connection.quote('b')},#{ActiveRecord::Base.connection.quote('c')})
+
+    assert_equal '1,2,3', bind('?', [1, 2, 3])
+    assert_equal quoted_abc, bind('?', %w(a b c))
+
+    assert_equal '1,2,3', bind(':a', :a => [1, 2, 3])
+    assert_equal quoted_abc, bind(':a', :a => %w(a b c)) # '
+
+    assert_equal '1,2,3', bind('?', SimpleEnumerable.new([1, 2, 3]))
+    assert_equal quoted_abc, bind('?', SimpleEnumerable.new(%w(a b c)))
+
+    assert_equal '1,2,3', bind(':a', :a => SimpleEnumerable.new([1, 2, 3]))
+    assert_equal quoted_abc, bind(':a', :a => SimpleEnumerable.new(%w(a b c))) # '
+  end
+
+  def test_bind_empty_enumerable
+    quoted_nil = ActiveRecord::Base.connection.quote(nil)
+    assert_equal quoted_nil, bind('?', [])
+    assert_equal " in (#{quoted_nil})", bind(' in (?)', [])
+    assert_equal "foo in (#{quoted_nil})", bind('foo in (?)', [])
+  end
+
+  def test_bind_empty_string
+    quoted_empty = ActiveRecord::Base.connection.quote('')
+    assert_equal quoted_empty, bind('?', '')
+  end
+
+  def test_bind_chars
+    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
+    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi}", bind('name=?', "Bambi")
+    assert_equal "name=#{quoted_bambi_and_thumper}", bind('name=?', "Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi}", bind('name=?', "Bambi".mb_chars)
+    assert_equal "name=#{quoted_bambi_and_thumper}", bind('name=?', "Bambi\nand\nThumper".mb_chars)
+  end
+
+  def test_bind_record
+    o = Struct.new(:quoted_id).new(1)
+    assert_equal '1', bind('?', o)
+
+    os = [o] * 3
+    assert_equal '1,1,1', bind('?', os)
+  end
+
+  def test_named_bind_with_postgresql_type_casts
+    l = Proc.new { bind(":a::integer '2009-01-01'::date", :a => '10') }
+    assert_nothing_raised(&l)
+    assert_equal "#{ActiveRecord::Base.connection.quote('10')}::integer '2009-01-01'::date", l.call
+  end
+
+  private
+    def bind(statement, *vars)
+      if vars.first.is_a?(Hash)
+        ActiveRecord::Base.send(:replace_named_bind_variables, statement, vars.first)
+      else
+        ActiveRecord::Base.send(:replace_bind_variables, statement, vars)
+      end
+    end
 end

data/test/cases/schema_dumper_test.rb

@@ -3,7 +3,7 @@ require 'support/schema_dumping_helper'
 
 class SchemaDumperTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
-  self.use_transactional_fixtures = false
+  self.use_transactional_tests = false
 
   setup do
     ActiveRecord::SchemaMigration.create_table
@@ -17,6 +17,12 @@ class SchemaDumperTest < ActiveRecord::TestCase
     dump_all_table_schema []
   end
 
+  def test_dump_schema_information_with_empty_versions
+    ActiveRecord::SchemaMigration.delete_all
+    schema_info = ActiveRecord::Base.connection.dump_schema_information
+    assert_no_match(/INSERT INTO/, schema_info)
+  end
+
   def test_dump_schema_information_outputs_lexically_ordered_versions
     versions = %w{ 20100101010101 20100201010101 20100301010101 }
     versions.reverse_each do |v|
@@ -29,15 +35,31 @@ class SchemaDumperTest < ActiveRecord::TestCase
     ActiveRecord::SchemaMigration.delete_all
   end
 
-  def test_magic_comment
-    assert_match "# encoding: #{Encoding.default_external.name}", standard_dump
+  if current_adapter?(:SQLite3Adapter)
+    %w{3.7.8 3.7.11 3.7.12}.each do |version_string|
+      test "dumps schema version for sqlite version #{version_string}" do
+        version = ActiveRecord::ConnectionAdapters::SQLite3Adapter::Version.new(version_string)
+        ActiveRecord::Base.connection.stubs(:sqlite_version).returns(version)
+
+        versions = %w{ 20100101010101 20100201010101 20100301010101 }
+        versions.reverse_each do |v|
+          ActiveRecord::SchemaMigration.create!(:version => v)
+        end
+
+        schema_info = ActiveRecord::Base.connection.dump_schema_information
+        assert_match(/20100201010101.*20100301010101/m, schema_info)
+        ActiveRecord::SchemaMigration.delete_all
+      end
+    end
   end
 
   def test_schema_dump
     output = standard_dump
     assert_match %r{create_table "accounts"}, output
     assert_match %r{create_table "authors"}, output
+    assert_no_match %r{(?<=, ) do \|t\|}, output
     assert_no_match %r{create_table "schema_migrations"}, output
+    assert_no_match %r{create_table "ar_internal_metadata"}, output
   end
 
   def test_schema_dump_uses_force_cascade_on_create_table
@@ -78,10 +100,10 @@ class SchemaDumperTest < ActiveRecord::TestCase
       next if column_set.empty?
 
       lengths = column_set.map do |column|
-        if match = column.match(/t\.(?:integer|decimal|float|datetime|timestamp|time|date|text|binary|string|boolean|uuid|point)\s+"/)
+        if match = column.match(/\bt\.\w+\s+(?="\w+?")/)
           match[0].length
         end
-      end
+      end.compact
 
       assert_equal 1, lengths.uniq.length
     end
@@ -122,8 +144,8 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
       assert_match %r{c_int_4.*}, output
       assert_no_match %r{c_int_4.*limit:}, output
-    elsif current_adapter?(:MysqlAdapter, :Mysql2Adapter)
-      assert_match %r{c_int_without_limit.*limit: 4}, output
+    elsif current_adapter?(:Mysql2Adapter)
+      assert_match %r{c_int_without_limit"$}, output
 
       assert_match %r{c_int_1.*limit: 1}, output
       assert_match %r{c_int_2.*limit: 2}, output
@@ -151,10 +173,10 @@ class SchemaDumperTest < ActiveRecord::TestCase
       assert_match %r{c_int_7.*limit: 7}, output
       assert_match %r{c_int_8.*limit: 8}, output
     else
-      assert_match %r{c_int_5.*limit: 8}, output
-      assert_match %r{c_int_6.*limit: 8}, output
-      assert_match %r{c_int_7.*limit: 8}, output
-      assert_match %r{c_int_8.*limit: 8}, output
+      assert_match %r{t\.bigint\s+"c_int_5"$}, output
+      assert_match %r{t\.bigint\s+"c_int_6"$}, output
+      assert_match %r{t\.bigint\s+"c_int_7"$}, output
+      assert_match %r{t\.bigint\s+"c_int_8"$}, output
     end
   end
 
@@ -163,6 +185,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_no_match %r{create_table "accounts"}, output
     assert_match %r{create_table "authors"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
+    assert_no_match %r{create_table "ar_internal_metadata"}, output
   end
 
   def test_schema_dump_with_regexp_ignored_table
@@ -170,27 +193,30 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_no_match %r{create_table "accounts"}, output
     assert_match %r{create_table "authors"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
+    assert_no_match %r{create_table "ar_internal_metadata"}, output
   end
 
   def test_schema_dumps_index_columns_in_right_order
-    index_definition = standard_dump.split(/\n/).grep(/add_index.*companies/).first.strip
-    if current_adapter?(:MysqlAdapter, :Mysql2Adapter, :PostgreSQLAdapter)
-      assert_equal 'add_index "companies", ["firm_id", "type", "rating"], name: "company_index", using: :btree', index_definition
+    index_definition = standard_dump.split(/\n/).grep(/t\.index.*company_index/).first.strip
+    if current_adapter?(:PostgreSQLAdapter)
+      assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", order: { rating: :desc }, using: :btree', index_definition
+    elsif current_adapter?(:Mysql2Adapter)
+      assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", length: { type: 10 }, using: :btree', index_definition
     else
-      assert_equal 'add_index "companies", ["firm_id", "type", "rating"], name: "company_index"', index_definition
+      assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index"', index_definition
     end
   end
 
   def test_schema_dumps_partial_indices
-    index_definition = standard_dump.split(/\n/).grep(/add_index.*company_partial_index/).first.strip
+    index_definition = standard_dump.split(/\n/).grep(/t\.index.*company_partial_index/).first.strip
     if current_adapter?(:PostgreSQLAdapter)
-      assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", where: "(rating > 10)", using: :btree', index_definition
-    elsif current_adapter?(:MysqlAdapter, :Mysql2Adapter)
-      assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", using: :btree', index_definition
+      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "(rating > 10)", using: :btree', index_definition
+    elsif current_adapter?(:Mysql2Adapter)
+      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", using: :btree', index_definition
     elsif current_adapter?(:SQLite3Adapter) && ActiveRecord::Base.connection.supports_partial_index?
-      assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", where: "rating > 10"', index_definition
+      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "rating > 10"', index_definition
     else
-      assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index"', index_definition
+      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index"', index_definition
     end
   end
 
@@ -206,28 +232,28 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_match %r{t\.boolean\s+"has_fun",.+default: false}, output
   end
 
-  if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+  if current_adapter?(:Mysql2Adapter)
     def test_schema_dump_should_add_default_value_for_mysql_text_field
       output = standard_dump
-      assert_match %r{t.text\s+"body",\s+limit: 65535,\s+null: false$}, output
+      assert_match %r{t\.text\s+"body",\s+limit: 65535,\s+null: false$}, output
     end
 
     def test_schema_dump_includes_length_for_mysql_binary_fields
       output = standard_dump
-      assert_match %r{t.binary\s+"var_binary",\s+limit: 255$}, output
-      assert_match %r{t.binary\s+"var_binary_large",\s+limit: 4095$}, output
+      assert_match %r{t\.binary\s+"var_binary",\s+limit: 255$}, output
+      assert_match %r{t\.binary\s+"var_binary_large",\s+limit: 4095$}, output
     end
 
     def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
       output = standard_dump
-      assert_match %r{t.binary\s+"tiny_blob",\s+limit: 255$}, output
-      assert_match %r{t.binary\s+"normal_blob",\s+limit: 65535$}, output
-      assert_match %r{t.binary\s+"medium_blob",\s+limit: 16777215$}, output
-      assert_match %r{t.binary\s+"long_blob",\s+limit: 4294967295$}, output
-      assert_match %r{t.text\s+"tiny_text",\s+limit: 255$}, output
-      assert_match %r{t.text\s+"normal_text",\s+limit: 65535$}, output
-      assert_match %r{t.text\s+"medium_text",\s+limit: 16777215$}, output
-      assert_match %r{t.text\s+"long_text",\s+limit: 4294967295$}, output
+      assert_match %r{t\.blob\s+"tiny_blob",\s+limit: 255$}, output
+      assert_match %r{t\.binary\s+"normal_blob",\s+limit: 65535$}, output
+      assert_match %r{t\.binary\s+"medium_blob",\s+limit: 16777215$}, output
+      assert_match %r{t\.binary\s+"long_blob",\s+limit: 4294967295$}, output
+      assert_match %r{t\.text\s+"tiny_text",\s+limit: 255$}, output
+      assert_match %r{t\.text\s+"normal_text",\s+limit: 65535$}, output
+      assert_match %r{t\.text\s+"medium_text",\s+limit: 16777215$}, output
+      assert_match %r{t\.text\s+"long_text",\s+limit: 4294967295$}, output
     end
 
     def test_schema_does_not_include_limit_for_emulated_mysql_boolean_fields
@@ -237,32 +263,35 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
     def test_schema_dumps_index_type
       output = standard_dump
-      assert_match %r{add_index "key_tests", \["awesome"\], name: "index_key_tests_on_awesome", type: :fulltext}, output
-      assert_match %r{add_index "key_tests", \["pizza"\], name: "index_key_tests_on_pizza", using: :btree}, output
-    end
-  end
-
-  if mysql_56?
-    def test_schema_dump_includes_datetime_precision
-      output = standard_dump
-      assert_match %r{t.datetime\s+"written_on",\s+precision: 6$}, output
+      assert_match %r{t\.index \["awesome"\], name: "index_key_tests_on_awesome", type: :fulltext}, output
+      assert_match %r{t\.index \["pizza"\], name: "index_key_tests_on_pizza", using: :btree}, output
     end
   end
 
   def test_schema_dump_includes_decimal_options
     output = dump_all_table_schema([/^[^n]/])
-    assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: 2.78}, output
+    assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: "2\.78"}, output
   end
 
   if current_adapter?(:PostgreSQLAdapter)
     def test_schema_dump_includes_bigint_default
       output = standard_dump
-      assert_match %r{t.integer\s+"bigint_default",\s+limit: 8,\s+default: 0}, output
+      assert_match %r{t\.bigint\s+"bigint_default",\s+default: 0}, output
     end
 
     def test_schema_dump_includes_limit_on_array_type
       output = standard_dump
-      assert_match %r{t\.integer\s+"big_int_data_points\",\s+limit: 8,\s+array: true}, output
+      assert_match %r{t\.bigint\s+"big_int_data_points\",\s+array: true}, output
+    end
+
+    def test_schema_dump_allows_array_of_decimal_defaults
+      output = standard_dump
+      assert_match %r{t\.decimal\s+"decimal_array_default",\s+default: \["1.23", "3.45"\],\s+array: true}, output
+    end
+
+    def test_schema_dump_expression_indices
+      index_definition = standard_dump.split(/\n/).grep(/t\.index.*company_expression_index/).first.strip
+      assert_equal 't.index "lower((name)::text)", name: "company_expression_index", using: :btree', index_definition
     end
 
     if ActiveRecord::Base.connection.supports_extensions?
@@ -280,89 +309,20 @@ class SchemaDumperTest < ActiveRecord::TestCase
         assert_no_match %r{enable_extension}, output
       end
     end
-
-    def test_schema_dump_includes_xml_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_xml_data_type"} =~ output
-        assert_match %r{t.xml "data"}, output
-      end
-    end
-
-    def test_schema_dump_includes_inet_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_network_addresses"} =~ output
-        assert_match %r{t.inet\s+"inet_address",\s+default: "192.168.1.1"}, output
-      end
-    end
-
-    def test_schema_dump_includes_cidr_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_network_addresses"} =~ output
-        assert_match %r{t.cidr\s+"cidr_address",\s+default: "192.168.1.0/24"}, output
-      end
-    end
-
-    def test_schema_dump_includes_macaddr_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_network_addresses"} =~ output
-        assert_match %r{t.macaddr\s+"mac_address",\s+default: "ff:ff:ff:ff:ff:ff"}, output
-      end
-    end
-
-    def test_schema_dump_includes_uuid_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_uuids"} =~ output
-        assert_match %r{t.uuid "guid"}, output
-      end
-    end
-
-    def test_schema_dump_includes_hstores_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_hstores"} =~ output
-        assert_match %r[t.hstore "hash_store", default: {}], output
-      end
-    end
-
-    def test_schema_dump_includes_citext_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_citext"} =~ output
-        assert_match %r[t.citext "text_citext"], output
-      end
-    end
-
-    def test_schema_dump_includes_ltrees_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_ltrees"} =~ output
-        assert_match %r[t.ltree "path"], output
-      end
-    end
-
-    def test_schema_dump_includes_arrays_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_arrays"} =~ output
-        assert_match %r[t.text\s+"nicknames",\s+array: true], output
-        assert_match %r[t.integer\s+"commission_by_quarter",\s+array: true], output
-      end
-    end
-
-    def test_schema_dump_includes_tsvector_shorthand_definition
-      output = standard_dump
-      if %r{create_table "postgresql_tsvectors"} =~ output
-        assert_match %r{t.tsvector "text_vector"}, output
-      end
-    end
   end
 
   def test_schema_dump_keeps_large_precision_integer_columns_as_decimal
     output = standard_dump
     # Oracle supports precision up to 38 and it identifies decimals with scale 0 as integers
     if current_adapter?(:OracleAdapter)
-      assert_match %r{t.integer\s+"atoms_in_universe",\s+precision: 38}, output
-    elsif current_adapter?(:IBM_DBAdapter)
+      assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 38}, output
+	elsif current_adapter?(:IBM_DBAdapter)
       # DB2 supports precision up to 31
-      assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 31,\s+scale: 0}, output
+      assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 31,\s+scale: 0}, output    
+    elsif current_adapter?(:FbAdapter)
+      assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 18}, output
     else
-      assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 55}, output
+      assert_match %r{t\.decimal\s+"atoms_in_universe",\s+precision: 55}, output
     end
   end
 
@@ -371,7 +331,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     match = output.match(%r{create_table "goofy_string_id"(.*)do.*\n(.*)\n})
     assert_not_nil(match, "goofy_string_id table not found")
     assert_match %r(id: false), match[1], "no table id not preserved"
-    assert_match %r{t.string\s+"id",.*?null: false$}, match[2], "non-primary key id column not preserved"
+    assert_match %r{t\.string\s+"id",.*?null: false$}, match[2], "non-primary key id column not preserved"
   end
 
   def test_schema_dump_keeps_id_false_when_id_is_false_and_unique_not_null_column_added
@@ -391,7 +351,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     end
   end
 
-  class CreateDogMigration < ActiveRecord::Migration
+  class CreateDogMigration < ActiveRecord::Migration::Current
     def up
       create_table("dog_owners") do |t|
       end
@@ -399,9 +359,9 @@ class SchemaDumperTest < ActiveRecord::TestCase
       create_table("dogs") do |t|
         t.column :name, :string
         t.column :owner_id, :integer
+        t.index [:name]
+        t.foreign_key :dog_owners, column: "owner_id" if supports_foreign_keys?
       end
-      add_index "dogs", [:name]
-      add_foreign_key :dogs, :dog_owners, column: "owner_id" if supports_foreign_keys?
     end
     def down
       drop_table("dogs")
@@ -421,6 +381,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_no_match %r{create_table "foo_.+_bar"}, output
     assert_no_match %r{add_index "foo_.+_bar"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
+    assert_no_match %r{create_table "ar_internal_metadata"}, output
 
     if ActiveRecord::Base.connection.supports_foreign_keys?
       assert_no_match %r{add_foreign_key "foo_.+_bar"}, output
@@ -432,6 +393,38 @@ class SchemaDumperTest < ActiveRecord::TestCase
     ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ''
     $stdout = original
   end
+
+  def test_schema_dump_with_table_name_prefix_and_ignoring_tables
+    original, $stdout = $stdout, StringIO.new
+
+    create_cat_migration = Class.new(ActiveRecord::Migration::Current) do
+      def change
+        create_table("cats") do |t|
+        end
+        create_table("omg_cats") do |t|
+        end
+      end
+    end
+
+    original_table_name_prefix = ActiveRecord::Base.table_name_prefix
+    original_schema_dumper_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+    ActiveRecord::Base.table_name_prefix = 'omg_'
+    ActiveRecord::SchemaDumper.ignore_tables = ["cats"]
+    migration = create_cat_migration.new
+    migration.migrate(:up)
+
+    stream = StringIO.new
+    output = ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream).string
+
+    assert_match %r{create_table "omg_cats"}, output
+    refute_match %r{create_table "cats"}, output
+  ensure
+    migration.migrate(:down)
+    ActiveRecord::Base.table_name_prefix = original_table_name_prefix
+    ActiveRecord::SchemaDumper.ignore_tables = original_schema_dumper_ignore_tables
+
+    $stdout = original
+  end
 end
 
 class SchemaDumperDefaultsTest < ActiveRecord::TestCase
@@ -449,7 +442,8 @@ class SchemaDumperDefaultsTest < ActiveRecord::TestCase
 
   teardown do
     return unless @connection
-    @connection.execute 'DROP TABLE defaults' if @connection.table_exists? 'defaults'
+    @connection.drop_table 'defaults'
+	#, if_exists: true
   end
 
   def test_schema_dump_defaults_with_universally_supported_types