normalizes indentation and whitespace across the project

36 files changed, 1092 insertions, 1092 deletions

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index db798bc303..535d79b525 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -150,61 +150,61 @@ module ActiveRecord
 
         private
 
-        def internal_poll(timeout)
-          no_wait_poll || (timeout && wait_poll(timeout))
-        end
+          def internal_poll(timeout)
+            no_wait_poll || (timeout && wait_poll(timeout))
+          end
 
-        def synchronize(&block)
-          @lock.synchronize(&block)
-        end
+          def synchronize(&block)
+            @lock.synchronize(&block)
+          end
 
         # Test if the queue currently contains any elements.
-        def any?
-          !@queue.empty?
-        end
+          def any?
+            !@queue.empty?
+          end
 
         # A thread can remove an element from the queue without
         # waiting if and only if the number of currently available
         # connections is strictly greater than the number of waiting
         # threads.
-        def can_remove_no_wait?
-          @queue.size > @num_waiting
-        end
+          def can_remove_no_wait?
+            @queue.size > @num_waiting
+          end
 
         # Removes and returns the head of the queue if possible, or nil.
-        def remove
-          @queue.shift
-        end
+          def remove
+            @queue.shift
+          end
 
         # Remove and return the head the queue if the number of
         # available elements is strictly greater than the number of
         # threads currently waiting.  Otherwise, return nil.
-        def no_wait_poll
-          remove if can_remove_no_wait?
-        end
+          def no_wait_poll
+            remove if can_remove_no_wait?
+          end
 
         # Waits on the queue up to +timeout+ seconds, then removes and
         # returns the head of the queue.
-        def wait_poll(timeout)
-          @num_waiting += 1
+          def wait_poll(timeout)
+            @num_waiting += 1
 
-          t0 = Time.now
-          elapsed = 0
-          loop do
-            @cond.wait(timeout - elapsed)
+            t0 = Time.now
+            elapsed = 0
+            loop do
+              @cond.wait(timeout - elapsed)
 
-            return remove if any?
+              return remove if any?
 
-            elapsed = Time.now - t0
-            if elapsed >= timeout
-              msg = "could not obtain a connection from the pool within %0.3f seconds (waited %0.3f seconds); all pooled connections were in use" %
-                [timeout, elapsed]
-              raise ConnectionTimeoutError, msg
+              elapsed = Time.now - t0
+              if elapsed >= timeout
+                msg = "could not obtain a connection from the pool within %0.3f seconds (waited %0.3f seconds); all pooled connections were in use" %
+                  [timeout, elapsed]
+                raise ConnectionTimeoutError, msg
+              end
             end
+          ensure
+            @num_waiting -= 1
           end
-        ensure
-          @num_waiting -= 1
-        end
       end
 
       # Adds the ability to turn a basic fair FIFO queue into one
@@ -274,11 +274,11 @@ module ActiveRecord
         include BiasableQueue
 
         private
-        def internal_poll(timeout)
-          conn = super
-          conn.lease if conn
-          conn
-        end
+          def internal_poll(timeout)
+            conn = super
+            conn.lease if conn
+            conn
+          end
       end
 
       # Every +frequency+ seconds, the reaper will call +reap+ on +pool+.
@@ -584,111 +584,111 @@ module ActiveRecord
       private
       #--
       # this is unfortunately not concurrent
-      def bulk_make_new_connections(num_new_conns_needed)
-        num_new_conns_needed.times do
-          # try_to_checkout_new_connection will not exceed pool's @size limit
-          if new_conn = try_to_checkout_new_connection
-            # make the new_conn available to the starving threads stuck @available Queue
-            checkin(new_conn)
+        def bulk_make_new_connections(num_new_conns_needed)
+          num_new_conns_needed.times do
+            # try_to_checkout_new_connection will not exceed pool's @size limit
+            if new_conn = try_to_checkout_new_connection
+              # make the new_conn available to the starving threads stuck @available Queue
+              checkin(new_conn)
+            end
           end
         end
-      end
 
       #--
       # From the discussion on GitHub:
       #  https://github.com/rails/rails/pull/14938#commitcomment-6601951
       # This hook-in method allows for easier monkey-patching fixes needed by
       # JRuby users that use Fibers.
-      def connection_cache_key(thread)
-        thread
-      end
+        def connection_cache_key(thread)
+          thread
+        end
 
       # Take control of all existing connections so a "group" action such as
       # reload/disconnect can be performed safely. It is no longer enough to
       # wrap it in +synchronize+ because some pool's actions are allowed
       # to be performed outside of the main +synchronize+ block.
-      def with_exclusively_acquired_all_connections(raise_on_acquisition_timeout = true)
-        with_new_connections_blocked do
-          attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout)
-          yield
+        def with_exclusively_acquired_all_connections(raise_on_acquisition_timeout = true)
+          with_new_connections_blocked do
+            attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout)
+            yield
+          end
         end
-      end
 
-      def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = true)
-        collected_conns = synchronize do
-          # account for our own connections
-          @connections.select {|conn| conn.owner == Thread.current}
-        end
+        def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = true)
+          collected_conns = synchronize do
+            # account for our own connections
+            @connections.select {|conn| conn.owner == Thread.current}
+          end
 
-        newly_checked_out = []
-        timeout_time      = Time.now + (@checkout_timeout * 2)
+          newly_checked_out = []
+          timeout_time      = Time.now + (@checkout_timeout * 2)
 
-        @available.with_a_bias_for(Thread.current) do
-          loop do
-            synchronize do
-              return if collected_conns.size == @connections.size && @now_connecting == 0
-              remaining_timeout = timeout_time - Time.now
-              remaining_timeout = 0 if remaining_timeout < 0
-              conn = checkout_for_exclusive_access(remaining_timeout)
-              collected_conns   << conn
-              newly_checked_out << conn
+          @available.with_a_bias_for(Thread.current) do
+            loop do
+              synchronize do
+                return if collected_conns.size == @connections.size && @now_connecting == 0
+                remaining_timeout = timeout_time - Time.now
+                remaining_timeout = 0 if remaining_timeout < 0
+                conn = checkout_for_exclusive_access(remaining_timeout)
+                collected_conns   << conn
+                newly_checked_out << conn
+              end
             end
           end
-        end
-      rescue ExclusiveConnectionTimeoutError
-        # <tt>raise_on_acquisition_timeout == false</tt> means we are directed to ignore any
-        # timeouts and are expected to just give up: we've obtained as many connections
-        # as possible, note that in a case like that we don't return any of the
-        # +newly_checked_out+ connections.
-
-        if raise_on_acquisition_timeout
+        rescue ExclusiveConnectionTimeoutError
+          # <tt>raise_on_acquisition_timeout == false</tt> means we are directed to ignore any
+          # timeouts and are expected to just give up: we've obtained as many connections
+          # as possible, note that in a case like that we don't return any of the
+          # +newly_checked_out+ connections.
+
+          if raise_on_acquisition_timeout
+            release_newly_checked_out = true
+            raise
+          end
+        rescue Exception # if something else went wrong
+          # this can't be a "naked" rescue, because we have should return conns
+          # even for non-StandardErrors
           release_newly_checked_out = true
           raise
+        ensure
+          if release_newly_checked_out && newly_checked_out
+            # releasing only those conns that were checked out in this method, conns
+            # checked outside this method (before it was called) are not for us to release
+            newly_checked_out.each {|conn| checkin(conn)}
+          end
         end
-      rescue Exception # if something else went wrong
-        # this can't be a "naked" rescue, because we have should return conns
-        # even for non-StandardErrors
-        release_newly_checked_out = true
-        raise
-      ensure
-        if release_newly_checked_out && newly_checked_out
-          # releasing only those conns that were checked out in this method, conns
-          # checked outside this method (before it was called) are not for us to release
-          newly_checked_out.each {|conn| checkin(conn)}
-        end
-      end
 
       #--
       # Must be called in a synchronize block.
-      def checkout_for_exclusive_access(checkout_timeout)
-        checkout(checkout_timeout)
-      rescue ConnectionTimeoutError
-        # this block can't be easily moved into attempt_to_checkout_all_existing_connections's
-        # rescue block, because doing so would put it outside of synchronize section, without
-        # being in a critical section thread_report might become inaccurate
-        msg = "could not obtain ownership of all database connections in #{checkout_timeout} seconds"
-
-        thread_report = []
-        @connections.each do |conn|
-          unless conn.owner == Thread.current
-            thread_report << "#{conn} is owned by #{conn.owner}"
+        def checkout_for_exclusive_access(checkout_timeout)
+          checkout(checkout_timeout)
+        rescue ConnectionTimeoutError
+          # this block can't be easily moved into attempt_to_checkout_all_existing_connections's
+          # rescue block, because doing so would put it outside of synchronize section, without
+          # being in a critical section thread_report might become inaccurate
+          msg = "could not obtain ownership of all database connections in #{checkout_timeout} seconds"
+
+          thread_report = []
+          @connections.each do |conn|
+            unless conn.owner == Thread.current
+              thread_report << "#{conn} is owned by #{conn.owner}"
+            end
           end
-        end
 
-        msg << " (#{thread_report.join(', ')})" if thread_report.any?
+          msg << " (#{thread_report.join(', ')})" if thread_report.any?
 
-        raise ExclusiveConnectionTimeoutError, msg
-      end
+          raise ExclusiveConnectionTimeoutError, msg
+        end
 
-      def with_new_connections_blocked
-        previous_value = nil
-        synchronize do
-          previous_value, @new_cons_enabled = @new_cons_enabled, false
+        def with_new_connections_blocked
+          previous_value = nil
+          synchronize do
+            previous_value, @new_cons_enabled = @new_cons_enabled, false
+          end
+          yield
+        ensure
+          synchronize { @new_cons_enabled = previous_value }
         end
-        yield
-      ensure
-        synchronize { @new_cons_enabled = previous_value }
-      end
 
       # Acquire a connection by one of 1) immediately removing one
       # from the queue of available connections, 2) creating a new
@@ -701,86 +701,86 @@ module ActiveRecord
       #--
       # Implementation detail: the connection returned by +acquire_connection+
       # will already be "+connection.lease+ -ed" to the current thread.
-      def acquire_connection(checkout_timeout)
-        # NOTE: we rely on +@available.poll+ and +try_to_checkout_new_connection+ to
-        # +conn.lease+ the returned connection (and to do this in a +synchronized+
-        # section). This is not the cleanest implementation, as ideally we would
-        # <tt>synchronize { conn.lease }</tt> in this method, but by leaving it to +@available.poll+
-        # and +try_to_checkout_new_connection+ we can piggyback on +synchronize+ sections
-        # of the said methods and avoid an additional +synchronize+ overhead.
-        if conn = @available.poll || try_to_checkout_new_connection
-          conn
-        else
-          reap
-          @available.poll(checkout_timeout)
+        def acquire_connection(checkout_timeout)
+          # NOTE: we rely on +@available.poll+ and +try_to_checkout_new_connection+ to
+          # +conn.lease+ the returned connection (and to do this in a +synchronized+
+          # section). This is not the cleanest implementation, as ideally we would
+          # <tt>synchronize { conn.lease }</tt> in this method, but by leaving it to +@available.poll+
+          # and +try_to_checkout_new_connection+ we can piggyback on +synchronize+ sections
+          # of the said methods and avoid an additional +synchronize+ overhead.
+          if conn = @available.poll || try_to_checkout_new_connection
+            conn
+          else
+            reap
+            @available.poll(checkout_timeout)
+          end
         end
