ibm_db 5.1.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/connection_adapters/mysql_type_lookup_test.rb

@@ -1,69 +1,81 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/connection_helper"
 
 if current_adapter?(:Mysql2Adapter)
-module ActiveRecord
-  module ConnectionAdapters
-    class MysqlTypeLookupTest < ActiveRecord::TestCase
-      setup do
-        @connection = ActiveRecord::Base.connection
-      end
+  module ActiveRecord
+    module ConnectionAdapters
+      class MysqlTypeLookupTest < ActiveRecord::TestCase
+        include ConnectionHelper
 
-      def test_boolean_types
-        emulate_booleans(true) do
-          assert_lookup_type :boolean, 'tinyint(1)'
-          assert_lookup_type :boolean, 'TINYINT(1)'
+        setup do
+          @connection = ActiveRecord::Base.connection
         end
-      end
 
-      def test_string_types
-        assert_lookup_type :string, "enum('one', 'two', 'three')"
-        assert_lookup_type :string, "ENUM('one', 'two', 'three')"
-        assert_lookup_type :string, "set('one', 'two', 'three')"
-        assert_lookup_type :string, "SET('one', 'two', 'three')"
-      end
+        def teardown
+          reset_connection
+        end
 
-      def test_set_type_with_value_matching_other_type
-        assert_lookup_type :string, "SET('unicode', '8bit', 'none', 'time')"
-      end
+        def test_boolean_types
+          emulate_booleans(true) do
+            assert_lookup_type :boolean, "tinyint(1)"
+            assert_lookup_type :boolean, "TINYINT(1)"
+          end
+        end
 
-      def test_enum_type_with_value_matching_other_type
-        assert_lookup_type :string, "ENUM('unicode', '8bit', 'none')"
-      end
+        def test_string_types
+          assert_lookup_type :string, "enum('one', 'two', 'three')"
+          assert_lookup_type :string, "ENUM('one', 'two', 'three')"
+          assert_lookup_type :string, "enum ('one', 'two', 'three')"
+          assert_lookup_type :string, "ENUM ('one', 'two', 'three')"
+          assert_lookup_type :string, "set('one', 'two', 'three')"
+          assert_lookup_type :string, "SET('one', 'two', 'three')"
+          assert_lookup_type :string, "set ('one', 'two', 'three')"
+          assert_lookup_type :string, "SET ('one', 'two', 'three')"
+        end
 
-      def test_binary_types
-        assert_lookup_type :binary, 'bit'
-        assert_lookup_type :binary, 'BIT'
-      end
+        def test_set_type_with_value_matching_other_type
+          assert_lookup_type :string, "SET('unicode', '8bit', 'none', 'time')"
+        end
 
-      def test_integer_types
-        emulate_booleans(false) do
-          assert_lookup_type :integer, 'tinyint(1)'
-          assert_lookup_type :integer, 'TINYINT(1)'
-          assert_lookup_type :integer, 'year'
-          assert_lookup_type :integer, 'YEAR'
+        def test_enum_type_with_value_matching_other_type
+          assert_lookup_type :string, "ENUM('unicode', '8bit', 'none', 'time')"
         end
-      end
 
-      private
+        def test_binary_types
+          assert_lookup_type :binary, "bit"
+          assert_lookup_type :binary, "BIT"
+        end
 
-      def assert_lookup_type(type, lookup)
-        cast_type = @connection.type_map.lookup(lookup)
-        assert_equal type, cast_type.type
-      end
+        def test_integer_types
+          emulate_booleans(false) do
+            assert_lookup_type :integer, "tinyint(1)"
+            assert_lookup_type :integer, "TINYINT(1)"
+            assert_lookup_type :integer, "year"
+            assert_lookup_type :integer, "YEAR"
+          end
+        end
 
-      def emulate_booleans(value)
-        old_emulate_booleans = @connection.emulate_booleans
-        change_emulate_booleans(value)
-        yield
-      ensure
-        change_emulate_booleans(old_emulate_booleans)
-      end
+        private
+          def assert_lookup_type(type, lookup)
+            cast_type = @connection.send(:type_map).lookup(lookup)
+            assert_equal type, cast_type.type
+          end
 
-      def change_emulate_booleans(value)
-        @connection.emulate_booleans = value
-        @connection.clear_cache!
+          def emulate_booleans(value)
+            old_emulate_booleans = @connection.emulate_booleans
+            change_emulate_booleans(value)
+            yield
+          ensure
+            change_emulate_booleans(old_emulate_booleans)
+          end
+
+          def change_emulate_booleans(value)
+            @connection.emulate_booleans = value
+            @connection.clear_cache!
+          end
       end
     end
   end
 end
-end

data/test/cases/connection_adapters/schema_cache_test.rb

