ibm_db 3.0.4 → 5.0.4

data/test/cases/adapters/mysql2/schema_migrations_test.rb

@@ -0,0 +1,59 @@
+require "cases/helper"
+
+class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
+  def test_renaming_index_on_foreign_key
+    connection.add_index "engines", "car_id"
+    connection.add_foreign_key :engines, :cars, name: "fk_engines_cars"
+
+    connection.rename_index("engines", "index_engines_on_car_id", "idx_renamed")
+    assert_equal ["idx_renamed"], connection.indexes("engines").map(&:name)
+  ensure
+    connection.remove_foreign_key :engines, name: "fk_engines_cars"
+  end
+
+  def test_initializes_schema_migrations_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      table_name = ActiveRecord::SchemaMigration.table_name
+      connection.drop_table table_name, if_exists: true
+
+      connection.initialize_schema_migrations_table
+
+      assert connection.column_exists?(table_name, :version, :string, collation: 'utf8_general_ci')
+    end
+  end
+
+  def test_initializes_internal_metadata_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      table_name = ActiveRecord::InternalMetadata.table_name
+      connection.drop_table table_name, if_exists: true
+
+      connection.initialize_internal_metadata_table
+
+      assert connection.column_exists?(table_name, :key, :string, collation: 'utf8_general_ci')
+    end
+  end
+
+  private
+
+  def with_encoding_utf8mb4
+    database_name = connection.current_database
+    database_info = connection.select_one("SELECT * FROM information_schema.schemata WHERE schema_name = '#{database_name}'")
+
+    original_charset = database_info["DEFAULT_CHARACTER_SET_NAME"]
+    original_collation = database_info["DEFAULT_COLLATION_NAME"]
+
+    execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET utf8mb4")
+
+    yield
+  ensure
+    execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET #{original_charset} COLLATE #{original_collation}")
+  end
+
+  def connection
+    @connection ||= ActiveRecord::Base.connection
+  end
+
+  def execute(sql)
+    connection.execute(sql)
+  end
+end

data/test/cases/adapters/mysql2/schema_test.rb

@@ -0,0 +1,126 @@
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Mysql2SchemaTest < ActiveRecord::Mysql2TestCase
+      fixtures :posts
+
+      def setup
+        @connection = ActiveRecord::Base.connection
+        db          = Post.connection_pool.spec.config[:database]
+        table       = Post.table_name
+        @db_name    = db
+
+        @omgpost = Class.new(ActiveRecord::Base) do
+          self.inheritance_column = :disabled
+          self.table_name = "#{db}.#{table}"
+          def self.name; 'Post'; end
+        end
+      end
+
+      def test_float_limits
+        @connection.create_table :mysql_doubles do |t|
+          t.float :float_no_limit
+          t.float :float_short, limit: 5
+          t.float :float_long, limit: 53
+
+          t.float :float_23, limit: 23
+          t.float :float_24, limit: 24
+          t.float :float_25, limit: 25
+        end
+
+        column_no_limit = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_no_limit' }
+        column_short = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_short' }
+        column_long = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_long' }
+
+        column_23 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_23' }
+        column_24 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_24' }
+        column_25 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_25' }
+
+        # Mysql floats are precision 0..24, Mysql doubles are precision 25..53
+        assert_equal 24, column_no_limit.limit
+        assert_equal 24, column_short.limit
+        assert_equal 53, column_long.limit
+
+        assert_equal 24, column_23.limit
+        assert_equal 24, column_24.limit
+        assert_equal 53, column_25.limit
+      ensure
+        @connection.drop_table "mysql_doubles", if_exists: true
+      end
+
+      def test_schema
+        assert @omgpost.first
+      end
+
+      def test_primary_key
+        assert_equal 'id', @omgpost.primary_key
+      end
+
+      def test_data_source_exists?
+        name = @omgpost.table_name
+        assert @connection.data_source_exists?(name), "#{name} data_source should exist"
+      end
+
+      def test_data_source_exists_wrong_schema
+        assert(!@connection.data_source_exists?("#{@db_name}.zomg"), "data_source should not exist")
+      end
+
+      def test_dump_indexes
+        index_a_name = 'index_key_tests_on_snack'
+        index_b_name = 'index_key_tests_on_pizza'
+        index_c_name = 'index_key_tests_on_awesome'
+
+        table = 'key_tests'
+
+        indexes = @connection.indexes(table).sort_by(&:name)
+        assert_equal 3,indexes.size
+
+        index_a = indexes.select{|i| i.name == index_a_name}[0]
+        index_b = indexes.select{|i| i.name == index_b_name}[0]
+        index_c = indexes.select{|i| i.name == index_c_name}[0]
+        assert_equal :btree, index_a.using
+        assert_nil index_a.type
+        assert_equal :btree, index_b.using
+        assert_nil index_b.type
+
+        assert_nil index_c.using
+        assert_equal :fulltext, index_c.type
+      end
+
+      unless mysql_enforcing_gtid_consistency?
+        def test_drop_temporary_table
+          @connection.transaction do
+            @connection.create_table(:temp_table, temporary: true)
+            # if it doesn't properly say DROP TEMPORARY TABLE, the transaction commit
+            # will complain that no transaction is active
+            @connection.drop_table(:temp_table, temporary: true)
+          end
+        end
+      end
+    end
+  end
+end
+
+class Mysql2AnsiQuotesTest < ActiveRecord::Mysql2TestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute("SET SESSION sql_mode='ANSI_QUOTES'")
+  end
+
+  def teardown
+    @connection.reconnect!
+  end
+
+  def test_primary_key_method_with_ansi_quotes
+    assert_equal "id", @connection.primary_key("topics")
+  end
+
+  def test_foreign_keys_method_with_ansi_quotes
+    fks = @connection.foreign_keys("lessons_students")
+    assert_equal([["lessons_students", "students", :cascade]],
+                 fks.map {|fk| [fk.from_table, fk.to_table, fk.on_delete] })
+  end
+end

