ibm_db 5.6.1-arm64-darwin-24

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

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  class PostgresqlConnectionTest < ActiveRecord::PostgreSQLTestCase
+    include ConnectionHelper
+
+    class NonExistentTable < ActiveRecord::Base
+    end
+
+    fixtures :comments
+
+    def setup
+      super
+      @subscriber = SQLSubscriber.new
+      @connection = ActiveRecord::Base.connection
+      @connection.materialize_transactions
+      @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
+    end
+
+    def teardown
+      ActiveSupport::Notifications.unsubscribe(@subscription)
+      super
+    end
+
+    def test_encoding
+      assert_queries(1, ignore_none: true) do
+        assert_not_nil @connection.encoding
+      end
+    end
+
+    def test_collation
+      assert_queries(1, ignore_none: true) do
+        assert_not_nil @connection.collation
+      end
+    end
+
+    def test_ctype
+      assert_queries(1, ignore_none: true) do
+        assert_not_nil @connection.ctype
+      end
+    end
+
+    def test_default_client_min_messages
+      assert_equal "warning", @connection.client_min_messages
+    end
+
+    # Ensure, we can set connection params using the example of Generic
+    # Query Optimizer (geqo). It is 'on' per default.
+    def test_connection_options
+      params = ActiveRecord::Base.connection_db_config.configuration_hash.dup
+      params[:options] = "-c geqo=off"
+      NonExistentTable.establish_connection(params)
+
+      # Verify the connection param has been applied.
+      expect = NonExistentTable.connection.query("show geqo").first.first
+      assert_equal "off", expect
+    end
+
+    def test_reset
+      @connection.query("ROLLBACK")
+      @connection.query("SET geqo TO off")
+
+      # Verify the setting has been applied.
+      expect = @connection.query("show geqo").first.first
+      assert_equal "off", expect
+
+      @connection.reset!
+
+      # Verify the setting has been cleared.
+      expect = @connection.query("show geqo").first.first
+      assert_equal "on", expect
+    end
+
+    def test_reset_with_transaction
+      @connection.query("ROLLBACK")
+      @connection.query("SET geqo TO off")
+
+      # Verify the setting has been applied.
+      expect = @connection.query("show geqo").first.first
+      assert_equal "off", expect
+
+      @connection.query("BEGIN")
+      @connection.reset!
+
+      # Verify the setting has been cleared.
+      expect = @connection.query("show geqo").first.first
+      assert_equal "on", expect
+    end
+
+    def test_tables_logs_name
+      @connection.tables
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+
+    def test_indexes_logs_name
+      @connection.indexes("items")
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+
+    def test_table_exists_logs_name
+      @connection.table_exists?("items")
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+
+    def test_table_alias_length_logs_name
+      @connection.instance_variable_set("@max_identifier_length", nil)
+      @connection.table_alias_length
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+
+    def test_current_database_logs_name
+      @connection.current_database
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+
+    def test_encoding_logs_name
+      @connection.encoding
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+
+    def test_schema_names_logs_name
+      @connection.schema_names
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+
+    if ActiveRecord::Base.connection.prepared_statements
+      def test_statement_key_is_logged
+        bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
+        @connection.exec_query("SELECT $1::integer", "SQL", [bind], prepare: true)
+        name = @subscriber.payloads.last[:statement_name]
+        assert name
+        res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
+        plan = res.column_types["QUERY PLAN"].deserialize res.rows.first.first
+        assert_operator plan.length, :>, 0
+      end
+    end
+
+    def test_reconnection_after_actual_disconnection_with_verify
+      original_connection_pid = @connection.query("select pg_backend_pid()")
+
+      # Sanity check.
+      assert_predicate @connection, :active?
+
+      secondary_connection = ActiveRecord::Base.connection_pool.checkout
+      secondary_connection.query("select pg_terminate_backend(#{original_connection_pid.first.first})")
+      ActiveRecord::Base.connection_pool.checkin(secondary_connection)
+
+      @connection.verify!
+
+      assert_predicate @connection, :active?
+
+      # If we get no exception here, then either we re-connected successfully, or
+      # we never actually got disconnected.
+      new_connection_pid = @connection.query("select pg_backend_pid()")
+
+      assert_not_equal original_connection_pid, new_connection_pid,
+        "umm -- looks like you didn't break the connection, because we're still " \
+        "successfully querying with the same connection pid."
+    ensure
+      # Repair all fixture connections so other tests won't break.
+      @fixture_connections.each(&:verify!)
+    end
+
+    def test_set_session_variable_true
+      run_without_connection do |orig_connection|
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: true }))
+        set_true = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
+        assert_equal set_true.rows, [["on"]]
+      end
+    end
+
+    def test_set_session_variable_false
+      run_without_connection do |orig_connection|
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: false }))
+        set_false = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
+        assert_equal set_false.rows, [["off"]]
+      end
+    end
+
+    def test_set_session_variable_nil
+      run_without_connection do |orig_connection|
+        # This should be a no-op that does not raise an error
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: nil }))
+      end
+    end
+
+    def test_set_session_variable_default
+      run_without_connection do |orig_connection|
+        # This should execute a query that does not raise an error
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: :default }))
+      end
+    end
+
+    def test_set_session_timezone
+      run_without_connection do |orig_connection|
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { timezone: "America/New_York" }))
+        assert_equal "America/New_York", ActiveRecord::Base.connection.query_value("SHOW TIME ZONE")
+      end
+    end
+
+    def test_get_and_release_advisory_lock
+      lock_id = 5295901941911233559
+      list_advisory_locks = <<~SQL
+        SELECT locktype,
+              (classid::bigint << 32) | objid::bigint AS lock_id
+        FROM pg_locks
+        WHERE locktype = 'advisory'
+      SQL
+
+      got_lock = @connection.get_advisory_lock(lock_id)
+      assert got_lock, "get_advisory_lock should have returned true but it didn't"
+
+      advisory_lock = @connection.query(list_advisory_locks).find { |l| l[1] == lock_id }
+      assert advisory_lock,
+        "expected to find an advisory lock with lock_id #{lock_id} but there wasn't one"
+
+      released_lock = @connection.release_advisory_lock(lock_id)
+      assert released_lock, "expected release_advisory_lock to return true but it didn't"
+
+      advisory_locks = @connection.query(list_advisory_locks).select { |l| l[1] == lock_id }
+      assert_empty advisory_locks,
+        "expected to have released advisory lock with lock_id #{lock_id} but it was still held"
+    end
+
+    def test_release_non_existent_advisory_lock
+      fake_lock_id = 2940075057017742022
+      with_warning_suppression do
+        released_non_existent_lock = @connection.release_advisory_lock(fake_lock_id)
+        assert_equal released_non_existent_lock, false,
+          "expected release_advisory_lock to return false when there was no lock to release"
+      end
+    end
+
+    private
+      def with_warning_suppression
+        log_level = @connection.client_min_messages
+        @connection.client_min_messages = "error"
+        yield
+        @connection.client_min_messages = log_level
+      end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class UnloggedTablesTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  TABLE_NAME = "things"
+  LOGGED_FIELD = "relpersistence"
+  LOGGED_QUERY = "SELECT #{LOGGED_FIELD} FROM pg_class WHERE relname = '#{TABLE_NAME}'"
+  LOGGED = "p"
+  UNLOGGED = "u"
+  TEMPORARY = "t"
+
+  class Thing < ActiveRecord::Base
+    self.table_name = TABLE_NAME
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+  end
+
+  teardown do
+    @connection.drop_table TABLE_NAME, if_exists: true
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+  end
+
+  def test_logged_by_default
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], LOGGED
+  end
+
+  def test_unlogged_in_test_environment_when_unlogged_setting_enabled
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], UNLOGGED
+  end
+
+  def test_not_included_in_schema_dump
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+    assert_no_match(/unlogged/i, dump_table_schema(TABLE_NAME))
+  end
+
+  def test_not_changed_in_change_table
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+
+    @connection.change_table(TABLE_NAME) do |t|
+      t.column :name, :string
+    end
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], LOGGED
+  end
+
+  def test_gracefully_handles_temporary_tables
+    @connection.create_table(TABLE_NAME, temporary: true) do |t|
+    end
+
+    # Temporary tables are already unlogged, though this query results in a
+    # different result ("t" vs. "u"). This test is really just checking that we
+    # didn't try to run `CREATE TEMPORARY UNLOGGED TABLE`, which would result in
+    # a PostgreSQL error.
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], TEMPORARY
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+
+class PostgresqlTime < ActiveRecord::Base
+  # Declare attributes to get rid from deprecation warnings on ActiveRecord 6.1
+  attribute :time_interval,        :string
+  attribute :scaled_time_interval, :interval
+end
+
+class PostgresqlOid < ActiveRecord::Base
+end
+
+class PostgresqlLtree < ActiveRecord::Base
+end
+
+class PostgresqlDataTypeTest < ActiveRecord::PostgreSQLTestCase
+  self.use_transactional_tests = false
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    @connection.execute("INSERT INTO postgresql_times (id, time_interval, scaled_time_interval) VALUES (1, '1 year 2 days ago', '3 weeks ago')")
+    @first_time = PostgresqlTime.find(1)
+
+    @connection.execute("INSERT INTO postgresql_oids (id, obj_id) VALUES (1, 1234)")
+    @first_oid = PostgresqlOid.find(1)
+  end
+
+  teardown do
+    [PostgresqlTime, PostgresqlOid].each(&:delete_all)
+  end
+
+  def test_data_type_of_time_types
+    assert_equal :interval, @first_time.column_for_attribute(:time_interval).type
+    assert_equal :interval, @first_time.column_for_attribute(:scaled_time_interval).type
+  end
+
+  def test_data_type_of_oid_types
+    assert_equal :oid, @first_oid.column_for_attribute(:obj_id).type
+  end
+
+  def test_time_values
+    assert_equal "P-1Y-2D", @first_time.time_interval
+    assert_equal (-21.day), @first_time.scaled_time_interval
+  end
+
+  def test_oid_values
+    assert_equal 1234, @first_oid.obj_id
+  end
+
+  def test_update_oid
+    new_value = 2147483648
+    @first_oid.obj_id = new_value
+    assert @first_oid.save
+    assert @first_oid.reload
+    assert_equal new_value, @first_oid.obj_id
+  end
+
+  def test_text_columns_are_limitless_the_upper_limit_is_one_GB
+    assert_equal "text", @connection.type_to_sql(:text, limit: 100_000)
+    assert_raise ArgumentError do
+      @connection.type_to_sql(:text, limit: 4294967295)
+    end
+  end
+end
+
+class PostgresqlInternalDataTypeTest < ActiveRecord::PostgreSQLTestCase
+  include DdlHelper
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def test_name_column_type
+    with_example_table @connection, "ex", "data name" do
+      column = @connection.columns("ex").find { |col| col.name == "data" }
+      assert_equal :string, column.type
+    end
+  end
+
+  def test_char_column_type
+    with_example_table @connection, "ex", 'data "char"' do
+      column = @connection.columns("ex").find { |col| col.name == "data" }
+      assert_equal :string, column.type
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+class PostgresqlDateTest < ActiveRecord::PostgreSQLTestCase
+  def test_load_infinity_and_beyond
+    topic = Topic.find_by_sql("SELECT 'infinity'::date AS last_read").first
+    assert topic.last_read.infinite?, "timestamp should be infinite"
+    assert_operator topic.last_read, :>, 0
+
+    topic = Topic.find_by_sql("SELECT '-infinity'::date AS last_read").first
+    assert topic.last_read.infinite?, "timestamp should be infinite"
+    assert_operator topic.last_read, :<, 0
+  end
+
+  def test_save_infinity_and_beyond
+    topic = Topic.create!(last_read: 1.0 / 0.0)
+    assert_equal(1.0 / 0.0, topic.last_read)
+
+    topic = Topic.create!(last_read: -1.0 / 0.0)
+    assert_equal(-1.0 / 0.0, topic.last_read)
+  end
+
+  def test_bc_date
+    date = Date.new(0) - 1.week
+    topic = Topic.create!(last_read: date)
+    assert_equal date, Topic.find(topic.id).last_read
+  end
+
+  def test_bc_date_leap_year
+    date = Time.utc(-4, 2, 29).to_date
+    topic = Topic.create!(last_read: date)
+    assert_equal date, Topic.find(topic.id).last_read
+  end
+
+  def test_bc_date_year_zero
+    date = Time.utc(0, 4, 7).to_date
+    topic = Topic.create!(last_read: date)
+    assert_equal date, Topic.find(topic.id).last_read
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+class PostgresqlDomainTest < ActiveRecord::PostgreSQLTestCase
+  include ConnectionHelper
+
+  class PostgresqlDomain < ActiveRecord::Base
+    self.table_name = "postgresql_domains"
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.execute "CREATE DOMAIN custom_money as numeric(8,2)"
+      @connection.create_table("postgresql_domains") do |t|
+        t.column :price, :custom_money
+      end
+    end
+  end
+
+  teardown do
+    @connection.drop_table "postgresql_domains", if_exists: true
+    @connection.execute "DROP DOMAIN IF EXISTS custom_money"
+    reset_connection
+  end
+
+  def test_column
+    column = PostgresqlDomain.columns_hash["price"]
+    assert_equal :decimal, column.type
+    assert_equal "custom_money", column.sql_type
+    assert_not_predicate column, :array?
+
+    type = PostgresqlDomain.type_for_attribute("price")
+    assert_not_predicate type, :binary?
+  end
+
+  def test_domain_acts_like_basetype
+    PostgresqlDomain.create price: ""
+    record = PostgresqlDomain.first
+    assert_nil record.price
+
+    record.price = "34.15"
+    record.save!
+
+    assert_equal BigDecimal("34.15"), record.reload.price
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
+  include ConnectionHelper
+
+  class PostgresqlEnum < ActiveRecord::Base
+    self.table_name = "postgresql_enums"
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.execute <<~SQL
+        CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
+      SQL
+      @connection.create_table("postgresql_enums") do |t|
+        t.column :current_mood, :mood
+      end
+    end
+  end
+
+  teardown do
+    @connection.drop_table "postgresql_enums", if_exists: true
+    @connection.execute "DROP TYPE IF EXISTS mood"
+    reset_connection
+  end
+
+  def test_column
+    column = PostgresqlEnum.columns_hash["current_mood"]
+    assert_equal :enum, column.type
+    assert_equal "mood", column.sql_type
+    assert_not_predicate column, :array?
+
+    type = PostgresqlEnum.type_for_attribute("current_mood")
+    assert_not_predicate type, :binary?
+  end
+
+  def test_enum_defaults
+    @connection.add_column "postgresql_enums", "good_mood", :mood, default: "happy"
+    PostgresqlEnum.reset_column_information
+
+    assert_equal "happy", PostgresqlEnum.column_defaults["good_mood"]
+    assert_equal "happy", PostgresqlEnum.new.good_mood
+  ensure
+    PostgresqlEnum.reset_column_information
+  end
+
+  def test_enum_mapping
+    @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
+    enum = PostgresqlEnum.first
+    assert_equal "sad", enum.current_mood
+
+    enum.current_mood = "happy"
+    enum.save!
+
+    assert_equal "happy", enum.reload.current_mood
+  end
+
+  def test_invalid_enum_update
+    @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
+    enum = PostgresqlEnum.first
+    enum.current_mood = "angry"
+
+    assert_raise ActiveRecord::StatementInvalid do
+      enum.save
+    end
+  end
+
+  def test_no_oid_warning
+    @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
+    stderr_output = capture(:stderr) { PostgresqlEnum.first }
+
+    assert_predicate stderr_output, :blank?
+  end
+
+  def test_enum_type_cast
+    enum = PostgresqlEnum.new
+    enum.current_mood = :happy
+
+    assert_equal "happy", enum.current_mood
+  end
+
+  def test_assigning_enum_to_nil
+    model = PostgresqlEnum.new(current_mood: nil)
+
+    assert_nil model.current_mood
+    assert model.save
+    assert_nil model.reload.current_mood
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/post"
+
+class PostgreSQLExplainTest < ActiveRecord::PostgreSQLTestCase
+  fixtures :authors
+
+  def test_explain_for_one_query
+    explain = Author.where(id: 1).explain
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %(QUERY PLAN), explain
+  end
+
+  def test_explain_with_eager_loading
+    explain = Author.where(id: 1).includes(:posts).explain
+    assert_match %(QUERY PLAN), explain
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN for: SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\$1 \[\["author_id", 1\]\]|1)), explain
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PostgresqlExtensionMigrationTest < ActiveRecord::PostgreSQLTestCase
+  self.use_transactional_tests = false
+
+  class EnableHstore < ActiveRecord::Migration::Current
+    def change
+      enable_extension "hstore"
+    end
+  end
+
+  class DisableHstore < ActiveRecord::Migration::Current
+    def change
+      disable_extension "hstore"
+    end
+  end
+
+  def setup
+    super
+
+    @connection = ActiveRecord::Base.connection
+
+    @old_table_name_prefix = ActiveRecord::Base.table_name_prefix
+    @old_table_name_suffix = ActiveRecord::Base.table_name_suffix
+
+    ActiveRecord::Base.table_name_prefix = "p_"
+    ActiveRecord::Base.table_name_suffix = "_s"
+    @connection.schema_migration.reset_table_name
+    ActiveRecord::InternalMetadata.reset_table_name
+
+    @connection.schema_migration.delete_all rescue nil
+    ActiveRecord::Migration.verbose = false
+  end
+
+  def teardown
+    @connection.schema_migration.delete_all rescue nil
+    ActiveRecord::Migration.verbose = true
+
+    ActiveRecord::Base.table_name_prefix = @old_table_name_prefix
+    ActiveRecord::Base.table_name_suffix = @old_table_name_suffix
+    @connection.schema_migration.reset_table_name
+    ActiveRecord::InternalMetadata.reset_table_name
+
+    super
+  end
+
+  def test_enable_extension_migration_ignores_prefix_and_suffix
+    @connection.disable_extension("hstore")
+
+    migrations = [EnableHstore.new(nil, 1)]
+    ActiveRecord::Migrator.new(:up, migrations, ActiveRecord::Base.connection.schema_migration).migrate
+    assert @connection.extension_enabled?("hstore"), "extension hstore should be enabled"
+  end
+
+  def test_disable_extension_migration_ignores_prefix_and_suffix
+    @connection.enable_extension("hstore")
+
+    migrations = [DisableHstore.new(nil, 1)]
+    ActiveRecord::Migrator.new(:up, migrations, ActiveRecord::Base.connection.schema_migration).migrate
+    assert_not @connection.extension_enabled?("hstore"), "extension hstore should not be enabled"
+  end
+end