ibm_db 5.6.1 → 5.7.0

data/test/cases/adapters/abstract_mysql_adapter/nested_deadlock_test.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  class NestedDeadlockTest < ActiveRecord::AbstractMysqlTestCase
+    self.use_transactional_tests = false
+
+    class Sample < ActiveRecord::Base
+      self.table_name = "samples"
+    end
+
+    setup do
+      @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
+      Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
+
+      connection = ActiveRecord::Base.lease_connection
+      connection.clear_cache!
+
+      connection.create_table("samples", force: true) do |t|
+        t.integer "value"
+      end
+
+      Sample.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "deadlock correctly raises Deadlocked inside nested SavepointTransaction" do
+      connection = Sample.lease_connection
+      assert_raises(ActiveRecord::Deadlocked) do
+        barrier = Concurrent::CyclicBarrier.new(2)
+
+        s1 = Sample.create value: 1
+        s2 = Sample.create value: 2
+
+        begin
+          thread = Thread.new do
+            Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s1.lock!
+                barrier.wait
+                s2.update value: 1
+              end
+            end
+          end
+
+          begin
+            Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s2.lock!
+                barrier.wait
+                s1.update value: 2
+              end
+            end
+          ensure
+            thread.join
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          if /SAVEPOINT active_record_. does not exist/ =~ e.to_s
+            flunk "ROLLBACK TO SAVEPOINT query issued for savepoint that no longer exists due to deadlock: #{e}"
+          else
+            raise e
+          end
+        end
+      end
+      assert_predicate connection, :active?
+    end
+
+    test "rollback exception is swallowed after a rollback" do
+      barrier = Concurrent::CyclicBarrier.new(2)
+      deadlocks = 0
+
+      s1 = Sample.create value: 1
+      s2 = Sample.create value: 2
+
+      thread = Thread.new do
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          Sample.transaction(requires_new: true) do
+            assert_current_transaction_is_savepoint_transaction
+            s1.lock!
+            barrier.wait
+            s2.update value: 4
+
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+
+            # This rollback is actually wrong as mysql automatically rollbacks the transaction
+            # which means we have nothing to rollback on the db side
+            # but we expect the framework to handle our mistake gracefully
+            raise ActiveRecord::Rollback
+          end
+
+          s2.update value: 10
+        end
+      end
+
+      begin
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          Sample.transaction(requires_new: true) do
+            assert_current_transaction_is_savepoint_transaction
+            s2.lock!
+            barrier.wait
+            s1.update value: 3
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+            raise ActiveRecord::Rollback
+          end
+          s1.update value: 10
+        end
+      ensure
+        thread.join
+      end
+
+      assert_equal 1, deadlocks, "deadlock is required for the test setup"
+      assert_equal [10, 10], Sample.pluck(:value)
+    end
+
+    test "deadlock inside nested SavepointTransaction is recoverable" do
+      barrier = Concurrent::CyclicBarrier.new(2)
+      deadlocks = 0
+
+      s1 = Sample.create value: 1
+      s2 = Sample.create value: 2
+
+      thread = Thread.new do
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          begin
+            Sample.transaction(requires_new: true) do
+              assert_current_transaction_is_savepoint_transaction
+              s1.lock!
+              barrier.wait
+              s2.update value: 4
+            end
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+          end
+          s2.update value: 10
+        end
+      end
+
+      begin
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          begin
+            Sample.transaction(requires_new: true) do
+              assert_current_transaction_is_savepoint_transaction
+              s2.lock!
+              barrier.wait
+              s1.update value: 3
+            end
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+          end
+          s1.update value: 10
+        end
+      ensure
+        thread.join
+      end
+      assert_equal 1, deadlocks
+      assert_equal [10, 10], Sample.pluck(:value)
+    end
+
+    private
+      # This should cause the next nested transaction to be a savepoint transaction.
+      def make_parent_transaction_dirty
+        Sample.take
+      end
+
+      def assert_current_transaction_is_savepoint_transaction
+        current_transaction = Sample.lease_connection.current_transaction
+        unless current_transaction.is_a?(ActiveRecord::ConnectionAdapters::SavepointTransaction)
+          flunk("current transaction is not a savepoint transaction")
+        end
+      end
+  end
+end