-      end
 
       #--
       # if owner_thread param is omitted, this must be called in synchronize block
-      def remove_connection_from_thread_cache(conn, owner_thread = conn.owner)
-        @thread_cached_conns.delete_pair(connection_cache_key(owner_thread), conn)
-      end
-      alias_method :release, :remove_connection_from_thread_cache
+        def remove_connection_from_thread_cache(conn, owner_thread = conn.owner)
+          @thread_cached_conns.delete_pair(connection_cache_key(owner_thread), conn)
+        end
+        alias_method :release, :remove_connection_from_thread_cache
 
-      def new_connection
-        Base.send(spec.adapter_method, spec.config).tap do |conn|
-          conn.schema_cache = schema_cache.dup if schema_cache
+        def new_connection
+          Base.send(spec.adapter_method, spec.config).tap do |conn|
+            conn.schema_cache = schema_cache.dup if schema_cache
+          end
         end
-      end
 
       # If the pool is not at a +@size+ limit, establish new connection. Connecting
       # to the DB is done outside main synchronized section.
       #--
       # Implementation constraint: a newly established connection returned by this
       # method must be in the +.leased+ state.
-      def try_to_checkout_new_connection
-        # first in synchronized section check if establishing new conns is allowed
-        # and increment @now_connecting, to prevent overstepping this pool's @size
-        # constraint
-        do_checkout = synchronize do
-          if @new_cons_enabled && (@connections.size + @now_connecting) < @size
-            @now_connecting += 1
-          end
-        end
-        if do_checkout
-          begin
-            # if successfully incremented @now_connecting establish new connection
-            # outside of synchronized section
-            conn = checkout_new_connection
-          ensure
-            synchronize do
-              if conn
-                adopt_connection(conn)
-                # returned conn needs to be already leased
-                conn.lease
+        def try_to_checkout_new_connection
+          # first in synchronized section check if establishing new conns is allowed
+          # and increment @now_connecting, to prevent overstepping this pool's @size
+          # constraint
+          do_checkout = synchronize do
+            if @new_cons_enabled && (@connections.size + @now_connecting) < @size
+              @now_connecting += 1
+            end
+          end
+          if do_checkout
+            begin
+              # if successfully incremented @now_connecting establish new connection
+              # outside of synchronized section
+              conn = checkout_new_connection
+            ensure
+              synchronize do
+                if conn
+                  adopt_connection(conn)
+                  # returned conn needs to be already leased
+                  conn.lease
+                end
+                @now_connecting -= 1
               end
-              @now_connecting -= 1
             end
           end
         end
-      end
 
-      def adopt_connection(conn)
-        conn.pool = self
-        @connections << conn
-      end
+        def adopt_connection(conn)
+          conn.pool = self
+          @connections << conn
+        end
 
-      def checkout_new_connection
-        raise ConnectionNotEstablished unless @automatic_reconnect
-        new_connection
-      end
+        def checkout_new_connection
+          raise ConnectionNotEstablished unless @automatic_reconnect
+          new_connection
+        end
 
-      def checkout_and_verify(c)
-        c._run_checkout_callbacks do
-          c.verify!
+        def checkout_and_verify(c)
+          c._run_checkout_callbacks do
+            c.verify!
+          end
+          c
+        rescue
+          remove c
+          c.disconnect!
+          raise
         end
-        c
-      rescue
-        remove c
-        c.disconnect!
-        raise
-      end
     end
 
     # ConnectionHandler is a collection of ConnectionPool objects. It is used
@@ -942,14 +942,14 @@ module ActiveRecord
 
       private
 
-      def owner_to_pool
-        @owner_to_pool[Process.pid]
-      end
+        def owner_to_pool
+          @owner_to_pool[Process.pid]
+        end
 
-      def pool_from_any_process_for(spec_name)
-        owner_to_pool = @owner_to_pool.values.find { |v| v[spec_name] }
-        owner_to_pool && owner_to_pool[spec_name]
-      end
+        def pool_from_any_process_for(spec_name)
+          owner_to_pool = @owner_to_pool.values.find { |v| v[spec_name] }
+          owner_to_pool && owner_to_pool[spec_name]
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
index 47f24df22f..10c60080d5 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
@@ -73,23 +73,23 @@ module ActiveRecord
 
       private
 
-      def cache_sql(sql, binds)
-        result =
-          if @query_cache[sql].key?(binds)
-            ActiveSupport::Notifications.instrument("sql.active_record",
-              sql: sql, binds: binds, name: "CACHE", connection_id: object_id)
-            @query_cache[sql][binds]
-          else
-            @query_cache[sql][binds] = yield
-          end
-        result.dup
-      end
+        def cache_sql(sql, binds)
+          result =
+            if @query_cache[sql].key?(binds)
+              ActiveSupport::Notifications.instrument("sql.active_record",
+                sql: sql, binds: binds, name: "CACHE", connection_id: object_id)
+              @query_cache[sql][binds]
+            else
+              @query_cache[sql][binds] = yield
+            end
+          result.dup
+        end
 
       # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
       # queries should not be cached.
-      def locked?(arel)
-        arel.respond_to?(:locked) && arel.locked
-      end
+        def locked?(arel)
+          arel.respond_to?(:locked) && arel.locked
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 20d009bbf8..bbd52b8a91 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -152,47 +152,47 @@ module ActiveRecord
 
       private
 
-      def type_casted_binds(binds)
-        binds.map { |attr| type_cast(attr.value_for_database) }
-      end
-
-      def types_which_need_no_typecasting
-        [nil, Numeric, String]
-      end
-
-      def _quote(value)
-        case value
-        when String, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-          "'#{quote_string(value.to_s)}'"
-        when true       then quoted_true
-        when false      then quoted_false
-        when nil        then "NULL"
-        # BigDecimals need to be put in a non-normalized form and quoted.
-        when BigDecimal then value.to_s("F")
-        when Numeric, ActiveSupport::Duration then value.to_s
-        when Type::Time::Value then "'#{quoted_time(value)}'"
-        when Date, Time then "'#{quoted_date(value)}'"
-        when Symbol     then "'#{quote_string(value.to_s)}'"
-        when Class      then "'#{value}'"
-        else raise TypeError, "can't quote #{value.class.name}"
+        def type_casted_binds(binds)
+          binds.map { |attr| type_cast(attr.value_for_database) }
         end
-      end
 
-      def _type_cast(value)
-        case value
-        when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-          value.to_s
-        when true       then unquoted_true
-        when false      then unquoted_false
-        # BigDecimals need to be put in a non-normalized form and quoted.
-        when BigDecimal then value.to_s("F")
-        when Type::Time::Value then quoted_time(value)
-        when Date, Time then quoted_date(value)
-        when *types_which_need_no_typecasting
-          value
-        else raise TypeError
+        def types_which_need_no_typecasting
+          [nil, Numeric, String]
+        end
+
+        def _quote(value)
+          case value
+          when String, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+            "'#{quote_string(value.to_s)}'"
+          when true       then quoted_true
+          when false      then quoted_false
+          when nil        then "NULL"
+          # BigDecimals need to be put in a non-normalized form and quoted.
+          when BigDecimal then value.to_s("F")
+          when Numeric, ActiveSupport::Duration then value.to_s
+          when Type::Time::Value then "'#{quoted_time(value)}'"
+          when Date, Time then "'#{quoted_date(value)}'"
+          when Symbol     then "'#{quote_string(value.to_s)}'"
+          when Class      then "'#{value}'"
+          else raise TypeError, "can't quote #{value.class.name}"
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+            value.to_s
+          when true       then unquoted_true
+          when false      then unquoted_false
+          # BigDecimals need to be put in a non-normalized form and quoted.
+          when BigDecimal then value.to_s("F")
+          when Type::Time::Value then quoted_time(value)
+          when Date, Time then quoted_date(value)
+          when *types_which_need_no_typecasting
+            value
+          else raise TypeError
+          end
         end
-      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index c1fc99ce1f..1d18a58eab 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -61,9 +61,9 @@ module ActiveRecord
       end
 
       private
-      def default_primary_key
-        "id"
-      end
+        def default_primary_key
+          "id"
+        end
     end
 
     class ReferenceDefinition # :nodoc:
@@ -103,51 +103,51 @@ module ActiveRecord
 
       protected
 
-      attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
+        attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
 
       private
 
-      def as_options(value, default = {})
-        if value.is_a?(Hash)
-          value
-        else
-          default
+        def as_options(value, default = {})
+          if value.is_a?(Hash)
+            value
+          else
+            default
+          end
         end
-      end
 
-      def polymorphic_options
-        as_options(polymorphic, options)
-      end
+        def polymorphic_options
+          as_options(polymorphic, options)
+        end
 
-      def index_options
-        as_options(index)
-      end
+        def index_options
+          as_options(index)
+        end
 
-      def foreign_key_options
-        as_options(foreign_key).merge(column: column_name)
-      end
+        def foreign_key_options
+          as_options(foreign_key).merge(column: column_name)
+        end
 
-      def columns
-        result = [[column_name, type, options]]
-        if polymorphic
-          result.unshift(["#{name}_type", :string, polymorphic_options])
+        def columns
+          result = [[column_name, type, options]]
+          if polymorphic
+            result.unshift(["#{name}_type", :string, polymorphic_options])
+          end
+          result
         end
-        result
-      end
 
-      def column_name
-        "#{name}_id"
-      end
+        def column_name
+          "#{name}_id"
+        end
 
-      def column_names
-        columns.map(&:first)
-      end
+        def column_names
+          columns.map(&:first)
+        end
 
-      def foreign_table_name
-        foreign_key_options.fetch(:to_table) do
-          Base.pluralize_table_names ? name.to_s.pluralize : name
+        def foreign_table_name
+          foreign_key_options.fetch(:to_table) do
+            Base.pluralize_table_names ? name.to_s.pluralize : name
+          end
         end
-      end
     end
 
     module ColumnMethods
@@ -383,13 +383,13 @@ module ActiveRecord
       end
 
       private
-      def create_column_definition(name, type)
-        ColumnDefinition.new name, type
-      end
+        def create_column_definition(name, type)
+          ColumnDefinition.new name, type
+        end
 