@@ -1,61 +1,294 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   module ConnectionAdapters
     class SchemaCacheTest < ActiveRecord::TestCase
       def setup
-        connection = ActiveRecord::Base.connection
-        @cache     = SchemaCache.new connection
+        @connection       = ActiveRecord::Base.connection
+        @cache            = SchemaCache.new @connection
+        @database_version = @connection.get_database_version
       end
 
       def test_primary_key
-        assert_equal 'id', @cache.primary_keys('posts')
+        assert_equal "id", @cache.primary_keys("posts")
+      end
+
+      def test_yaml_dump_and_load
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".yml"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Load the cache.
+        cache = SchemaCache.load_from(tempfile.path)
+
+        # Give it a connection. Usually the connection
+        # would get set on the cache when it's retrieved
+        # from the pool.
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_yaml_dump_and_load_with_gzip
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".yml.gz"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Unzip and load manually.
+        cache = Zlib::GzipReader.open(tempfile.path) do |gz|
+          YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(gz.read) : YAML.load(gz.read)
+        end
+
+        # Give it a connection. Usually the connection
+        # would get set on the cache when it's retrieved
+        # from the pool.
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+
+        # Load the cache the usual way.
+        cache = SchemaCache.load_from(tempfile.path)
+
+        # Give it a connection.
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_yaml_loads_5_1_dump
+        cache = SchemaCache.load_from(schema_dump_path)
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 11, cache.columns("posts").size
+          assert_equal 11, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+        end
+      end
+
+      def test_yaml_loads_5_1_dump_without_indexes_still_queries_for_indexes
+        cache = SchemaCache.load_from(schema_dump_path)
+        cache.connection = @connection
+
+        assert_queries :any, ignore_none: true do
+          assert_equal 1, cache.indexes("posts").size
+        end
+      end
+
+      def test_yaml_loads_5_1_dump_without_database_version_still_queries_for_database_version
+        cache = SchemaCache.load_from(schema_dump_path)
+        cache.connection = @connection
+
+        # We can't verify queries get executed because the database version gets
+        # cached in both MySQL and PostgreSQL outside of the schema cache.
+        assert_nil cache.instance_variable_get(:@database_version)
+        assert_equal @database_version.to_s, cache.database_version.to_s
       end
 
       def test_primary_key_for_non_existent_table
-        assert_nil @cache.primary_keys('omgponies')
+        assert_nil @cache.primary_keys("omgponies")
       end
 
       def test_caches_columns
-        columns = @cache.columns('posts')
-        assert_equal columns, @cache.columns('posts')
+        columns = @cache.columns("posts")
+        assert_equal columns, @cache.columns("posts")
       end
 
       def test_caches_columns_hash
-        columns_hash = @cache.columns_hash('posts')
-        assert_equal columns_hash, @cache.columns_hash('posts')
+        columns_hash = @cache.columns_hash("posts")
+        assert_equal columns_hash, @cache.columns_hash("posts")
+      end
+
+      def test_caches_indexes
+        indexes = @cache.indexes("posts")
+        assert_equal indexes, @cache.indexes("posts")
+      end
+
+      def test_caches_database_version
+        @cache.database_version # cache database_version
+
+        assert_no_queries do
+          assert_equal @database_version.to_s, @cache.database_version.to_s
+
+          if current_adapter?(:Mysql2Adapter)
+            assert_not_nil @cache.database_version.full_version_string
+          end
+        end
       end
 
       def test_clearing
-        @cache.columns('posts')
-        @cache.columns_hash('posts')
-        @cache.data_sources('posts')
-        @cache.primary_keys('posts')
+        @cache.columns("posts")
+        @cache.columns_hash("posts")
+        @cache.data_sources("posts")
+        @cache.primary_keys("posts")
+        @cache.indexes("posts")
 
         @cache.clear!
 
         assert_equal 0, @cache.size
+        assert_nil @cache.instance_variable_get(:@database_version)
+      end
+
+      def test_marshal_dump_and_load
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        # Populate it.
+        cache.add("posts")
+
+        # Create a new cache by marchal dumping / loading.
+        cache = Marshal.load(Marshal.dump(cache))
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      end
+
+      def test_marshal_dump_and_load_via_disk
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".dump"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Load a new cache.
+        cache = SchemaCache.load_from(tempfile.path)
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_marshal_dump_and_load_with_gzip
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".dump.gz"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Load a new cache manually.
+        cache = Zlib::GzipReader.open(tempfile.path) { |gz| Marshal.load(gz.read) }
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+
+        # Load a new cache.
+        cache = SchemaCache.load_from(tempfile.path)
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_data_source_exist
+        assert @cache.data_source_exists?("posts")
+        assert_not @cache.data_source_exists?("foo")
       end
 