data/test/cases/adapters/mysql2/sp_test.rb

@@ -0,0 +1,36 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/reply'
+
+class Mysql2StoredProcedureTest < ActiveRecord::Mysql2TestCase
+  fixtures :topics
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    unless ActiveRecord::Base.connection.version >= '5.6.0'
+      skip("no stored procedure support")
+    end
+  end
+
+  # Test that MySQL allows multiple results for stored procedures
+  #
+  # In MySQL 5.6, CLIENT_MULTI_RESULTS is enabled by default.
+  # http://dev.mysql.com/doc/refman/5.6/en/call.html
+  def test_multi_results
+    rows = @connection.select_rows('CALL ten();')
+    assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
+    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_rows'"
+  end
+
+  def test_multi_results_from_select_one
+    row = @connection.select_one('CALL topics(1);')
+    assert_equal 'David', row['author_name']
+    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_one'"
+  end
+
+  def test_multi_results_from_find_by_sql
+    topics = Topic.find_by_sql 'CALL topics(3);'
+    assert_equal 3, topics.size
+    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select'"
+  end
+end

data/test/cases/adapters/mysql2/sql_types_test.rb

@@ -0,0 +1,14 @@
+require "cases/helper"
+
+class Mysql2SqlTypesTest < ActiveRecord::Mysql2TestCase
+  def test_binary_types
+    assert_equal 'varbinary(64)', type_to_sql(:binary, 64)
+    assert_equal 'varbinary(4095)', type_to_sql(:binary, 4095)
+    assert_equal 'blob', type_to_sql(:binary, 4096)
+    assert_equal 'blob', type_to_sql(:binary)
+  end
+
+  def type_to_sql(*args)
+    ActiveRecord::Base.connection.type_to_sql(*args)
+  end
+end

data/test/cases/adapters/mysql2/table_options_test.rb

