ibm_db 5.6.1 → 5.7.0

data/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb

@@ -9,9 +9,12 @@ module ActiveRecord
       def test_sqlite_creates_directory
         Dir.mktmpdir do |dir|
           dir = Pathname.new(dir)
-          @conn = Base.sqlite3_connection database: dir.join("db/foo.sqlite3"),
-                               adapter: "sqlite3",
-                               timeout: 100
+          @conn = SQLite3Adapter.new(
+            database: dir.join("db/foo.sqlite3"),
+            adapter: "sqlite3",
+            timeout: 100,
+          )
+          @conn.connect!
 
           assert Dir.exist? dir.join("db")
           assert File.exist? dir.join("db/foo.sqlite3")

data/test/cases/adapters/sqlite3/sqlite_rake_test.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+require "pathname"
+
+module ActiveRecord
+  class SqliteDBCreateTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_db_checks_database_exists
+      ActiveRecord::Base.stub(:establish_connection, nil) do
+        assert_called_with(File, :exist?, [@database], returns: false) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+        end
+      end
+    end
+
+    def test_when_db_created_successfully_outputs_info_to_stdout
+      ActiveRecord::Base.stub(:establish_connection, nil) do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+
+        assert_equal "Created database '#{@database}'\n", $stdout.string
+      end
+    end
+
+    def test_db_create_when_file_exists
+      File.stub(:exist?, true) do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+
+        assert_equal "Database '#{@database}' already exists\n", $stderr.string
+      end
+    end
+
+    def test_db_create_with_file_does_nothing
+      File.stub(:exist?, true) do
+        assert_not_called(ActiveRecord::Base, :establish_connection) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+        end
+      end
+    end
+
+    def test_db_create_establishes_a_connection
+      calls = []
+      ActiveRecord::Base.stub(:establish_connection, proc { |*args| calls << args }) do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+      end
+
+      assert_equal [@configuration.symbolize_keys], calls.map { |c| c.first.configuration_hash }
+    end
+
+    def test_db_create_with_error_prints_message
+      ActiveRecord::Base.stub(:establish_connection, proc { raise Exception }) do
+        assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root" }
+        assert_match "Couldn't create '#{@configuration['database']}' database. Please check your configuration.", $stderr.string
+      end
+    end
+  end
+
+  class SqliteDBDropTest < ActiveRecord::TestCase
+    def setup
+      @root          = "/rails/root"
+      @database      = "db_create.sqlite3"
+      @database_root = File.join(@root, @database)
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+      @configuration_root = {
+        "adapter"  => "sqlite3",
+        "database" => @database_root
+      }
+
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_checks_db_dir_is_absolute
+      assert_called_with(File, :absolute_path?, [@database], returns: false) do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, @root
+      end
+    end
+
+    def test_removes_file_with_absolute_path
+      assert_called_with(FileUtils, :rm, [@database_root]) do
+        assert_called_with(FileUtils, :rm_f, [["#{@database_root}-shm", "#{@database_root}-wal"]]) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration_root, @root
+        end
+      end
+    end
+
+    def test_generates_absolute_path_with_given_root
+      assert_called_with(File, :join, [@root, @database], returns: "#{@root}/#{@database}") do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, @root
+      end
+    end
+
+    def test_removes_file_with_relative_path
+      assert_called_with(FileUtils, :rm, [@database_root]) do
+        assert_called_with(FileUtils, :rm_f, [["#{@database_root}-shm", "#{@database_root}-wal"]]) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration, @root
+        end
+      end
+    end
+
+    def test_when_db_dropped_successfully_outputs_info_to_stdout
+      FileUtils.stub(:rm, nil) do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, @root
+
+        assert_equal "Dropped database '#{@database}'\n", $stdout.string
+      end
+    end
+  end
+
+  class SqliteDBCharsetTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @connection    = Class.new { def encoding; end }.new
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+    end
+
+    def test_db_retrieves_charset
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :encoding) do
+          ActiveRecord::Tasks::DatabaseTasks.charset @configuration, "/rails/root"
+        end
+      end
+    end
+  end
+
+  class SqliteDBCollationTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+    end
+
+    def test_db_retrieves_collation
+      assert_raise NoMethodError do
+        ActiveRecord::Tasks::DatabaseTasks.collation @configuration, "/rails/root"
+      end
+    end
+  end
+
+  class SqliteStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+
+      `sqlite3 #{@database} 'CREATE TABLE bar(id INTEGER)'`
+      `sqlite3 #{@database} 'CREATE TABLE foo(id INTEGER)'`
+    end
+
+    def test_structure_dump
+      dbfile   = @database
+      filename = "awesome-file.sql"
+
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump @configuration, filename, "/rails/root"
+      assert File.exist?(dbfile)
+      assert File.exist?(filename)
+      assert_match(/CREATE TABLE foo/, File.read(filename))
+      assert_match(/CREATE TABLE bar/, File.read(filename))
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+
+    def test_structure_dump_with_ignore_tables
+      dbfile   = @database
+      filename = "awesome-file.sql"
+      ActiveRecord::Base.lease_connection.stub(:data_sources, ["foo", "bar", "prefix_foo", "ignored_foo"]) do
+        ActiveRecord::SchemaDumper.stub(:ignore_tables, [/^prefix_/, "ignored_foo"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename, "/rails/root")
+        end
+      end
+      assert File.exist?(dbfile)
+      assert File.exist?(filename)
+      contents = File.read(filename)
+      assert_match(/bar/, contents)
+      assert_no_match(/prefix_foo/, contents)
+      assert_no_match(/ignored_foo/, contents)
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+
+    def test_structure_dump_execution_fails
+      dbfile   = @database
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["sqlite3", "--noop", "db_create.sqlite3", ".schema --nosys"],
+        returns: nil,
+        out: "awesome-file.sql"
+      ) do
+        e = assert_raise(RuntimeError) do
+          with_structure_dump_flags(["--noop"]) do
+            quietly { ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename, "/rails/root") }
+          end
+        end
+        assert_match("failed to execute:", e.message)
+      end
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+
+    private
+      def with_structure_dump_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
+      end
+  end
+
+  class SqliteStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+    end
+
+    def test_structure_load
+      dbfile   = @database
+      filename = "awesome-file.sql"
+
+      open(filename, "w") { |f| f.puts("select datetime('now', 'localtime');") }
+      ActiveRecord::Tasks::DatabaseTasks.structure_load @configuration, filename, "/rails/root"
+      assert File.exist?(dbfile)
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+  end
+end

