ibm_db 5.6.1-arm64-darwin-24

data/test/cases/collection_cache_key_test.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/computer"
+require "models/developer"
+require "models/project"
+require "models/topic"
+require "models/post"
+require "models/comment"
+require "models/ship"
+
+module ActiveRecord
+  class CollectionCacheKeyTest < ActiveRecord::TestCase
+    fixtures :developers, :projects, :developers_projects, :topics, :comments, :posts
+
+    test "collection_cache_key on model" do
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, Developer.collection_cache_key)
+    end
+
+    test "cache_key for relation" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with limit" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with custom select and limit" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5)
+      developers_with_select = developers.select("developers.*")
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers_with_select.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers_with_select.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers_with_select.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for loaded relation" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5).load
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with table alias" do
+      table_alias = Developer.arel_table.alias("omg_developers")
+      table_metadata = ActiveRecord::TableMetadata.new(Developer, table_alias)
+      predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
+
+      developers = ActiveRecord::Relation.create(
+        Developer,
+        table: table_alias,
+        predicate_builder: predicate_builder
+      )
+      developers = developers.where(salary: 100000).order(updated_at: :desc)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with includes" do
+      comments = Comment.includes(:post).where("posts.type": "Post")
+      assert_match(/\Acomments\/query-(\h+)-(\d+)-(\d+)\z/, comments.cache_key)
+    end
+
+    test "cache_key for loaded relation with includes" do
+      comments = Comment.includes(:post).where("posts.type": "Post").load
+      assert_match(/\Acomments\/query-(\h+)-(\d+)-(\d+)\z/, comments.cache_key)
+    end
+
+    test "update_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.update_all(updated_at: Time.now.utc)
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "update_all with includes will update cache_key" do
+      developers = Developer.includes(:projects).where("projects.name": "Active Record")
+      cache_key = developers.cache_key
+
+      developers.update_all(updated_at: Time.now.utc)
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "delete_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.delete_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "delete_all with includes will update cache_key" do
+      developers = Developer.includes(:projects).where("projects.name": "Active Record")
+      cache_key = developers.cache_key
+
+      developers.delete_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "destroy_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.destroy_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "it triggers at most one query" do
+      developers = Developer.where(name: "David")
+
+      assert_queries(1) { developers.cache_key }
+      assert_no_queries { developers.cache_key }
+    end
+
+    test "it doesn't trigger any query if the relation is already loaded" do
+      developers = Developer.where(name: "David").load
+      assert_no_queries { developers.cache_key }
+    end
+
+    test "it doesn't trigger any query if collection_cache_versioning is enabled" do
+      with_collection_cache_versioning do
+        developers = Developer.where(name: "David")
+        assert_no_queries { developers.cache_key }
+      end
+    end
+
+    test "relation cache_key changes when the sql query changes" do
+      developers = Developer.where(name: "David")
+      other_relation = Developer.where(name: "David").where("1 = 1")
+
+      assert_not_equal developers.cache_key, other_relation.cache_key
+    end
+
+    test "cache_key for empty relation" do
+      developers = Developer.where(name: "Non Existent Developer")
+      assert_match(/\Adevelopers\/query-(\h+)-0\z/, developers.cache_key)
+    end
+
+    test "cache_key with custom timestamp column" do
+      topics = Topic.where("title like ?", "%Topic%")
+      last_topic_timestamp = topics(:fifth).written_on.utc.to_s(:usec)
+      assert_match(last_topic_timestamp, topics.cache_key(:written_on))
+    end
+
+    test "cache_key with unknown timestamp column" do
+      topics = Topic.where("title like ?", "%Topic%")
+      assert_raises(ActiveRecord::StatementInvalid) { topics.cache_key(:published_at) }
+    end
+
+    test "collection proxy provides a cache_key" do
+      developers = projects(:active_record).developers
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key for loaded collection with zero size" do
+      Comment.delete_all
+      posts = Post.includes(:comments)
+      empty_loaded_collection = posts.first.comments
+
+      assert_match(/\Acomments\/query-(\h+)-0\z/, empty_loaded_collection.cache_key)
+    end
+
+    test "cache_key for queries with offset which return 0 rows" do
+      developers = Developer.offset(20)
+      assert_match(/\Adevelopers\/query-(\h+)-0\z/, developers.cache_key)
+    end
+
+    test "cache_key with a relation having selected columns" do
+      developers = Developer.select(:salary)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key with a relation having distinct and order" do
+      developers = Developer.distinct.order(:salary).limit(5)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key with a relation having custom select and order" do
+      developers = Developer.select("name AS dev_name").order("dev_name DESC").limit(5)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key should be stable when using collection_cache_versioning" do
+      with_collection_cache_versioning do
+        developers = Developer.where(salary: 100000)
+
+        assert_match(/\Adevelopers\/query-(\h+)\z/, developers.cache_key)
+
+        /\Adevelopers\/query-(\h+)\z/ =~ developers.cache_key
+
+        assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      end
+    end
+
+    test "cache_version for relation" do
+      with_collection_cache_versioning do
+        developers = Developer.where(salary: 100000).order(updated_at: :desc)
+        last_developer_timestamp = developers.first.updated_at
+
+        assert_match(/(\d+)-(\d+)\z/, developers.cache_version)
+
+        /(\d+)-(\d+)\z/ =~ developers.cache_version
+
+        assert_equal developers.count.to_s, $1
+        assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $2
+      end
+    end
+
+    test "cache_key_with_version contains key and version regardless of collection_cache_versioning setting" do
+      key_with_version_1 = Developer.all.cache_key_with_version
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, key_with_version_1)
+
+      with_collection_cache_versioning do
+        key_with_version_2 = Developer.all.cache_key_with_version
+        assert_equal(key_with_version_1, key_with_version_2)
+      end
+    end
+
+    def with_collection_cache_versioning(value = true)
+      @old_collection_cache_versioning = ActiveRecord::Base.collection_cache_versioning
+      ActiveRecord::Base.collection_cache_versioning = value
+      yield
+    ensure
+      ActiveRecord::Base.collection_cache_versioning = @old_collection_cache_versioning
+    end
+  end
+end