-      def aliased_types(name, fallback)
-        "timestamp" == name ? :datetime : fallback
-      end
+        def aliased_types(name, fallback)
+          "timestamp" == name ? :datetime : fallback
+        end
     end
 
     class AlterTable # :nodoc:
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
index 321e08c5ca..8bb7362c2e 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
@@ -58,48 +58,48 @@ module ActiveRecord
 
       private
 
-      def default_primary_key?(column)
-        schema_type(column) == :integer
-      end
+        def default_primary_key?(column)
+          schema_type(column) == :integer
+        end
 
-      def schema_type(column)
-        if column.bigint?
-          :bigint
-        else
-          column.type
+        def schema_type(column)
+          if column.bigint?
+            :bigint
+          else
+            column.type
+          end
         end
-      end
 
-      def schema_limit(column)
-        limit = column.limit unless column.bigint?
-        limit.inspect if limit && limit != native_database_types[column.type][:limit]
-      end
+        def schema_limit(column)
+          limit = column.limit unless column.bigint?
+          limit.inspect if limit && limit != native_database_types[column.type][:limit]
+        end
 
-      def schema_precision(column)
-        column.precision.inspect if column.precision
-      end
+        def schema_precision(column)
+          column.precision.inspect if column.precision
+        end
 
-      def schema_scale(column)
-        column.scale.inspect if column.scale
-      end
+        def schema_scale(column)
+          column.scale.inspect if column.scale
+        end
 
-      def schema_default(column)
-        type = lookup_cast_type_from_column(column)
-        default = type.deserialize(column.default)
-        if default.nil?
-          schema_expression(column)
-        else
-          type.type_cast_for_schema(default)
+        def schema_default(column)
+          type = lookup_cast_type_from_column(column)
+          default = type.deserialize(column.default)
+          if default.nil?
+            schema_expression(column)
+          else
+            type.type_cast_for_schema(default)
+          end
         end
-      end
 
-      def schema_expression(column)
-        "-> { #{column.default_function.inspect} }" if column.default_function
-      end
+        def schema_expression(column)
+          "-> { #{column.default_function.inspect} }" if column.default_function
+        end
 
-      def schema_collation(column)
-        column.collation.inspect if column.collation
-      end
+        def schema_collation(column)
+          column.collation.inspect if column.collation
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
index f2134fe035..d2ebc36fff 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -1245,49 +1245,49 @@ module ActiveRecord
         end
 
       private
-      def create_table_definition(*args)
-        TableDefinition.new(*args)
-      end
-
-      def create_alter_table(name)
-        AlterTable.new create_table_definition(name)
-      end
+        def create_table_definition(*args)
+          TableDefinition.new(*args)
+        end
 
-      def index_name_options(column_names) # :nodoc:
-        if column_names.is_a?(String)
-          column_names = column_names.scan(/\w+/).join("_")
+        def create_alter_table(name)
+          AlterTable.new create_table_definition(name)
         end
 
-        { column: column_names }
-      end
+        def index_name_options(column_names) # :nodoc:
+          if column_names.is_a?(String)
+            column_names = column_names.scan(/\w+/).join("_")
+          end
 
-      def foreign_key_name(table_name, options) # :nodoc:
-        identifier = "#{table_name}_#{options.fetch(:column)}_fk"
-        hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
-        options.fetch(:name) do
-          "fk_rails_#{hashed_identifier}"
+          { column: column_names }
+        end
+
+        def foreign_key_name(table_name, options) # :nodoc:
+          identifier = "#{table_name}_#{options.fetch(:column)}_fk"
+          hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+          options.fetch(:name) do
+            "fk_rails_#{hashed_identifier}"
+          end
         end
-      end
 
-      def validate_index_length!(table_name, new_name, internal = false) # :nodoc:
-        max_index_length = internal ? index_name_length : allowed_index_name_length
+        def validate_index_length!(table_name, new_name, internal = false) # :nodoc:
+          max_index_length = internal ? index_name_length : allowed_index_name_length
 
-        if new_name.length > max_index_length
-          raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{allowed_index_name_length} characters"
+          if new_name.length > max_index_length
+            raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{allowed_index_name_length} characters"
+          end
         end
-      end
 
-      def extract_new_default_value(default_or_changes)
-        if default_or_changes.is_a?(Hash) && default_or_changes.has_key?(:from) && default_or_changes.has_key?(:to)
-          default_or_changes[:to]
-        else
-          default_or_changes
+        def extract_new_default_value(default_or_changes)
+          if default_or_changes.is_a?(Hash) && default_or_changes.has_key?(:from) && default_or_changes.has_key?(:to)
+            default_or_changes[:to]
+          else
+            default_or_changes
+          end
         end
-      end
 
-      def can_remove_index_by_name?(options)
-        options.is_a?(Hash) && options.key?(:name) && options.except(:name, :algorithm).empty?
-      end
+        def can_remove_index_by_name?(options)
+          options.is_a?(Hash) && options.key?(:name) && options.except(:name, :algorithm).empty?
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 7ba3b5f43b..8a2a1fafb1 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -497,115 +497,115 @@ module ActiveRecord
 
       protected
 
-      def initialize_type_map(m) # :nodoc:
-        register_class_with_limit m, %r(boolean)i,       Type::Boolean
-        register_class_with_limit m, %r(char)i,          Type::String
-        register_class_with_limit m, %r(binary)i,        Type::Binary
-        register_class_with_limit m, %r(text)i,          Type::Text
-        register_class_with_precision m, %r(date)i,      Type::Date
-        register_class_with_precision m, %r(time)i,      Type::Time
-        register_class_with_precision m, %r(datetime)i,  Type::DateTime
-        register_class_with_limit m, %r(float)i,         Type::Float
-        register_class_with_limit m, %r(int)i,           Type::Integer
-
-        m.alias_type %r(blob)i,      "binary"
-        m.alias_type %r(clob)i,      "text"
-        m.alias_type %r(timestamp)i, "datetime"
-        m.alias_type %r(numeric)i,   "decimal"
-        m.alias_type %r(number)i,    "decimal"
-        m.alias_type %r(double)i,    "float"
-
-        m.register_type(%r(decimal)i) do |sql_type|
-          scale = extract_scale(sql_type)
-          precision = extract_precision(sql_type)
-
-          if scale == 0
-            # FIXME: Remove this class as well
-            Type::DecimalWithoutScale.new(precision: precision)
-          else
-            Type::Decimal.new(precision: precision, scale: scale)
+        def initialize_type_map(m) # :nodoc:
+          register_class_with_limit m, %r(boolean)i,       Type::Boolean
+          register_class_with_limit m, %r(char)i,          Type::String
+          register_class_with_limit m, %r(binary)i,        Type::Binary
+          register_class_with_limit m, %r(text)i,          Type::Text
+          register_class_with_precision m, %r(date)i,      Type::Date
+          register_class_with_precision m, %r(time)i,      Type::Time
+          register_class_with_precision m, %r(datetime)i,  Type::DateTime
+          register_class_with_limit m, %r(float)i,         Type::Float
+          register_class_with_limit m, %r(int)i,           Type::Integer
+
+          m.alias_type %r(blob)i,      "binary"
+          m.alias_type %r(clob)i,      "text"
+          m.alias_type %r(timestamp)i, "datetime"
+          m.alias_type %r(numeric)i,   "decimal"
+          m.alias_type %r(number)i,    "decimal"
+          m.alias_type %r(double)i,    "float"
+
+          m.register_type(%r(decimal)i) do |sql_type|
+            scale = extract_scale(sql_type)
+            precision = extract_precision(sql_type)
+
+            if scale == 0
+              # FIXME: Remove this class as well
+              Type::DecimalWithoutScale.new(precision: precision)
+            else
+              Type::Decimal.new(precision: precision, scale: scale)
+            end
           end
         end
-      end
-
-      def reload_type_map # :nodoc:
-        type_map.clear
-        initialize_type_map(type_map)
-      end
 
-      def register_class_with_limit(mapping, key, klass) # :nodoc:
-        mapping.register_type(key) do |*args|
-          limit = extract_limit(args.last)
-          klass.new(limit: limit)
+        def reload_type_map # :nodoc:
+          type_map.clear
+          initialize_type_map(type_map)
         end
-      end
 
-      def register_class_with_precision(mapping, key, klass) # :nodoc:
-        mapping.register_type(key) do |*args|
-          precision = extract_precision(args.last)
-          klass.new(precision: precision)
+        def register_class_with_limit(mapping, key, klass) # :nodoc:
+          mapping.register_type(key) do |*args|
+            limit = extract_limit(args.last)
+            klass.new(limit: limit)
+          end
         end
-      end
 
-      def extract_scale(sql_type) # :nodoc:
-        case sql_type
-          when /\((\d+)\)/ then 0
-          when /\((\d+)(,(\d+))\)/ then $3.to_i
+        def register_class_with_precision(mapping, key, klass) # :nodoc:
+          mapping.register_type(key) do |*args|
+            precision = extract_precision(args.last)
+            klass.new(precision: precision)
+          end
         end
-      end
 
-      def extract_precision(sql_type) # :nodoc:
-        $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
-      end
+        def extract_scale(sql_type) # :nodoc:
+          case sql_type
+            when /\((\d+)\)/ then 0
+            when /\((\d+)(,(\d+))\)/ then $3.to_i
+          end
+        end
 
-      def extract_limit(sql_type) # :nodoc:
-        case sql_type
-        when /^bigint/i
-          8
-        when /\((.*)\)/
-          $1.to_i
+        def extract_precision(sql_type) # :nodoc:
+          $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
         end
-      end
 
-      def translate_exception_class(e, sql)
-        begin
-          message = "#{e.class.name}: #{e.message}: #{sql}"
-        rescue Encoding::CompatibilityError
-          message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+        def extract_limit(sql_type) # :nodoc:
+          case sql_type
+          when /^bigint/i
+            8
+          when /\((.*)\)/
+            $1.to_i
+          end
         end
 
-        exception = translate_exception(e, message)
-        exception.set_backtrace e.backtrace
-        exception
-      end
+        def translate_exception_class(e, sql)
+          begin
+            message = "#{e.class.name}: #{e.message}: #{sql}"
+          rescue Encoding::CompatibilityError
+            message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+          end
 
-      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
-        @instrumenter.instrument(
-          "sql.active_record",
-          sql:               sql,
-          name:              name,
-          binds:             binds,
-          type_casted_binds: type_casted_binds,
-          statement_name:    statement_name,
-          connection_id:     object_id) { yield }
-      rescue => e
-        raise translate_exception_class(e, sql)
-      end
+          exception = translate_exception(e, message)
+          exception.set_backtrace e.backtrace
+          exception
+        end
 
