ibm_db 5.6.1-arm64-darwin-24

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.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.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.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.connection
+      @connection.create_table @table_name, force: 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,61 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/computer"
+require "models/developer"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      class InactivePgConnection
+        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 $?.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.connection.instance_variable_get(:@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,92 @@
+# 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.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
+    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 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 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 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 = Date.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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
+  setup do
+    @connection = ActiveRecord::Base.connection
+  end
+
+  test "array delimiters are looked up correctly" do
+    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
+  end
+
+  test "array types correctly respect registration of subtypes" do
+    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) }
+    assert_equal "{123456789123456789}", @connection.type_cast(bigint_array.serialize(big_array))
+  end
+
+  test "range types correctly respect registration of subtypes" do
+    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]", @connection.type_cast(bigint_range.serialize(big_range))
+  end
+end