ibm_db 5.6.1 → 5.7.0

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

@@ -7,7 +7,8 @@ module ActiveRecord
     class PostgreSQLAdapter
       class QuotingTest < ActiveRecord::PostgreSQLTestCase
         def setup
-          @conn = ActiveRecord::Base.connection
+          @conn = ActiveRecord::Base.lease_connection
+          @raise_int_wider_than_64bit = ActiveRecord.raise_int_wider_than_64bit
         end
 
         def test_type_cast_true
@@ -28,6 +29,18 @@ module ActiveRecord
           assert_equal "'Infinity'", @conn.quote(infinity)
         end
 
+        def test_quote_integer
+          assert_equal "42", @conn.quote(42)
+        end
+
+        def test_quote_big_decimal
+          assert_equal "4.2", @conn.quote(BigDecimal("4.2"))
+        end
+
+        def test_quote_rational
+          assert_equal "3/4", @conn.quote(Rational(3, 4))
+        end
+
         def test_quote_range
           range = "1,2]'; SELECT * FROM users; --".."a"
           type = OID::Range.new(Type::Integer.new, :int8range)
@@ -44,6 +57,52 @@ module ActiveRecord
           value = "user posts"
           assert_equal "\"user posts\"", @conn.quote_table_name(value)
         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
+
+        def test_raise_when_int_is_wider_than_64bit
+          value = 9223372036854775807 + 1
+          assert_raise ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting::IntegerOutOf64BitRange do
+            @conn.quote(value)
+          end
+
+          value = -9223372036854775808 - 1
+          assert_raise ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting::IntegerOutOf64BitRange do
+            @conn.quote(value)
+          end
+        end
+
+        def test_do_not_raise_when_int_is_not_wider_than_64bit
+          value = 9223372036854775807
+          assert_equal "9223372036854775807", @conn.quote(value)
+
+          value = -9223372036854775808
+          assert_equal "-9223372036854775808", @conn.quote(value)
+        end
+
+        def test_do_not_raise_when_raise_int_wider_than_64bit_is_false
+          ActiveRecord.raise_int_wider_than_64bit = false
+          value = 9223372036854775807 + 1
+          assert_equal "9223372036854775808", @conn.quote(value)
+          ActiveRecord.raise_int_wider_than_64bit = @raise_int_wider_than_64bit
+        end
       end
     end
   end

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

@@ -9,12 +9,11 @@ class PostgresqlRange < ActiveRecord::Base
 end
 
 class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
-  self.use_transactional_tests = false
   include ConnectionHelper
   include InTimeZone
 
   def setup
-    @connection = PostgresqlRange.connection
+    @connection = PostgresqlRange.lease_connection
     @connection.transaction do
       @connection.execute <<~SQL
         CREATE TYPE floatrange AS RANGE (
@@ -31,7 +30,9 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
         t.daterange :date_range
         t.numrange  :num_range
         t.tsrange   :ts_range
+        t.tsrange   :ts_ranges, array: true
         t.tstzrange :tstz_range
+        t.tstzrange :tstz_ranges, array: true
         t.int4range :int4_range
         t.int8range :int8_range
       end
@@ -143,9 +144,10 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_tsrange_values
-    tz = ::ActiveRecord::Base.default_timezone
+    tz = ::ActiveRecord.default_timezone
     assert_equal Time.public_send(tz, 2010, 1, 1, 14, 30, 0)..Time.public_send(tz, 2011, 1, 1, 14, 30, 0), @first_range.ts_range
     assert_equal Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...Time.public_send(tz, 2011, 1, 1, 14, 30, 0), @second_range.ts_range
+    assert_equal Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...nil, @third_range.ts_range
     assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.ts_range)
     assert_nil @empty_range.ts_range
   end
@@ -153,6 +155,7 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
   def test_tstzrange_values
     assert_equal Time.parse("2010-01-01 09:30:00 UTC")..Time.parse("2011-01-01 17:30:00 UTC"), @first_range.tstz_range
     assert_equal Time.parse("2010-01-01 09:30:00 UTC")...Time.parse("2011-01-01 17:30:00 UTC"), @second_range.tstz_range