data/test/cases/adapters/sqlite3/statement_pool_test.rb

@@ -15,7 +15,7 @@ class SQLite3StatementPoolTest < ActiveRecord::SQLite3TestCase
       }
 
       Process.waitpid pid
-      assert $?.success?, "process should exit successfully"
+      assert_predicate $?, :success?, "process should exit successfully"
     end
   end
 end

data/test/cases/adapters/sqlite3/transaction_test.rb

@@ -59,6 +59,7 @@ class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
 
   test "reset the read_uncommitted PRAGMA when a transaction is rolled back" do
     with_connection(flags: shared_cache_flags) do |conn|
+      conn.connect!
       conn.transaction(joinable: false, isolation: :read_uncommitted) do
         assert_not(read_uncommitted?(conn))
         conn.transaction_manager.materialize_transactions
@@ -73,6 +74,7 @@ class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
 
   test "reset the read_uncommitted PRAGMA when a transaction is committed" do
     with_connection(flags: shared_cache_flags) do |conn|
+      conn.connect!
       conn.transaction(joinable: false, isolation: :read_uncommitted) do
         assert_not(read_uncommitted?(conn))
         conn.transaction_manager.materialize_transactions
@@ -85,8 +87,9 @@ class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
 
   test "set the read_uncommitted PRAGMA to its previous value" do
     with_connection(flags: shared_cache_flags) do |conn|
+      conn.connect!
       conn.transaction(joinable: false, isolation: :read_uncommitted) do
-        conn.instance_variable_get(:@connection).read_uncommitted = true
+        conn.instance_variable_get(:@raw_connection).read_uncommitted = true
         assert(read_uncommitted?(conn))
         conn.transaction_manager.materialize_transactions
         assert(read_uncommitted?(conn))