-      def test_dump_and_load
-        @cache.columns('posts')
-        @cache.columns_hash('posts')
-        @cache.data_sources('posts')
-        @cache.primary_keys('posts')
+      def test_clear_data_source_cache
+        @cache.clear_data_source_cache!("posts")
+      end
+
+      test "#columns_hash? is populated by #columns_hash" do
+        assert_not @cache.columns_hash?("posts")
 
-        @cache = Marshal.load(Marshal.dump(@cache))
+        @cache.columns_hash("posts")
 
-        assert_equal 11, @cache.columns('posts').size
-        assert_equal 11, @cache.columns_hash('posts').size
-        assert @cache.data_sources('posts')
-        assert_equal 'id', @cache.primary_keys('posts')
+        assert @cache.columns_hash?("posts")
       end
 
-      def test_table_methods_deprecation
-        assert_deprecated { assert @cache.table_exists?('posts') }
-        assert_deprecated { assert @cache.tables('posts') }
-        assert_deprecated { @cache.clear_table_cache!('posts') }
+      test "#columns_hash? is not populated by #data_source_exists?" do
+        assert_not @cache.columns_hash?("posts")
+
+        @cache.data_source_exists?("posts")
+
+        assert_not @cache.columns_hash?("posts")
       end
+
+      # This test covers a patch for a Ruby 2.6 bug that was only fixed in Ruby 2.7.
+      # See: https://bugs.ruby-lang.org/issues/15926
+      test "#deep_duplicate does not modify the frozen/ufrozen state of untainted or tainted string arguments" do
+        test_string = "banana"
+        [
+          test_string.dup,
+          test_string.dup.taint,
+          test_string.dup.freeze,
+          test_string.dup.taint.freeze
+        ].each do |str|
+          starting_frozen_state = str.frozen?
+          @cache.send(:deep_deduplicate, str)
+          assert_equal(starting_frozen_state, str.frozen?)
+        end
+      end
+
+      private
+        def schema_dump_path
+          "#{ASSETS_ROOT}/schema_dump_5_1.yml"
+        end
     end
   end
 end

data/test/cases/connection_adapters/type_lookup_test.rb

@@ -1,118 +1,119 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strings for lookup
-module ActiveRecord
-  module ConnectionAdapters
-    class TypeLookupTest < ActiveRecord::TestCase
-      setup do
-        @connection = ActiveRecord::Base.connection
-      end
-
-      def test_boolean_types
-        assert_lookup_type :boolean, 'boolean'
-        assert_lookup_type :boolean, 'BOOLEAN'
-      end
+  module ActiveRecord
+    module ConnectionAdapters
+      class TypeLookupTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+        end
 
-      def test_string_types
-        assert_lookup_type :string, 'char'
-        assert_lookup_type :string, 'varchar'
-        assert_lookup_type :string, 'VARCHAR'
-        assert_lookup_type :string, 'varchar(255)'
-        assert_lookup_type :string, 'character varying'
-      end
+        def test_boolean_types
+          assert_lookup_type :boolean, "boolean"
+          assert_lookup_type :boolean, "BOOLEAN"
+        end
 
-      def test_binary_types
-        assert_lookup_type :binary, 'binary'
-        assert_lookup_type :binary, 'BINARY'
-        assert_lookup_type :binary, 'blob'
-        assert_lookup_type :binary, 'BLOB'
-      end
+        def test_string_types
+          assert_lookup_type :string, "char"
+          assert_lookup_type :string, "varchar"
+          assert_lookup_type :string, "VARCHAR"
+          assert_lookup_type :string, "varchar(255)"
+          assert_lookup_type :string, "character varying"
+        end
 
-      def test_text_types
-        assert_lookup_type :text, 'text'
-        assert_lookup_type :text, 'TEXT'
-        assert_lookup_type :text, 'clob'
-        assert_lookup_type :text, 'CLOB'
-      end
+        def test_binary_types
+          assert_lookup_type :binary, "binary"
+          assert_lookup_type :binary, "BINARY"
+          assert_lookup_type :binary, "blob"
+          assert_lookup_type :binary, "BLOB"
+        end
 
-      def test_date_types
-        assert_lookup_type :date, 'date'
-        assert_lookup_type :date, 'DATE'
-      end
+        def test_text_types
+          assert_lookup_type :text, "text"
+          assert_lookup_type :text, "TEXT"
+          assert_lookup_type :text, "clob"
+          assert_lookup_type :text, "CLOB"
+        end
 
-      def test_time_types
-        assert_lookup_type :time, 'time'
-        assert_lookup_type :time, 'TIME'
-      end
+        def test_date_types
+          assert_lookup_type :date, "date"
+          assert_lookup_type :date, "DATE"
+        end
 