-      def translate_exception(exception, message)
-        # override in derived class
-        ActiveRecord::StatementInvalid.new(message)
-      end
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+          @instrumenter.instrument(
+            "sql.active_record",
+            sql:               sql,
+            name:              name,
+            binds:             binds,
+            type_casted_binds: type_casted_binds,
+            statement_name:    statement_name,
+            connection_id:     object_id) { yield }
+        rescue => e
+          raise translate_exception_class(e, sql)
+        end
 
-      def without_prepared_statement?(binds)
-        !prepared_statements || binds.empty?
-      end
+        def translate_exception(exception, message)
+          # override in derived class
+          ActiveRecord::StatementInvalid.new(message)
+        end
 
-      def column_for(table_name, column_name) # :nodoc:
-        column_name = column_name.to_s
-        columns(table_name).detect { |c| c.name == column_name } ||
-          raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
-      end
+        def without_prepared_statement?(binds)
+          !prepared_statements || binds.empty?
+        end
+
+        def column_for(table_name, column_name) # :nodoc:
+          column_name = column_name.to_s
+          columns(table_name).detect { |c| c.name == column_name } ||
+            raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
index 8ac8996d21..bea8d8dda6 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -651,340 +651,340 @@ module ActiveRecord
 
       protected
 
-      def initialize_type_map(m) # :nodoc:
-        super
-
-        register_class_with_limit m, %r(char)i, MysqlString
-
-        m.register_type %r(tinytext)i,   Type::Text.new(limit: 2**8 - 1)
-        m.register_type %r(tinyblob)i,   Type::Binary.new(limit: 2**8 - 1)
-        m.register_type %r(text)i,       Type::Text.new(limit: 2**16 - 1)
-        m.register_type %r(blob)i,       Type::Binary.new(limit: 2**16 - 1)
-        m.register_type %r(mediumtext)i, Type::Text.new(limit: 2**24 - 1)
-        m.register_type %r(mediumblob)i, Type::Binary.new(limit: 2**24 - 1)
-        m.register_type %r(longtext)i,   Type::Text.new(limit: 2**32 - 1)
-        m.register_type %r(longblob)i,   Type::Binary.new(limit: 2**32 - 1)
-        m.register_type %r(^float)i,     Type::Float.new(limit: 24)
-        m.register_type %r(^double)i,    Type::Float.new(limit: 53)
-        m.register_type %r(^json)i,      MysqlJson.new
-
-        register_integer_type m, %r(^bigint)i,    limit: 8
-        register_integer_type m, %r(^int)i,       limit: 4
-        register_integer_type m, %r(^mediumint)i, limit: 3
-        register_integer_type m, %r(^smallint)i,  limit: 2
-        register_integer_type m, %r(^tinyint)i,   limit: 1
-
-        m.register_type %r(^tinyint\(1\))i, Type::Boolean.new if emulate_booleans
-        m.alias_type %r(year)i,          "integer"
-        m.alias_type %r(bit)i,           "binary"
-
-        m.register_type(%r(enum)i) do |sql_type|
-          limit = sql_type[/^enum\((.+)\)/i, 1]
-            .split(",").map{|enum| enum.strip.length - 2}.max
-          MysqlString.new(limit: limit)
-        end
-
-        m.register_type(%r(^set)i) do |sql_type|
-          limit = sql_type[/^set\((.+)\)/i, 1]
-            .split(",").map{|set| set.strip.length - 1}.sum - 1
-          MysqlString.new(limit: limit)
-        end
-      end
-
-      def register_integer_type(mapping, key, options) # :nodoc:
-        mapping.register_type(key) do |sql_type|
-          if /\bunsigned\z/ === sql_type
-            Type::UnsignedInteger.new(options)
-          else
-            Type::Integer.new(options)
+        def initialize_type_map(m) # :nodoc:
+          super
+
+          register_class_with_limit m, %r(char)i, MysqlString
+
+          m.register_type %r(tinytext)i,   Type::Text.new(limit: 2**8 - 1)
+          m.register_type %r(tinyblob)i,   Type::Binary.new(limit: 2**8 - 1)
+          m.register_type %r(text)i,       Type::Text.new(limit: 2**16 - 1)
+          m.register_type %r(blob)i,       Type::Binary.new(limit: 2**16 - 1)
+          m.register_type %r(mediumtext)i, Type::Text.new(limit: 2**24 - 1)
+          m.register_type %r(mediumblob)i, Type::Binary.new(limit: 2**24 - 1)
+          m.register_type %r(longtext)i,   Type::Text.new(limit: 2**32 - 1)
+          m.register_type %r(longblob)i,   Type::Binary.new(limit: 2**32 - 1)
+          m.register_type %r(^float)i,     Type::Float.new(limit: 24)
+          m.register_type %r(^double)i,    Type::Float.new(limit: 53)
+          m.register_type %r(^json)i,      MysqlJson.new
+
+          register_integer_type m, %r(^bigint)i,    limit: 8
+          register_integer_type m, %r(^int)i,       limit: 4
+          register_integer_type m, %r(^mediumint)i, limit: 3
+          register_integer_type m, %r(^smallint)i,  limit: 2
+          register_integer_type m, %r(^tinyint)i,   limit: 1
+
+          m.register_type %r(^tinyint\(1\))i, Type::Boolean.new if emulate_booleans
+          m.alias_type %r(year)i,          "integer"
+          m.alias_type %r(bit)i,           "binary"
+
+          m.register_type(%r(enum)i) do |sql_type|
+            limit = sql_type[/^enum\((.+)\)/i, 1]
+              .split(",").map{|enum| enum.strip.length - 2}.max
+            MysqlString.new(limit: limit)
           end
-        end
-      end
 
-      def extract_precision(sql_type)
-        if /time/ === sql_type
-          super || 0
-        else
-          super
+          m.register_type(%r(^set)i) do |sql_type|
+            limit = sql_type[/^set\((.+)\)/i, 1]
+              .split(",").map{|set| set.strip.length - 1}.sum - 1
+            MysqlString.new(limit: limit)
+          end
         end
-      end
 
-      def fetch_type_metadata(sql_type, extra = "")
-        MySQL::TypeMetadata.new(super(sql_type), extra: extra, strict: strict_mode?)
-      end
+        def register_integer_type(mapping, key, options) # :nodoc:
+          mapping.register_type(key) do |sql_type|
+            if /\bunsigned\z/ === sql_type
+              Type::UnsignedInteger.new(options)
+            else
+              Type::Integer.new(options)
+            end
+          end
+        end
 
-      def add_index_length(option_strings, column_names, options = {})
-        if options.is_a?(Hash) && length = options[:length]
-          case length
-          when Hash
-            column_names.each {|name| option_strings[name] += "(#{length[name]})" if length.has_key?(name) && length[name].present?}
-          when Integer
-            column_names.each {|name| option_strings[name] += "(#{length})"}
+        def extract_precision(sql_type)
+          if /time/ === sql_type
+            super || 0
+          else
+            super
           end
         end
 
-        return option_strings
-      end
+        def fetch_type_metadata(sql_type, extra = "")
+          MySQL::TypeMetadata.new(super(sql_type), extra: extra, strict: strict_mode?)
+        end
 
-      def quoted_columns_for_index(column_names, options = {})
-        option_strings = Hash[column_names.map {|name| [name, ""]}]
+        def add_index_length(option_strings, column_names, options = {})
+          if options.is_a?(Hash) && length = options[:length]
+            case length
+            when Hash
+              column_names.each {|name| option_strings[name] += "(#{length[name]})" if length.has_key?(name) && length[name].present?}
+            when Integer
+              column_names.each {|name| option_strings[name] += "(#{length})"}
+            end
+          end
 
-        # add index length
-        option_strings = add_index_length(option_strings, column_names, options)
+          return option_strings
+        end
 
-        # add index sort order
-        option_strings = add_index_sort_order(option_strings, column_names, options)
+        def quoted_columns_for_index(column_names, options = {})
+          option_strings = Hash[column_names.map {|name| [name, ""]}]
 
-        column_names.map {|name| quote_column_name(name) + option_strings[name]}
-      end
+          # add index length
+          option_strings = add_index_length(option_strings, column_names, options)
+
+          # add index sort order
+          option_strings = add_index_sort_order(option_strings, column_names, options)
+
+          column_names.map {|name| quote_column_name(name) + option_strings[name]}
+        end
 
       # See https://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
-      ER_DUP_ENTRY            = 1062
-      ER_NO_REFERENCED_ROW_2  = 1452
-      ER_DATA_TOO_LONG        = 1406
-      ER_LOCK_DEADLOCK        = 1213
-
-      def translate_exception(exception, message)
-        case error_number(exception)
-        when ER_DUP_ENTRY
-          RecordNotUnique.new(message)
-        when ER_NO_REFERENCED_ROW_2
-          InvalidForeignKey.new(message)
-        when ER_DATA_TOO_LONG
-          ValueTooLong.new(message)
-        when ER_LOCK_DEADLOCK
-          Deadlocked.new(message)
-        else
-          super
+        ER_DUP_ENTRY            = 1062
+        ER_NO_REFERENCED_ROW_2  = 1452
+        ER_DATA_TOO_LONG        = 1406
+        ER_LOCK_DEADLOCK        = 1213
+
+        def translate_exception(exception, message)
+          case error_number(exception)
+          when ER_DUP_ENTRY
+            RecordNotUnique.new(message)
+          when ER_NO_REFERENCED_ROW_2
+            InvalidForeignKey.new(message)
+          when ER_DATA_TOO_LONG
+            ValueTooLong.new(message)
+          when ER_LOCK_DEADLOCK
+            Deadlocked.new(message)
+          else
+            super
+          end
         end
-      end
 
-      def add_column_sql(table_name, column_name, type, options = {})
-        td = create_table_definition(table_name)
-        cd = td.new_column_definition(column_name, type, options)
-        schema_creation.accept(AddColumnDefinition.new(cd))
-      end
+        def add_column_sql(table_name, column_name, type, options = {})
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column_name, type, options)
+          schema_creation.accept(AddColumnDefinition.new(cd))
+        end
 
-      def change_column_sql(table_name, column_name, type, options = {})
-        column = column_for(table_name, column_name)
+        def change_column_sql(table_name, column_name, type, options = {})
+          column = column_for(table_name, column_name)
 
-        unless options_include_default?(options)
-          options[:default] = column.default
-        end
+          unless options_include_default?(options)
+            options[:default] = column.default
+          end
 
-        unless options.has_key?(:null)
-          options[:null] = column.null
-        end
+          unless options.has_key?(:null)
+            options[:null] = column.null
+          end
 
-        td = create_table_definition(table_name)
-        cd = td.new_column_definition(column.name, type, options)
-        schema_creation.accept(ChangeColumnDefinition.new(cd, column.name))
-      end
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column.name, type, options)
+          schema_creation.accept(ChangeColumnDefinition.new(cd, column.name))
+        end
 
