ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

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

@@ -1,6 +1,8 @@
-require 'cases/helper'
-require 'models/developer'
-require 'models/topic'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+require "models/topic"
 
 class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlTimestampWithZone < ActiveRecord::Base; end
@@ -21,7 +23,7 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
       @connection.reconnect!
 
       timestamp = PostgresqlTimestampWithZone.find(1)
-      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
       assert_instance_of Time, timestamp.time
     end
   ensure
@@ -32,10 +34,10 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
     with_timezone_config default: :local, aware_attributes: false do
       @connection.reconnect!
       # make sure to use a non-UTC time zone
-      @connection.execute("SET time zone 'America/Jamaica'", 'SCHEMA')
+      @connection.execute("SET time zone 'America/Jamaica'", "SCHEMA")
 
       timestamp = PostgresqlTimestampWithZone.find(1)
-      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
       assert_instance_of Time, timestamp.time
     end
   ensure
@@ -53,38 +55,38 @@ class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_load_infinity_and_beyond
-    d = Developer.find_by_sql("select 'infinity'::timestamp as updated_at")
-    assert d.first.updated_at.infinite?, 'timestamp should be infinite'
+    d = Developer.find_by_sql("select 'infinity'::timestamp as legacy_updated_at")
+    assert d.first.updated_at.infinite?, "timestamp should be infinite"
 
-    d = Developer.find_by_sql("select '-infinity'::timestamp as updated_at")
+    d = Developer.find_by_sql("select '-infinity'::timestamp as legacy_updated_at")
     time = d.first.updated_at
-    assert time.infinite?, 'timestamp should be infinite'
+    assert time.infinite?, "timestamp should be infinite"
     assert_operator time, :<, 0
   end
 
   def test_save_infinity_and_beyond
-    d = Developer.create!(:name => 'aaron', :updated_at => 1.0 / 0.0)
+    d = Developer.create!(name: "aaron", updated_at: 1.0 / 0.0)
     assert_equal(1.0 / 0.0, d.updated_at)
 
-    d = Developer.create!(:name => 'aaron', :updated_at => -1.0 / 0.0)
+    d = Developer.create!(name: "aaron", updated_at: -1.0 / 0.0)
     assert_equal(-1.0 / 0.0, d.updated_at)
   end
 
   def test_bc_timestamp
     date = Date.new(0) - 1.week
-    Developer.create!(:name => "aaron", :updated_at => date)
+    Developer.create!(name: "aaron", updated_at: date)
     assert_equal date, Developer.find_by_name("aaron").updated_at
   end
 
   def test_bc_timestamp_leap_year
     date = Time.utc(-4, 2, 29)
-    Developer.create!(:name => "taihou", :updated_at => date)
+    Developer.create!(name: "taihou", updated_at: date)
     assert_equal date, Developer.find_by_name("taihou").updated_at
   end
 
   def test_bc_timestamp_year_zero
     date = Time.utc(0, 4, 7)
-    Developer.create!(:name => "yahagi", :updated_at => date)
+    Developer.create!(name: "yahagi", updated_at: date)
     assert_equal date, Developer.find_by_name("yahagi").updated_at
   end
 end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+require "concurrent/atomic/cyclic_barrier"