+    assert_equal Time.parse("2010-01-01 09:30:00 UTC")...nil, @third_range.tstz_range
     assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.tstz_range)
     assert_nil @empty_range.tstz_range
   end
@@ -185,6 +188,75 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
+  def test_timezone_awareness_endless_tzrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(tstz_range: time_string...)
+      assert_equal time..., record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal time..., record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
+    end
+  end
+
+  def test_timezone_awareness_beginless_tzrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(tstz_range: ..time_string)
+      assert_equal nil..time, record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.end.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal nil..time, record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.end.time_zone
+    end
+  end
+
+  def test_timezone_array_awareness_tzrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+
+      from_time_string = Time.current.to_s
+      from_time = Time.zone.parse(from_time_string)
+      to_time_string = (from_time + 1.hour).to_s
+      to_time = Time.zone.parse(to_time_string)
+
+      record = PostgresqlRange.new(tstz_ranges: [from_time_string...to_time_string, from_time_string..to_time_string, from_time_string..., ..to_time_string])
+      assert_equal [from_time...to_time, from_time..to_time, from_time..., ..to_time], record.tstz_ranges
+      record.tstz_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
+      end
+
+      record.save!
+      record.reload
+
+      assert_equal [from_time...to_time, from_time..to_time, from_time...nil, nil..to_time], record.tstz_ranges
+      record.tstz_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
+      end
+    end
+  end
+
   def test_create_tstzrange
     tstzrange = Time.parse("2010-01-01 14:30:00 +0100")...Time.parse("2011-02-02 14:30:00 CDT")
     round_trip(@new_range, :tstz_range, tstzrange)
@@ -204,14 +276,19 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
                             Time.parse("-1000-01-01 14:30:00 CDT")...Time.parse("2020-02-02 14:30:00 CET"))
   end
 
+  def test_unbounded_tstzrange
+    assert_equal_round_trip @first_range, :tstz_range, Time.parse("2010-01-01 14:30:00 CDT")...nil
+    assert_equal_round_trip @first_range, :tstz_range, nil..Time.parse("2010-01-01 14:30:00 CDT")
+  end
+
   def test_create_tsrange
-    tz = ::ActiveRecord::Base.default_timezone
+    tz = ::ActiveRecord.default_timezone
     assert_equal_round_trip(@new_range, :ts_range,
                             Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0))
   end
 
   def test_update_tsrange
-    tz = ::ActiveRecord::Base.default_timezone
+    tz = ::ActiveRecord.default_timezone
     assert_equal_round_trip(@first_range, :ts_range,
                             Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0))
     assert_nil_round_trip(@first_range, :ts_range,
@@ -219,11 +296,17 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_escaped_tsrange
-    tz = ::ActiveRecord::Base.default_timezone
+    tz = ::ActiveRecord.default_timezone
     assert_equal_round_trip(@first_range, :ts_range,
                             Time.public_send(tz, -1000, 1, 1, 14, 30, 0)...Time.public_send(tz, 2020, 2, 2, 14, 30, 0))
   end
 
+  def test_unbounded_tsrange
+    tz = ::ActiveRecord.default_timezone
+    assert_equal_round_trip @first_range, :ts_range, Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...nil
+    assert_equal_round_trip @first_range, :ts_range, nil..Time.public_send(tz, 2010, 1, 1, 14, 30, 0)
+  end
+
   def test_timezone_awareness_tsrange
     tz = "Pacific Time (US & Canada)"
 
@@ -244,6 +327,75 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
+  def test_timezone_awareness_endless_tsrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(ts_range: time_string...)
+      assert_equal time..., record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal time..., record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+    end
+  end
+
+  def test_timezone_awareness_beginless_tsrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(ts_range: ..time_string)
+      assert_equal nil..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.end.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal nil..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.end.time_zone
+    end
+  end
+
+  def test_timezone_array_awareness_tsrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+
+      from_time_string = Time.current.to_s
+      from_time = Time.zone.parse(from_time_string)
+      to_time_string = (from_time + 1.hour).to_s
+      to_time = Time.zone.parse(to_time_string)
+
+      record = PostgresqlRange.new(ts_ranges: [from_time_string...to_time_string, from_time_string..to_time_string, from_time_string..., ..to_time_string])
+      assert_equal [from_time...to_time, from_time..to_time, from_time..., ..to_time], record.ts_ranges
+      record.ts_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
+      end
+
+      record.save!
+      record.reload
+
+      assert_equal [from_time...to_time, from_time..to_time, from_time..., ..to_time], record.ts_ranges
+      record.ts_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
+      end
+    end
+  end
+
   def test_create_tstzrange_preserve_usec
     tstzrange = Time.parse("2010-01-01 14:30:00.670277 +0100")...Time.parse("2011-02-02 14:30:00.745125 CDT")
     round_trip(@new_range, :tstz_range, tstzrange)
@@ -258,14 +410,14 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
                           Time.parse("2010-01-01 14:30:00.245124 +0100")...Time.parse("2010-01-01 13:30:00.245124 +0000"))
   end
 
