activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/tasks/database_tasks.rb

@@ -0,0 +1,158 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class DatabaseAlreadyExists < StandardError; end # :nodoc:
+    class DatabaseNotSupported < StandardError; end # :nodoc:
+
+    module DatabaseTasks # :nodoc:
+      extend self
+
+      attr_writer :current_config
+
+      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)
+
+      def current_config(options = {})
+        options.reverse_merge! :env => Rails.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 = Rails.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 = Rails.env)
+        each_current_configuration(environment) { |configuration|
+          drop configuration
+        }
+      end
+
+      def drop_database_url
+        drop database_url_config
+      end
+
+      def charset_current(environment = Rails.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 = Rails.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
+
+      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/mysql_database_tasks.rb

@@ -0,0 +1,138 @@
+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
+          connection.execute grant_statement.gsub(/\s+/, ' ').strip
+          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']}"])
+        Kernel.system(*args)
+      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/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 -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/test_case.rb

@@ -1,23 +1,13 @@
+require 'active_support/test_case'
+
+ActiveSupport::Deprecation.warn('ActiveRecord::TestCase is deprecated, please use ActiveSupport::TestCase')
 module ActiveRecord
   # = Active Record Test Case
   #
   # Defines some test assertions to test against SQL queries.
   class TestCase < ActiveSupport::TestCase #:nodoc:
-    setup :cleanup_identity_map
-
-    def setup
-      cleanup_identity_map
-    end
-
-    def cleanup_identity_map
-      ActiveRecord::IdentityMap.clear
-    end
-
-    # Backport skip to Ruby 1.8. test/unit doesn't support it, so just
-    # make it a noop.
-    unless instance_methods.map(&:to_s).include?("skip")
-      def skip(message)
-      end
+    def teardown
+      SQLCounter.clear_log
     end
 
     def assert_date_from_db(expected, actual, message = nil)
@@ -31,43 +21,76 @@ module ActiveRecord
     end
 
     def assert_sql(*patterns_to_match)
-      ActiveRecord::SQLCounter.log = []
+      SQLCounter.clear_log
       yield
-      ActiveRecord::SQLCounter.log
+      SQLCounter.log_all
     ensure
       failed_patterns = []
       patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless ActiveRecord::SQLCounter.log.any?{ |sql| pattern === sql }
+        failed_patterns << pattern unless SQLCounter.log_all.any?{ |sql| pattern === sql }
       end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
+      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{SQLCounter.log.join("\n")}"}"
     end
 
-    def assert_queries(num = 1)
-      ActiveRecord::SQLCounter.log = []
+    def assert_queries(num = 1, options = {})
+      ignore_none = options.fetch(:ignore_none) { num == :any }
+      SQLCounter.clear_log
       yield
     ensure
-      assert_equal num, ActiveRecord::SQLCounter.log.size, "#{ActiveRecord::SQLCounter.log.size} instead of #{num} queries were executed.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
+      the_log = ignore_none ? SQLCounter.log_all : SQLCounter.log
+      if num == :any
+        assert_operator the_log.size, :>=, 1, "1 or more queries expected, but none were executed."
+      else
+        mesg = "#{the_log.size} instead of #{num} queries were executed.#{the_log.size == 0 ? '' : "\nQueries:\n#{the_log.join("\n")}"}"
+        assert_equal num, the_log.size, mesg
+      end
     end
 
     def assert_no_queries(&block)
-      prev_ignored_sql = ActiveRecord::SQLCounter.ignored_sql
-      ActiveRecord::SQLCounter.ignored_sql = []
-      assert_queries(0, &block)
-    ensure
-      ActiveRecord::SQLCounter.ignored_sql = prev_ignored_sql
+      assert_queries(0, :ignore_none => true, &block)
     end
 
-    def with_kcode(kcode)
-      if RUBY_VERSION < '1.9'
-        orig_kcode, $KCODE = $KCODE, kcode
-        begin
-          yield
-        ensure
-          $KCODE = orig_kcode
-        end
-      else
-        yield
-      end
+  end
+
+  class SQLCounter
+    class << self
+      attr_accessor :ignored_sql, :log, :log_all
+      def clear_log; self.log = []; self.log_all = []; end
+    end
+
+    self.clear_log
+
+    self.ignored_sql = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL, or better yet, use a different notification for the queries
+    # instead examining the SQL content.
+    oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+    mysql_ignored      = [/^SHOW TABLES/i, /^SHOW FULL FIELDS/]
+    postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
+    sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im]
+
+    [oracle_ignored, mysql_ignored, postgresql_ignored, sqlite3_ignored].each do |db_ignored_sql|
+      ignored_sql.concat db_ignored_sql
+    end
+
+    attr_reader :ignore
+
+    def initialize(ignore = Regexp.union(self.class.ignored_sql))
+      @ignore = ignore
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      return if 'CACHE' == values[:name]
+
+      self.class.log_all << sql
+      self.class.log << sql unless ignore =~ sql
     end
   end
+
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
 end