ibm_db 3.0.3-x86-mingw32 → 5.0.3-x86-mingw32

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

@@ -0,0 +1,193 @@
+require "cases/helper"
+require 'support/connection_helper'
+
+class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
+  include ConnectionHelper
+
+  def setup
+    ActiveRecord::Base.connection.singleton_class.class_eval do
+      alias_method :execute_without_stub, :execute
+      def execute(sql, name = nil) return sql end
+    end
+  end
+
+  teardown do
+    reset_connection
+  end
+
+  def test_add_index
+    # add_index calls data_source_exists? and index_name_exists? which can't work since execute is stubbed
+    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
+    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
+
+    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
+    assert_equal expected, add_index(:people, :last_name, :length => nil)
+
+    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`(10)) "
+    assert_equal expected, add_index(:people, :last_name, :length => 10)
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(15)) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: 15)
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: { last_name: 15 })
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(10)) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
+    assert_equal expected, add_index(:people, ["last_name", :first_name], length: { last_name: 15, "first_name" => 10 })
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "CREATE #{type} INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
+      assert_equal expected, add_index(:people, :last_name, :type => type)
+    end
+
+    %w(btree hash).each do |using|
+      expected = "CREATE  INDEX `index_people_on_last_name` USING #{using} ON `people` (`last_name`) "
+      assert_equal expected, add_index(:people, :last_name, :using => using)
+    end
+
+    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) "
+    assert_equal expected, add_index(:people, :last_name, :length => 10, :using => :btree)
+
+    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) ALGORITHM = COPY"
+    assert_equal expected, add_index(:people, :last_name, :length => 10, using: :btree, algorithm: :copy)
+
+    assert_raise ArgumentError do
+      add_index(:people, :last_name, algorithm: :coyp)
+    end
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` USING btree ON `people` (`last_name`(15), `first_name`(15)) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], :length => 15, :using => :btree)
+  end
+
+  def test_index_in_create
+    def (ActiveRecord::Base.connection).data_source_exists?(*); false; end
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "CREATE TABLE `people` (#{type} INDEX `index_people_on_last_name`  (`last_name`)) ENGINE=InnoDB"
+      actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
+        t.index :last_name, type: type
+      end
+      assert_equal expected, actual
+    end
+
+    expected = "CREATE TABLE `people` ( INDEX `index_people_on_last_name` USING btree (`last_name`(10))) ENGINE=InnoDB"
+    actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
+      t.index :last_name, length: 10, using: :btree
+    end
+    assert_equal expected, actual
+  end
+
+  def test_index_in_bulk_change
+    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
+    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "ALTER TABLE `people` ADD #{type} INDEX `index_people_on_last_name`  (`last_name`)"
+      actual = ActiveRecord::Base.connection.change_table(:people, bulk: true) do |t|
+        t.index :last_name, type: type
+      end
+      assert_equal expected, actual
+    end
+
+    expected = "ALTER TABLE `peaple` ADD  INDEX `index_peaple_on_last_name` USING btree (`last_name`(10)), ALGORITHM = COPY"
+    actual = ActiveRecord::Base.connection.change_table(:peaple, bulk: true) do |t|
+      t.index :last_name, length: 10, using: :btree, algorithm: :copy
+    end
+    assert_equal expected, actual
+  end
+
+  def test_drop_table
+    assert_equal "DROP TABLE `people`", drop_table(:people)
+  end
+
+  def test_create_mysql_database_with_encoding
+    assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt)
+    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => 'latin1'})
+    assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, {:charset => :big5, :collation => :big5_chinese_ci})
+  end
+
+  def test_recreate_mysql_database_with_encoding
+    create_database(:luca, {:charset => 'latin1'})
+    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, {:charset => 'latin1'})
+  end
+
+  def test_add_column
+    assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
+  end
+
+  def test_add_column_with_limit
+    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32)
+  end
+
+  def test_drop_table_with_specific_database
+    assert_equal "DROP TABLE `otherdb`.`people`", drop_table('otherdb.people')
+  end
+
+  def test_add_timestamps
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me
+        ActiveRecord::Base.connection.add_timestamps :delete_me, null: true
+        assert column_present?('delete_me', 'updated_at', 'datetime')
+        assert column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
+    end
+  end
+
+  def test_remove_timestamps
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me do |t|
+          t.timestamps null: true
+        end
+        ActiveRecord::Base.connection.remove_timestamps :delete_me, { null: true }
+        assert !column_present?('delete_me', 'updated_at', 'datetime')
+        assert !column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
+    end
+  end
+
+  def test_indexes_in_create
+    ActiveRecord::Base.connection.stubs(:data_source_exists?).with(:temp).returns(false)
+    ActiveRecord::Base.connection.stubs(:index_name_exists?).with(:index_temp_on_zip).returns(false)
+
+    expected = "CREATE TEMPORARY TABLE `temp` ( INDEX `index_temp_on_zip`  (`zip`)) ENGINE=InnoDB AS SELECT id, name, zip FROM a_really_complicated_query"
+    actual = ActiveRecord::Base.connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
+      t.index :zip
+    end
+
+    assert_equal expected, actual
+  end
+
+  private
+    def with_real_execute
+      ActiveRecord::Base.connection.singleton_class.class_eval do
+        alias_method :execute_with_stub, :execute
+        remove_method :execute
+        alias_method :execute, :execute_without_stub
+      end
+
+      yield
+    ensure
+      ActiveRecord::Base.connection.singleton_class.class_eval do
+        remove_method :execute
+        alias_method :execute, :execute_with_stub
+      end
+    end
+
+    def method_missing(method_symbol, *arguments)
+      ActiveRecord::Base.connection.send(method_symbol, *arguments)
+    end
+
+    def column_present?(table_name, column_name, type)
+      results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
+      results.first && results.first['Type'] == type
+    end
+end

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

