ibm_db 5.7.0-x64-mingw-ucrt

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class PostgresqlSerial < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table "postgresql_serials", force: true do |t|
+      t.serial :seq
+      t.integer :serials_id, default: -> { "nextval('postgresql_serials_id_seq')" }
+    end
+  end
+
+  teardown do
+    @connection.drop_table "postgresql_serials", if_exists: true
+  end
+
+  def test_serial_column
+    column = PostgresqlSerial.columns_hash["seq"]
+    assert_equal :integer, column.type
+    assert_equal "integer", column.sql_type
+    assert_predicate column, :serial?
+  end
+
+  def test_not_serial_column
+    column = PostgresqlSerial.columns_hash["serials_id"]
+    assert_equal :integer, column.type
+    assert_equal "integer", column.sql_type
+    assert_not_predicate column, :serial?
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema "postgresql_serials"
+    assert_match %r{t\.serial\s+"seq",\s+null: false$}, output
+  end
+
+  def test_schema_dump_with_not_serial
+    output = dump_table_schema "postgresql_serials"
+    assert_match %r{t\.integer\s+"serials_id",\s+default: -> \{ "nextval\('postgresql_serials_id_seq'::regclass\)" \}$}, output
+  end
+end
+
+class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class PostgresqlBigSerial < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table "postgresql_big_serials", force: true do |t|
+      t.bigserial :seq
+      t.bigint :serials_id, default: -> { "nextval('postgresql_big_serials_id_seq')" }
+    end
+  end
+
+  teardown do
+    @connection.drop_table "postgresql_big_serials", if_exists: true
+  end
+
+  def test_bigserial_column
+    column = PostgresqlBigSerial.columns_hash["seq"]
+    assert_equal :integer, column.type
+    assert_equal "bigint", column.sql_type
+    assert_predicate column, :serial?
+  end
+
+  def test_not_bigserial_column
+    column = PostgresqlBigSerial.columns_hash["serials_id"]
+    assert_equal :integer, column.type
+    assert_equal "bigint", column.sql_type
+    assert_not_predicate column, :serial?
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema "postgresql_big_serials"
+    assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+  end
+
+  def test_schema_dump_with_not_bigserial
+    output = dump_table_schema "postgresql_big_serials"
+    assert_match %r{t\.bigint\s+"serials_id",\s+default: -> \{ "nextval\('postgresql_big_serials_id_seq'::regclass\)" \}$}, output
+  end
+end
+
+module SequenceNameDetectionTestCases
+  class CollidedSequenceNameTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :foo_bar, force: true do |t|
+        t.serial :baz_id
+      end
+      @connection.create_table :foo, force: true do |t|
+        t.serial :bar_id
+        t.bigserial :bar_baz_id
+      end
+    end
+
+    def teardown
+      @connection.drop_table :foo_bar, if_exists: true
+      @connection.drop_table :foo, if_exists: true
+    end
+
+    def test_serial_columns
+      columns = @connection.columns(:foo)
+      columns.each do |column|
+        assert_equal :integer, column.type
+        assert_predicate column, :serial?
+      end
+    end
+
+    def test_schema_dump_with_collided_sequence_name
+      output = dump_table_schema "foo"
+      assert_match %r{t\.serial\s+"bar_id",\s+null: false$}, output
+      assert_match %r{t\.bigserial\s+"bar_baz_id",\s+null: false$}, output
+    end
+  end
+
+  class LongerSequenceNameDetectionTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    def setup
+      @table_name = "long_table_name_to_test_sequence_name_detection_for_serial_cols"
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table @table_name, force: true, _uses_legacy_table_name: true do |t|
+        t.serial :seq
+        t.bigserial :bigseq
+      end
+    end
+
+    def teardown
+      @connection.drop_table @table_name, if_exists: true
+    end
+
+    def test_serial_columns
+      columns = @connection.columns(@table_name)
+      columns.each do |column|
+        assert_equal :integer, column.type
+        assert_predicate column, :serial?
+      end
+    end
+
+    def test_schema_dump_with_long_table_name
+      output = dump_table_schema @table_name
+      assert_match %r{create_table "#{@table_name}", force: :cascade}, output
+      assert_match %r{t\.serial\s+"seq",\s+null: false$}, output
+      assert_match %r{t\.bigserial\s+"bigseq",\s+null: false$}, output
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/computer"
+require "models/developer"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      class InactivePgConnection
+        def initialize
+          @raw_connection = nil
+        end
+
+        def query(*args)
+          raise PG::Error
+        end
+
+        def status
+          PG::CONNECTION_BAD
+        end
+      end
+
+      class StatementPoolTest < ActiveRecord::PostgreSQLTestCase
+        fixtures :developers
+
+        if Process.respond_to?(:fork)
+          def test_cache_is_per_pid
+            cache = StatementPool.new nil, 10
+            cache["foo"] = "bar"
+            assert_equal "bar", cache["foo"]
+
+            pid = fork {
+              lookup = cache["foo"]
+              exit!(!lookup)
+            }
+
+            Process.waitpid pid
+            assert_predicate $?, :success?, "process should exit successfully"
+          end
+        end
+
+        def test_dealloc_does_not_raise_on_inactive_connection
+          cache = StatementPool.new InactivePgConnection.new, 10
+          cache["foo"] = "bar"
+          assert_nothing_raised { cache.clear }
+        end
+
+        def test_prepared_statements_do_not_get_stuck_on_query_interruption
+          pg_connection = ActiveRecord::Base.lease_connection.connect!.instance_variable_get(:@raw_connection)
+          pg_connection.stub(:get_last_result, -> { raise "random error" }) do
+            assert_raises(RuntimeError) do
+              Developer.where(name: "David").last
+            end
+
+            # without fix, this raises PG::DuplicatePstatement: ERROR:  prepared statement "a3" already exists
+            assert_raises(RuntimeError) do
+              Developer.where(name: "David").last
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+require "models/topic"
+
+class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_no_time_zone_set
+    with_timezone_config default: :utc, aware_attributes: true do
+      @connection.reconnect!
+
+      timestamp = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+      assert_instance_of Time, timestamp.time
+    end
+  ensure
+    @connection.reconnect!
+  end
+
+  def test_timestamp_with_zone_values_without_rails_time_zone_support
+    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")
+
+      timestamp = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+      assert_instance_of Time, timestamp.time
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
+class PostgresqlTimestampWithAwareTypesTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_time_zone_set
+    with_timezone_config default: :utc, aware_attributes: true, zone: "Pacific Time (US & Canada)", aware_types: [:timestamptz, :datetime, :time] do
+      @connection.reconnect!
+
+      timestamp = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+      assert_instance_of ActiveSupport::TimeWithZone, timestamp.time
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
+class PostgresqlTimestampWithTimeZoneTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    with_postgresql_datetime_type(:timestamptz) do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+    end
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_timestamptz_and_no_time_zone_set
+    with_postgresql_datetime_type(:timestamptz) do
+      with_timezone_config default: :utc, aware_attributes: true, aware_types: [:timestamptz, :datetime, :time] do
+        @connection.reconnect!
+
+        timestamp = PostgresqlTimestampWithZone.find(1)
+        assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+        assert_instance_of Time, timestamp.time
+      end
+    end
+  ensure
+    @connection.reconnect!
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_timestamptz_and_time_zone_set
+    with_postgresql_datetime_type(:timestamptz) do
+      with_timezone_config default: :utc, aware_attributes: true, zone: "Pacific Time (US & Canada)", aware_types: [:timestamptz, :datetime, :time] do
+        @connection.reconnect!
+
+        timestamp = PostgresqlTimestampWithZone.find(1)
+        assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+        assert_instance_of ActiveSupport::TimeWithZone, timestamp.time
+      end
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
+class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
+  fixtures :topics
+
+  def test_group_by_date
+    keys = Topic.group("date_trunc('month', created_at)").count.keys
+    assert_operator keys.length, :>, 0
+    keys.each { |k| assert_kind_of Time, k }
+  end
+
+  def test_load_infinity_and_beyond
+    d = Developer.find_by_sql("select 'infinity'::timestamp as legacy_updated_at")
+    assert_predicate d.first.updated_at, :infinite?, "timestamp should be infinite"
+
+    d = Developer.find_by_sql("select '-infinity'::timestamp as legacy_updated_at")
+    time = d.first.updated_at
+    assert_predicate 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)
+    assert_equal(1.0 / 0.0, d.updated_at)
+
+    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 = Time.new(0) - 1.week
+    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)
+    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)
+    assert_equal date, Developer.find_by_name("yahagi").updated_at
+  end
+end
+
+class PostgresqlTimestampMigrationTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  def test_adds_column_as_timestamp
+    original, $stdout = $stdout, StringIO.new
+
+    ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+    assert_equal({ "data_type" => "timestamp without time zone" },
+                 PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+  ensure
+    $stdout = original
+  end
+
+  def test_adds_column_as_timestamptz_if_datetime_type_changed
+    original, $stdout = $stdout, StringIO.new
+
+    with_postgresql_datetime_type(:timestamptz) do
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+      assert_equal({ "data_type" => "timestamp with time zone" },
+                   PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+    end
+  ensure
+    $stdout = original
+  end
+
+  def test_adds_column_as_custom_type
+    original, $stdout = $stdout, StringIO.new
+
+    PostgresqlTimestampWithZone.lease_connection.execute("CREATE TYPE custom_time_format AS ENUM ('past', 'present', 'future');")
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:datetimes_as_enum] = { name: "custom_time_format" }
+    with_postgresql_datetime_type(:datetimes_as_enum) do
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime, precision: nil
+
+      assert_equal({ "data_type" => "USER-DEFINED", "udt_name" => "custom_time_format" },
+                   PostgresqlTimestampWithZone.lease_connection.execute("select data_type, udt_name from information_schema.columns where column_name = 'times'").to_a.first)
+    end
+  ensure
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES.delete(:datetimes_as_enum)
+    $stdout = original
+  end
+end

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

@@ -0,0 +1,238 @@
+# 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
+    class Bit < ActiveRecord::Base
+      self.table_name = "bits"
+    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.transaction do
+        connection.drop_table "samples", if_exists: true
+        connection.drop_table "bits", if_exists: true
+        connection.create_table("samples") do |t|
+          t.integer "value"
+        end
+        connection.create_table("bits") do |t|
+          t.integer "value"
+        end
+      end
+
+      Sample.reset_column_information
+      Bit.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
+      ActiveRecord::Base.lease_connection.drop_table "bits", 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
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                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
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                before.wait
+                Sample.create value: Sample.sum(:value)
+                after.wait
+              end
+            end
+          end
+        ensure
+          thread.join
+        end
+      end
+    end
+
+    test "SerializationFailure inside nested SavepointTransaction is recoverable" do
+      start_right = Concurrent::Event.new
+      commit_left = Concurrent::Event.new
+      finish_right = Concurrent::Event.new
+      Sample.create value: 1
+
+      thread = Thread.new do
+        with_warning_suppression do
+          Sample.transaction(isolation: :serializable, requires_new: false) do
+            Sample.update_all value: 2
+            start_right.set
+            commit_left.wait(1)
+          end
+          finish_right.set
+        end
+      end
+
+      begin
+        with_warning_suppression do
+          start_right.wait
+          Sample.transaction(isolation: :serializable, requires_new: false) do
+            make_parent_transaction_dirty
+            assert_raises(ActiveRecord::SerializationFailure) do
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                Sample.create value: 3
+                commit_left.set
+                finish_right.wait(2)
+                Sample.update_all value: 4
+              end
+            end
+            Bit.create value: 1
+          end
+        end
+      ensure
+        thread.join
+      end
+      assert_equal [2], Sample.pluck(:value)
+      assert_equal [1], Bit.pluck(:value)
+    end
+
+    test "deadlock raises Deadlocked inside nested SavepointTransaction" do
+      with_warning_suppression do
+        connections = Concurrent::Set.new
+        assert_raises(ActiveRecord::Deadlocked) do
+          barrier = Concurrent::CyclicBarrier.new(2)
+
+          s1 = Sample.create value: 1
+          s2 = Sample.create value: 2
+
+          thread = Thread.new do
+            connections.add Sample.lease_connection
+            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
+            connections.add Sample.lease_connection
+            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
+        end
+        assert connections.all?(&:active?)
+      end
+    end
+
+    test "deadlock inside nested SavepointTransaction is recoverable" do
+      with_warning_suppression 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
+    end
+
+    private
+      def with_warning_suppression
+        log_level = ActiveRecord::Base.lease_connection.client_min_messages
+        ActiveRecord::Base.lease_connection.client_min_messages = "error"
+        yield
+      ensure
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+        ActiveRecord::Base.lease_connection.client_min_messages = log_level
+      end
+
+      # These tests are coordinating a controlled sequence of accesses to rows in `samples` table under serializable isolation.
+      # We need to run a query to dirty our transaction, but must avoid touching `samples` rows
+      # because otherwise our no-op query becomes an active participant of the test setup
+      def make_parent_transaction_dirty
+        Bit.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