-      def rename_column_sql(table_name, column_name, new_column_name)
-        column  = column_for(table_name, column_name)
-        options = {
-          default: column.default,
-          null: column.null,
-          auto_increment: column.auto_increment?
-        }
+        def rename_column_sql(table_name, column_name, new_column_name)
+          column  = column_for(table_name, column_name)
+          options = {
+            default: column.default,
+            null: column.null,
+            auto_increment: column.auto_increment?
+          }
 
-        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", "SCHEMA")["Type"]
-        td = create_table_definition(table_name)
-        cd = td.new_column_definition(new_column_name, current_type, options)
-        schema_creation.accept(ChangeColumnDefinition.new(cd, column.name))
-      end
+          current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", "SCHEMA")["Type"]
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(new_column_name, current_type, options)
+          schema_creation.accept(ChangeColumnDefinition.new(cd, column.name))
+        end
 
-      def remove_column_sql(table_name, column_name, type = nil, options = {})
-        "DROP #{quote_column_name(column_name)}"
-      end
+        def remove_column_sql(table_name, column_name, type = nil, options = {})
+          "DROP #{quote_column_name(column_name)}"
+        end
 
-      def remove_columns_sql(table_name, *column_names)
-        column_names.map {|column_name| remove_column_sql(table_name, column_name) }
-      end
+        def remove_columns_sql(table_name, *column_names)
+          column_names.map {|column_name| remove_column_sql(table_name, column_name) }
+        end
 
-      def add_index_sql(table_name, column_name, options = {})
-        index_name, index_type, index_columns, _, index_algorithm, index_using = add_index_options(table_name, column_name, options)
-        index_algorithm[0, 0] = ", " if index_algorithm.present?
-        "ADD #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_algorithm}"
-      end
+        def add_index_sql(table_name, column_name, options = {})
+          index_name, index_type, index_columns, _, index_algorithm, index_using = add_index_options(table_name, column_name, options)
+          index_algorithm[0, 0] = ", " if index_algorithm.present?
+          "ADD #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_algorithm}"
+        end
 
-      def remove_index_sql(table_name, options = {})
-        index_name = index_name_for_remove(table_name, options)
-        "DROP INDEX #{index_name}"
-      end
+        def remove_index_sql(table_name, options = {})
+          index_name = index_name_for_remove(table_name, options)
+          "DROP INDEX #{index_name}"
+        end
 
-      def add_timestamps_sql(table_name, options = {})
-        [add_column_sql(table_name, :created_at, :datetime, options), add_column_sql(table_name, :updated_at, :datetime, options)]
-      end
+        def add_timestamps_sql(table_name, options = {})
+          [add_column_sql(table_name, :created_at, :datetime, options), add_column_sql(table_name, :updated_at, :datetime, options)]
+        end
 
