activerecord 4.2.0 → 5.2.8.1

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -1,10 +1,8 @@
+# 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
-
       delegate :connection, :establish_connection, to: ActiveRecord::Base
 
       def initialize(configuration)
@@ -13,38 +11,24 @@ module ActiveRecord
 
       def create
         establish_connection configuration_without_database
-        connection.create_database configuration['database'], creation_options
+        connection.create_database configuration["database"], creation_options
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => error
-        if /database exists/ === error.message
+        if error.message.include?("database exists")
           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
       end
 
       def drop
         establish_connection configuration
-        connection.drop_database configuration['database']
+        connection.drop_database configuration["database"]
       end
 
       def purge
         establish_connection configuration
-        connection.recreate_database configuration['database'], creation_options
+        connection.recreate_database configuration["database"], creation_options
       end
 
       def charset
@@ -55,91 +39,77 @@ 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=#{configuration['database']}.#{table}" }
+        end
 
-      private
+        args.concat(["#{configuration['database']}"])
+        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", "#{configuration['database']}"])
+        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
 
-          # Set default collation only when charset is also default.
-          options[:collation] ||= DEFAULT_COLLATION if options[:charset] == DEFAULT_CHARSET
+        def configuration
+          @configuration
         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 configuration_without_database
+          configuration.merge("database" => nil)
         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 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 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[opt]}" if configuration[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".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

@@ -1,9 +1,13 @@
-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".freeze
+      SQL_COMMENT_BEGIN = "--".freeze
 
       delegate :connection, :establish_connection, :clear_active_connections!,
         to: ActiveRecord::Base
@@ -14,11 +18,11 @@ module ActiveRecord
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration['database'],
-          configuration.merge('encoding' => encoding)
+        connection.create_database configuration["database"],
+          configuration.merge("encoding" => encoding)
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => error
-        if /database .* already exists/ === error.message
+        if error.cause.is_a?(PG::DuplicateDatabase)
           raise DatabaseAlreadyExists
         else
           raise
@@ -27,7 +31,7 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration['database']
+        connection.drop_database configuration["database"]
       end
 
       def charset
@@ -44,47 +48,96 @@ 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["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?
-          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 << 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)
+      def structure_load(filename, extra_flags)
         set_psql_env
-        Kernel.system("psql -q -f #{Shellwords.escape(filename)} #{configuration['database']}")
+        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 configuration
+          @configuration
+        end
 
-      def encoding
-        configuration['encoding'] || DEFAULT_ENCODING
-      end
+        def encoding
+          configuration["encoding"] || DEFAULT_ENCODING
+        end
 
-      def establish_master_connection
-        establish_connection configuration.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']     = 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 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Tasks # :nodoc:
     class SQLiteDatabaseTasks # :nodoc:
@@ -8,22 +10,26 @@ module ActiveRecord
       end
 
       def create
-        raise DatabaseAlreadyExists if File.exist?(configuration['database'])
+        raise DatabaseAlreadyExists if File.exist?(configuration["database"])
 
         establish_connection configuration
         connection
       end
 
       def drop