data/test/cases/column_alias_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+class TestColumnAlias < ActiveRecord::TestCase
+  fixtures :topics
+
+  QUERY = if "Oracle" == ActiveRecord::Base.connection.adapter_name
+    "SELECT id AS pk FROM topics WHERE ROWNUM < 2"
+  else
+    "SELECT id AS pk FROM topics"
+  end
+
+  def test_column_alias
+    records = Topic.connection.select_all(QUERY)
+    assert_equal "pk", records[0].keys[0]
+  end
+end

data/test/cases/column_definition_test.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ColumnDefinitionTest < ActiveRecord::TestCase
+      def setup
+        @adapter = AbstractAdapter.new(nil)
+        def @adapter.native_database_types
+          { string: "varchar" }
+        end
+        @viz = @adapter.send(:schema_creation)
+      end
+
+      # Avoid column definitions in create table statements like:
+      # `title` varchar(255) DEFAULT NULL
+      def test_should_not_include_default_clause_when_default_is_null
+        column_def = ColumnDefinition.new("title", "string", limit: 20)
+        assert_equal "title varchar(20)", @viz.accept(column_def)
+      end
+
+      def test_should_include_default_clause_when_default_is_present
+        column_def = ColumnDefinition.new("title", "string", limit: 20, default: "Hello")
+        assert_equal "title varchar(20) DEFAULT 'Hello'", @viz.accept(column_def)
+      end
+
+      def test_should_specify_not_null_if_null_option_is_false
+        column_def = ColumnDefinition.new("title", "string", limit: 20, default: "Hello", null: false)
+        assert_equal "title varchar(20) DEFAULT 'Hello' NOT NULL", @viz.accept(column_def)
+      end
+    end
+  end
+end