@@ -0,0 +1,42 @@
+require "cases/helper"
+require 'support/schema_dumping_helper'
+
+class Mysql2TableOptionsTest < ActiveRecord::Mysql2TestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.drop_table "mysql_table_options", if_exists: true
+  end
+
+  test "table options with ENGINE" do
+    @connection.create_table "mysql_table_options", force: true, options: "ENGINE=MyISAM"
+    output = dump_table_schema("mysql_table_options")
+    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
+    assert_match %r{ENGINE=MyISAM}, options
+  end
+
+  test "table options with ROW_FORMAT" do
+    @connection.create_table "mysql_table_options", force: true, options: "ROW_FORMAT=REDUNDANT"
+    output = dump_table_schema("mysql_table_options")
+    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
+    assert_match %r{ROW_FORMAT=REDUNDANT}, options
+  end
+
+  test "table options with CHARSET" do
+    @connection.create_table "mysql_table_options", force: true, options: "CHARSET=utf8mb4"
+    output = dump_table_schema("mysql_table_options")
+    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
+    assert_match %r{CHARSET=utf8mb4}, options
+  end
+
+  test "table options with COLLATE" do
+    @connection.create_table "mysql_table_options", force: true, options: "COLLATE=utf8mb4_bin"
+    output = dump_table_schema("mysql_table_options")
+    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
+    assert_match %r{COLLATE=utf8mb4_bin}, options
+  end
+end

data/test/cases/adapters/mysql2/unsigned_type_test.rb

@@ -0,0 +1,66 @@
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
+  include SchemaDumpingHelper
+  self.use_transactional_tests = false
+
+  class UnsignedType < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table("unsigned_types", force: true) do |t|
+      t.integer :unsigned_integer, unsigned: true
+      t.bigint  :unsigned_bigint,  unsigned: true
+      t.float   :unsigned_float,   unsigned: true
+      t.decimal :unsigned_decimal, unsigned: true, precision: 10, scale: 2
+    end
+  end
+
+  teardown do
+    @connection.drop_table "unsigned_types", if_exists: true
+  end
+
+  test "unsigned int max value is in range" do
+    assert expected = UnsignedType.create(unsigned_integer: 4294967295)
+    assert_equal expected, UnsignedType.find_by(unsigned_integer: 4294967295)
+  end
+
+  test "minus value is out of range" do
+    assert_raise(ActiveModel::RangeError) do
+      UnsignedType.create(unsigned_integer: -10)
+    end
+    assert_raise(ActiveModel::RangeError) do
+      UnsignedType.create(unsigned_bigint: -10)
+    end
+    assert_raise(ActiveRecord::StatementInvalid) do
+      UnsignedType.create(unsigned_float: -10.0)
+    end
+    assert_raise(ActiveRecord::StatementInvalid) do
+      UnsignedType.create(unsigned_decimal: -10.0)
+    end
+  end
+
+  test "schema definition can use unsigned as the type" do
+    @connection.change_table("unsigned_types") do |t|
+      t.unsigned_integer :unsigned_integer_t
+      t.unsigned_bigint  :unsigned_bigint_t
+      t.unsigned_float   :unsigned_float_t
+      t.unsigned_decimal :unsigned_decimal_t, precision: 10, scale: 2
+      t.column :unsigned_zerofill, "int unsigned zerofill"
+    end
+
+    @connection.columns("unsigned_types").select { |c| /^unsigned_/ === c.name }.each do |column|
+      assert column.unsigned?
+    end
+  end
+
+  test "schema dump includes unsigned option" do
+    schema = dump_table_schema "unsigned_types"
+    assert_match %r{t.integer\s+"unsigned_integer",\s+unsigned: true$}, schema
+    assert_match %r{t.bigint\s+"unsigned_bigint",\s+unsigned: true$}, schema
+    assert_match %r{t.float\s+"unsigned_float",\s+limit: 24,\s+unsigned: true$}, schema
+    assert_match %r{t.decimal\s+"unsigned_decimal",\s+precision: 10,\s+scale: 2,\s+unsigned: true$}, schema
+  end
+end

data/test/cases/adapters/postgresql/active_schema_test.rb