-        require 'pathname'
-        path = Pathname.new configuration['database']
+        require "pathname"
+        path = Pathname.new configuration["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 +37,47 @@ 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 << 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)
-        dbfile = configuration['database']
-        `sqlite3 #{dbfile} < "#{filename}"`
+      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 configuration
+          @configuration
+        end
 
-      def root
-        @root
-      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

data/lib/active_record/timestamp.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Timestamp
+  # = Active Record \Timestamp
   #
   # Active Record automatically timestamps create and update operations if the
   # table has fields named <tt>created_at/created_on</tt> or
@@ -15,14 +17,25 @@ module ActiveRecord
   #
   # == Time Zone aware attributes
   #
-  # By default, ActiveRecord::Base keeps all the datetime columns time zone aware by executing following code.
+  # Active Record keeps all the <tt>datetime</tt> and <tt>time</tt> columns
+  # timezone aware. By default, these values are stored in the database as UTC
+  # and converted back to the current <tt>Time.zone</tt> when pulled from the database.
+  #
+  # This feature can be turned off completely by setting:
+  #
+  #   config.active_record.time_zone_aware_attributes = false
+  #
+  # You can also specify that only <tt>datetime</tt> columns should be time-zone
+  # aware (while <tt>time</tt> should not) by setting:
   #
-  #   config.active_record.time_zone_aware_attributes = true
+  #   ActiveRecord::Base.time_zone_aware_types = [:datetime]
   #
-  # This feature can easily be turned off by assigning value <tt>false</tt> .
+  # You can also add database specific timezone aware types. For example, for PostgreSQL:
   #
-  # If your attributes are time zone aware and you desire to skip time zone conversion to the current Time.zone
-  # when reading certain attributes then you can do following:
+  #   ActiveRecord::Base.time_zone_aware_types += [:tsrange, :tstzrange]
+  #
+  # Finally, you can indicate specific attributes of a model for which time zone
+  # conversion should not applied, for instance by setting:
   #
   #   class Topic < ActiveRecord::Base
   #     self.skip_time_zone_conversion_for_attributes = [:written_on]
@@ -31,8 +44,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :record_timestamps
-      self.record_timestamps = true
+      class_attribute :record_timestamps, default: true
     end
 
     def initialize_dup(other) # :nodoc:
@@ -40,16 +52,49 @@ module ActiveRecord
       clear_timestamp_attributes
     end
 
+    module ClassMethods # :nodoc:
+      def touch_attributes_with_time(*names, time: nil)
+        attribute_names = timestamp_attributes_for_update_in_model
+        attribute_names |= names.map(&:to_s)
+        time ||= current_time_from_proper_timezone
+        attribute_names.each_with_object({}) { |attr_name, result| result[attr_name] = time }
+      end
+
+      private
+        def timestamp_attributes_for_create_in_model
+          timestamp_attributes_for_create.select { |c| column_names.include?(c) }
+        end
+
+        def timestamp_attributes_for_update_in_model
+          timestamp_attributes_for_update.select { |c| column_names.include?(c) }
+        end
+
+        def all_timestamp_attributes_in_model
+          timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+        end
+
+        def timestamp_attributes_for_create
+          ["created_at", "created_on"]
+        end
+
+        def timestamp_attributes_for_update
+          ["updated_at", "updated_on"]
+        end
+
+        def current_time_from_proper_timezone
+          default_timezone == :utc ? Time.now.utc : Time.now
+        end
+    end
+
   private
 
     def _create_record
-      if self.record_timestamps
+      if record_timestamps
         current_time = current_time_from_proper_timezone
 
-        all_timestamp_attributes.each do |column|
-          column = column.to_s
-          if has_attribute?(column) && !attribute_present?(column)
-            write_attribute(column, current_time)
+        all_timestamp_attributes_in_model.each do |column|
+          if !attribute_present?(column)
+            _write_attribute(column, current_time)
           end
         end
       end
@@ -57,48 +102,39 @@ module ActiveRecord
       super
     end
 
-    def _update_record(*args)
-      if should_record_timestamps?
+    def _update_record(*args, touch: true, **options)
+      if touch && should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
         timestamp_attributes_for_update_in_model.each do |column|
-          column = column.to_s
-          next if attribute_changed?(column)
-          write_attribute(column, current_time)
+          next if will_save_change_to_attribute?(column)
+          _write_attribute(column, current_time)
         end
       end
-      super
+      super(*args)
     end
 
     def should_record_timestamps?
-      self.record_timestamps && (!partial_writes? || changed?)
+      record_timestamps && (!partial_writes? || has_changes_to_save?)
     end
 
     def timestamp_attributes_for_create_in_model
-      timestamp_attributes_for_create.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.send(:timestamp_attributes_for_create_in_model)
     end
 
     def timestamp_attributes_for_update_in_model
-      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.send(:timestamp_attributes_for_update_in_model)
     end
 
     def all_timestamp_attributes_in_model
-      timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
-    end
-
-    def timestamp_attributes_for_update
-      [:updated_at, :updated_on]
-    end
-
-    def timestamp_attributes_for_create
-      [:created_at, :created_on]
+      self.class.send(:all_timestamp_attributes_in_model)
     end
 
-    def all_timestamp_attributes
-      timestamp_attributes_for_create + timestamp_attributes_for_update
+    def current_time_from_proper_timezone
+      self.class.send(:current_time_from_proper_timezone)
     end
 
-    def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
+    def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update_in_model)
       timestamp_names
         .map { |attr| self[attr] }
         .compact
@@ -106,10 +142,6 @@ module ActiveRecord
         .max
     end
 
-    def current_time_from_proper_timezone
-      self.class.default_timezone == :utc ? Time.now.utc : Time.now
-    end
-
     # Clear attributes and changed_attributes
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|