ibm_db 3.0.4 → 5.0.4

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

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

@@ -0,0 +1,210 @@
+require "cases/helper"
+require 'support/connection_helper'
+
+class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
+  include ConnectionHelper
+
+  fixtures :comments
+
+  def setup
+    super
+    @subscriber = SQLSubscriber.new
+    @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    ActiveSupport::Notifications.unsubscribe(@subscription)
+    super
+  end
+
+  def test_bad_connection
+    assert_raise ActiveRecord::NoDatabaseError do
+      configuration = ActiveRecord::Base.configurations['arunit'].merge(database: 'inexistent_activerecord_unittest')
+      connection = ActiveRecord::Base.mysql2_connection(configuration)
+      connection.drop_table 'ex', if_exists: true
+    end
+  end
+
+  def test_truncate
+    rows = ActiveRecord::Base.connection.exec_query("select count(*) from comments")
+    count = rows.first.values.first
+    assert_operator count, :>, 0
+
+    ActiveRecord::Base.connection.truncate("comments")
+    rows = ActiveRecord::Base.connection.exec_query("select count(*) from comments")
+    count = rows.first.values.first
+    assert_equal 0, count
+  end
+
+  def test_no_automatic_reconnection_after_timeout
+    assert @connection.active?
+    @connection.update('set @@wait_timeout=1')
+    sleep 2
+    assert !@connection.active?
+
+    # Repair all fixture connections so other tests won't break.
+    @fixture_connections.each(&:verify!)
+  end
+
+  def test_successful_reconnection_after_timeout_with_manual_reconnect
+    assert @connection.active?
+    @connection.update('set @@wait_timeout=1')
+    sleep 2
+    @connection.reconnect!
+    assert @connection.active?
+  end
+
+  def test_successful_reconnection_after_timeout_with_verify
+    assert @connection.active?
+    @connection.update('set @@wait_timeout=1')
+    sleep 2
+    @connection.verify!
+    assert @connection.active?
+  end
+
+  def test_execute_after_disconnect
+    @connection.disconnect!
+
+    assert_raise(ActiveRecord::StatementInvalid) do
+      @connection.execute("SELECT 1")
+    end
+  end
+
+  def test_quote_after_disconnect
+    @connection.disconnect!
+
+    assert_raise(Mysql2::Error) do
+      @connection.quote("string")
+    end
+  end
+
+  def test_active_after_disconnect
+    @connection.disconnect!
+    assert_equal false, @connection.active?
+  end
+
+  def test_wait_timeout_as_string
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(wait_timeout: "60"))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.wait_timeout")
+      assert_equal 60, result
+    end
+  end
+
+  def test_wait_timeout_as_url
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge("url" => "mysql2:///?wait_timeout=60"))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.wait_timeout")
+      assert_equal 60, result
+    end
+  end
+
+  def test_mysql_connection_collation_is_configured
+    assert_equal 'utf8_unicode_ci', @connection.show_variable('collation_connection')
+    assert_equal 'utf8_general_ci', ARUnit2Model.connection.show_variable('collation_connection')
+  end
+
+  def test_mysql_default_in_strict_mode
+    result = @connection.select_value("SELECT @@SESSION.sql_mode")
+    assert_match %r(STRICT_ALL_TABLES), result
+  end
+
+  def test_mysql_strict_mode_disabled
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: false))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
+      assert_no_match %r(STRICT_ALL_TABLES), result
+    end
+  end
+
+  def test_mysql_strict_mode_specified_default
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: :default))
+      global_sql_mode = ActiveRecord::Base.connection.select_value("SELECT @@GLOBAL.sql_mode")
+      session_sql_mode = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
+      assert_equal global_sql_mode, session_sql_mode
+    end
+  end
+
+  def test_mysql_sql_mode_variable_overrides_strict_mode
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { 'sql_mode' => 'ansi' }))
+      result = ActiveRecord::Base.connection.select_value('SELECT @@SESSION.sql_mode')
+      assert_no_match %r(STRICT_ALL_TABLES), result
+    end
+  end
+
+  def test_passing_arbitary_flags_to_adapter
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge({flags: Mysql2::Client::COMPRESS}))
+      assert_equal (Mysql2::Client::COMPRESS |  Mysql2::Client::FOUND_ROWS), ActiveRecord::Base.connection.raw_connection.query_options[:flags]
+    end
+  end
+
+  def test_passing_flags_by_array_to_adapter
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge({flags: ['COMPRESS'] }))
+      assert_equal ["COMPRESS", "FOUND_ROWS"], ActiveRecord::Base.connection.raw_connection.query_options[:flags]
+    end
+  end
+
+  def test_mysql_set_session_variable
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge({:variables => {:default_week_format => 3}}))
+      session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
+      assert_equal 3, session_mode.rows.first.first.to_i
+    end
+  end
+
+  def test_mysql_set_session_variable_to_default
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge({:variables => {:default_week_format => :default}}))
+      global_mode = ActiveRecord::Base.connection.exec_query "SELECT @@GLOBAL.DEFAULT_WEEK_FORMAT"
+      session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
+      assert_equal global_mode.rows, session_mode.rows
+    end
+  end
+
+  def test_logs_name_show_variable
+    @connection.show_variable 'foo'
+    assert_equal "SCHEMA", @subscriber.logged[0][1]
+  end
+
+  def test_logs_name_rename_column_sql
+    @connection.execute "CREATE TABLE `bar_baz` (`foo` varchar(255))"
+    @subscriber.logged.clear
+    @connection.send(:rename_column_sql, 'bar_baz', 'foo', 'foo2')
+    assert_equal "SCHEMA", @subscriber.logged[0][1]
+  ensure
+    @connection.execute "DROP TABLE `bar_baz`"
+  end
+
+  def test_get_and_release_advisory_lock
+    lock_name = "test_lock_name"
+
+    got_lock = @connection.get_advisory_lock(lock_name)
+    assert got_lock, "get_advisory_lock should have returned true but it didn't"
+
+    assert_equal test_lock_free(lock_name), false,
+      "expected the test advisory lock to be held but it wasn't"
+
+    released_lock = @connection.release_advisory_lock(lock_name)
+    assert released_lock, "expected release_advisory_lock to return true but it didn't"
+
+    assert test_lock_free(lock_name), 'expected the test lock to be available after releasing'
+  end
+
+  def test_release_non_existent_advisory_lock
+    lock_name = "fake_lock_name"
+    released_non_existent_lock = @connection.release_advisory_lock(lock_name)
+    assert_equal released_non_existent_lock, false,
+      'expected release_advisory_lock to return false when there was no lock to release'
+  end
+
+  protected
+
+  def test_lock_free(lock_name)
+    @connection.select_value("SELECT IS_FREE_LOCK('#{lock_name}');") == 1
+  end
+end