ibm_db 5.6.1-arm64-darwin-24

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

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+require "support/stubs/strong_parameters"
+
+class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+  class Hstore < ActiveRecord::Base
+    self.table_name = "hstores"
+
+    store_accessor :settings, :language, :timezone
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    enable_extension!("hstore", @connection)
+
+    @connection.transaction do
+      @connection.create_table("hstores") do |t|
+        t.hstore "tags", default: ""
+        t.hstore "payload", array: true
+        t.hstore "settings"
+      end
+    end
+    Hstore.reset_column_information
+    @column = Hstore.columns_hash["tags"]
+    @type = Hstore.type_for_attribute("tags")
+  end
+
+  teardown do
+    @connection.drop_table "hstores", if_exists: true
+    disable_extension!("hstore", @connection)
+  end
+
+  def test_hstore_included_in_extensions
+    assert_respond_to @connection, :extensions
+    assert_includes @connection.extensions, "hstore", "extension list should include hstore"
+  end
+
+  def test_disable_enable_hstore
+    assert @connection.extension_enabled?("hstore")
+    @connection.disable_extension "hstore"
+    assert_not @connection.extension_enabled?("hstore")
+    @connection.enable_extension "hstore"
+    assert @connection.extension_enabled?("hstore")
+  ensure
+    # Restore column(s) dropped by `drop extension hstore cascade;`
+    load_schema
+  end
+
+  def test_column
+    assert_equal :hstore, @column.type
+    assert_equal "hstore", @column.sql_type
+    assert_not_predicate @column, :array?
+
+    assert_not_predicate @type, :binary?
+  end
+
+  def test_default
+    @connection.add_column "hstores", "permissions", :hstore, default: '"users"=>"read", "articles"=>"write"'
+    Hstore.reset_column_information
+
+    assert_equal({ "users" => "read", "articles" => "write" }, Hstore.column_defaults["permissions"])
+    assert_equal({ "users" => "read", "articles" => "write" }, Hstore.new.permissions)
+  ensure
+    Hstore.reset_column_information
+  end
+
+  def test_change_table_supports_hstore
+    @connection.transaction do
+      @connection.change_table("hstores") do |t|
+        t.hstore "users", default: ""
+      end
+      Hstore.reset_column_information
+      column = Hstore.columns_hash["users"]
+      assert_equal :hstore, column.type
+
+      raise ActiveRecord::Rollback # reset the schema change
+    end
+  ensure
+    Hstore.reset_column_information
+  end
+
+  def test_hstore_migration
+    hstore_migration = Class.new(ActiveRecord::Migration::Current) do
+      def change
+        change_table("hstores") do |t|
+          t.hstore :keys
+        end
+      end
+    end
+
+    hstore_migration.new.suppress_messages do
+      hstore_migration.migrate(:up)
+      assert_includes @connection.columns(:hstores).map(&:name), "keys"
+      hstore_migration.migrate(:down)
+      assert_not_includes @connection.columns(:hstores).map(&:name), "keys"
+    end
+  end
+
+  def test_cast_value_on_write
+    x = Hstore.new tags: { "bool" => true, "number" => 5 }
+    assert_equal({ "bool" => true, "number" => 5 }, x.tags_before_type_cast)
+    assert_equal({ "bool" => "true", "number" => "5" }, x.tags)
+    x.save
+    assert_equal({ "bool" => "true", "number" => "5" }, x.reload.tags)
+  end
+
+  def test_type_cast_hstore
+    assert_equal({ "1" => "2" }, @type.deserialize("\"1\"=>\"2\""))
+    assert_equal({}, @type.deserialize(""))
+    assert_equal({ "key" => nil }, @type.deserialize("key => NULL"))
+    assert_equal({ "c" => "}", '"a"' => 'b "a b' }, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
+  end
+
+  def test_with_store_accessors
+    x = Hstore.new(language: "fr", timezone: "GMT")
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
+
+    x.save!
+    x = Hstore.first
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
+
+    x.language = "de"
+    x.save!
+
+    x = Hstore.first
+    assert_equal "de", x.language
+    assert_equal "GMT", x.timezone
+  end
+
+  def test_duplication_with_store_accessors
+    x = Hstore.new(language: "fr", timezone: "GMT")
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
+
+    y = x.dup
+    assert_equal "fr", y.language
+    assert_equal "GMT", y.timezone
+  end
+
+  def test_yaml_round_trip_with_store_accessors
+    x = Hstore.new(language: "fr", timezone: "GMT")
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
+
+    payload = YAML.dump(x)
+    y = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    assert_equal "fr", y.language
+    assert_equal "GMT", y.timezone
+  end
+
+  def test_changes_with_store_accessors
+    x = Hstore.new(language: "de")
+    assert x.language_changed?
+    assert_nil x.language_was
+    assert_equal [nil, "de"], x.language_change
+    x.save!
+
+    assert_not x.language_changed?
+    x.reload
+
+    x.settings = nil
+    assert x.language_changed?
+    assert_equal "de", x.language_was
+    assert_equal ["de", nil], x.language_change
+  end
+
+  def test_changes_in_place
+    hstore = Hstore.create!(settings: { "one" => "two" })
+    hstore.settings["three"] = "four"
+    hstore.save!
+    hstore.reload
+
+    assert_equal "four", hstore.settings["three"]
+    assert_not_predicate hstore, :changed?
+  end
+
+  def test_dirty_from_user_equal
+    settings = { "alongkey" => "anything", "key" => "value" }
+    hstore = Hstore.create!(settings: settings)
+
+    hstore.settings = { "key" => "value", "alongkey" => "anything" }
+    assert_equal settings, hstore.settings
+    assert_not_predicate hstore, :changed?
+  end
+
+  def test_hstore_dirty_from_database_equal
+    settings = { "alongkey" => "anything", "key" => "value" }
+    hstore = Hstore.create!(settings: settings)
+    hstore.reload
+
+    assert_equal settings, hstore.settings
+    hstore.settings = settings
+    assert_not_predicate hstore, :changed?
+  end
+
+  def test_gen1
+    assert_equal('" "=>""', @type.serialize(" " => ""))
+  end
+
+  def test_gen2
+    assert_equal('","=>""', @type.serialize("," => ""))
+  end
+
+  def test_gen3
+    assert_equal('"="=>""', @type.serialize("=" => ""))
+  end
+
+  def test_gen4
+    assert_equal('">"=>""', @type.serialize(">" => ""))
+  end
+
+  def test_parse1
+    assert_equal({ "a" => nil, "b" => nil, "c" => "NuLl", "null" => "c" }, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+  end
+
+  def test_parse2
+    assert_equal({ " " => " " },  @type.deserialize("\\ =>\\ "))
+  end
+
+  def test_parse3
+    assert_equal({ "=" => ">" },  @type.deserialize("==>>"))
+  end
+
+  def test_parse4
+    assert_equal({ "=a" => "q=w" },   @type.deserialize('\=a=>q=w'))
+  end
+
+  def test_parse5
+    assert_equal({ "=a" => "q=w" },   @type.deserialize('"=a"=>q\=w'))
+  end
+
+  def test_parse6
+    assert_equal({ "\"a" => "q>w" },  @type.deserialize('"\"a"=>q>w'))
+  end
+
+  def test_parse7
+    assert_equal({ "\"a" => "q\"w" }, @type.deserialize('\"a=>q"w'))
+  end
+
+  def test_rewrite
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+    x = Hstore.first
+    x.tags = { '"a\'' => "b" }
+    assert x.save!
+  end
+
+  def test_select
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+    x = Hstore.first
+    assert_equal({ "1" => "2" }, x.tags)
+  end
+
+  def test_array_cycle
+    assert_array_cycle([{ "AA" => "BB", "CC" => "DD" }, { "AA" => nil }])
+  end
+
+  def test_array_strings_with_quotes
+    assert_array_cycle([{ "this has" => 'some "s that need to be escaped"' }])
+  end
+
+  def test_array_strings_with_commas
+    assert_array_cycle([{ "this,has" => "many,values" }])
+  end
+
+  def test_array_strings_with_array_delimiters
+    assert_array_cycle(["{" => "}"])
+  end
+
+  def test_array_strings_with_null_strings
+    assert_array_cycle([{ "NULL" => "NULL" }])
+  end
+
+  def test_contains_nils
+    assert_array_cycle([{ "NULL" => nil }])
+  end
+
+  def test_select_multikey
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
+    x = Hstore.first
+    assert_equal({ "1" => "2", "2" => "3" }, x.tags)
+  end
+
+  def test_create
+    assert_cycle("a" => "b", "1" => "2")
+  end
+
+  def test_nil
+    assert_cycle("a" => nil)
+  end
+
+  def test_quotes
+    assert_cycle("a" => 'b"ar', '1"foo' => "2")
+  end
+
+  def test_whitespace
+    assert_cycle("a b" => "b ar", '1"foo' => "2")
+  end
+
+  def test_backslash
+    assert_cycle('a\\b' => 'b\\ar', '1"foo' => "2")
+  end
+
+  def test_comma
+    assert_cycle("a, b" => "bar", '1"foo' => "2")
+  end
+
+  def test_arrow
+    assert_cycle("a=>b" => "bar", '1"foo' => "2")
+  end
+
+  def test_quoting_special_characters
+    assert_cycle("ca" => "cà", "ac" => "àc")
+  end
+
+  def test_multiline
+    assert_cycle("a\nb" => "c\nd")
+  end
+
+  class TagCollection
+    def initialize(hash); @hash = hash end
+    def to_hash; @hash end
+    def self.load(hash); new(hash) end
+    def self.dump(object); object.to_hash end
+  end
+
+  class HstoreWithSerialize < Hstore
+    serialize :tags, TagCollection
+  end
+
+  def test_hstore_with_serialized_attributes
+    HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
+    record = HstoreWithSerialize.first
+    assert_instance_of TagCollection, record.tags
+    assert_equal({ "one" => "two" }, record.tags.to_hash)
+    record.tags = TagCollection.new("three" => "four")
+    record.save!
+    assert_equal({ "three" => "four" }, HstoreWithSerialize.first.tags.to_hash)
+  end
+
+  def test_clone_hstore_with_serialized_attributes
+    HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
+    record = HstoreWithSerialize.first
+    dupe = record.dup
+    assert_equal({ "one" => "two" }, dupe.tags.to_hash)
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema("hstores")
+    assert_match %r[t\.hstore "tags",\s+default: {}], output
+  end
+
+  def test_supports_to_unsafe_h_values
+    assert_equal "\"hi\"=>\"hi\"", @type.serialize(ProtectedParams.new("hi" => "hi"))
+  end
+
+  private
+    def assert_array_cycle(array)
+      # test creation
+      x = Hstore.create!(payload: array)
+      x.reload
+      assert_equal(array, x.payload)
+
+      # test updating
+      x = Hstore.create!(payload: [])
+      x.payload = array
+      x.save!
+      x.reload
+      assert_equal(array, x.payload)
+    end
+
+    def assert_cycle(hash)
+      # test creation
+      x = Hstore.create!(tags: hash)
+      x.reload
+      assert_equal(hash, x.tags)
+
+      # test updating
+      x = Hstore.create!(tags: {})
+      x.tags = hash
+      x.save!
+      x.reload
+      assert_equal(hash, x.tags)
+    end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
+  include InTimeZone
+
+  class PostgresqlInfinity < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:postgresql_infinities) do |t|
+      t.float :float
+      t.datetime :datetime
+      t.date :date
+    end
+  end
+
+  teardown do
+    @connection.drop_table "postgresql_infinities", if_exists: true
+  end
+
+  test "type casting infinity on a float column" do
+    record = PostgresqlInfinity.create!(float: Float::INFINITY)
+    record.reload
+    assert_equal Float::INFINITY, record.float
+  end
+
+  test "type casting string on a float column" do
+    record = PostgresqlInfinity.new(float: "Infinity")
+    assert_equal Float::INFINITY, record.float
+    record = PostgresqlInfinity.new(float: "-Infinity")
+    assert_equal(-Float::INFINITY, record.float)
+    record = PostgresqlInfinity.new(float: "NaN")
+    assert record.float.nan?, "Expected #{record.float} to be NaN"
+  end
+
+  test "update_all with infinity on a float column" do
+    record = PostgresqlInfinity.create!
+    PostgresqlInfinity.update_all(float: Float::INFINITY)
+    record.reload
+    assert_equal Float::INFINITY, record.float
+  end
+
+  test "type casting infinity on a datetime column" do
+    record = PostgresqlInfinity.create!(datetime: "infinity")
+    record.reload
+    assert_equal Float::INFINITY, record.datetime
+
+    record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
+    record.reload
+    assert_equal Float::INFINITY, record.datetime
+  end
+
+  test "type casting infinity on a date column" do
+    record = PostgresqlInfinity.create!(date: "infinity")
+    record.reload
+    assert_equal Float::INFINITY, record.date
+
+    record = PostgresqlInfinity.create!(date: Float::INFINITY)
+    record.reload
+    assert_equal Float::INFINITY, record.date
+  end
+
+  test "update_all with infinity on a datetime column" do
+    record = PostgresqlInfinity.create!
+    PostgresqlInfinity.update_all(datetime: Float::INFINITY)
+    record.reload
+    assert_equal Float::INFINITY, record.datetime
+  end
+
+  test "assigning 'infinity' on a datetime column with TZ aware attributes" do
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = PostgresqlInfinity.create!(datetime: "infinity")
+      assert_equal Float::INFINITY, record.datetime
+      assert_equal record.datetime, record.reload.datetime
+    end
+  ensure
+    # setting time_zone_aware_attributes causes the types to change.
+    # There is no way to do this automatically since it can be set on a superclass
+    PostgresqlInfinity.reset_column_information
+  end
+
+  test "where clause with infinite range on a datetime column" do
+    record = PostgresqlInfinity.create!(datetime: Time.current)
+
+    string = PostgresqlInfinity.where(datetime: "-infinity".."infinity")
+    assert_equal record, string.take
+
+    infinity = PostgresqlInfinity.where(datetime: -::Float::INFINITY..::Float::INFINITY)
+    assert_equal record, infinity.take
+
+    assert_equal infinity.to_sql, string.to_sql
+  end
+
+  test "where clause with infinite range on a date column" do
+    record = PostgresqlInfinity.create!(date: Date.current)
+
+    string = PostgresqlInfinity.where(date: "-infinity".."infinity")
+    assert_equal record, string.take
+
+    infinity = PostgresqlInfinity.where(date: -::Float::INFINITY..::Float::INFINITY)
+    assert_equal record, infinity.take
+
+    assert_equal infinity.to_sql, string.to_sql
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/core_ext/numeric/bytes"
+
+class PostgresqlIntegerTest < ActiveRecord::PostgreSQLTestCase
+  class PgInteger < ActiveRecord::Base
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    @connection.transaction do
+      @connection.create_table "pg_integers", force: true do |t|
+        t.integer :quota, limit: 8, default: 2.gigabytes
+      end
+    end
+  end
+
+  teardown do
+    @connection.drop_table "pg_integers", if_exists: true
+  end
+
+  test "schema properly respects bigint ranges" do
+    assert_equal 2.gigabytes, PgInteger.new.quota
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class PostgresqlIntervalTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class IntervalDataType < ActiveRecord::Base
+    attribute :maximum_term, :interval
+    attribute :minimum_term, :interval, precision: 3
+    attribute :default_term, :interval
+    attribute :all_terms,    :interval, array: true
+    attribute :legacy_term,  :string
+  end
+
+  class DeprecatedIntervalDataType < ActiveRecord::Base; end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.create_table("interval_data_types") do |t|
+        t.interval "maximum_term"
+        t.interval "minimum_term", precision: 3
+        t.interval "default_term", default: "P3Y"
+        t.interval "all_terms", array: true
+        t.interval "legacy_term"
+      end
+      @connection.create_table("deprecated_interval_data_types") do |t|
+        t.interval "duration"
+      end
+    end
+    @column_max = IntervalDataType.columns_hash["maximum_term"]
+    @column_min = IntervalDataType.columns_hash["minimum_term"]
+    assert(@column_max.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+    assert(@column_min.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+    assert_nil @column_max.precision
+    assert_equal 3,   @column_min.precision
+  end
+
+  teardown do
+    @connection.execute "DROP TABLE IF EXISTS interval_data_types"
+    @connection.execute "DROP TABLE IF EXISTS deprecated_interval_data_types"
+  end
+
+  def test_column
+    assert_equal :interval,     @column_max.type
+    assert_equal :interval,     @column_min.type
+    assert_equal "interval",    @column_max.sql_type
+    assert_equal "interval(3)", @column_min.sql_type
+  end
+
+  def test_interval_type
+    IntervalDataType.create!(
+      maximum_term: 6.year + 5.month + 4.days + 3.hours + 2.minutes + 1.seconds,
+      minimum_term: 1.year + 2.month + 3.days + 4.hours + 5.minutes + (6.234567).seconds,
+      all_terms:    [1.month, 1.year, 1.hour],
+      legacy_term:  "33 years",
+    )
+    i = IntervalDataType.last!
+    assert_equal "P6Y5M4DT3H2M1S",     i.maximum_term.iso8601
+    assert_equal "P1Y2M3DT4H5M6.235S", i.minimum_term.iso8601
+    assert_equal "P3Y",                i.default_term.iso8601
+    assert_equal %w[ P1M P1Y PT1H ],   i.all_terms.map(&:iso8601)
+    assert_equal "P33Y",               i.legacy_term
+  end
+
+  def test_interval_type_cast_from_invalid_string
+    i = IntervalDataType.create!(maximum_term: "1 year 2 minutes")
+    i.reload
+    assert_nil i.maximum_term
+  end
+
+  def test_interval_type_cast_from_numeric
+    i = IntervalDataType.create!(minimum_term: 36000)
+    i.reload
+    assert_equal "PT10H",  i.minimum_term.iso8601
+  end
+
+  def test_interval_type_cast_string_and_numeric_from_user
+    i = IntervalDataType.new(maximum_term: "P1YT2M", minimum_term: "PT10H", legacy_term: "P1DT1H")
+    assert i.maximum_term.is_a?(ActiveSupport::Duration)
+    assert i.legacy_term.is_a?(String)
+    assert_equal "P1YT2M", i.maximum_term.iso8601
+    assert_equal "PT10H",  i.minimum_term.iso8601
+    assert_equal "P1DT1H", i.legacy_term
+  end
+
+  def test_deprecated_legacy_type
+    assert_deprecated do
+      DeprecatedIntervalDataType.new
+    end
+  end
+
+  def test_schema_dump_with_default_value
+    output = dump_table_schema "interval_data_types"
+    assert_match %r{t\.interval "default_term", default: "P3Y"}, output
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/json_shared_test_cases"
+
+module PostgresqlJSONSharedTestCases
+  include JSONSharedTestCases
+
+  def setup
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.public_send column_type, "payload", default: {} # t.json 'payload', default: {}
+      t.public_send column_type, "settings"             # t.json 'settings'
+      t.public_send column_type, "objects", array: true # t.json 'objects', array: true
+    end
+  rescue ActiveRecord::StatementInvalid
+    skip "do not test on PostgreSQL without #{column_type} type."
+  end
+
+  def test_default
+    @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
+    klass.reset_column_information
+
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.column_defaults["permissions"])
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.new.permissions)
+  end
+
+  def test_deserialize_with_array
+    x = klass.new(objects: ["foo" => "bar"])
+    assert_equal ["foo" => "bar"], x.objects
+    x.save!
+    assert_equal ["foo" => "bar"], x.objects
+    x.reload
+    assert_equal ["foo" => "bar"], x.objects
+  end
+end
+
+class PostgresqlJSONTest < ActiveRecord::PostgreSQLTestCase
+  include PostgresqlJSONSharedTestCases
+
+  def column_type
+    :json
+  end
+end
+
+class PostgresqlJSONBTest < ActiveRecord::PostgreSQLTestCase
+  include PostgresqlJSONSharedTestCases
+
+  def column_type
+    :jsonb
+  end
+end