-      def remove_timestamps_sql(table_name, options = {})
-        [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
-      end
+        def remove_timestamps_sql(table_name, options = {})
+          [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
+        end
 
       private
 
       # MySQL is too stupid to create a temporary table for use subquery, so we have
       # to give it some prompting in the form of a subsubquery. Ugh!
-      def subquery_for(key, select)
-        subsubselect = select.clone
-        subsubselect.projections = [key]
+        def subquery_for(key, select)
+          subsubselect = select.clone
+          subsubselect.projections = [key]
 
-        # Materialize subquery by adding distinct
-        # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
-        subsubselect.distinct unless select.limit || select.offset || select.orders.any?
+          # Materialize subquery by adding distinct
+          # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
+          subsubselect.distinct unless select.limit || select.offset || select.orders.any?
 
-        subselect = Arel::SelectManager.new(select.engine)
-        subselect.project Arel.sql(key.name)
-        subselect.from subsubselect.as("__active_record_temp")
-      end
+          subselect = Arel::SelectManager.new(select.engine)
+          subselect.project Arel.sql(key.name)
+          subselect.from subsubselect.as("__active_record_temp")
+        end
 
-      def supports_rename_index?
-        mariadb? ? false : version >= "5.7.6"
-      end
+        def supports_rename_index?
+          mariadb? ? false : version >= "5.7.6"
+        end
 
-      def configure_connection
-        variables = @config.fetch(:variables, {}).stringify_keys
+        def configure_connection
+          variables = @config.fetch(:variables, {}).stringify_keys
 
-        # By default, MySQL 'where id is null' selects the last inserted id; Turn this off.
-        variables["sql_auto_is_null"] = 0
+          # By default, MySQL 'where id is null' selects the last inserted id; Turn this off.
+          variables["sql_auto_is_null"] = 0
 
-        # Increase timeout so the server doesn't disconnect us.
-        wait_timeout = @config[:wait_timeout]
-        wait_timeout = 2147483 unless wait_timeout.is_a?(Integer)
-        variables["wait_timeout"] = self.class.type_cast_config_to_integer(wait_timeout)
+          # Increase timeout so the server doesn't disconnect us.
+          wait_timeout = @config[:wait_timeout]
+          wait_timeout = 2147483 unless wait_timeout.is_a?(Integer)
+          variables["wait_timeout"] = self.class.type_cast_config_to_integer(wait_timeout)
 
-        defaults = [":default", :default].to_set
+          defaults = [":default", :default].to_set
 
-        # Make MySQL reject illegal values rather than truncating or blanking them, see
-        # http://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_strict_all_tables
-        # If the user has provided another value for sql_mode, don't replace it.
-        if sql_mode = variables.delete("sql_mode")
-          sql_mode = quote(sql_mode)
-        elsif !defaults.include?(strict_mode?)
-          if strict_mode?
-            sql_mode = "CONCAT(@@sql_mode, ',STRICT_ALL_TABLES')"
-          else
-            sql_mode = "REPLACE(@@sql_mode, 'STRICT_TRANS_TABLES', '')"
-            sql_mode = "REPLACE(#{sql_mode}, 'STRICT_ALL_TABLES', '')"
-            sql_mode = "REPLACE(#{sql_mode}, 'TRADITIONAL', '')"
+          # Make MySQL reject illegal values rather than truncating or blanking them, see
+          # http://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_strict_all_tables
+          # If the user has provided another value for sql_mode, don't replace it.
+          if sql_mode = variables.delete("sql_mode")
+            sql_mode = quote(sql_mode)
+          elsif !defaults.include?(strict_mode?)
+            if strict_mode?
+              sql_mode = "CONCAT(@@sql_mode, ',STRICT_ALL_TABLES')"
+            else
+              sql_mode = "REPLACE(@@sql_mode, 'STRICT_TRANS_TABLES', '')"
+              sql_mode = "REPLACE(#{sql_mode}, 'STRICT_ALL_TABLES', '')"
+              sql_mode = "REPLACE(#{sql_mode}, 'TRADITIONAL', '')"
+            end
+            sql_mode = "CONCAT(#{sql_mode}, ',NO_AUTO_VALUE_ON_ZERO')"
           end
-          sql_mode = "CONCAT(#{sql_mode}, ',NO_AUTO_VALUE_ON_ZERO')"
-        end
-        sql_mode_assignment = "@@SESSION.sql_mode = #{sql_mode}, " if sql_mode
-
-        # NAMES does not have an equals sign, see
-        # http://dev.mysql.com/doc/refman/5.7/en/set-statement.html#id944430
-        # (trailing comma because variable_assignments will always have content)
-        if @config[:encoding]
-          encoding = "NAMES #{@config[:encoding]}"
-          encoding << " COLLATE #{@config[:collation]}" if @config[:collation]
-          encoding << ", "
-        end
-
-        # Gather up all of the SET variables...
-        variable_assignments = variables.map do |k, v|
-          if defaults.include?(v)
-            "@@SESSION.#{k} = DEFAULT" # Sets the value to the global or compile default
-          elsif !v.nil?
-            "@@SESSION.#{k} = #{quote(v)}"
+          sql_mode_assignment = "@@SESSION.sql_mode = #{sql_mode}, " if sql_mode
+
+          # NAMES does not have an equals sign, see
+          # http://dev.mysql.com/doc/refman/5.7/en/set-statement.html#id944430
+          # (trailing comma because variable_assignments will always have content)
+          if @config[:encoding]
+            encoding = "NAMES #{@config[:encoding]}"
+            encoding << " COLLATE #{@config[:collation]}" if @config[:collation]
+            encoding << ", "
           end
-          # or else nil; compact to clear nils out
-        end.compact.join(", ")
 
-        # ...and send them all in one query
-        @connection.query  "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}"
-      end
+          # Gather up all of the SET variables...
+          variable_assignments = variables.map do |k, v|
+            if defaults.include?(v)
+              "@@SESSION.#{k} = DEFAULT" # Sets the value to the global or compile default
+            elsif !v.nil?
+              "@@SESSION.#{k} = #{quote(v)}"
+            end
+            # or else nil; compact to clear nils out
+          end.compact.join(", ")
 
-      def column_definitions(table_name) # :nodoc:
-        execute_and_free("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
-          each_hash(result)
+          # ...and send them all in one query
+          @connection.query  "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}"
         end
-      end
 
-      def extract_foreign_key_action(specifier) # :nodoc:
-        case specifier
-        when "CASCADE"; :cascade
-        when "SET NULL"; :nullify
+        def column_definitions(table_name) # :nodoc:
+          execute_and_free("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
+            each_hash(result)
+          end
         end
-      end
-
-      def create_table_info(table_name) # :nodoc:
-        select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
-      end
 
-      def create_table_definition(*args) # :nodoc:
-        MySQL::TableDefinition.new(*args)
-      end
+        def extract_foreign_key_action(specifier) # :nodoc:
+          case specifier
+          when "CASCADE"; :cascade
+          when "SET NULL"; :nullify
+          end
+        end
 
-      def extract_schema_qualified_name(string) # :nodoc:
-        schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
-        schema, name = @config[:database], schema unless name
-        [schema, name]
-      end
+        def create_table_info(table_name) # :nodoc:
+          select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
+        end
 
-      def integer_to_sql(limit) # :nodoc:
-        case limit
-        when 1; "tinyint"
-        when 2; "smallint"
-        when 3; "mediumint"
-        when nil, 4; "int"
-        when 5..8; "bigint"
-        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+        def create_table_definition(*args) # :nodoc:
+          MySQL::TableDefinition.new(*args)
         end
-      end
 
-      def text_to_sql(limit) # :nodoc:
-        case limit
-        when 0..0xff;               "tinytext"
-        when nil, 0x100..0xffff;    "text"
-        when 0x10000..0xffffff;     "mediumtext"
-        when 0x1000000..0xffffffff; "longtext"
-        else raise(ActiveRecordError, "No text type has byte length #{limit}")
+        def extract_schema_qualified_name(string) # :nodoc:
+          schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+          schema, name = @config[:database], schema unless name
+          [schema, name]
         end
-      end
 
-      def binary_to_sql(limit) # :nodoc:
-        case limit
-        when 0..0xff;               "tinyblob"
-        when nil, 0x100..0xffff;    "blob"
-        when 0x10000..0xffffff;     "mediumblob"
-        when 0x1000000..0xffffffff; "longblob"
-        else raise(ActiveRecordError, "No binary type has byte length #{limit}")
+        def integer_to_sql(limit) # :nodoc:
+          case limit
+          when 1; "tinyint"
+          when 2; "smallint"
+          when 3; "mediumint"
+          when nil, 4; "int"
+          when 5..8; "bigint"
+          else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+          end
         end
-      end
 
-      class MysqlJson < Type::Internal::AbstractJson # :nodoc:
-        def changed_in_place?(raw_old_value, new_value)
-          # Normalization is required because MySQL JSON data format includes
-          # the space between the elements.
-          super(serialize(deserialize(raw_old_value)), new_value)
+        def text_to_sql(limit) # :nodoc:
+          case limit
+          when 0..0xff;               "tinytext"
+          when nil, 0x100..0xffff;    "text"
+          when 0x10000..0xffffff;     "mediumtext"
+          when 0x1000000..0xffffffff; "longtext"
+          else raise(ActiveRecordError, "No text type has byte length #{limit}")
+          end
         end
-      end
 
-      class MysqlString < Type::String # :nodoc:
-        def serialize(value)
-          case value
-          when true then MySQL::Quoting::QUOTED_TRUE
-          when false then MySQL::Quoting::QUOTED_FALSE
-          else super
+        def binary_to_sql(limit) # :nodoc:
+          case limit
+          when 0..0xff;               "tinyblob"
+          when nil, 0x100..0xffff;    "blob"
+          when 0x10000..0xffffff;     "mediumblob"
+          when 0x1000000..0xffffffff; "longblob"
+          else raise(ActiveRecordError, "No binary type has byte length #{limit}")
           end
         end
 
-        private
+        class MysqlJson < Type::Internal::AbstractJson # :nodoc:
+          def changed_in_place?(raw_old_value, new_value)
+            # Normalization is required because MySQL JSON data format includes
+            # the space between the elements.
+            super(serialize(deserialize(raw_old_value)), new_value)
+          end
+        end
 
-        def cast_value(value)
-          case value
-          when true then MySQL::Quoting::QUOTED_TRUE
-          when false then MySQL::Quoting::QUOTED_FALSE
-          else super
+        class MysqlString < Type::String # :nodoc:
+          def serialize(value)
+            case value
+            when true then MySQL::Quoting::QUOTED_TRUE
+            when false then MySQL::Quoting::QUOTED_FALSE
+            else super
+            end
           end
+
+          private
+
+            def cast_value(value)
+              case value
+              when true then MySQL::Quoting::QUOTED_TRUE
+              when false then MySQL::Quoting::QUOTED_FALSE
+              else super
+              end
+            end
         end
-      end
 
-      ActiveRecord::Type.register(:json, MysqlJson, adapter: :mysql2)
-      ActiveRecord::Type.register(:string, MysqlString, adapter: :mysql2)
-      ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :mysql2)
+        ActiveRecord::Type.register(:json, MysqlJson, adapter: :mysql2)
+        ActiveRecord::Type.register(:string, MysqlString, adapter: :mysql2)
+        ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :mysql2)
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
index 28f0c8686a..1808173592 100644
--- a/activerecord/lib/active_record/connection_adapters/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -52,9 +52,9 @@ module ActiveRecord
 
       protected
 
-      def attributes_for_hash
-        [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
-      end
+        def attributes_for_hash
+          [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
+        end
     end
 
     class NullColumn < Column
diff --git a/activerecord/lib/active_record/connection_adapters/connection_specification.rb b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
index 996075e08a..c0c7ce46b2 100644
--- a/activerecord/lib/active_record/connection_adapters/connection_specification.rb
+++ b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
@@ -56,13 +56,13 @@ module ActiveRecord
 
         private
 
-        def uri
-          @uri
-        end
+          def uri
+            @uri
+          end
 
-        def uri_parser
-          @uri_parser ||= URI::Parser.new
-        end
+          def uri_parser
+            @uri_parser ||= URI::Parser.new
+          end
 
         # Converts the query parameters of the URI into a hash.
         #
@@ -73,39 +73,39 @@ module ActiveRecord
         #
         #   "localhost"
         #   # => {}
-        def query_hash
-          Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
-        end
+          def query_hash
+            Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
+          end
 
-        def raw_config
-          if uri.opaque
-            query_hash.merge(              "adapter"  => @adapter,
-              "database" => uri.opaque)
-          else
-            query_hash.merge(              "adapter"  => @adapter,
-              "username" => uri.user,
-              "password" => uri.password,
-              "port"     => uri.port,
-              "database" => database_from_path,
-              "host"     => uri.hostname)
+          def raw_config
+            if uri.opaque
+              query_hash.merge(              "adapter"  => @adapter,
+                "database" => uri.opaque)
+            else
+              query_hash.merge(              "adapter"  => @adapter,
+                "username" => uri.user,
+                "password" => uri.password,
+                "port"     => uri.port,
+                "database" => database_from_path,
+                "host"     => uri.hostname)
+            end
           end
-        end
 
         # Returns name of the database.
-        def database_from_path
-          if @adapter == "sqlite3"
-            # 'sqlite3:/foo' is absolute, because that makes sense. The
-            # corresponding relative version, 'sqlite3:foo', is handled
-            # elsewhere, as an "opaque".
+          def database_from_path
+            if @adapter == "sqlite3"
+              # 'sqlite3:/foo' is absolute, because that makes sense. The
+              # corresponding relative version, 'sqlite3:foo', is handled
+              # elsewhere, as an "opaque".
 
-            uri.path
-          else
-            # Only SQLite uses a filename as the "database" name; for
-            # anything else, a leading slash would be silly.
+              uri.path
+            else
+              # Only SQLite uses a filename as the "database" name; for
+              # anything else, a leading slash would be silly.
 
-            uri.path.sub(%r{^/}, "")
+              uri.path.sub(%r{^/}, "")
+            end
           end
-        end
       end
 
       ##
@@ -211,16 +211,16 @@ module ActiveRecord
         #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
         #
-        def resolve_connection(spec)
-          case spec
-          when Symbol
-            resolve_symbol_connection spec
-          when String
-            resolve_url_connection spec
-          when Hash
-            resolve_hash_connection spec
+          def resolve_connection(spec)
+            case spec
+            when Symbol
+              resolve_symbol_connection spec
+            when String
+              resolve_url_connection spec
+            when Hash
+              resolve_hash_connection spec
+            end
           end
-        end
 
         # Takes the environment such as +:production+ or +:development+.
         # This requires that the @configurations was initialized with a key that
@@ -229,34 +229,34 @@ module ActiveRecord
         #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
         #   # => {}
         #
-        def resolve_symbol_connection(spec)
-          if config = configurations[spec.to_s]
-            resolve_connection(config).merge("name" => spec.to_s)
-          else
-            raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+          def resolve_symbol_connection(spec)
+            if config = configurations[spec.to_s]
+              resolve_connection(config).merge("name" => spec.to_s)
+            else
+              raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+            end
           end
-        end
 
         # Accepts a hash. Expands the "url" key that contains a
         # URL database connection to a full connection
         # hash and merges with the rest of the hash.
         # Connection details inside of the "url" key win any merge conflicts
-        def resolve_hash_connection(spec)
-          if spec["url"] && spec["url"] !~ /^jdbc:/
-            connection_hash = resolve_url_connection(spec.delete("url"))
-            spec.merge!(connection_hash)
+          def resolve_hash_connection(spec)
+            if spec["url"] && spec["url"] !~ /^jdbc:/
+              connection_hash = resolve_url_connection(spec.delete("url"))
+              spec.merge!(connection_hash)
+            end
+            spec
           end
-          spec
-        end
 
         # Takes a connection URL.
         #
         #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
         #
-        def resolve_url_connection(url)
-          ConnectionUrlResolver.new(url).to_hash
-        end
+          def resolve_url_connection(url)
+            ConnectionUrlResolver.new(url).to_hash
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/column.rb b/activerecord/lib/active_record/connection_adapters/mysql/column.rb
index cb068a61c7..5452e44c84 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/column.rb
@@ -32,11 +32,11 @@ module ActiveRecord
 
         private
 
-        def extract_default
-          if blob_or_text_column?
-            @default = null || strict ? nil : ""
+          def extract_default
+            if blob_or_text_column?
+              @default = null || strict ? nil : ""
+            end
           end
-        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb b/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb
index cd606d11a7..c8238eb266 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb
@@ -56,56 +56,56 @@ module ActiveRecord
 
         protected
 
-        def last_inserted_id(result)
-          @connection.last_id
-        end
+          def last_inserted_id(result)
+            @connection.last_id
+          end
 
         private
 
-        def select_result(sql, name = nil, binds = [])
-          if without_prepared_statement?(binds)
-            execute_and_free(sql, name) { |result| yield result }
-          else
-            exec_stmt_and_free(sql, name, binds, cache_stmt: true) { |_, result| yield result }
-          end
-        end
-
-        def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
-          if @connection
-            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
-            # made since we established the connection
-            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+          def select_result(sql, name = nil, binds = [])
+            if without_prepared_statement?(binds)
+              execute_and_free(sql, name) { |result| yield result }
+            else
+              exec_stmt_and_free(sql, name, binds, cache_stmt: true) { |_, result| yield result }
+            end
           end
 
-          type_casted_binds = type_casted_binds(binds)
-
-          log(sql, name, binds, type_casted_binds) do
-            if cache_stmt
-              cache = @statements[sql] ||= {
-                stmt: @connection.prepare(sql)
-              }
-              stmt = cache[:stmt]
-            else
-              stmt = @connection.prepare(sql)
+          def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
+            if @connection
+              # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+              # made since we established the connection
+              @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
             end
 
-            begin
-              result = stmt.execute(*type_casted_binds)
-            rescue Mysql2::Error => e
+            type_casted_binds = type_casted_binds(binds)
+
+            log(sql, name, binds, type_casted_binds) do
               if cache_stmt
-                @statements.delete(sql)
+                cache = @statements[sql] ||= {
+                  stmt: @connection.prepare(sql)
+                }
+                stmt = cache[:stmt]
               else
-                stmt.close
+                stmt = @connection.prepare(sql)
+              end
+
+              begin
+                result = stmt.execute(*type_casted_binds)
+              rescue Mysql2::Error => e
+                if cache_stmt
+                  @statements.delete(sql)
+                else
+                  stmt.close
+                end
+                raise e
               end
-              raise e
-            end
 
-            ret = yield stmt, result
-            result.free if result
-            stmt.close unless cache_stmt
-            ret
+              ret = yield stmt, result
+              result.free if result
+              stmt.close unless cache_stmt
+              ret
+            end
           end
-        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb b/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
index 5a6b33cb04..0b7dea232f 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
@@ -36,34 +36,34 @@ module ActiveRecord
 
         private
 
-        def compute_column_widths(result)
-          [].tap do |widths|
-            result.columns.each_with_index do |column, i|
-              cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? "NULL" : r[i].to_s}
-              widths << cells_in_column.map(&:length).max
+          def compute_column_widths(result)
+            [].tap do |widths|
+              result.columns.each_with_index do |column, i|
+                cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? "NULL" : r[i].to_s}
+                widths << cells_in_column.map(&:length).max
+              end
             end
           end
-        end
 
-        def build_separator(widths)
-          padding = 1
-          "+" + widths.map {|w| "-" * (w + (padding*2))}.join("+") + "+"
-        end
+          def build_separator(widths)
+            padding = 1
+            "+" + widths.map {|w| "-" * (w + (padding*2))}.join("+") + "+"
+          end
 
-        def build_cells(items, widths)
-          cells = []
-          items.each_with_index do |item, i|
-            item = "NULL" if item.nil?
-            justifier = item.is_a?(Numeric) ? "rjust" : "ljust"
-            cells << item.to_s.send(justifier, widths[i])
+          def build_cells(items, widths)
+            cells = []
+            items.each_with_index do |item, i|
+              item = "NULL" if item.nil?
+              justifier = item.is_a?(Numeric) ? "rjust" : "ljust"
+              cells << item.to_s.send(justifier, widths[i])
+            end
+            "| " + cells.join(" | ") + " |"
           end
-          "| " + cells.join(" | ") + " |"
-        end
 
-        def build_footer(nrows, elapsed)
-          rows_label = nrows == 1 ? "row" : "rows"
-          "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
-        end
+          def build_footer(nrows, elapsed)
+            rows_label = nrows == 1 ? "row" : "rows"
+            "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb b/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb
index 381787868b..9d11ad28d4 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb
@@ -38,13 +38,13 @@ module ActiveRecord
 
         private
 
-        def _quote(value)
-          if value.is_a?(Type::Binary::Data)
-            "x'#{value.hex}'"
-          else
-            super
+          def _quote(value)
+            if value.is_a?(Type::Binary::Data)
+              "x'#{value.hex}'"
+            else
+              super
+            end
           end
-        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb b/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb
index fd2dc2aee8..d808b50332 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb
@@ -7,60 +7,60 @@ module ActiveRecord
 
         private
 
-        def visit_DropForeignKey(name)
-          "DROP FOREIGN KEY #{name}"
-        end
-
-        def visit_ColumnDefinition(o)
-          o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.unsigned)
-          super
-        end
-
-        def visit_AddColumnDefinition(o)
-          add_column_position!(super, column_options(o.column))
-        end
+          def visit_DropForeignKey(name)
+            "DROP FOREIGN KEY #{name}"
+          end
 
-        def visit_ChangeColumnDefinition(o)
-          change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
-          add_column_position!(change_column_sql, column_options(o.column))
-        end
+          def visit_ColumnDefinition(o)
+            o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.unsigned)
+            super
+          end
 