-      def test_datetime_types
-        assert_lookup_type :datetime, 'datetime'
-        assert_lookup_type :datetime, 'DATETIME'
-        assert_lookup_type :datetime, 'timestamp'
-        assert_lookup_type :datetime, 'TIMESTAMP'
-      end
+        def test_time_types
+          assert_lookup_type :time, "time"
+          assert_lookup_type :time, "TIME"
+        end
 
-      def test_decimal_types
-        assert_lookup_type :decimal, 'decimal'
-        assert_lookup_type :decimal, 'decimal(2,8)'
-        assert_lookup_type :decimal, 'DECIMAL'
-        assert_lookup_type :decimal, 'numeric'
-        assert_lookup_type :decimal, 'numeric(2,8)'
-        assert_lookup_type :decimal, 'NUMERIC'
-        assert_lookup_type :decimal, 'number'
-        assert_lookup_type :decimal, 'number(2,8)'
-        assert_lookup_type :decimal, 'NUMBER'
-      end
+        def test_datetime_types
+          assert_lookup_type :datetime, "datetime"
+          assert_lookup_type :datetime, "DATETIME"
+          assert_lookup_type :datetime, "timestamp"
+          assert_lookup_type :datetime, "TIMESTAMP"
+        end
 
-      def test_float_types
-        assert_lookup_type :float, 'float'
-        assert_lookup_type :float, 'FLOAT'
-        assert_lookup_type :float, 'double'
-        assert_lookup_type :float, 'DOUBLE'
-      end
+        def test_decimal_types
+          assert_lookup_type :decimal, "decimal"
+          assert_lookup_type :decimal, "decimal(2,8)"
+          assert_lookup_type :decimal, "DECIMAL"
+          assert_lookup_type :decimal, "numeric"
+          assert_lookup_type :decimal, "numeric(2,8)"
+          assert_lookup_type :decimal, "NUMERIC"
+          assert_lookup_type :decimal, "number"
+          assert_lookup_type :decimal, "number(2,8)"
+          assert_lookup_type :decimal, "NUMBER"
+        end
 
-      def test_integer_types
-        assert_lookup_type :integer, 'integer'
-        assert_lookup_type :integer, 'INTEGER'
-        assert_lookup_type :integer, 'tinyint'
-        assert_lookup_type :integer, 'smallint'
-        assert_lookup_type :integer, 'bigint'
-      end
+        def test_float_types
+          assert_lookup_type :float, "float"
+          assert_lookup_type :float, "FLOAT"
+          assert_lookup_type :float, "double"
+          assert_lookup_type :float, "DOUBLE"
+        end
 
-      def test_bigint_limit
-        cast_type = @connection.type_map.lookup("bigint")
-        if current_adapter?(:OracleAdapter)
-          assert_equal 19, cast_type.limit
-        else
-          assert_equal 8, cast_type.limit
+        def test_integer_types
+          assert_lookup_type :integer, "integer"
+          assert_lookup_type :integer, "INTEGER"
+          assert_lookup_type :integer, "tinyint"
+          assert_lookup_type :integer, "smallint"
+          assert_lookup_type :integer, "bigint"
         end
-      end
 
-      def test_decimal_without_scale
-        if current_adapter?(:OracleAdapter)
-          {
-            decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0)},
-            integer: %w{number(2) number(2,0)}
-          }
-        else
-          { decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)} }
-        end.each do |expected_type, types|
-          types.each do |type|
-            cast_type = @connection.type_map.lookup(type)
-
-            assert_equal expected_type, cast_type.type
-            assert_equal 2, cast_type.cast(2.1)
+        def test_bigint_limit
+          limit = @connection.send(:type_map).lookup("bigint").send(:_limit)
+          if current_adapter?(:OracleAdapter)
+            assert_equal 19, limit
+          else
+            assert_equal 8, limit
           end
         end
-      end
 
-      private
+        def test_decimal_without_scale
+          if current_adapter?(:OracleAdapter)
+            {
+              decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0)},
+              integer: %w{number(2) number(2,0)}
+            }
+          else
+            { decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)} }
+          end.each do |expected_type, types|
+            types.each do |type|
+              cast_type = @connection.send(:type_map).lookup(type)
+
+              assert_equal expected_type, cast_type.type
+              assert_equal 2, cast_type.cast(2.1)
+            end
+          end
+        end
 
-      def assert_lookup_type(type, lookup)
-        cast_type = @connection.type_map.lookup(lookup)
-        assert_equal type, cast_type.type
+        private
+          def assert_lookup_type(type, lookup)
+            cast_type = @connection.send(:type_map).lookup(lookup)
+            assert_equal type, cast_type.type
+          end
       end
     end
   end
 end
-end