-  def test_create_tsrange_preseve_usec
-    tz = ::ActiveRecord::Base.default_timezone
+  def test_create_tsrange_preserve_usec
+    tz = ::ActiveRecord.default_timezone
     assert_equal_round_trip(@new_range, :ts_range,
                             Time.public_send(tz, 2010, 1, 1, 14, 30, 0, 125435)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0, 225435))
   end
 
   def test_update_tsrange_preserve_usec
-    tz = ::ActiveRecord::Base.default_timezone
+    tz = ::ActiveRecord.default_timezone
     assert_equal_round_trip(@first_range, :ts_range,
                             Time.public_send(tz, 2010, 1, 1, 14, 30, 0, 142432)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0, 224242))
     assert_nil_round_trip(@first_range, :ts_range,
@@ -398,20 +550,32 @@ class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
     assert_equal(-Float::INFINITY...Float::INFINITY, record.float_range)
   end
 
-  if RUBY_VERSION >= "2.6"
-    def test_endless_range_values
-      record = PostgresqlRange.create!(
-        int4_range: eval("1.."),
-        int8_range: eval("10.."),
-        float_range: eval("0.5..")
-      )
+  def test_endless_range_values
+    record = PostgresqlRange.create!(
+      int4_range: 1..,
+      int8_range: 10..,
+      float_range: 0.5..
+    )
 
-      record = PostgresqlRange.find(record.id)
+    record = PostgresqlRange.find(record.id)
 
-      assert_equal 1...Float::INFINITY, record.int4_range
-      assert_equal 10...Float::INFINITY, record.int8_range
-      assert_equal 0.5...Float::INFINITY, record.float_range
-    end
+    assert_equal 1...Float::INFINITY, record.int4_range
+    assert_equal 10...Float::INFINITY, record.int8_range
+    assert_equal 0.5...Float::INFINITY, record.float_range
+  end
+
+  def test_empty_string_range_values
+    record = PostgresqlRange.create!(
+      int4_range: "",
+      int8_range: "",
+      float_range: ""
+    )
+
+    record = PostgresqlRange.find(record.id)
+
+    assert_nil record.int4_range
+    assert_nil record.int8_range
+    assert_nil record.float_range
   end
 
   private

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

@@ -4,8 +4,6 @@ require "cases/helper"
 require "support/connection_helper"
 
 class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
-  self.use_transactional_tests = false
-
   include ConnectionHelper
 
   IS_REFERENTIAL_INTEGRITY_SQL = lambda do |sql|
@@ -34,12 +32,12 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def teardown
     reset_connection
-    if ActiveRecord::Base.connection.is_a?(MissingSuperuserPrivileges)
+    if ActiveRecord::Base.lease_connection.is_a?(MissingSuperuserPrivileges)
       raise "MissingSuperuserPrivileges patch was not removed"
     end
   end
@@ -70,7 +68,7 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
       end
       assert_equal "Should be re-raised", e.message
     end
-    assert warning.blank?, "expected no warnings but got:\n#{warning}"
+    assert_predicate warning, :blank?, "expected no warnings but got:\n#{warning}"
   end
 
   def test_does_not_break_transactions
@@ -105,6 +103,32 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
+  def test_all_foreign_keys_valid_having_foreign_keys_in_multiple_schemas
+    @connection.execute <<~SQL
+      CREATE SCHEMA referential_integrity_test_schema;
+
+      CREATE TABLE referential_integrity_test_schema.nodes (
+        id          BIGSERIAL,
+        parent_id   INT      NOT NULL,
+        PRIMARY KEY(id),
+        CONSTRAINT fk_parent_node FOREIGN KEY(parent_id)
+                                  REFERENCES referential_integrity_test_schema.nodes(id)
+      );
+    SQL
+
+    result = @connection.execute <<~SQL
+      SELECT count(*) AS count
+        FROM information_schema.table_constraints
+       WHERE constraint_schema = 'referential_integrity_test_schema'
+         AND constraint_type = 'FOREIGN KEY';
+    SQL
+
+    assert_equal 1, result.first["count"], "referential_integrity_test_schema should have 1 foreign key"
+    @connection.check_all_foreign_keys_valid!
+  ensure
+    @connection.drop_schema "referential_integrity_test_schema", if_exists: true
+  end
+
   private
     def assert_transaction_is_not_broken
       assert_equal 1, @connection.select_value("SELECT 1")

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

@@ -4,8 +4,7 @@ require "cases/helper"
 
 class PostgresqlRenameTableTest < ActiveRecord::PostgreSQLTestCase
   def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table :before_rename, force: true
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def teardown
@@ -13,18 +12,46 @@ class PostgresqlRenameTableTest < ActiveRecord::PostgreSQLTestCase
     @connection.drop_table "after_rename", if_exists: true
   end
 
-  test "renaming a table also renames the primary key index" do
-    # sanity check
-    assert_equal 1, num_indices_named("before_rename_pkey")
-    assert_equal 0, num_indices_named("after_rename_pkey")
+  test "renaming a table also renames the primary key sequence" do
+    @connection.create_table :before_rename, force: true
 
     @connection.rename_table :before_rename, :after_rename
 
-    assert_equal 0, num_indices_named("before_rename_pkey")
-    assert_equal 1, num_indices_named("after_rename_pkey")
+    pk, seq = @connection.pk_and_sequence_for("after_rename")
+    assert_equal "after_rename_#{pk}_seq", seq.identifier
+  end
+
+  test "renaming a table also renames the primary key index" do
+    @connection.create_table :before_rename, force: true
+
+    assert_renames_index("before_rename_pkey", "after_rename_pkey") do
+      @connection.rename_table :before_rename, :after_rename
+    end
+  end
+
+  test "renaming a table with uuid primary key and uuid_generate_v4() default also renames the primary key index" do
+    @connection.create_table :before_rename, force: true, id: :uuid, default: -> { "uuid_generate_v4()" }
+
+    assert_renames_index("before_rename_pkey", "after_rename_pkey") do
+      @connection.rename_table :before_rename, :after_rename
+    end
+  end
+
+  test "renaming a table with uuid primary key and gen_random_uuid() default also renames the primary key index" do
+    @connection.create_table :before_rename, force: true, id: :uuid, default: -> { "gen_random_uuid()" }
+
+    assert_renames_index("before_rename_pkey", "after_rename_pkey") do
+      @connection.rename_table :before_rename, :after_rename
+    end
   end
 
   private
+    def assert_renames_index(from, to, &block)
+      assert_changes(-> { num_indices_named(from) }, from: 1, to: 0) do
+        assert_changes(-> { num_indices_named(to) }, from: 0, to: 1, &block)
+      end
+    end
+
     def num_indices_named(name)
       @connection.execute(<<~SQL).values.length
         SELECT 1 FROM "pg_index"

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

@@ -16,7 +16,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
   USERS = ["rails_pg_schema_user1", "rails_pg_schema_user2"]
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute "SET search_path TO '$user',public"
     set_session_auth
     USERS.each do |u|
@@ -63,7 +63,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
-  if ActiveRecord::Base.connection.prepared_statements
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_auth_with_bind
       assert_nothing_raised do
         set_session_auth