activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/tasks/database_tasks.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class DatabaseAlreadyExists < StandardError; end # :nodoc:
+    class DatabaseNotSupported < StandardError; end # :nodoc:
+
+    # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
+    # logic behind common tasks used to manage database and migrations.
+    #
+    # The tasks defined here are used with Rake tasks provided by Active Record.
+    #
+    # In order to use DatabaseTasks, a few config values need to be set. All the needed
+    # config values are set by Rails already, so it's necessary to do it only if you
+    # want to change the defaults or when you want to use Active Record outside of Rails
+    # (in such case after configuring the database tasks, you can also use the rake tasks
+    # defined in Active Record).
+    #
+    # The possible config values are:
+    #
+    # * +env+: current environment (like Rails.env).
+    # * +database_configuration+: configuration of your databases (as in +config/database.yml+).
+    # * +db_dir+: your +db+ directory.
+    # * +fixtures_path+: a path to fixtures directory.
+    # * +migrations_paths+: a list of paths to directories with migrations.
+    # * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
+    # * +root+: a path to the root of the application.
+    #
+    # Example usage of DatabaseTasks outside Rails could look as such:
+    #
+    #   include ActiveRecord::Tasks
+    #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
+    #   DatabaseTasks.db_dir = 'db'
+    #   # other settings...
+    #
+    #   DatabaseTasks.create_current('production')
+    module DatabaseTasks
+      ##
+      # :singleton-method:
+      # Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:structure:dump
+      mattr_accessor :structure_dump_flags, instance_accessor: false
+
+      ##
+      # :singleton-method:
+      # Extra flags passed to database CLI tool when calling db:structure:load
+      mattr_accessor :structure_load_flags, instance_accessor: false
+
+      extend self
+
+      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
+      attr_accessor :database_configuration
+
+      LOCAL_HOSTS = ["127.0.0.1", "localhost"]
+
+      def check_protected_environments!
+        unless ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
+          current = ActiveRecord::Base.connection.migration_context.current_environment
+          stored  = ActiveRecord::Base.connection.migration_context.last_stored_environment
+
+          if ActiveRecord::Base.connection.migration_context.protected_environment?
+            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+          end
+
+          if stored && stored != current
+            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+          end
+        end
+      rescue ActiveRecord::NoDatabaseError
+      end
+
+      def register_task(pattern, task)
+        @tasks ||= {}
+        @tasks[pattern] = task
+      end
+
+      register_task(/mysql/,        "ActiveRecord::Tasks::MySQLDatabaseTasks")
+      register_task(/postgresql/,   "ActiveRecord::Tasks::PostgreSQLDatabaseTasks")
+      register_task(/sqlite/,       "ActiveRecord::Tasks::SQLiteDatabaseTasks")
+
+      def db_dir
+        @db_dir ||= Rails.application.config.paths["db"].first
+      end
+
+      def migrations_paths
+        @migrations_paths ||= Rails.application.paths["db/migrate"].to_a
+      end
+
+      def fixtures_path
+        @fixtures_path ||= if ENV["FIXTURES_PATH"]
+          File.join(root, ENV["FIXTURES_PATH"])
+        else
+          File.join(root, "test", "fixtures")
+        end
+      end
+
+      def root
+        @root ||= Rails.root
+      end
+
+      def env
+        @env ||= Rails.env
+      end
+
+      def seed_loader
+        @seed_loader ||= Rails.application
+      end
+
+      def current_config(options = {})
+        options.reverse_merge! env: env
+        if options.has_key?(:config)
+          @current_config = options[:config]
+        else
+          @current_config ||= ActiveRecord::Base.configurations[options[:env]]
+        end
+      end
+
+      def create(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration["adapter"]).new(*arguments).create
+        $stdout.puts "Created database '#{configuration['database']}'"
+      rescue DatabaseAlreadyExists
+        $stderr.puts "Database '#{configuration['database']}' already exists"
+      rescue Exception => error
+        $stderr.puts error
+        $stderr.puts "Couldn't create '#{configuration['database']}' database. Please check your configuration."
+        raise
+      end
+
+      def create_all
+        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
+        each_local_configuration { |configuration| create configuration }
+        if old_pool
+          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec.to_hash)
+        end
+      end
+
+      def create_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          create configuration
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def drop(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration["adapter"]).new(*arguments).drop
+        $stdout.puts "Dropped database '#{configuration['database']}'"
+      rescue ActiveRecord::NoDatabaseError
+        $stderr.puts "Database '#{configuration['database']}' does not exist"
+      rescue Exception => error
+        $stderr.puts error
+        $stderr.puts "Couldn't drop database '#{configuration['database']}'"
+        raise
+      end
+
+      def drop_all
+        each_local_configuration { |configuration| drop configuration }
+      end
+
+      def drop_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          drop configuration
+        }
+      end
+
+      def migrate
+        check_target_version
+
+        verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] != "false" : true
+        scope = ENV["SCOPE"]
+        verbose_was, Migration.verbose = Migration.verbose, verbose
+        Base.connection.migration_context.migrate(target_version) do |migration|
+          scope.blank? || scope == migration.scope
+        end
+        ActiveRecord::Base.clear_cache!
+      ensure
+        Migration.verbose = verbose_was
+      end
+
+      def check_target_version
+        if target_version && !(Migration::MigrationFilenameRegexp.match?(ENV["VERSION"]) || /\A\d+\z/.match?(ENV["VERSION"]))
+          raise "Invalid format of target version: `VERSION=#{ENV['VERSION']}`"
+        end
+      end
+
+      def target_version
+        ENV["VERSION"].to_i if ENV["VERSION"] && !ENV["VERSION"].empty?
+      end
+
+      def charset_current(environment = env)
+        charset ActiveRecord::Base.configurations[environment]
+      end
+
+      def charset(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration["adapter"]).new(*arguments).charset
+      end
+
+      def collation_current(environment = env)
+        collation ActiveRecord::Base.configurations[environment]
+      end
+
+      def collation(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration["adapter"]).new(*arguments).collation
+      end
+
+      def purge(configuration)
+        class_for_adapter(configuration["adapter"]).new(configuration).purge
+      end
+
+      def purge_all
+        each_local_configuration { |configuration|
+          purge configuration
+        }
+      end
+
+      def purge_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          purge configuration
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def structure_dump(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration["adapter"]).new(*arguments).structure_dump(filename, structure_dump_flags)
+      end
+
+      def structure_load(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration["adapter"]).new(*arguments).structure_load(filename, structure_load_flags)
+      end
+
+      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env) # :nodoc:
+        file ||= schema_file(format)
+
+        check_schema_file(file)
+        ActiveRecord::Base.establish_connection(configuration)
+
+        case format
+        when :ruby
+          load(file)
+        when :sql
+          structure_load(configuration, file)
+        else
+          raise ArgumentError, "unknown format #{format.inspect}"
+        end
+        ActiveRecord::InternalMetadata.create_table
+        ActiveRecord::InternalMetadata[:environment] = environment
+      end
+
+      def schema_file(format = ActiveRecord::Base.schema_format)
+        case format
+        when :ruby
+          File.join(db_dir, "schema.rb")
+        when :sql
+          File.join(db_dir, "structure.sql")
+        end
+      end
+
+      def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+        each_current_configuration(environment) { |configuration, configuration_environment|
+          load_schema configuration, format, file, configuration_environment
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def check_schema_file(filename)
+        unless File.exist?(filename)
+          message = %{#{filename} doesn't exist yet. Run `rails db:migrate` to create it, then try again.}.dup
+          message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails.root)
+          Kernel.abort message
+        end
+      end
+
+      def load_seed
+        if seed_loader
+          seed_loader.load_seed
+        else
+          raise "You tried to load seed data, but no seed loader is specified. Please specify seed " \
+                "loader with ActiveRecord::Tasks::DatabaseTasks.seed_loader = your_seed_loader\n" \
+                "Seed loader should respond to load_seed method"
+        end
+      end
+
+      # Dumps the schema cache in YAML format for the connection into the file
+      #
+      # ==== Examples:
+      #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
+      def dump_schema_cache(conn, filename)
+        conn.schema_cache.clear!
+        conn.data_sources.each { |table| conn.schema_cache.add(table) }
+        open(filename, "wb") { |f| f.write(YAML.dump(conn.schema_cache)) }
+      end
+
+      private
+
+        def class_for_adapter(adapter)
+          _key, task = @tasks.each_pair.detect { |pattern, _task| adapter[pattern] }
+          unless task
+            raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
+          end
+          task.is_a?(String) ? task.constantize : task
+        end
+
+        def each_current_configuration(environment)
+          environments = [environment]
+          environments << "test" if environment == "development"
+
+          ActiveRecord::Base.configurations.slice(*environments).each do |configuration_environment, configuration|
+            next unless configuration["database"]
+
+            yield configuration, configuration_environment
+          end
+        end
+
+        def each_local_configuration
+          ActiveRecord::Base.configurations.each_value do |configuration|
+            next unless configuration["database"]
+
+            if local_database?(configuration)
+              yield configuration
+            else
+              $stderr.puts "This task only modifies local databases. #{configuration['database']} is on a remote host."
+            end
+          end
+        end
+
+        def local_database?(configuration)
+          configuration["host"].blank? || LOCAL_HOSTS.include?(configuration["host"])
+        end
+    end
+  end
+end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class MySQLDatabaseTasks # :nodoc:
+      delegate :connection, :establish_connection, to: ActiveRecord::Base
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def create
+        establish_connection configuration_without_database
+        connection.create_database configuration["database"], creation_options
+        establish_connection configuration
+      rescue ActiveRecord::StatementInvalid => error
+        if error.message.include?("database exists")
+          raise DatabaseAlreadyExists
+        else
+          raise
+        end
+      end
+
+      def drop
+        establish_connection configuration
+        connection.drop_database configuration["database"]
+      end
+
+      def purge
+        establish_connection configuration
+        connection.recreate_database configuration["database"], creation_options
+      end
+
+      def charset
+        connection.charset
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def structure_dump(filename, extra_flags)
+        args = prepare_command_options
+        args.concat(["--result-file", "#{filename}"])
+        args.concat(["--no-data"])
+        args.concat(["--routines"])
+        args.concat(["--skip-comments"])
+
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          args += ignore_tables.map { |table| "--ignore-table=#{configuration['database']}.#{table}" }
+        end
+
+        args.concat(["#{configuration['database']}"])
+        args.unshift(*extra_flags) if extra_flags
+
+        run_cmd("mysqldump", args, "dumping")
+      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", "#{configuration['database']}"])
+        args.unshift(*extra_flags) if extra_flags
+
+        run_cmd("mysql", args, "loading")
+      end
+
+      private
+
+        def configuration
+          @configuration
+        end
+
+        def configuration_without_database
+          configuration.merge("database" => nil)
+        end
+
+        def creation_options
+          Hash.new.tap do |options|
+            options[:charset]     = configuration["encoding"]   if configuration.include? "encoding"
+            options[:collation]   = configuration["collation"]  if configuration.include? "collation"
+          end
+        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[opt]}" if configuration[opt] }.compact
+
+          args
+        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: `#{cmd}`\n".dup
+          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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class PostgreSQLDatabaseTasks # :nodoc:
+      DEFAULT_ENCODING = ENV["CHARSET"] || "utf8"
+      ON_ERROR_STOP_1 = "ON_ERROR_STOP=1".freeze
+      SQL_COMMENT_BEGIN = "--".freeze
+
+      delegate :connection, :establish_connection, :clear_active_connections!,
+        to: ActiveRecord::Base
+
+      def initialize(configuration)
+        @configuration = configuration
+      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 error.cause.is_a?(PG::DuplicateDatabase)
+          raise DatabaseAlreadyExists
+        else
+          raise
+        end
+      end
+
+      def drop
+        establish_master_connection
+        connection.drop_database configuration["database"]
+      end
+
+      def charset
+        connection.encoding
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def purge
+        clear_active_connections!
+        drop
+        create true
+      end
+
+      def structure_dump(filename, extra_flags)
+        set_psql_env
+
+        search_path = \
+          case ActiveRecord::Base.dump_schemas
+          when :schema_search_path
+            configuration["schema_search_path"]
+          when :all
+            nil
+          when String
+            ActiveRecord::Base.dump_schemas
+          end
+
+        args = ["-s", "-x", "-O", "-f", filename]
+        args.concat(Array(extra_flags)) if extra_flags
+        unless search_path.blank?
+          args += search_path.split(",").map do |part|
+            "--schema=#{part.strip}"
+          end
+        end
+
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          args += ignore_tables.flat_map { |table| ["-T", table] }
+        end
+
+        args << configuration["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, extra_flags)
+        set_psql_env
+        args = ["-v", ON_ERROR_STOP_1, "-q", "-f", filename]
+        args.concat(Array(extra_flags)) if extra_flags
+        args << configuration["database"]
+        run_cmd("psql", args, "loading")
+      end
+
+      private
+
+        def configuration
+          @configuration
+        end
+
+        def encoding
+          configuration["encoding"] || DEFAULT_ENCODING
+        end
+
+        def establish_master_connection
+          establish_connection configuration.merge(
+            "database"           => "postgres",
+            "schema_search_path" => "public"
+          )
+        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".dup
+          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

@@ -0,0 +1,83 @@
+# 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
+      end
+
+      def create
+        raise DatabaseAlreadyExists if File.exist?(configuration["database"])
+
+        establish_connection configuration
+        connection
+      end
+
+      def drop
+        require "pathname"
+        path = Pathname.new configuration["database"]
+        file = path.absolute? ? path.to_s : File.join(root, path)
+
+        FileUtils.rm(file)
+      rescue Errno::ENOENT => error
+        raise NoDatabaseError.new(error.message)
+      end
+
+      def purge
+        drop
+      rescue NoDatabaseError
+      ensure
+        create
+      end
+
+      def charset
+        connection.encoding
+      end
+
+      def structure_dump(filename, extra_flags)
+        args = []
+        args.concat(Array(extra_flags)) if extra_flags
+        args << configuration["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, extra_flags)
+        dbfile = configuration["database"]
+        flags = extra_flags.join(" ") if extra_flags
+        `sqlite3 #{flags} #{dbfile} < "#{filename}"`
+      end
+
+      private
+
+        def configuration
+          @configuration
+        end
+
+        def root
+          @root
+        end
+
+        def run_cmd(cmd, args, out)
+          fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, out: out)
+        end
+
+        def run_cmd_error(cmd, args)
+          msg = "failed to execute:\n".dup
+          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