-        def add_table_options!(create_sql, options)
-          add_sql_comment!(super, options[:comment])
-        end
+          def visit_AddColumnDefinition(o)
+            add_column_position!(super, column_options(o.column))
+          end
 
-        def column_options(o)
-          column_options = super
-          column_options[:charset] = o.charset
-          column_options
-        end
+          def visit_ChangeColumnDefinition(o)
+            change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
+            add_column_position!(change_column_sql, column_options(o.column))
+          end
 
-        def add_column_options!(sql, options)
-          if charset = options[:charset]
-            sql << " CHARACTER SET #{charset}"
+          def add_table_options!(create_sql, options)
+            add_sql_comment!(super, options[:comment])
           end
 
-          if collation = options[:collation]
-            sql << " COLLATE #{collation}"
+          def column_options(o)
+            column_options = super
+            column_options[:charset] = o.charset
+            column_options
           end
 
-          add_sql_comment!(super, options[:comment])
-        end
+          def add_column_options!(sql, options)
+            if charset = options[:charset]
+              sql << " CHARACTER SET #{charset}"
+            end
+
+            if collation = options[:collation]
+              sql << " COLLATE #{collation}"
+            end
 
-        def add_column_position!(sql, options)
-          if options[:first]
-            sql << " FIRST"
-          elsif options[:after]
-            sql << " AFTER #{quote_column_name(options[:after])}"
+            add_sql_comment!(super, options[:comment])
           end
 
-          sql
-        end
+          def add_column_position!(sql, options)
+            if options[:first]
+              sql << " FIRST"
+            elsif options[:after]
+              sql << " AFTER #{quote_column_name(options[:after])}"
+            end
 
-        def index_in_create(table_name, column_name, options)
-          index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
-          add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})", comment)
-        end
+            sql
+          end
+
+          def index_in_create(table_name, column_name, options)
+            index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
+            add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})", comment)
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb
index 157e75dbf7..ce773ed75b 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb
@@ -80,9 +80,9 @@ module ActiveRecord
 
         private
 
-        def create_column_definition(name, type)
-          MySQL::ColumnDefinition.new(name, type)
-        end
+          def create_column_definition(name, type)
+            MySQL::ColumnDefinition.new(name, type)
+          end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb
index 3e644f386f..39221eeb0c 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb
@@ -25,29 +25,29 @@ module ActiveRecord
 
         private
 
-        def default_primary_key?(column)
-          super && column.auto_increment?
-        end
+          def default_primary_key?(column)
+            super && column.auto_increment?
+          end
 
-        def schema_type(column)
-          if column.sql_type == "tinyblob"
-            :blob
-          else
-            super
+          def schema_type(column)
+            if column.sql_type == "tinyblob"
+              :blob
+            else
+              super
+            end
           end
-        end
 
-        def schema_precision(column)
-          super unless /time/ === column.sql_type && column.precision == 0
-        end
+          def schema_precision(column)
+            super unless /time/ === column.sql_type && column.precision == 0
+          end
 
-        def schema_collation(column)
-          if column.collation && table_name = column.table_name
-            @table_collation_cache ||= {}
-            @table_collation_cache[table_name] ||= select_one("SHOW TABLE STATUS LIKE '#{table_name}'")["Collation"]
-            column.collation.inspect if column.collation != @table_collation_cache[table_name]
+          def schema_collation(column)
+            if column.collation && table_name = column.table_name
+              @table_collation_cache ||= {}
+              @table_collation_cache[table_name] ||= select_one("SHOW TABLE STATUS LIKE '#{table_name}'")["Collation"]
+              column.collation.inspect if column.collation != @table_collation_cache[table_name]
+            end
           end
-        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb b/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb
index e1e3f7b472..1be5cb4740 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb
@@ -23,9 +23,9 @@ module ActiveRecord
 
         protected
 
-        def attributes_for_hash
-          [self.class, @type_metadata, extra, strict]
-        end
+          def attributes_for_hash
+            [self.class, @type_metadata, extra, strict]
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index 154f0b2d3a..0130b4ef62 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -113,19 +113,19 @@ module ActiveRecord
 
       private
 
-      def connect
-        @connection = Mysql2::Client.new(@config)
-        configure_connection
-      end
+        def connect
+          @connection = Mysql2::Client.new(@config)
+          configure_connection
+        end
 
-      def configure_connection
-        @connection.query_options.merge!(as: :array)
-        super
-      end
+        def configure_connection
+          @connection.query_options.merge!(as: :array)
+          super
+        end
 
-      def full_version
-        @full_version ||= @connection.server_info[:version]
-      end
+        def full_version
+          @full_version ||= @connection.server_info[:version]
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb b/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb
index b5a3340c18..87338986b9 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb
@@ -169,9 +169,9 @@ module ActiveRecord
 
         private
 
-        def suppress_composite_primary_key(pk)
-          pk unless pk.is_a?(Array)
-        end
+          def suppress_composite_primary_key(pk)
+            pk unless pk.is_a?(Array)
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
index 9e0e6732c3..1a66afb23a 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
@@ -56,13 +56,13 @@ module ActiveRecord
 
           private
 
-          def type_cast_array(value, method)
-            if value.is_a?(::Array)
-              value.map { |item| type_cast_array(item, method) }
-            else
-              @subtype.public_send(method, value)
+            def type_cast_array(value, method)
+              if value.is_a?(::Array)
+                value.map { |item| type_cast_array(item, method) }
+              else
+                @subtype.public_send(method, value)
+              end
             end
-          end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
index ea0fa2517f..a6b5a89ec0 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
@@ -43,7 +43,7 @@ module ActiveRecord
 
             protected
 
-            attr_reader :value
+              attr_reader :value
           end
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb
index 91d339f32c..950d23d516 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb
@@ -9,9 +9,9 @@ module ActiveRecord
 
           private
 
-          def cast_value(value)
-            value.to_s
-          end
+            def cast_value(value)
+              value.to_s
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
index 2e55a5f8b8..2d3e6a925d 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
@@ -35,23 +35,23 @@ module ActiveRecord
 
           private
 
-          HstorePair = begin
-            quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
-            unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
-            /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
-          end
+            HstorePair = begin
+              quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+              unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+              /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
+            end
 
-          def escape_hstore(value)
-            if value.nil?
-              "NULL"
-            else
-              if value == ""
-                '""'
+            def escape_hstore(value)
+              if value.nil?
+                "NULL"
               else
-                '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+                if value == ""
+                  '""'
+                else
+                  '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+                end
               end
             end
-          end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
index 3657f20433..bb4db2564c 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
@@ -33,9 +33,9 @@ module ActiveRecord
 
           private
 
-          def number_for_point(number)
-            number.to_s.gsub(/\.0$/, "")
-          end
+            def number_for_point(number)
+              number.to_s.gsub(/\.0$/, "")
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/rails_5_1_point.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/rails_5_1_point.rb
index 3a52f05091..845ff5b6a9 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/rails_5_1_point.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/rails_5_1_point.rb
@@ -15,7 +15,7 @@ module ActiveRecord
             case value
             when ::String
               return if value.blank?
-              
+
               if value[0] == "(" && value[-1] == ")"
                 value = value[1...-1]
               end
@@ -38,13 +38,13 @@ module ActiveRecord
 
           private
 
-          def number_for_point(number)
-            number.to_s.gsub(/\.0$/, "")
-          end
+            def number_for_point(number)
+              number.to_s.gsub(/\.0$/, "")
+            end
 
-          def build_point(x, y)
-            ActiveRecord::Point.new(Float(x), Float(y))
-          end
+            def build_point(x, y)
+              ActiveRecord::Point.new(Float(x), Float(y))
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
index 58bf5c5640..2c714f4018 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
@@ -55,37 +55,37 @@ module ActiveRecord
 
           private
 
-          def type_cast_single(value)
-            infinity?(value) ? value : @subtype.deserialize(value)
-          end
+            def type_cast_single(value)
+              infinity?(value) ? value : @subtype.deserialize(value)
+            end
 