data/test/cases/adapters/abstract_mysql_adapter/optimizer_hints_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+class OptimizerHintsTest < ActiveRecord::AbstractMysqlTestCase
+  if supports_optimizer_hints?
+    fixtures :posts
+
+    def test_optimizer_hints
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain.inspect, "index_posts_on_author_id"
+      end
+    end
+
+    def test_optimizer_hints_with_count_subquery
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+        posts = posts.select(:id).where(author_id: [0, 1]).limit(5)
+        assert_equal 5, posts.count
+      end
+    end
+
+    def test_optimizer_hints_is_sanitized
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("/*+ NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain.inspect, "index_posts_on_author_id"
+      end
+
+      assert_queries_match(%r{\ASELECT /\*\+ \*\* // `posts`\.\*, // \*\* \*/}) do
+        posts = Post.optimizer_hints("**// `posts`.*, //**")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_equal({ "id" => 1 }, posts.first.as_json)
+      end
+    end
+
+    def test_optimizer_hints_with_unscope
+      assert_queries_match(%r{\ASELECT `posts`\.`id`}) do
+        posts = Post.optimizer_hints("/*+ NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        posts.unscope(:optimizer_hints).load
+      end
+    end
+
+    def test_optimizer_hints_with_or
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+          .or(Post.all).load
+      end
+
+      queries = capture_sql do
+        Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+          .or(Post.optimizer_hints("NO_ICP(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_includes queries.first, "NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)"
+      assert_not_includes queries.first, "NO_ICP(posts)"
+
+      queries = capture_sql do
+        Post.all.or(Post.optimizer_hints("NO_ICP(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_not_includes queries.first, "NO_ICP(posts)"
+    end
+  end
+end

data/test/cases/adapters/abstract_mysql_adapter/quoting_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class QuotingTest < ActiveRecord::AbstractMysqlTestCase
+  def setup
+    super
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  def test_cast_bound_integer
+    assert_equal "42", @conn.cast_bound_value(42)
+  end
+
+  def test_cast_bound_big_decimal
+    assert_equal "4.2", @conn.cast_bound_value(BigDecimal("4.2"))
+  end
+
+  def test_cast_bound_rational
+    assert_equal "0.75", @conn.cast_bound_value(Rational(3, 4))
+  end
+
+  def test_cast_bound_true
+    assert_equal "1", @conn.cast_bound_value(true)
+  end
+
+  def test_cast_bound_false
+    assert_equal "0", @conn.cast_bound_value(false)
+  end
+
+  def test_quote_string
+    assert_equal "\\'", @conn.quote_string("'")
+  end
+
+  def test_quote_column_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal "`foo`", adapter.quote_column_name("foo")
+      assert_equal '`hel"lo`', adapter.quote_column_name(%{hel"lo})
+    end
+  end
+
+  def test_quote_table_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal "`foo`", adapter.quote_table_name("foo")
+      assert_equal "`foo`.`bar`", adapter.quote_table_name("foo.bar")
+      assert_equal '`hel"lo.wol\\d`', adapter.quote_column_name('hel"lo.wol\\d')
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SchemaMigrationsTest < ActiveRecord::AbstractMysqlTestCase
+  def setup
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+  end
+
+  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 = @schema_migration.table_name
+      connection.drop_table table_name, if_exists: true
+
+      @schema_migration.create_table
+
+      assert connection.column_exists?(table_name, :version, :string)
+    end
+  end
+
+  def test_initializes_internal_metadata_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      internal_metadata = @pool.internal_metadata
+      table_name = internal_metadata.table_name
+      connection.drop_table table_name, if_exists: true
+
+      internal_metadata.create_table
+
+      assert connection.column_exists?(table_name, :key, :string)
+    end
+  ensure
+    @pool.internal_metadata[:environment] = @pool.migration_context.current_environment
+  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.lease_connection
+    end
+
+    def execute(sql)
+      connection.execute(sql)
+    end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SchemaTest < ActiveRecord::AbstractMysqlTestCase
+      fixtures :posts
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+        db          = Post.connection_pool.db_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_not(@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)
+            assert_nothing_raised do
+              # 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
+end
+
+class MysqlAnsiQuotesTest < ActiveRecord::AbstractMysqlTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_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/abstract_mysql_adapter/set_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class SetTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  class SetTest < ActiveRecord::Base
+  end
+
+  def setup
+    SetTest.lease_connection.create_table :set_tests, id: false, force: true do |t|
+      t.column :set_column, "set('text','blob','tiny','medium','long','unsigned','bigint')"
+    end
+  end
+
+  def test_should_not_be_unsigned
+    column = SetTest.columns_hash["set_column"]
+    assert_not_predicate column, :unsigned?
+  end
+
+  def test_should_not_be_bigint
+    column = SetTest.columns_hash["set_column"]
+    assert_not_predicate column, :bigint?
+  end
+
+  def test_schema_dumping
+    schema = dump_table_schema "set_tests"
+    assert_match %r{t\.column "set_column", "set\('text','blob','tiny','medium','long','unsigned','bigint'\)"$}, schema
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+
+class StoredProcedureTest < ActiveRecord::AbstractMysqlTestCase
+  fixtures :topics
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    unless ActiveRecord::Base.lease_connection.database_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.
+  # https://dev.mysql.com/doc/refman/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_predicate @connection, :active?, "Bad connection use by '#{@connection.class}.select_rows'"
+  end
+
+  def test_multi_results_from_select_one
+    row = @connection.select_one("CALL topics(1);")
+    assert_equal "David", row["author_name"]
+    assert_predicate @connection, :active?, "Bad connection use by '#{@connection.class}.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_predicate @connection, :active?, "Bad connection use by '#{@connection.class}.select'"
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SqlTypesTest < ActiveRecord::AbstractMysqlTestCase
+  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(type, limit = nil)
+    ActiveRecord::Base.lease_connection.type_to_sql(type, limit: limit)
+  end
+end