activerecord 3.0.0 → 4.0.0

data/lib/active_record/tasks/database_tasks.rb

@@ -0,0 +1,203 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class DatabaseAlreadyExists < StandardError; end # :nodoc:
+    class DatabaseNotSupported < StandardError; end # :nodoc:
+
+    # <tt>ActiveRecord::Tasks::DatabaseTasks</tt> is a utility class, which encapsulates
+    # logic behind common tasks used to manage database and migrations.
+    #
+    # The tasks defined here are used in 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.
+    #
+    # Example usage of +DatabaseTasks+ outside Rails could look as such:
+    #
+    #   include ActiveRecord::Tasks
+    #   DatabaseTasks.database_configuration = YAML.load(File.read('my_database_config.yml'))
+    #   DatabaseTasks.db_dir = 'db'
+    #   # other settings...
+    #
+    #   DatabaseTasks.create_current('production')
+    module DatabaseTasks
+      extend self
+
+      attr_writer :current_config
+      attr_accessor :database_configuration, :migrations_paths, :seed_loader, :db_dir,
+                    :fixtures_path, :env
+
+      LOCAL_HOSTS    = ['127.0.0.1', 'localhost']
+
+      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)
+
+      register_task(/firebird/,     ActiveRecord::Tasks::FirebirdDatabaseTasks)
+      register_task(/sqlserver/,    ActiveRecord::Tasks::SqlserverDatabaseTasks)
+      register_task(/(oci|oracle)/, ActiveRecord::Tasks::OracleDatabaseTasks)
+
+      def current_config(options = {})
+        options.reverse_merge! :env => env
+        if options.has_key?(:config)
+          @current_config = options[:config]
+        else
+          @current_config ||= if ENV['DATABASE_URL']
+                                database_url_config
+                              else
+                                ActiveRecord::Base.configurations[options[:env]]
+                              end
+        end
+      end
+
+      def create(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).create
+      rescue DatabaseAlreadyExists
+        $stderr.puts "#{configuration['database']} already exists"
+      rescue Exception => error
+        $stderr.puts error, *(error.backtrace)
+        $stderr.puts "Couldn't create database for #{configuration.inspect}"
+      end
+
+      def create_all
+        each_local_configuration { |configuration| create configuration }
+      end
+
+      def create_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          create configuration
+        }
+        ActiveRecord::Base.establish_connection environment
+      end
+
+      def create_database_url
+        create database_url_config
+      end
+
+      def drop(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).drop
+      rescue Exception => error
+        $stderr.puts error, *(error.backtrace)
+        $stderr.puts "Couldn't drop #{configuration['database']}"
+      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 drop_database_url
+        drop database_url_config
+      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 structure_dump(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration['adapter']).new(*arguments).structure_dump(filename)
+      end
+
+      def structure_load(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration['adapter']).new(*arguments).structure_load(filename)
+      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
+
+      private
+
+      def database_url_config
+        @database_url_config ||=
+               ConnectionAdapters::ConnectionSpecification::Resolver.new(ENV["DATABASE_URL"], {}).spec.config.stringify_keys
+      end
+
+      def class_for_adapter(adapter)
+        key = @tasks.keys.detect { |pattern| adapter[pattern] }
+        unless key
+          raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
+        end
+        @tasks[key]
+      end
+
+      def each_current_configuration(environment)
+        environments = [environment]
+        environments << 'test' if environment == 'development'
+
+        configurations = ActiveRecord::Base.configurations.values_at(*environments)
+        configurations.compact.each do |configuration|
+          yield configuration unless configuration['database'].blank?
+        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/firebird_database_tasks.rb