@@ -0,0 +1,50 @@
+require "cases/helper"
+require 'models/topic'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Mysql2Adapter
+      class BindParameterTest < ActiveRecord::Mysql2TestCase
+        fixtures :topics
+
+        def test_update_question_marks
+          str       = "foo?bar"
+          x         = Topic.first
+          x.title   = str
+          x.content = str
+          x.save!
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_create_question_marks
+          str = "foo?bar"
+          x   = Topic.create!(:title => str, :content => str)
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_update_null_bytes
+          str       = "foo\0bar"
+          x         = Topic.first
+          x.title   = str
+          x.content = str
+          x.save!
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_create_null_bytes
+          str = "foo\0bar"
+          x   = Topic.create!(:title => str, :content => str)
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require "cases/helper"
+
+class Mysql2BooleanTest < ActiveRecord::Mysql2TestCase
+  self.use_transactional_tests = false
+
+  class BooleanType < ActiveRecord::Base
+    self.table_name = "mysql_booleans"
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.clear_cache!
+    @connection.create_table("mysql_booleans") do |t|
+      t.boolean "archived"
+      t.string "published", limit: 1
+    end
+    BooleanType.reset_column_information
+
+    @emulate_booleans = ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans
+  end
+
+  teardown do
+    emulate_booleans @emulate_booleans
+    @connection.drop_table "mysql_booleans"
+  end
+
+  test "column type with emulated booleans" do
+    emulate_booleans true
+
+    assert_equal :boolean, boolean_column.type
+    assert_equal :string, string_column.type
+  end
+
+  test "column type without emulated booleans" do
+    emulate_booleans false
+
+    assert_equal :integer, boolean_column.type
+    assert_equal :string, string_column.type
+  end
+
+  test "test type casting with emulated booleans" do
+    emulate_booleans true
+
+    boolean = BooleanType.create!(archived: true, published: true)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 1, attributes["archived"]
+    assert_equal "1", attributes["published"]
+
+    boolean = BooleanType.create!(archived: false, published: false)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 0, attributes["archived"]
+    assert_equal "0", attributes["published"]
+
+    assert_equal 1, @connection.type_cast(true)
+    assert_equal 0, @connection.type_cast(false)
+  end
+
+  test "test type casting without emulated booleans" do
+    emulate_booleans false
+
+    boolean = BooleanType.create!(archived: true, published: true)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 1, attributes["archived"]
+    assert_equal "1", attributes["published"]
+
+    boolean = BooleanType.create!(archived: false, published: false)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 0, attributes["archived"]
+    assert_equal "0", attributes["published"]
+
+    assert_equal 1, @connection.type_cast(true)
+    assert_equal 0, @connection.type_cast(false)
+  end
+
+  test "with booleans stored as 1 and 0" do
+    @connection.execute "INSERT INTO mysql_booleans(archived, published) VALUES(1, '1')"
+    boolean = BooleanType.first
+    assert_equal true, boolean.archived
+    assert_equal "1", boolean.published
+  end
+
+  test "with booleans stored as t" do
+    @connection.execute "INSERT INTO mysql_booleans(published) VALUES('t')"
+    boolean = BooleanType.first
+    assert_equal "t", boolean.published
+  end
+
+  def boolean_column
+    BooleanType.columns.find { |c| c.name == 'archived' }
+  end
+
+  def string_column
+    BooleanType.columns.find { |c| c.name == 'published' }
+  end
+
+  def emulate_booleans(value)
+    ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans = value
+    BooleanType.reset_column_information
+  end
+end

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