-          def type_cast_single_for_database(value)
-            infinity?(value) ? "" : @subtype.serialize(value)
-          end
+            def type_cast_single_for_database(value)
+              infinity?(value) ? "" : @subtype.serialize(value)
+            end
 
-          def extract_bounds(value)
-            from, to = value[1..-2].split(",")
-            {
-              from:          (value[1] == "," || from == "-infinity") ? infinity(negative: true) : from,
-              to:            (value[-2] == "," || to == "infinity") ? infinity : to,
-              exclude_start: (value[0] == "("),
-              exclude_end:   (value[-1] == ")")
-            }
-          end
+            def extract_bounds(value)
+              from, to = value[1..-2].split(",")
+              {
+                from:          (value[1] == "," || from == "-infinity") ? infinity(negative: true) : from,
+                to:            (value[-2] == "," || to == "infinity") ? infinity : to,
+                exclude_start: (value[0] == "("),
+                exclude_end:   (value[-1] == ")")
+              }
+            end
 
-          def infinity(negative: false)
-            if subtype.respond_to?(:infinity)
-              subtype.infinity(negative: negative)
-            elsif negative
-              -::Float::INFINITY
-            else
-              ::Float::INFINITY
+            def infinity(negative: false)
+              if subtype.respond_to?(:infinity)
+                subtype.infinity(negative: negative)
+              elsif negative
+                -::Float::INFINITY
+              else
+                ::Float::INFINITY
+              end
             end
-          end
 
-          def infinity?(value)
-            value.respond_to?(:infinite?) && value.infinite?
-          end
+            def infinity?(value)
+              value.respond_to?(:infinite?) && value.infinite?
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb
index 3a75e8d69d..d9ae1aa7a2 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb
@@ -42,66 +42,66 @@ module ActiveRecord
           end
 
           private
-          def register_mapped_type(row)
-            alias_type row["oid"], row["typname"]
-          end
+            def register_mapped_type(row)
+              alias_type row["oid"], row["typname"]
+            end
 
-          def register_enum_type(row)
-            register row["oid"], OID::Enum.new
-          end
+            def register_enum_type(row)
+              register row["oid"], OID::Enum.new
+            end
 
-          def register_array_type(row)
-            register_with_subtype(row["oid"], row["typelem"].to_i) do |subtype|
-              OID::Array.new(subtype, row["typdelim"])
+            def register_array_type(row)
+              register_with_subtype(row["oid"], row["typelem"].to_i) do |subtype|
+                OID::Array.new(subtype, row["typdelim"])
+              end
             end
-          end
 
-          def register_range_type(row)
-            register_with_subtype(row["oid"], row["rngsubtype"].to_i) do |subtype|
-              OID::Range.new(subtype, row["typname"].to_sym)
+            def register_range_type(row)
+              register_with_subtype(row["oid"], row["rngsubtype"].to_i) do |subtype|
+                OID::Range.new(subtype, row["typname"].to_sym)
+              end
             end
-          end
 
-          def register_domain_type(row)
-            if base_type = @store.lookup(row["typbasetype"].to_i)
-              register row["oid"], base_type
-            else
-              warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+            def register_domain_type(row)
+              if base_type = @store.lookup(row["typbasetype"].to_i)
+                register row["oid"], base_type
+              else
+                warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+              end
             end
-          end
 
-          def register_composite_type(row)
-            if subtype = @store.lookup(row["typelem"].to_i)
-              register row["oid"], OID::Vector.new(row["typdelim"], subtype)
+            def register_composite_type(row)
+              if subtype = @store.lookup(row["typelem"].to_i)
+                register row["oid"], OID::Vector.new(row["typdelim"], subtype)
+              end
             end
-          end
 
-          def register(oid, oid_type = nil, &block)
-            oid = assert_valid_registration(oid, oid_type || block)
-            if block_given?
-              @store.register_type(oid, &block)
-            else
-              @store.register_type(oid, oid_type)
+            def register(oid, oid_type = nil, &block)
+              oid = assert_valid_registration(oid, oid_type || block)
+              if block_given?
+                @store.register_type(oid, &block)
+              else
+                @store.register_type(oid, oid_type)
+              end
             end
-          end
 
-          def alias_type(oid, target)
-            oid = assert_valid_registration(oid, target)
-            @store.alias_type(oid, target)
-          end
+            def alias_type(oid, target)
+              oid = assert_valid_registration(oid, target)
+              @store.alias_type(oid, target)
+            end
 
-          def register_with_subtype(oid, target_oid)
-            if @store.key?(target_oid)
-              register(oid) do |_, *args|
-                yield @store.lookup(target_oid, *args)
+            def register_with_subtype(oid, target_oid)
+              if @store.key?(target_oid)
+                register(oid) do |_, *args|
+                  yield @store.lookup(target_oid, *args)
+                end
               end
             end
-          end
 
-          def assert_valid_registration(oid, oid_type)
-            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
-            oid.to_i
-          end
+            def assert_valid_registration(oid, oid_type)
+              raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
+              oid.to_i
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb b/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
index 90e88b1f3c..b5031d890f 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
@@ -74,42 +74,42 @@ module ActiveRecord
 
         private
 
-        def _quote(value)
-          case value
-          when Type::Binary::Data
-            "'#{escape_bytea(value.to_s)}'"
-          when OID::Xml::Data
-            "xml '#{quote_string(value.to_s)}'"
-          when OID::Bit::Data
-            if value.binary?
-              "B'#{value}'"
-            elsif value.hex?
-              "X'#{value}'"
-            end
-          when Float
-            if value.infinite? || value.nan?
-              "'#{value}'"
+          def _quote(value)
+            case value
+            when Type::Binary::Data
+              "'#{escape_bytea(value.to_s)}'"
+            when OID::Xml::Data
+              "xml '#{quote_string(value.to_s)}'"
+            when OID::Bit::Data
+              if value.binary?
+                "B'#{value}'"
+              elsif value.hex?
+                "X'#{value}'"
+              end
+            when Float
+              if value.infinite? || value.nan?
+                "'#{value}'"
+              else
+                super
+              end
             else
               super
             end
-          else
-            super
           end
-        end
 
-        def _type_cast(value)
-          case value
-          when Type::Binary::Data
-            # Return a bind param hash with format as binary.
-            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
-            # for more information
-            { value: value.to_s, format: 1 }
-          when OID::Xml::Data, OID::Bit::Data
-            value.to_s
-          else
-            super
+          def _type_cast(value)
+            case value
+            when Type::Binary::Data
+              # Return a bind param hash with format as binary.
+              # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
+              # for more information
+              { value: value.to_s, format: 1 }
+            when OID::Xml::Data, OID::Bit::Data
+              value.to_s
+            else
+              super
+            end
           end
-        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb
index 2ed8f29b24..c20baf655c 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb
@@ -24,23 +24,23 @@ module ActiveRecord
 
         private
 
-        def default_primary_key?(column)
-          schema_type(column) == :serial
-        end
+          def default_primary_key?(column)
+            schema_type(column) == :serial
+          end
 
-        def schema_type(column)
-          return super unless column.serial?
+          def schema_type(column)
+            return super unless column.serial?
 
-          if column.bigint?
-            :bigserial
-          else
-            :serial
+            if column.bigint?
+              :bigserial
+            else
+              :serial
+            end
           end
-        end
 
-        def schema_expression(column)
-          super unless column.serial?
-        end
+          def schema_expression(column)
+            super unless column.serial?
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
index 55c5fcafa6..56280f15e9 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
@@ -6,17 +6,17 @@ module ActiveRecord
       class SchemaCreation < AbstractAdapter::SchemaCreation
         private
 
-        def visit_ColumnDefinition(o)
-          o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.array)
-          super
-        end
+          def visit_ColumnDefinition(o)
+            o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.array)
+            super
+          end
 
-        def add_column_options!(sql, options)
-          if options[:collation]
-            sql << " COLLATE \"#{options[:collation]}\""
+          def add_column_options!(sql, options)
+            if options[:collation]
+              sql << " COLLATE \"#{options[:collation]}\""
+            end
+            super
           end
-          super
-        end
       end
 
       module SchemaStatements
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb b/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
index b2c49989a4..bcef8ac715 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
@@ -27,9 +27,9 @@ module ActiveRecord
 
       protected
 
-      def attributes_for_hash
-        [self.class, @type_metadata, oid, fmod]
-      end
+        def attributes_for_hash
+          [self.class, @type_metadata, oid, fmod]
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb b/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
index ccb7e154ee..9e12ae0de8 100644
--- a/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
+++ b/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
@@ -24,9 +24,9 @@ module ActiveRecord
 
       protected
 
-      def attributes_for_hash
-        [self.class, sql_type, type, limit, precision, scale]
-      end
+        def attributes_for_hash
+          [self.class, sql_type, type, limit, precision, scale]
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb
index fa20175b0e..f01ed67b0f 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb
@@ -20,28 +20,28 @@ module ActiveRecord
 
         private
 
-        def _quote(value)
-          if value.is_a?(Type::Binary::Data)
-            "x'#{value.hex}'"
-          else
-            super
+          def _quote(value)
+            if value.is_a?(Type::Binary::Data)
+              "x'#{value.hex}'"
+            else
+              super
+            end
           end
-        end
 
-        def _type_cast(value)
-          case value
-          when BigDecimal
-            value.to_f
-          when String
-            if value.encoding == Encoding::ASCII_8BIT
-              super(value.encode(Encoding::UTF_8))
+          def _type_cast(value)
+            case value
+            when BigDecimal
+              value.to_f
+            when String
+              if value.encoding == Encoding::ASCII_8BIT
+                super(value.encode(Encoding::UTF_8))
+              else
+                super
+              end
             else
               super
             end
-          else
-            super
           end
-        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index 4558e1f80f..57699badba 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -70,9 +70,9 @@ module ActiveRecord
       class StatementPool < ConnectionAdapters::StatementPool
         private
 
-        def dealloc(stmt)
-          stmt[:stmt].close unless stmt[:stmt].closed?
-        end
+          def dealloc(stmt)
+            stmt[:stmt].close unless stmt[:stmt].closed?
+          end
       end
 
       def schema_creation # :nodoc:
diff --git a/activerecord/lib/active_record/connection_adapters/statement_pool.rb b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
index 9b0ed3e08b..273b1b0b5c 100644
--- a/activerecord/lib/active_record/connection_adapters/statement_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
@@ -47,13 +47,13 @@ module ActiveRecord
 
       private
 
-      def cache
-        @cache[Process.pid]
-      end
+        def cache
+          @cache[Process.pid]
+        end
 
-      def dealloc(stmt)
-        raise NotImplementedError
-      end
+        def dealloc(stmt)
+          raise NotImplementedError
+        end
     end
   end
 end