@@ -0,0 +1,98 @@
+require 'cases/helper'
+
+class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+      def execute(sql, name = nil) sql end
+    end
+  end
+
+  teardown do
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+      remove_method :execute
+    end
+  end
+
+  def test_create_database_with_encoding
+    assert_equal %(CREATE DATABASE "matt" ENCODING = 'utf8'), create_database(:matt)
+    assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'latin1'), create_database(:aimonetti, :encoding => :latin1)
+    assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'latin1'), create_database(:aimonetti, 'encoding' => :latin1)
+  end
+
+  def test_create_database_with_collation_and_ctype
+    assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'UTF8' LC_COLLATE = 'ja_JP.UTF8' LC_CTYPE = 'ja_JP.UTF8'), create_database(:aimonetti, :encoding => :"UTF8", :collation => :"ja_JP.UTF8", :ctype => :"ja_JP.UTF8")
+  end
+
+  def test_add_index
+    # add_index calls index_name_exists? which can't work since execute is stubbed
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_exists?) { |*| false }
+
+    expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name" ON "people"  ("last_name") WHERE state = 'active')
+    assert_equal expected, add_index(:people, :last_name, unique: true, where: "state = 'active'")
+
+    expected = %(CREATE UNIQUE INDEX  "index_people_on_lower_last_name" ON "people"  (lower(last_name)))
+    assert_equal expected, add_index(:people, 'lower(last_name)', unique: true)
+
+    expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name_varchar_pattern_ops" ON "people"  (last_name varchar_pattern_ops))
+    assert_equal expected, add_index(:people, 'last_name varchar_pattern_ops', unique: true)
+
+    expected = %(CREATE  INDEX CONCURRENTLY "index_people_on_last_name" ON "people"  ("last_name"))
+    assert_equal expected, add_index(:people, :last_name, algorithm: :concurrently)
+
+    expected = %(CREATE  INDEX  "index_people_on_last_name_and_first_name" ON "people"  ("last_name" DESC, "first_name" ASC))
+    assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: :desc, first_name: :asc })
+    assert_equal expected, add_index(:people, ["last_name", :first_name], order: { last_name: :desc, "first_name" => :asc })
+
+    %w(gin gist hash btree).each do |type|
+      expected = %(CREATE  INDEX  "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+      assert_equal expected, add_index(:people, :last_name, using: type)
+
+      expected = %(CREATE  INDEX CONCURRENTLY "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+      assert_equal expected, add_index(:people, :last_name, using: type, algorithm: :concurrently)
+
+      expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name" ON "people" USING #{type} ("last_name") WHERE state = 'active')
+      assert_equal expected, add_index(:people, :last_name, using: type, unique: true, where: "state = 'active'")
+
+      expected = %(CREATE UNIQUE INDEX  "index_people_on_lower_last_name" ON "people" USING #{type} (lower(last_name)))
+      assert_equal expected, add_index(:people, 'lower(last_name)', using: type, unique: true)
+    end
+
+    assert_raise ArgumentError do
+      add_index(:people, :last_name, algorithm: :copy)
+    end
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :remove_method, :index_name_exists?
+  end
+
+  def test_remove_index
+    # remove_index calls index_name_for_remove which can't work since execute is stubbed
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_for_remove) do |*|
+      'index_people_on_last_name'
+    end
+
+    expected = %(DROP INDEX CONCURRENTLY "index_people_on_last_name")
+    assert_equal expected, remove_index(:people, name: "index_people_on_last_name", algorithm: :concurrently)
+
+    assert_raise ArgumentError do
+      add_index(:people, :last_name, algorithm: :copy)
+    end
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :remove_method, :index_name_for_remove
+  end
+
+  def test_remove_index_when_name_is_specified
+    expected = %(DROP INDEX CONCURRENTLY "index_people_on_last_name")
+    assert_equal expected, remove_index(:people, name: "index_people_on_last_name", algorithm: :concurrently)
+  end
+
+  def test_remove_index_with_wrong_option
+    assert_raises ArgumentError do
+      remove_index(:people, coulmn: :last_name)
+    end
+  end
+
+  private
+    def method_missing(method_symbol, *arguments)
+      ActiveRecord::Base.connection.send(method_symbol, *arguments)
+    end
+end