@@ -0,0 +1,63 @@
+require "cases/helper"
+
+class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
+  class CollationTest < ActiveRecord::Base
+  end
+
+  repair_validations(CollationTest)
+
+  def test_columns_include_collation_different_from_table
+    assert_equal 'utf8_bin', CollationTest.columns_hash['string_cs_column'].collation
+    assert_equal 'utf8_general_ci', CollationTest.columns_hash['string_ci_column'].collation
+  end
+
+  def test_case_sensitive
+    assert !CollationTest.columns_hash['string_ci_column'].case_sensitive?
+    assert CollationTest.columns_hash['string_cs_column'].case_sensitive?
+  end
+
+  def test_case_insensitive_comparison_for_ci_column
+    CollationTest.validates_uniqueness_of(:string_ci_column, :case_sensitive => false)
+    CollationTest.create!(:string_ci_column => 'A')
+    invalid = CollationTest.new(:string_ci_column => 'a')
+    queries = assert_sql { invalid.save }
+    ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
+    assert_no_match(/lower/i, ci_uniqueness_query)
+  end
+
+  def test_case_insensitive_comparison_for_cs_column
+    CollationTest.validates_uniqueness_of(:string_cs_column, :case_sensitive => false)
+    CollationTest.create!(:string_cs_column => 'A')
+    invalid = CollationTest.new(:string_cs_column => 'a')
+    queries = assert_sql { invalid.save }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/)}
+    assert_match(/lower/i, cs_uniqueness_query)
+  end
+
+  def test_case_sensitive_comparison_for_ci_column
+    CollationTest.validates_uniqueness_of(:string_ci_column, :case_sensitive => true)
+    CollationTest.create!(:string_ci_column => 'A')
+    invalid = CollationTest.new(:string_ci_column => 'A')
+    queries = assert_sql { invalid.save }
+    ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
+    assert_match(/binary/i, ci_uniqueness_query)
+  end
+
+  def test_case_sensitive_comparison_for_cs_column
+    CollationTest.validates_uniqueness_of(:string_cs_column, :case_sensitive => true)
+    CollationTest.create!(:string_cs_column => 'A')
+    invalid = CollationTest.new(:string_cs_column => 'A')
+    queries = assert_sql { invalid.save }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
+    assert_no_match(/binary/i, cs_uniqueness_query)
+  end
+
+  def test_case_sensitive_comparison_for_binary_column
+    CollationTest.validates_uniqueness_of(:binary_column, case_sensitive: true)
+    CollationTest.create!(binary_column: 'A')
+    invalid = CollationTest.new(binary_column: 'A')
+    queries = assert_sql { invalid.save }
+    bin_uniqueness_query = queries.detect { |q| q.match(/binary_column/) }
+    assert_no_match(/\bBINARY\b/, bin_uniqueness_query)
+  end
+end

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

@@ -0,0 +1,54 @@
+require "cases/helper"
+require 'support/schema_dumping_helper'
+
+class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
+  include SchemaDumpingHelper
+  self.use_transactional_tests = false
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table :charset_collations, force: true do |t|
+      t.string :string_ascii_bin, charset: 'ascii', collation: 'ascii_bin'
+      t.text :text_ucs2_unicode_ci, charset: 'ucs2', collation: 'ucs2_unicode_ci'
+    end
+  end
+
+  teardown do
+    @connection.drop_table :charset_collations, if_exists: true
+  end
+
+  test "string column with charset and collation" do
+    column = @connection.columns(:charset_collations).find { |c| c.name == 'string_ascii_bin' }
+    assert_equal :string, column.type
+    assert_equal 'ascii_bin', column.collation
+  end
+
+  test "text column with charset and collation" do
+    column = @connection.columns(:charset_collations).find { |c| c.name == 'text_ucs2_unicode_ci' }
+    assert_equal :text, column.type
+    assert_equal 'ucs2_unicode_ci', column.collation
+  end
+
+  test "add column with charset and collation" do
+    @connection.add_column :charset_collations, :title, :string, charset: 'utf8', collation: 'utf8_bin'
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == 'title' }
+    assert_equal :string, column.type
+    assert_equal 'utf8_bin', column.collation
+  end
+
+  test "change column with charset and collation" do
+    @connection.add_column :charset_collations, :description, :string, charset: 'utf8', collation: 'utf8_unicode_ci'
+    @connection.change_column :charset_collations, :description, :text, charset: 'utf8', collation: 'utf8_general_ci'
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == 'description' }
+    assert_equal :text, column.type
+    assert_equal 'utf8_general_ci', column.collation
+  end
+
+  test "schema dump includes collation" do
+    output = dump_table_schema("charset_collations")
+    assert_match %r{t.string\s+"string_ascii_bin",\s+collation: "ascii_bin"$}, output
+    assert_match %r{t.text\s+"text_ucs2_unicode_ci",\s+limit: 65535,\s+collation: "ucs2_unicode_ci"$}, output
+  end
+end