activerecord 4.2.0 → 6.1.7.1

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -1,50 +1,35 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Tasks # :nodoc:
     class MySQLDatabaseTasks # :nodoc:
-      DEFAULT_CHARSET     = ENV['CHARSET']   || 'utf8'
-      DEFAULT_COLLATION   = ENV['COLLATION'] || 'utf8_unicode_ci'
-      ACCESS_DENIED_ERROR = 1045
+      ER_DB_CREATE_EXISTS = 1007
 
       delegate :connection, :establish_connection, to: ActiveRecord::Base
 
-      def initialize(configuration)
-        @configuration = configuration
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
       end
 
       def create
-        establish_connection configuration_without_database
-        connection.create_database configuration['database'], creation_options
-        establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if /database exists/ === error.message
-          raise DatabaseAlreadyExists
-        else
-          raise
-        end
-      rescue error_class => error
-        if error.respond_to?(:errno) && error.errno == ACCESS_DENIED_ERROR
-          $stdout.print error.error
-          establish_connection root_configuration_without_database
-          connection.create_database configuration['database'], creation_options
-          if configuration['username'] != 'root'
-            connection.execute grant_statement.gsub(/\s+/, ' ').strip
-          end
-          establish_connection configuration
-        else
-          $stderr.puts error.inspect
-          $stderr.puts "Couldn't create database for #{configuration.inspect}, #{creation_options.inspect}"
-          $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration['encoding']
-        end
+        establish_connection(configuration_hash_without_database)
+        connection.create_database(db_config.database, creation_options)
+        establish_connection(db_config)
       end
 
       def drop
-        establish_connection configuration
-        connection.drop_database configuration['database']
+        establish_connection(db_config)
+        connection.drop_database(db_config.database)
       end
 
       def purge
-        establish_connection configuration
-        connection.recreate_database configuration['database'], creation_options
+        establish_connection(db_config)
+        connection.recreate_database(db_config.database, creation_options)
       end
 
       def charset
@@ -55,91 +40,74 @@ module ActiveRecord
         connection.collation
       end
 
-      def structure_dump(filename)
-        args = prepare_command_options('mysqldump')
+      def structure_dump(filename, extra_flags)
+        args = prepare_command_options
         args.concat(["--result-file", "#{filename}"])
         args.concat(["--no-data"])
-        args.concat(["#{configuration['database']}"])
-        unless Kernel.system(*args)
-          $stderr.puts "Could not dump the database structure. "\
-                       "Make sure `mysqldump` is in your PATH and check the command output for warnings."
-        end
-      end
+        args.concat(["--routines"])
+        args.concat(["--skip-comments"])
 