data/test/cases/comment_test.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.connection.supports_comments?
+  class CommentTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    class Commented < ActiveRecord::Base
+      self.table_name = "commenteds"
+    end
+
+    class BlankComment < ActiveRecord::Base
+    end
+
+    class PkCommented < ActiveRecord::Base
+    end
+
+    setup do
+      @connection = ActiveRecord::Base.connection
+
+      @connection.create_table("commenteds", comment: "A table with comment", force: true) do |t|
+        t.string  "name",    comment: "Comment should help clarify the column purpose"
+        t.boolean "obvious", comment: "Question is: should you comment obviously named objects?"
+        t.string  "content"
+        t.index   "name",    comment: %Q["Very important" index that powers all the performance.\nAnd it's fun!]
+      end
+
+      @connection.create_table("blank_comments", comment: " ", force: true) do |t|
+        t.string :space_comment, comment: " "
+        t.string :empty_comment, comment: ""
+        t.string :nil_comment, comment: nil
+        t.string :absent_comment
+        t.index :space_comment, comment: " "
+        t.index :empty_comment, comment: ""
+        t.index :nil_comment, comment: nil
+        t.index :absent_comment
+      end
+
+      @connection.create_table("pk_commenteds", comment: "Table comment", id: false, force: true) do |t|
+        t.primary_key :id, comment: "Primary key comment"
+      end
+
+      Commented.reset_column_information
+      BlankComment.reset_column_information
+      PkCommented.reset_column_information
+    end
+
+    teardown do
+      @connection.drop_table "commenteds", if_exists: true
+      @connection.drop_table "blank_comments", if_exists: true
+    end
+
+    def test_default_primary_key_comment
+      column = Commented.columns_hash["id"]
+      assert_nil column.comment
+    end
+
+    def test_column_created_in_block
+      column = Commented.columns_hash["name"]
+      assert_equal :string, column.type
+      assert_equal "Comment should help clarify the column purpose", column.comment
+    end
+
+    def test_blank_columns_created_in_block
+      %w[ space_comment empty_comment nil_comment absent_comment ].each do |field|
+        column = BlankComment.columns_hash[field]
+        assert_equal :string, column.type
+        assert_nil column.comment
+      end
+    end
+
+    def test_blank_indexes_created_in_block
+      puts "test_blank_indexes_created_in_block"
+      @connection.indexes("blank_comments").each do |index|
+        assert_nil index.comment
+      end
+    end
+
+    def test_add_column_with_comment_later
+      @connection.add_column :commenteds, :rating, :integer, comment: "I am running out of imagination"
+      Commented.reset_column_information
+      column = Commented.columns_hash["rating"]
+
+      assert_equal :integer, column.type
+      assert_equal "I am running out of imagination", column.comment
+    end
+
+    def test_add_index_with_comment_later
+      unless current_adapter?(:OracleAdapter)
+        @connection.add_index :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
+        index = @connection.indexes("commenteds").find { |idef| idef.name == "idx_obvious" }
+        assert_equal "We need to see obvious comments", index.comment
+      end
+    end
+
+    def test_add_comment_to_column
+      @connection.change_column :commenteds, :content, :string, comment: "Whoa, content describes itself!"
+
+      Commented.reset_column_information
+      column = Commented.columns_hash["content"]
+
+      assert_equal :string, column.type
+      assert_equal "Whoa, content describes itself!", column.comment
+    end
+
+    def test_remove_comment_from_column
+      @connection.change_column :commenteds, :obvious, :string, comment: nil
+
+      Commented.reset_column_information
+      column = Commented.columns_hash["obvious"]
+
+      assert_equal :string, column.type
+      assert_nil column.comment
+    end
+
+    def test_rename_column_preserves_comment
+      @connection.add_column    :commenteds, :rating, :string, comment: "I am running out of imagination"
+      @connection.rename_column :commenteds, :rating, :new_rating
+
+      Commented.reset_column_information
+      column = Commented.columns_hash["new_rating"]
+
+      assert_equal :string, column.type
+      assert_equal column.comment, "I am running out of imagination"
+    end
+
+    def test_schema_dump_with_comments
+      # Do all the stuff from other tests
+      @connection.add_column    :commenteds, :rating, :integer, comment: "I am running out of imagination"
+      @connection.change_column :commenteds, :content, :string, comment: "Whoa, content describes itself!"
+      @connection.change_column :commenteds, :content, :string
+      @connection.change_column :commenteds, :obvious, :string, comment: nil
+      @connection.add_index     :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
+
+      # And check that these changes are reflected in dump
+      output = dump_table_schema "commenteds"
+      assert_match %r[create_table "commenteds",.*\s+comment: "A table with comment"], output
+      assert_match %r[t\.string\s+"name",.*\s+comment: "Comment should help clarify the column purpose"], output
+      assert_match %r[t\.string\s+"obvious"], output
+      assert_match %r[t\.string\s+"content",.*\s+comment: "Whoa, content describes itself!"], output
+      if current_adapter?(:OracleAdapter)
+        assert_match %r[t\.integer\s+"rating",\s+precision: 38,\s+comment: "I am running out of imagination"], output
+      else
+        assert_match %r[t\.integer\s+"rating",.*\s+comment: "I am running out of imagination"], output
+        assert_match %r[t\.index\s+.+\s+comment: "\\\"Very important\\\" index that powers all the performance.\\nAnd it's fun!"], output
+        assert_match %r[t\.index\s+.+\s+name: "idx_obvious",.*\s+comment: "We need to see obvious comments"], output
+      end
+    end
+
+    def test_schema_dump_omits_blank_comments
+      output = dump_table_schema "blank_comments"
+
+      assert_match %r[create_table "blank_comments"], output
+      assert_no_match %r[create_table "blank_comments",.+comment:], output
+
+      assert_match %r[t\.string\s+"space_comment".*\n], output
+      assert_no_match %r[t\.string\s+"space_comment", comment:\n], output
+
+      assert_match %r[t\.string\s+"empty_comment".*\n], output
+      assert_no_match %r[t\.string\s+"empty_comment", comment:\n], output
+
+      assert_match %r[t\.string\s+"nil_comment".*\n], output
+      assert_no_match %r[t\.string\s+"nil_comment", comment:\n], output
+
+      assert_match %r[t\.string\s+"absent_comment".*\n], output
+      assert_no_match %r[t\.string\s+"absent_comment", comment:\n], output
+    end
+
+    def test_change_table_comment
+      @connection.change_table_comment :commenteds, "Edited table comment"
+      assert_equal "Edited table comment", @connection.table_comment("commenteds")
+    end
+
+    def test_change_table_comment_to_nil
+      @connection.change_table_comment :commenteds, nil
+      assert_nil @connection.table_comment("commenteds")
+    end
+
+    def test_change_column_comment
+      @connection.change_column_comment :commenteds, :name, "Edited column comment"
+      column = Commented.columns_hash["name"]
+      assert_equal "Edited column comment", column.comment
+    end
+
+    def test_change_column_comment_to_nil
+      @connection.change_column_comment :commenteds, :name, nil
+      column = Commented.columns_hash["name"]
+      assert_nil column.comment
+    end
+
+    def test_comment_on_primary_key
+      column = PkCommented.columns_hash["id"]
+      assert_equal "Primary key comment", column.comment
+      assert_equal "Table comment", @connection.table_comment("pk_commenteds")
+    end
+
+    def test_schema_dump_with_primary_key_comment
+      output = dump_table_schema "pk_commenteds"
+      assert_match %r[create_table "pk_commenteds", id: { .*comment: "Primary key comment" }.*, comment: "Table comment"], output
+    end
+  end
+end

data/test/cases/connection_adapters/adapter_leasing_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AdapterLeasingTest < ActiveRecord::TestCase
+      class Pool < ConnectionPool
+        def insert_connection_for_test!(c)
+          synchronize do
+            adopt_connection(c)
+            @available.add c
+          end
+        end
+      end
+
+      def setup
+        @adapter = AbstractAdapter.new nil, nil
+      end
+
+      def test_in_use?
+        assert_not @adapter.in_use?, "adapter is not in use"
+        assert @adapter.lease, "lease adapter"
+        assert @adapter.in_use?, "adapter is in use"
+      end
+
+      def test_lease_twice
+        assert @adapter.lease, "should lease adapter"
+        assert_raises(ActiveRecordError) do
+          @adapter.lease
+        end
+      end
+
+      def test_expire_mutates_in_use
+        assert @adapter.lease, "lease adapter"
+        assert @adapter.in_use?, "adapter is in use"
+        @adapter.expire
+        assert_not @adapter.in_use?, "adapter is in use"
+      end
+
+      def test_close
+        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", {})
+        pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config)
+        pool = Pool.new(pool_config)
+        pool.insert_connection_for_test! @adapter
+        @adapter.pool = pool
+
+        # Make sure the pool marks the connection in use
+        assert_equal @adapter, pool.connection
+        assert_predicate @adapter, :in_use?
+
+        # Close should put the adapter back in the pool
+        @adapter.close
+        assert_not_predicate @adapter, :in_use?
+
+        assert_equal @adapter, pool.connection
+      end
+    end
+  end
+end