@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class FirebirdDatabaseTasks # :nodoc:
+      delegate :connection, :establish_connection, to: ActiveRecord::Base
+
+      def initialize(configuration)
+        ActiveSupport::Deprecation.warn "This database tasks were deprecated, because this tasks should be served by the 3rd party adapter."
+        @configuration = configuration
+      end
+
+      def create
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def drop
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def purge
+        establish_connection(:test)
+        connection.recreate_database!
+      end
+
+      def charset
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def structure_dump(filename)
+        set_firebird_env(configuration)
+        db_string = firebird_db_string(configuration)
+        Kernel.system "isql -a #{db_string} > #{filename}"
+      end
+
+      def structure_load(filename)
+        set_firebird_env(configuration)
+        db_string = firebird_db_string(configuration)
+        Kernel.system "isql -i #{filename} #{db_string}"
+      end
+
+      private
+
+      def set_firebird_env(config)
+        ENV['ISC_USER']     = config['username'].to_s if config['username']
+        ENV['ISC_PASSWORD'] = config['password'].to_s if config['password']
+      end
+
+      def firebird_db_string(config)
+        FireRuby::Database.db_string_for(config.symbolize_keys)
+      end
+
+      def configuration
+        @configuration
+      end
+    end
+  end
+end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -0,0 +1,143 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class MySQLDatabaseTasks # :nodoc:
+      DEFAULT_CHARSET     = ENV['CHARSET']   || 'utf8'
+      DEFAULT_COLLATION   = ENV['COLLATION'] || 'utf8_unicode_ci'
+      ACCESS_DENIED_ERROR = 1045
+
+      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 /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 "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
+      end
+
+      def drop
+        establish_connection configuration
+        connection.drop_database configuration['database']
+      end
+
+      def purge
+        establish_connection :test
+        connection.recreate_database configuration['database'], creation_options
+      end
+
+      def charset
+        connection.charset
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def structure_dump(filename)
+        args = prepare_command_options('mysqldump')
+        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
+
+      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
+
+      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'
+
+          # Set default charset only when collation isn't set.
+          options[:charset]   ||= DEFAULT_CHARSET unless options[:collation]
+
+          # Set default collation only when charset is also default.
+          options[:collation] ||= DEFAULT_COLLATION if options[:charset] == DEFAULT_CHARSET
+        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
+        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(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 ]) if v
+        end
+        args
+      end
+    end
+  end
+end

data/lib/active_record/tasks/oracle_database_tasks.rb

@@ -0,0 +1,45 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class OracleDatabaseTasks # :nodoc:
+      delegate :connection, :establish_connection, to: ActiveRecord::Base
+
+      def initialize(configuration)
+        ActiveSupport::Deprecation.warn "This database tasks were deprecated, because this tasks should be served by the 3rd party adapter."
+        @configuration = configuration
+      end
+
+      def create
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def drop
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def purge
+        establish_connection(:test)
+        connection.structure_drop.split(";\n\n").each { |ddl| connection.execute(ddl) }
+      end
+
+      def charset
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def structure_dump(filename)
+        establish_connection(configuration)
+        File.open(filename, "w:utf-8") { |f| f << connection.structure_dump }
+      end
+
+      def structure_load(filename)
+        establish_connection(configuration)
+        IO.read(filename).split(";\n\n").each { |ddl| connection.execute(ddl) }
+      end
+
+      private
+
+      def configuration
+        @configuration
+      end
+    end
+  end
+end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -0,0 +1,90 @@
+require 'shellwords'
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class PostgreSQLDatabaseTasks # :nodoc:
+      DEFAULT_ENCODING = ENV['CHARSET'] || 'utf8'
+
+      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 /database .* already exists/ === error.message
+          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)
+        set_psql_env
+        search_path = configuration['schema_search_path']
+        unless search_path.blank?
+          search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
+        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)
+
+        File.open(filename, "a") { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
+      end
+
+      def structure_load(filename)
+        set_psql_env
+        Kernel.system("psql -q -f #{filename} #{configuration['database']}")
+      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
+    end
+  end
+end

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class SQLiteDatabaseTasks # :nodoc:
+      delegate :connection, :establish_connection, to: ActiveRecord::Base
+
+      def initialize(configuration, root = Rails.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) if File.exist?(file)
+      end
+      alias :purge :drop
+
+      def charset
+        connection.encoding
+      end
+
+      def structure_dump(filename)
+        dbfile = configuration['database']
+        `sqlite3 #{dbfile} .schema > #{filename}`
+      end
+
+      def structure_load(filename)
+        dbfile = configuration['database']
+        `sqlite3 #{dbfile} < "#{filename}"`
+      end
+
+      private
+
+      def configuration
+        @configuration
+      end
+
+      def root
+        @root
+      end
+    end
+  end
+end

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -0,0 +1,48 @@
+require 'shellwords'
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class SqlserverDatabaseTasks # :nodoc:
+      delegate :connection, :establish_connection, to: ActiveRecord::Base
+
+      def initialize(configuration)
+        ActiveSupport::Deprecation.warn "This database tasks were deprecated, because this tasks should be served by the 3rd party adapter."
+        @configuration = configuration
+      end
+
+      def create
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def drop
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def purge
+        test = configuration.deep_dup
+        test_database = test['database']
+        test['database'] = 'master'
+        establish_connection(test)
+        connection.recreate_database!(test_database)
+      end
+
+      def charset
+        $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      end
+
+      def structure_dump(filename)
+        Kernel.system("smoscript -s #{configuration['host']} -d #{configuration['database']} -u #{configuration['username']} -p #{configuration['password']} -f #{filename} -A -U")
+      end
+
+      def structure_load(filename)
+        Kernel.system("sqlcmd -S #{configuration['host']} -d #{configuration['database']} -U #{configuration['username']} -P #{configuration['password']} -i #{filename}")
+      end
+
+      private
+
+      def configuration
+        @configuration
+      end
+    end
+  end
+end