-      def structure_load(filename)
-        args = prepare_command_options('mysql')
-        args.concat(['--execute', %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
-        args.concat(["--database", "#{configuration['database']}"])
-        Kernel.system(*args)
-      end
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          args += ignore_tables.map { |table| "--ignore-table=#{db_config.database}.#{table}" }
+        end
 
-      private
+        args.concat([db_config.database.to_s])
+        args.unshift(*extra_flags) if extra_flags
 
-      def configuration
-        @configuration
+        run_cmd("mysqldump", args, "dumping")
       end
 
-      def configuration_without_database
-        configuration.merge('database' => nil)
-      end
+      def structure_load(filename, extra_flags)
+        args = prepare_command_options
+        args.concat(["--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
+        args.concat(["--database", db_config.database.to_s])
+        args.unshift(*extra_flags) if extra_flags
 
-      def creation_options
-        Hash.new.tap do |options|
-          options[:charset]     = configuration['encoding']   if configuration.include? 'encoding'
-          options[:collation]   = configuration['collation']  if configuration.include? 'collation'
+        run_cmd("mysql", args, "loading")
+      end
 
-          # Set default charset only when collation isn't set.
-          options[:charset]   ||= DEFAULT_CHARSET unless options[:collation]
+      private
+        attr_reader :db_config, :configuration_hash
 
-          # Set default collation only when charset is also default.
-          options[:collation] ||= DEFAULT_COLLATION if options[:charset] == DEFAULT_CHARSET
+        def configuration_hash_without_database
+          configuration_hash.merge(database: nil)
         end
-      end
 
-      def error_class
-        if configuration['adapter'] =~ /jdbc/
-          require 'active_record/railties/jdbcmysql_error'
-          ArJdbcMySQL::Error
-        elsif defined?(Mysql2)
-          Mysql2::Error
-        elsif defined?(Mysql)
-          Mysql::Error
-        else
-          StandardError
+        def creation_options
+          Hash.new.tap do |options|
+            options[:charset]     = configuration_hash[:encoding]   if configuration_hash.include?(:encoding)
+            options[:collation]   = configuration_hash[:collation]  if configuration_hash.include?(:collation)
+          end
         end
-      end
-
-      def grant_statement
-        <<-SQL
-GRANT ALL PRIVILEGES ON #{configuration['database']}.*
-  TO '#{configuration['username']}'@'localhost'
-IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
-        SQL
-      end
 
-      def root_configuration_without_database
-        configuration_without_database.merge(
-          'username' => 'root',
-          'password' => root_password
-        )
-      end
-
-      def root_password
-        $stdout.print "Please provide the root password for your MySQL installation\n>"
-        $stdin.gets.strip
-      end
+        def prepare_command_options
+          args = {
+            host:      "--host",
+            port:      "--port",
+            socket:    "--socket",
+            username:  "--user",
+            password:  "--password",
+            encoding:  "--default-character-set",
+            sslca:     "--ssl-ca",
+            sslcert:   "--ssl-cert",
+            sslcapath: "--ssl-capath",
+            sslcipher: "--ssl-cipher",
+            sslkey:    "--ssl-key"
+          }.map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }.compact
+
+          args
+        end
 
-      def prepare_command_options(command)
-        args = [command]
-        args.concat(['--user', configuration['username']]) if configuration['username']
-        args << "--password=#{configuration['password']}"  if configuration['password']
-        args.concat(['--default-character-set', configuration['encoding']]) if configuration['encoding']
-        configuration.slice('host', 'port', 'socket').each do |k, v|
-          args.concat([ "--#{k}", v.to_s ]) if v
+        def run_cmd(cmd, args, action)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
         end
 
-        args
-      end
+        def run_cmd_error(cmd, args, action)
+          msg = +"failed to execute: `#{cmd}`\n"
+          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+          msg
+        end
     end
   end
 end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -1,33 +1,35 @@
-require 'shellwords'
+# frozen_string_literal: true
+
+require "tempfile"
 
 module ActiveRecord
   module Tasks # :nodoc:
     class PostgreSQLDatabaseTasks # :nodoc:
-      DEFAULT_ENCODING = ENV['CHARSET'] || 'utf8'
+      DEFAULT_ENCODING = ENV["CHARSET"] || "utf8"
+      ON_ERROR_STOP_1 = "ON_ERROR_STOP=1"
+      SQL_COMMENT_BEGIN = "--"
 
       delegate :connection, :establish_connection, :clear_active_connections!,
         to: ActiveRecord::Base
 
-      def initialize(configuration)
-        @configuration = configuration
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
       end
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration['database'],
-          configuration.merge('encoding' => encoding)
-        establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if /database .* already exists/ === error.message
-          raise DatabaseAlreadyExists
-        else
-          raise
-        end
+        connection.create_database(db_config.database, configuration_hash.merge(encoding: encoding))
+        establish_connection(db_config)
       end
 
       def drop
         establish_master_connection
-        connection.drop_database configuration['database']
+        connection.drop_database(db_config.database)
       end
 
       def charset
@@ -44,47 +46,93 @@ module ActiveRecord
         create true
       end
 
-      def structure_dump(filename)
+      def structure_dump(filename, extra_flags)
         set_psql_env
-        search_path = configuration['schema_search_path']
+
+        search_path = \
+          case ActiveRecord::Base.dump_schemas
+          when :schema_search_path
+            configuration_hash[:schema_search_path]
+          when :all
+            nil
+          when String
+            ActiveRecord::Base.dump_schemas
+          end
+
+        args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
+        args.concat(Array(extra_flags)) if extra_flags
         unless search_path.blank?
-          search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
+          args += search_path.split(",").map do |part|
+            "--schema=#{part.strip}"
+          end
         end
 
-        command = "pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
-        raise 'Error dumping database' unless Kernel.system(command)
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          args += ignore_tables.flat_map { |table| ["-T", table] }
+        end
 
+        args << db_config.database
+        run_cmd("pg_dump", args, "dumping")
+        remove_sql_header_comments(filename)
         File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
-      def structure_load(filename)
+      def structure_load(filename, extra_flags)
         set_psql_env
-        Kernel.system("psql -q -f #{Shellwords.escape(filename)} #{configuration['database']}")
+        args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--file", filename]
+        args.concat(Array(extra_flags)) if extra_flags
+        args << db_config.database
+        run_cmd("psql", args, "loading")
       end
 
       private
+        attr_reader :db_config, :configuration_hash
 
-      def configuration
-        @configuration
-      end
+        def encoding
+          configuration_hash[:encoding] || DEFAULT_ENCODING
+        end
 
-      def encoding
-        configuration['encoding'] || DEFAULT_ENCODING
-      end
+        def establish_master_connection
+          establish_connection configuration_hash.merge(
+            database: "postgres",
+            schema_search_path: "public"
+          )
+        end
 
-      def establish_master_connection
-        establish_connection configuration.merge(
-          'database'           => 'postgres',
-          'schema_search_path' => 'public'
-        )
-      end
+        def set_psql_env
+          ENV["PGHOST"]     = db_config.host                     if db_config.host
+          ENV["PGPORT"]     = configuration_hash[:port].to_s     if configuration_hash[:port]
+          ENV["PGPASSWORD"] = configuration_hash[:password].to_s if configuration_hash[:password]
+          ENV["PGUSER"]     = configuration_hash[:username].to_s if configuration_hash[:username]
+        end
 
-      def set_psql_env
-        ENV['PGHOST']     = configuration['host']          if configuration['host']
-        ENV['PGPORT']     = configuration['port'].to_s     if configuration['port']
-        ENV['PGPASSWORD'] = configuration['password'].to_s if configuration['password']
-        ENV['PGUSER']     = configuration['username'].to_s if configuration['username']
-      end
+        def run_cmd(cmd, args, action)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+        end
+
+        def run_cmd_error(cmd, args, action)
+          msg = +"failed to execute:\n"
+          msg << "#{cmd} #{args.join(' ')}\n\n"
+          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+          msg
+        end
+
+        def remove_sql_header_comments(filename)
+          removing_comments = true
+          tempfile = Tempfile.open("uncommented_structure.sql")
+          begin
+            File.foreach(filename) do |line|
+              unless removing_comments && (line.start_with?(SQL_COMMENT_BEGIN) || line.blank?)
+                tempfile << line
+                removing_comments = false
+              end
+            end
+          ensure
+            tempfile.close
+          end
+          FileUtils.cp(tempfile.path, filename)
+        end
     end
   end
 end

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -1,29 +1,40 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Tasks # :nodoc:
     class SQLiteDatabaseTasks # :nodoc:
       delegate :connection, :establish_connection, to: ActiveRecord::Base
 
-      def initialize(configuration, root = ActiveRecord::Tasks::DatabaseTasks.root)
-        @configuration, @root = configuration, root
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config, root = ActiveRecord::Tasks::DatabaseTasks.root)
+        @db_config = db_config
+        @root = root
       end
 
       def create
-        raise DatabaseAlreadyExists if File.exist?(configuration['database'])
+        raise DatabaseAlreadyExists if File.exist?(db_config.database)
 
-        establish_connection configuration
+        establish_connection(db_config)
         connection
       end
 
       def drop
-        require 'pathname'
-        path = Pathname.new configuration['database']
+        require "pathname"
+        path = Pathname.new(db_config.database)
         file = path.absolute? ? path.to_s : File.join(root, path)
 
-        FileUtils.rm(file) if File.exist?(file)
+        FileUtils.rm(file)
+      rescue Errno::ENOENT => error
+        raise NoDatabaseError.new(error.message)
       end
 
       def purge
         drop
+      rescue NoDatabaseError
+      ensure
         create
       end
 
@@ -31,25 +42,39 @@ module ActiveRecord
         connection.encoding
       end
 
-      def structure_dump(filename)
-        dbfile = configuration['database']
-        `sqlite3 #{dbfile} .schema > #{filename}`
+      def structure_dump(filename, extra_flags)
+        args = []
+        args.concat(Array(extra_flags)) if extra_flags
+        args << db_config.database
+
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          condition = ignore_tables.map { |table| connection.quote(table) }.join(", ")
+          args << "SELECT sql FROM sqlite_master WHERE tbl_name NOT IN (#{condition}) ORDER BY tbl_name, type DESC, name"
+        else
+          args << ".schema"
+        end
+        run_cmd("sqlite3", args, filename)
       end
 
-      def structure_load(filename)
-        dbfile = configuration['database']
-        `sqlite3 #{dbfile} < "#{filename}"`
+      def structure_load(filename, extra_flags)
+        flags = extra_flags.join(" ") if extra_flags
+        `sqlite3 #{flags} #{db_config.database} < "#{filename}"`
       end
 
       private
+        attr_reader :db_config, :root
 
-      def configuration
-        @configuration
-      end
+        def run_cmd(cmd, args, out)
+          fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, out: out)
+        end
 
-      def root
-        @root
-      end
+        def run_cmd_error(cmd, args)
+          msg = +"failed to execute:\n"
+          msg << "#{cmd} #{args.join(' ')}\n\n"
+          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+          msg
+        end
     end
   end
 end

data/lib/active_record/test_databases.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "active_support/testing/parallelization"
+
+module ActiveRecord
+  module TestDatabases # :nodoc:
+    ActiveSupport::Testing::Parallelization.after_fork_hook do |i|
+      create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+    end
+
+    def self.create_and_load_schema(i, env_name:)
+      old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
+
+      ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
+        db_config._database = "#{db_config.database}-#{i}"
+
+        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord::Base.schema_format, nil)
+      end
+    ensure
+      ActiveRecord::Base.establish_connection
+      ENV["VERBOSE"] = old
+    end
+  end
+end