@@ -98,7 +101,7 @@ class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
 
   private
     def read_uncommitted?(conn)
-      conn.instance_variable_get(:@connection).get_first_value("PRAGMA read_uncommitted") != 0
+      conn.instance_variable_get(:@raw_connection).get_first_value("PRAGMA read_uncommitted") != 0
     end
 
     def shared_cache_flags
@@ -114,7 +117,7 @@ class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
         db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
         options[:database] ||= db_config.database
       end
-      conn = ActiveRecord::Base.sqlite3_connection(options)
+      conn = ActiveRecord::ConnectionAdapters::SQLite3Adapter.new(options)
 
       yield(conn)
     ensure

data/test/cases/adapters/sqlite3/virtual_column_test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+  class SQLite3VirtualColumnTest < ActiveRecord::SQLite3TestCase
+    include SchemaDumpingHelper
+
+    class VirtualColumn < ActiveRecord::Base
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :virtual_columns, force: true do |t|
+        t.string  :name
+        t.virtual :upper_name, type: :string, as: "UPPER(name)", stored: true
+        t.virtual :lower_name, type: :string, as: "LOWER(name)", stored: false
+        t.virtual :octet_name, type: :integer, as: "LENGTH(name)"
+        t.virtual :mutated_name, type: :string, as: "REPLACE(name, 'l', 'L')"
+        t.integer :column1
+      end
+      VirtualColumn.create(name: "Rails", column1: 10)
+    end
+
+    def teardown
+      @connection.drop_table :virtual_columns, if_exists: true
+      VirtualColumn.reset_column_information
+    end
+
+    def test_virtual_column_with_full_inserts
+      partial_inserts_was = VirtualColumn.partial_inserts
+      VirtualColumn.partial_inserts = false
+      assert_nothing_raised do
+        VirtualColumn.create!(name: "Rails")
+      end
+    ensure
+      VirtualColumn.partial_inserts = partial_inserts_was
+    end
+
+    def test_stored_column
+      column = VirtualColumn.columns_hash["upper_name"]
+      assert_predicate column, :virtual?
+      assert_predicate column, :virtual_stored?
+      assert_equal "RAILS", VirtualColumn.take.upper_name
+    end
+
+    def test_explicit_virtual_column
+      column = VirtualColumn.columns_hash["lower_name"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal "rails", VirtualColumn.take.lower_name
+    end
+
+    def test_implicit_virtual_column
+      column = VirtualColumn.columns_hash["octet_name"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal 5, VirtualColumn.take.octet_name
+    end
+
+    def test_virtual_column_with_comma_in_definition
+      column = VirtualColumn.columns_hash["mutated_name"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_not_nil column.default_function
+      assert_equal "RaiLs", VirtualColumn.take.mutated_name
+    end
+
+    def test_change_table_with_stored_generated_column
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :decr_column1, type: :integer, as: "column1 - 1", stored: true
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["decr_column1"]
+      assert_predicate column, :virtual?
+      assert_predicate column, :virtual_stored?
+      assert_equal 9, VirtualColumn.take.decr_column1
+    end
+
+    def test_change_table_with_explicit_virtual_generated_column
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :incr_column1, type: :integer, as: "column1 + 1", stored: false
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["incr_column1"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal 11, VirtualColumn.take.incr_column1
+    end
+
+    def test_change_table_with_implicit_virtual_generated_column
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :sqr_column1, type: :integer, as: "pow(column1, 2)"
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["sqr_column1"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal 100, VirtualColumn.take.sqr_column1
+    end
+
+    def test_schema_dumping
+      output = dump_table_schema("virtual_columns")
+      assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "UPPER\(name\)", stored: true$/i, output)
+    end
+
+    def test_build_fixture_sql
+      fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :virtual_columns).first
+      assert_equal 2, fixtures.size
+    end
+
+    def test_virtual_column_does_not_deduplicate_with_regular_column
+      @connection.create_table :regular_columns, force: true do |t|
+        t.string :name
+      end
+
+      regular_model = Class.new(ActiveRecord::Base) { self.table_name = "regular_columns" }
+
+      # Ensure deduplication has seen the virtual column first
+      VirtualColumn.columns_hash
+
+      regular_col = regular_model.columns_hash["name"]
+      virtual_col = VirtualColumn.columns_hash["upper_name"]
+
+      assert_predicate virtual_col, :virtual?
+      assert_not_predicate regular_col, :virtual?
+      assert_not_equal regular_col, virtual_col
+
+      # The regular column must not be excluded from inserts
+      record = regular_model.create!(name: "hello")
+      record.reload
+      assert_equal "hello", record.name
+    ensure
+      @connection.drop_table :regular_columns, if_exists: true
+    end
+  end
+end

data/test/cases/adapters/sqlite3/virtual_table_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class SQLite3VirtualTableTest < ActiveRecord::SQLite3TestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_virtual_table :searchables, :fts5, ["content", "meta UNINDEXED", "tokenize='porter ascii'"]
+  end
+
+  def teardown
+    @connection.drop_table :searchables, if_exists: true
+  end
+
+  def test_schema_dump
+    output = dump_all_table_schema
+
+    assert_not_includes output, "searchables_docsize"
+    assert_includes output, 'create_virtual_table "searchables", "fts5", ["content", "meta UNINDEXED", "tokenize=\'porter ascii\'"]'
+  end
+
+  def test_schema_dump_ignores_virtual_tables_in_ignore_tables
+    output = dump_all_table_schema(["searchables"])
+
+    assert_not_includes output, 'create_virtual_table "searchables"'
+  end
+
+  def test_schema_load
+    original, $stdout = $stdout, StringIO.new
+
+    ActiveRecord::Schema.define do
+      create_virtual_table :emails, :fts5, ["content", "meta UNINDEXED"]
+    end
+
+    assert @connection.virtual_table_exists?(:emails)
+  ensure
+    $stdout = original
+  end
+
+  def test_virtual_table_regex_matches_empty_parentheses
+    regex = ActiveRecord::ConnectionAdapters::SQLite3Adapter::VIRTUAL_TABLE_REGEX
+
+    match = "CREATE VIRTUAL TABLE foo USING bar()".match(regex)
+    assert_not_nil match
+    assert_equal "bar", match[1]
+    assert_equal "", match[2]
+  end
+end

data/test/cases/adapters/trilogy/dbconsole_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TrilogyDbConsoleTest < ActiveRecord::TrilogyTestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      def test_trilogy
+        config = make_db_config(adapter: "trilogy", database: "db")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "db"]) do
+          TrilogyAdapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_full
+        config = make_db_config(
+          adapter:   "trilogy",
+          database:  "db",
+          host:      "localhost",
+          port:      1234,
+          socket:    "socket",
+          username:  "user",
+          password:  "qwerty",
+          encoding:  "UTF-8",
+          sslca:     "/path/to/ca-cert.pem",
+          sslcert:   "/path/to/client-cert.pem",
+          sslcapath: "/path/to/cacerts",
+          sslcipher: "DHE-RSA-AES256-SHA",
+          sslkey:    "/path/to/client-key.pem",
+          ssl_mode:  "VERIFY_IDENTITY"
+        )
+
+        args = [
+          %w[mysql mysql5],
+          "--host=localhost",
+          "--port=1234",
+          "--socket=socket",
+          "--user=user",
+          "--default-character-set=UTF-8",
+          "--ssl-ca=/path/to/ca-cert.pem",
+          "--ssl-cert=/path/to/client-cert.pem",
+          "--ssl-capath=/path/to/cacerts",
+          "--ssl-cipher=DHE-RSA-AES256-SHA",
+          "--ssl-key=/path/to/client-key.pem",
+          "--ssl-mode=VERIFY_IDENTITY",
+          "-p", "db"
+        ]
+
+        assert_find_cmd_and_exec_called_with(args) do
+          TrilogyAdapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_include_password
+        config = make_db_config(adapter: "trilogy", database: "db", username: "user", password: "qwerty")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "--user=user", "--password=qwerty", "db"]) do
+          TrilogyAdapter.dbconsole(config, include_password: true)
+        end
+      end
+
+      private
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(TrilogyAdapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end