+
+module ActiveRecord
+  class PostgresqlTransactionNestedTest < ActiveRecord::PostgreSQLTestCase
+    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.connection
+
+      connection.transaction do
+        connection.drop_table "samples", if_exists: true
+        connection.create_table("samples") do |t|
+          t.integer "value"
+        end
+      end
+
+      Sample.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.connection.drop_table "samples", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "unserializable transaction raises SerializationFailure inside nested SavepointTransaction" do
+      assert_raises(ActiveRecord::SerializationFailure) do
+        before = Concurrent::CyclicBarrier.new(2)
+        after = Concurrent::CyclicBarrier.new(2)
+
+        thread = Thread.new do
+          with_warning_suppression do
+            Sample.transaction(isolation: :serializable, requires_new: false) do
+              Sample.transaction(requires_new: true) do
+                before.wait
+                Sample.create value: Sample.sum(:value)
+                after.wait
+              end
+            end
+          end
+        end
+
+        begin
+          with_warning_suppression do
+            Sample.transaction(isolation: :serializable, requires_new: false) do
+              Sample.transaction(requires_new: true) do
+                before.wait
+                Sample.create value: Sample.sum(:value)
+                after.wait
+              end
+            end
+          end
+        ensure
+          thread.join
+        end
+      end
+    end
+
+    test "deadlock raises Deadlocked inside nested SavepointTransaction" do
+      with_warning_suppression do
+        assert_raises(ActiveRecord::Deadlocked) do
+          barrier = Concurrent::CyclicBarrier.new(2)
+
+          s1 = Sample.create value: 1
+          s2 = Sample.create value: 2
+
+          thread = Thread.new do
+            Sample.transaction(requires_new: false) do
+              Sample.transaction(requires_new: true) do
+                s1.lock!
+                barrier.wait
+                s2.update value: 1
+              end
+            end
+          end
+
+          begin
+            Sample.transaction(requires_new: false) do
+              Sample.transaction(requires_new: true) do
+                s2.lock!
+                barrier.wait
+                s1.update value: 2
+              end
+            end
+          ensure
+            thread.join
+          end
+        end
+      end
+    end
+
+    private
+      def with_warning_suppression
+        log_level = ActiveRecord::Base.connection.client_min_messages
+        ActiveRecord::Base.connection.client_min_messages = "error"
+        yield
+      ensure
+        ActiveRecord::Base.clear_active_connections!
+        ActiveRecord::Base.connection.client_min_messages = log_level
+      end
+  end
+end

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+require "concurrent/atomic/cyclic_barrier"
+
+module ActiveRecord
+  class PostgresqlTransactionTest < ActiveRecord::PostgreSQLTestCase
+    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.connection
+
+      connection.transaction do
+        connection.drop_table "samples", if_exists: true
+        connection.create_table("samples") do |t|
+          t.integer "value"
+        end
+      end
+
+      Sample.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.connection.drop_table "samples", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "raises SerializationFailure when a serialization failure occurs" do
+      assert_raises(ActiveRecord::SerializationFailure) do
+        before = Concurrent::CyclicBarrier.new(2)
+        after = Concurrent::CyclicBarrier.new(2)
+
+        thread = Thread.new do
+          with_warning_suppression do
+            Sample.transaction isolation: :serializable do
+              before.wait
+              Sample.create value: Sample.sum(:value)
+              after.wait
+            end
+          end
+        end
+
+        begin
+          with_warning_suppression do
+            Sample.transaction isolation: :serializable do
+              before.wait
+              Sample.create value: Sample.sum(:value)
+              after.wait
+            end
+          end
+        ensure
+          thread.join
+        end
+      end
+    end
+
+    test "raises Deadlocked when a deadlock is encountered" do
+      with_warning_suppression do
+        assert_raises(ActiveRecord::Deadlocked) do
+          barrier = Concurrent::CyclicBarrier.new(2)
+
+          s1 = Sample.create value: 1
+          s2 = Sample.create value: 2
+
+          thread = Thread.new do
+            Sample.transaction do
+              s1.lock!
+              barrier.wait
+              s2.update value: 1
+            end
+          end
+
+          begin
+            Sample.transaction do
+              s2.lock!
+              barrier.wait
+              s1.update value: 2
+            end
+          ensure
+            thread.join
+          end
+        end
+      end
+    end
+
+    test "raises LockWaitTimeout when lock wait timeout exceeded" do
+      assert_raises(ActiveRecord::LockWaitTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.connection.execute("SET lock_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.connection.execute("SET lock_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises QueryCanceled when statement timeout exceeded" do
+      assert_raises(ActiveRecord::QueryCanceled) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.connection.execute("SET statement_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.connection.execute("SET statement_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises QueryCanceled when canceling statement due to user request" do
+      assert_raises(ActiveRecord::QueryCanceled) do
+        s = Sample.create!(value: 1)
+        latch = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch.count_down
+            sleep(0.5)
+            conn = Sample.connection
+            pid = conn.query_value("SELECT pid FROM pg_stat_activity WHERE query LIKE '% FOR UPDATE'")
+            conn.execute("SELECT pg_cancel_backend(#{pid})")
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch.wait
+            Sample.lock.find(s.id)
+          end
+        ensure
+          thread.join
+        end
+      end
+    end
+
+    private
+      def with_warning_suppression
+        log_level = ActiveRecord::Base.connection.client_min_messages
+        ActiveRecord::Base.connection.client_min_messages = "error"
+        yield
+      ensure
+        ActiveRecord::Base.clear_active_connections!
+        ActiveRecord::Base.connection.client_min_messages = log_level
+      end
+  end
+end

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

@@ -1,4 +1,6 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
 
 class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   setup do
@@ -6,16 +8,16 @@ class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "array delimiters are looked up correctly" do
-    box_array = @connection.type_map.lookup(1020)
-    int_array = @connection.type_map.lookup(1007)
+    box_array = @connection.send(:type_map).lookup(1020)
+    int_array = @connection.send(:type_map).lookup(1007)
 
-    assert_equal ';', box_array.delimiter
-    assert_equal ',', int_array.delimiter
+    assert_equal ";", box_array.delimiter
+    assert_equal ",", int_array.delimiter
   end
 
   test "array types correctly respect registration of subtypes" do
-    int_array = @connection.type_map.lookup(1007, -1, "integer[]")
-    bigint_array = @connection.type_map.lookup(1016, -1, "bigint[]")
+    int_array = @connection.send(:type_map).lookup(1007, -1, "integer[]")
+    bigint_array = @connection.send(:type_map).lookup(1016, -1, "bigint[]")
     big_array = [123456789123456789]
 
     assert_raises(ActiveModel::RangeError) { int_array.serialize(big_array) }
@@ -23,11 +25,11 @@ class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "range types correctly respect registration of subtypes" do
-    int_range = @connection.type_map.lookup(3904, -1, "int4range")
-    bigint_range = @connection.type_map.lookup(3926, -1, "int8range")
+    int_range = @connection.send(:type_map).lookup(3904, -1, "int4range")
+    bigint_range = @connection.send(:type_map).lookup(3926, -1, "int8range")
     big_range = 0..123456789123456789
 
     assert_raises(ActiveModel::RangeError) { int_range.serialize(big_range) }
-    assert_equal "[0,123456789123456789]", bigint_range.serialize(big_range)
+    assert_equal "[0,123456789123456789]", @connection.type_cast(bigint_range.serialize(big_range))
   end
 end

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

@@ -1,5 +1,7 @@
-require 'cases/helper'
-require 'active_record/connection_adapters/postgresql/utils'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/connection_adapters/postgresql/utils"
 
 class PostgreSQLUtilsTest < ActiveRecord::PostgreSQLTestCase
   Name = ActiveRecord::ConnectionAdapters::PostgreSQL::Name
@@ -7,14 +9,14 @@ class PostgreSQLUtilsTest < ActiveRecord::PostgreSQLTestCase
 
   def test_extract_schema_qualified_name
     {
-      %(table_name)            => [nil,'table_name'],
-      %("table.name")          => [nil,'table.name'],
+      %(table_name)            => [nil, "table_name"],
+      %("table.name")          => [nil, "table.name"],
       %(schema.table_name)     => %w{schema table_name},
       %("schema".table_name)   => %w{schema table_name},
       %(schema."table_name")   => %w{schema table_name},
       %("schema"."table_name") => %w{schema table_name},
-      %("even spaces".table)   => ['even spaces','table'],
-      %(schema."table.name")   => ['schema', 'table.name']
+      %("even spaces".table)   => ["even spaces", "table"],
+      %(schema."table.name")   => ["schema", "table.name"]
     }.each do |given, expect|
       assert_equal Name.new(*expect), extract_schema_qualified_name(given)
     end
@@ -54,9 +56,9 @@ class PostgreSQLNameTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "can be used as hash key" do
-    hash = {Name.new("schema", "article_seq") => "success"}
+    hash = { Name.new("schema", "article_seq") => "success" }
     assert_equal "success", hash[Name.new("schema", "article_seq")]
-    assert_equal nil, hash[Name.new("schema", "articles")]
-    assert_equal nil, hash[Name.new("public", "article_seq")]
+    assert_nil hash[Name.new("schema", "articles")]
+    assert_nil hash[Name.new("public", "article_seq")]
   end
 end