Merge branch 'master' into set_binds

* master: (2794 commits)
  doc, API example on how to use `Model#exists?` with multiple IDs. [ci skip]
  Restore DATABASE_URL even if it's nil in connection_handler test
  [ci skip] - error_messages_for has been deprecated since 2.3.8 - lets reduce any confusion for users
  Ensure Active Record connection consistency
  Revert "ask the fixture set for the sql statements"
  Check `respond_to` before delegation due to: https://github.com/ruby/ruby/commit/d781caaf313b8649948c107bba277e5ad7307314
  Adding Hash#compact and Hash#compact! methods
  MySQL version 4.1 was EOL on December 31, 2009 We should at least recommend modern versions of MySQL to users.
  clear cache on body close so that cache remains during rendering
  add a more restricted codepath for templates fixes #13390
  refactor generator tests to use block form of Tempfile
  Fix typo [ci skip]
  Move finish_template as the last public method in the generator
  Minor typos fix [ci skip]
  make `change_column_null` reversible. Closes #13576.
  create/drop test and development databases only if RAILS_ENV is nil
  Revert "Speedup String#to"
  typo fix in test name. [ci skip].
  `core_ext/string/access.rb` test what we are documenting.
  Fix typo in image_tag documentation
  ...

Conflicts:
	activerecord/lib/active_record/associations/join_dependency/join_association.rb
	activerecord/lib/active_record/relation/query_methods.rb

14 files changed, 831 insertions, 652 deletions

diff --git a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
index 16329689c0..22dd48e113 100644
--- a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
@@ -25,9 +25,7 @@ class PostgresqlActiveSchemaTest < ActiveRecord::TestCase
 
   def test_add_index
     # add_index calls index_name_exists? which can't work since execute is stubbed
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_exists?) do |*|
-      false
-    end
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.stubs(:index_name_exists?).returns(false)
 
     expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name" ON "people"  ("last_name") WHERE state = 'active')
     assert_equal expected, add_index(:people, :last_name, :unique => true, :where => "state = 'active'")
@@ -51,8 +49,6 @@ class PostgresqlActiveSchemaTest < ActiveRecord::TestCase
 
     expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name" ON "people" USING gist ("last_name") WHERE state = 'active')
     assert_equal expected, add_index(:people, :last_name, :unique => true, :where => "state = 'active'", :using => :gist)
-
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:remove_method, :index_name_exists?)
   end
 
   private
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 61a3a2ba0f..d71e2aa2bb 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -10,11 +10,12 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
 
   def setup
     @connection = ActiveRecord::Base.connection
-      @connection.transaction do
-        @connection.create_table('pg_arrays') do |t|
-          t.string 'tags', :array => true
-        end
+    @connection.transaction do
+      @connection.create_table('pg_arrays') do |t|
+        t.string 'tags', array: true
+        t.integer 'ratings', array: true
       end
+    end
     @column = PgArray.columns.find { |c| c.name == 'tags' }
   end
 
@@ -25,11 +26,36 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
   def test_column
     assert_equal :string, @column.type
     assert @column.array
+    assert_not @column.text?
+
+    ratings_column = PgArray.columns_hash['ratings']
+    assert_equal :integer, ratings_column.type
+    assert ratings_column.array
+    assert_not ratings_column.number?
   end
 
-  def test_type_cast_array
-    assert @column
+  def test_change_column_with_array
+    @connection.add_column :pg_arrays, :snippets, :string, array: true, default: []
+    @connection.change_column :pg_arrays, :snippets, :text, array: true, default: "{}"
+
+    PgArray.reset_column_information
+    column = PgArray.columns.find { |c| c.name == 'snippets' }
+
+    assert_equal :text, column.type
+    assert_equal [], column.default
+    assert column.array
+  end
 
+  def test_change_column_cant_make_non_array_column_to_array
+    @connection.add_column :pg_arrays, :a_string, :string
+    assert_raises ActiveRecord::StatementInvalid do
+      @connection.transaction do
+        @connection.change_column :pg_arrays, :a_string, :string, array: true
+      end
+    end
+  end
+
+  def test_type_cast_array
     data = '{1,2,3}'
     oid_type  = @column.instance_variable_get('@oid_type').subtype
     # we are getting the instance variable in this test, but in the
@@ -44,6 +70,12 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     assert_equal([nil], @column.type_cast('{NULL}'))
   end
 
+  def test_type_cast_integers
+    x = PgArray.new(ratings: ['1', '2'])
+    assert x.save!
+    assert_equal(['1', '2'], x.ratings)
+  end
+
   def test_rewrite
     @connection.execute "insert into pg_arrays (tags) VALUES ('{1,2,3}')"
     x = PgArray.first
@@ -57,28 +89,32 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     assert_equal(['1','2','3'], x.tags)
   end
 
-  def test_multi_dimensional
-    assert_cycle([['1','2'],['2','3']])
+  def test_multi_dimensional_with_strings
+    assert_cycle(:tags, [[['1'], ['2']], [['2'], ['3']]])
+  end
+
+  def test_multi_dimensional_with_integers
+    assert_cycle(:ratings, [[[1], [7]], [[8], [10]]])
   end
 
   def test_strings_with_quotes
-    assert_cycle(['this has','some "s that need to be escaped"'])
+    assert_cycle(:tags, ['this has','some "s that need to be escaped"'])
   end
 
   def test_strings_with_commas
-    assert_cycle(['this,has','many,values'])
+    assert_cycle(:tags, ['this,has','many,values'])
   end
 
   def test_strings_with_array_delimiters
-    assert_cycle(['{','}'])
+    assert_cycle(:tags, ['{','}'])
   end
 
   def test_strings_with_null_strings
-    assert_cycle(['NULL','NULL'])
+    assert_cycle(:tags, ['NULL','NULL'])
   end
 
   def test_contains_nils
-    assert_cycle(['1',nil,nil])
+    assert_cycle(:tags, ['1',nil,nil])
   end
 
   def test_insert_fixture
@@ -87,18 +123,33 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     assert_equal(PgArray.last.tags, tag_values)
   end
 
+  def test_attribute_for_inspect_for_array_field
+    record = PgArray.new { |a| a.ratings = (1..11).to_a }
+    assert_equal("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]", record.attribute_for_inspect(:ratings))
+  end
+
+  def test_update_all
+    pg_array = PgArray.create! tags: ["one", "two", "three"]
+
+    PgArray.update_all tags: ["four", "five"]
+    assert_equal ["four", "five"], pg_array.reload.tags
+
+    PgArray.update_all tags: []
+    assert_equal [], pg_array.reload.tags
+  end
+
   private
-  def assert_cycle array
+  def assert_cycle field, array
     # test creation
-    x = PgArray.create!(:tags => array)
+    x = PgArray.create!(field => array)
     x.reload
-    assert_equal(array, x.tags)
+    assert_equal(array, x.public_send(field))
 
     # test updating
-    x = PgArray.create!(:tags => [])
-    x.tags = array
+    x = PgArray.create!(field => [])
+    x.public_send("#{field}=", array)
     x.save!
     x.reload
-    assert_equal(array, x.tags)
+    assert_equal(array, x.public_send(field))
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index d7d77f96e2..b8dd35c4c5 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -15,6 +15,7 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
       @connection.transaction do
         @connection.create_table('bytea_data_type') do |t|
           t.binary 'payload'
+          t.binary 'serialized'
         end
       end
     end
@@ -65,7 +66,7 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
   def test_write_value
     data = "\u001F"
     record = ByteaDataType.create(payload: data)
-    refute record.new_record?
+    assert_not record.new_record?
     assert_equal(data, record.payload)
   end
 
@@ -73,15 +74,31 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
     data = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'example.log'))
     assert(data.size > 1)
     record = ByteaDataType.create(payload: data)
-    refute record.new_record?
+    assert_not record.new_record?
     assert_equal(data, record.payload)
     assert_equal(data, ByteaDataType.where(id: record.id).first.payload)
   end
 
   def test_write_nil
     record = ByteaDataType.create(payload: nil)
-    refute record.new_record?
+    assert_not record.new_record?
     assert_equal(nil, record.payload)
     assert_equal(nil, ByteaDataType.where(id: record.id).first.payload)
   end
+
+  class Serializer
+    def load(str); str; end
+    def dump(str); str; end
+  end
+
+  def test_serialize
+    klass = Class.new(ByteaDataType) {
+      serialize :serialized, Serializer.new
+    }
+    obj = klass.new
+    obj.serialized = "hello world"
+    obj.save!
+    obj.reload
+    assert_equal "hello world", obj.serialized
+  end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 6b726ce875..90cca7d3e6 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -7,14 +7,14 @@ module ActiveRecord
 
     def setup
       super
+      @subscriber = SQLSubscriber.new
+      ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
       @connection = ActiveRecord::Base.connection
-      @connection.extend(LogIntercepter)
-      @connection.intercepted = true
     end
 
     def teardown
-      @connection.intercepted = false
-      @connection.logged = []
+      ActiveSupport::Notifications.unsubscribe(@subscriber)
+      super
     end
 
     def test_encoding
@@ -47,38 +47,48 @@ module ActiveRecord
 
     def test_tables_logs_name
       @connection.tables('hello')
-      assert_equal 'SCHEMA', @connection.logged[0][1]
+      assert_equal 'SCHEMA', @subscriber.logged[0][1]
     end
 
     def test_indexes_logs_name
       @connection.indexes('items', 'hello')
-      assert_equal 'SCHEMA', @connection.logged[0][1]
+      assert_equal 'SCHEMA', @subscriber.logged[0][1]
     end
 
     def test_table_exists_logs_name
       @connection.table_exists?('items')
-      assert_equal 'SCHEMA', @connection.logged[0][1]
+      assert_equal 'SCHEMA', @subscriber.logged[0][1]
     end
 
     def test_table_alias_length_logs_name
       @connection.instance_variable_set("@table_alias_length", nil)
       @connection.table_alias_length
-      assert_equal 'SCHEMA', @connection.logged[0][1]
+      assert_equal 'SCHEMA', @subscriber.logged[0][1]
     end
 
     def test_current_database_logs_name
       @connection.current_database
-      assert_equal 'SCHEMA', @connection.logged[0][1]
+      assert_equal 'SCHEMA', @subscriber.logged[0][1]
     end
 
     def test_encoding_logs_name
       @connection.encoding
-      assert_equal 'SCHEMA', @connection.logged[0][1]
+      assert_equal 'SCHEMA', @subscriber.logged[0][1]
     end
 
     def test_schema_names_logs_name
       @connection.schema_names
-      assert_equal 'SCHEMA', @connection.logged[0][1]
+      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+    end
+
+    def test_statement_key_is_logged
+      bindval = 1
+      @connection.exec_query('SELECT $1::integer', 'SQL', [[nil, bindval]])
+      name = @subscriber.payloads.last[:statement_name]
+      assert name
+      res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(#{bindval})")
+      plan = res.column_types['QUERY PLAN'].type_cast res.rows.first.first
+      assert_operator plan.length, :>, 0
     end
 
     # Must have with_manual_interventions set to true for this
@@ -88,33 +98,33 @@ module ActiveRecord
     # you know the incantation to do that.
     # To restart PostgreSQL 9.1 on OS X, installed via MacPorts, ...
     # sudo su postgres -c "pg_ctl restart -D /opt/local/var/db/postgresql91/defaultdb/ -m fast"
-    def test_reconnection_after_actual_disconnection_with_verify
-      skip "with_manual_interventions is false in configuration" unless ARTest.config['with_manual_interventions']
-
-      original_connection_pid = @connection.query('select pg_backend_pid()')
+    if ARTest.config['with_manual_interventions']
+      def test_reconnection_after_actual_disconnection_with_verify
+        original_connection_pid = @connection.query('select pg_backend_pid()')
 
-      # Sanity check.
-      assert @connection.active?
+        # Sanity check.
+        assert @connection.active?
 
-      puts 'Kill the connection now (e.g. by restarting the PostgreSQL ' +
-           'server with the "-m fast" option) and then press enter.'
-      $stdin.gets
+        puts 'Kill the connection now (e.g. by restarting the PostgreSQL ' +
+          'server with the "-m fast" option) and then press enter.'
+        $stdin.gets
 
-      @connection.verify!
+        @connection.verify!
 
-      assert @connection.active?
+        assert @connection.active?
 
-      # If we get no exception here, then either we re-connected successfully, or
-      # we never actually got disconnected.
-      new_connection_pid = @connection.query('select pg_backend_pid()')
+        # If we get no exception here, then either we re-connected successfully, or
+        # we never actually got disconnected.
+        new_connection_pid = @connection.query('select pg_backend_pid()')
 
-      assert_not_equal original_connection_pid, new_connection_pid,
-        "umm -- looks like you didn't break the connection, because we're still " +
-        "successfully querying with the same connection pid."
+        assert_not_equal original_connection_pid, new_connection_pid,
+          "umm -- looks like you didn't break the connection, because we're still " +
+          "successfully querying with the same connection pid."
 
-      # Repair all fixture connections so other tests won't break.
-      @fixture_connections.each do |c|
-        c.verify!
+        # Repair all fixture connections so other tests won't break.
+        @fixture_connections.each do |c|
+          c.verify!
+        end
       end
     end
 
diff --git a/activerecord/test/cases/adapters/postgresql/datatype_test.rb b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
index b5d7ea603e..04a458fbce 100644
--- a/activerecord/test/cases/adapters/postgresql/datatype_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
@@ -3,9 +3,6 @@ require "cases/helper"
 class PostgresqlArray < ActiveRecord::Base
 end
 
-class PostgresqlRange < ActiveRecord::Base
-end
-
 class PostgresqlTsvector < ActiveRecord::Base
 end
 
@@ -46,104 +43,6 @@ class PostgresqlDataTypeTest < ActiveRecord::TestCase
     @connection.execute("INSERT INTO postgresql_arrays (id, commission_by_quarter, nicknames) VALUES (1, '{35000,21000,18000,17000}', '{foo,bar,baz}')")
     @first_array = PostgresqlArray.find(1)
 
-    @connection.execute <<_SQL if @connection.supports_ranges?
-    INSERT INTO postgresql_ranges (
-      date_range,
-      num_range,
-      ts_range,
-      tstz_range,
-      int4_range,
-      int8_range
-    ) VALUES (
-      '[''2012-01-02'', ''2012-01-04'']',
-      '[0.1, 0.2]',
-      '[''2010-01-01 14:30'', ''2011-01-01 14:30'']',
-      '[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']',
-      '[1, 10]',
-      '[10, 100]'
-    )
-_SQL
-
-    @connection.execute <<_SQL if @connection.supports_ranges?
-    INSERT INTO postgresql_ranges (
-      date_range,
-      num_range,
-      ts_range,
-      tstz_range,
-      int4_range,
-      int8_range
-    ) VALUES (
-      '(''2012-01-02'', ''2012-01-04'')',
-      '[0.1, 0.2)',
-      '[''2010-01-01 14:30'', ''2011-01-01 14:30'')',
-      '[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')',
-      '(1, 10)',
-      '(10, 100)'
-    )
-_SQL
-
-    @connection.execute <<_SQL if @connection.supports_ranges?
-    INSERT INTO postgresql_ranges (
-      date_range,
-      num_range,
-      ts_range,
-      tstz_range,
-      int4_range,
-      int8_range
-    ) VALUES (
-      '(''2012-01-02'',]',
-      '[0.1,]',
-      '[''2010-01-01 14:30'',]',
-      '[''2010-01-01 14:30:00+05'',]',
-      '(1,]',
-      '(10,]'
-    )
-_SQL
-
-    @connection.execute <<_SQL if @connection.supports_ranges?
-    INSERT INTO postgresql_ranges (
-      date_range,
-      num_range,
-      ts_range,
-      tstz_range,
-      int4_range,
-      int8_range
-    ) VALUES (
-      '[,]',
-      '[,]',
-      '[,]',
-      '[,]',
-      '[,]',
-      '[,]'
-    )
-_SQL
-
-    @connection.execute <<_SQL if @connection.supports_ranges?
-    INSERT INTO postgresql_ranges (
-      date_range,
-      num_range,
-      ts_range,
-      tstz_range,
-      int4_range,
-      int8_range
-    ) VALUES (
-      '(''2012-01-02'', ''2012-01-02'')',
-      '(0.1, 0.1)',
-      '(''2010-01-01 14:30'', ''2010-01-01 14:30'')',
-      '(''2010-01-01 14:30:00+05'', ''2010-01-01 06:30:00-03'')',
-      '(1, 1)',
-      '(10, 10)'
-    )
-_SQL
-
-    if @connection.supports_ranges?
-      @first_range = PostgresqlRange.find(1)
-      @second_range = PostgresqlRange.find(2)
-      @third_range = PostgresqlRange.find(3)
-      @fourth_range = PostgresqlRange.find(4)
-      @empty_range = PostgresqlRange.find(5)
-    end
-
     @connection.execute("INSERT INTO postgresql_tsvectors (id, text_vector) VALUES (1, ' ''text'' ''vector'' ')")
 
     @first_tsvector = PostgresqlTsvector.find(1)
@@ -184,16 +83,6 @@ _SQL
     assert_equal :text, @first_array.column_for_attribute(:nicknames).type
   end
 
-  def test_data_type_of_range_types
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    assert_equal :daterange, @first_range.column_for_attribute(:date_range).type
-    assert_equal :numrange, @first_range.column_for_attribute(:num_range).type
-    assert_equal :tsrange, @first_range.column_for_attribute(:ts_range).type
-    assert_equal :tstzrange, @first_range.column_for_attribute(:tstz_range).type
-    assert_equal :int4range, @first_range.column_for_attribute(:int4_range).type
-    assert_equal :int8range, @first_range.column_for_attribute(:int8_range).type
-  end
-
   def test_data_type_of_tsvector_types
     assert_equal :tsvector, @first_tsvector.column_for_attribute(:text_vector).type
   end
@@ -240,208 +129,28 @@ _SQL
     assert_equal "'text' 'vector'", @first_tsvector.text_vector
   end
 
-  def test_int4range_values
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    assert_equal 1...11, @first_range.int4_range
-    assert_equal 2...10, @second_range.int4_range
-    assert_equal 2...Float::INFINITY, @third_range.int4_range
-    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int4_range)
-    assert_equal nil, @empty_range.int4_range
-  end
-
-  def test_int8range_values
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    assert_equal 10...101, @first_range.int8_range
-    assert_equal 11...100, @second_range.int8_range
-    assert_equal 11...Float::INFINITY, @third_range.int8_range
-    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int8_range)
-    assert_equal nil, @empty_range.int8_range
-  end
-
-  def test_daterange_values
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 5), @first_range.date_range
-    assert_equal Date.new(2012, 1, 3)...Date.new(2012, 1, 4), @second_range.date_range
-    assert_equal Date.new(2012, 1, 3)...Float::INFINITY, @third_range.date_range
-    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.date_range)
-    assert_equal nil, @empty_range.date_range
-  end
-
-  def test_numrange_values
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    assert_equal BigDecimal.new('0.1')..BigDecimal.new('0.2'), @first_range.num_range
-    assert_equal BigDecimal.new('0.1')...BigDecimal.new('0.2'), @second_range.num_range
-    assert_equal BigDecimal.new('0.1')...BigDecimal.new('Infinity'), @third_range.num_range
-    assert_equal BigDecimal.new('-Infinity')...BigDecimal.new('Infinity'), @fourth_range.num_range
-    assert_equal nil, @empty_range.num_range
-  end
-
-  def test_tsrange_values
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    tz = ::ActiveRecord::Base.default_timezone
-    assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 0)..Time.send(tz, 2011, 1, 1, 14, 30, 0), @first_range.ts_range
-    assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 1, 1, 14, 30, 0), @second_range.ts_range
-    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.ts_range)
-    assert_equal nil, @empty_range.ts_range
-  end
-
-  def test_tstzrange_values
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    assert_equal Time.parse('2010-01-01 09:30:00 UTC')..Time.parse('2011-01-01 17:30:00 UTC'), @first_range.tstz_range
-    assert_equal Time.parse('2010-01-01 09:30:00 UTC')...Time.parse('2011-01-01 17:30:00 UTC'), @second_range.tstz_range
-    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.tstz_range)
-    assert_equal nil, @empty_range.tstz_range
-  end
-
   def test_money_values
     assert_equal 567.89, @first_money.wealth
     assert_equal(-567.89, @second_money.wealth)
   end
 
-  def test_create_tstzrange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    tstzrange = Time.parse('2010-01-01 14:30:00 +0100')...Time.parse('2011-02-02 14:30:00 CDT')
-    range = PostgresqlRange.new(:tstz_range => tstzrange)
-    assert range.save
-    assert range.reload
-    assert_equal range.tstz_range, tstzrange
-    assert_equal range.tstz_range, Time.parse('2010-01-01 13:30:00 UTC')...Time.parse('2011-02-02 19:30:00 UTC')
-  end
-
-  def test_update_tstzrange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    new_tstzrange = Time.parse('2010-01-01 14:30:00 CDT')...Time.parse('2011-02-02 14:30:00 CET')
-    assert @first_range.tstz_range = new_tstzrange
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.tstz_range, new_tstzrange
-    assert @first_range.tstz_range = Time.parse('2010-01-01 14:30:00 +0100')...Time.parse('2010-01-01 13:30:00 +0000')
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.tstz_range, nil
-  end
-
-  def test_create_tsrange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    tz = ::ActiveRecord::Base.default_timezone
-    tsrange = Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 2, 2, 14, 30, 0)
-    range = PostgresqlRange.new(:ts_range => tsrange)
-    assert range.save
-    assert range.reload
-    assert_equal range.ts_range, tsrange
-  end
-
-  def test_update_tsrange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    tz = ::ActiveRecord::Base.default_timezone
-    new_tsrange = Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 2, 2, 14, 30, 0)
-    assert @first_range.ts_range = new_tsrange
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.ts_range, new_tsrange
-    assert @first_range.ts_range = Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2010, 1, 1, 14, 30, 0)
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.ts_range, nil
-  end
-
-  def test_create_numrange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    numrange = BigDecimal.new('0.5')...BigDecimal.new('1')
-    range = PostgresqlRange.new(:num_range => numrange)
-    assert range.save
-    assert range.reload
-    assert_equal range.num_range, numrange
-  end
-
-  def test_update_numrange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    new_numrange = BigDecimal.new('0.5')...BigDecimal.new('1')
-    assert @first_range.num_range = new_numrange
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.num_range, new_numrange
-    assert @first_range.num_range = BigDecimal.new('0.5')...BigDecimal.new('0.5')
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.num_range, nil
-  end
-
-  def test_create_daterange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    daterange = Range.new(Date.new(2012, 1, 1), Date.new(2013, 1, 1), true)
-    range = PostgresqlRange.new(:date_range => daterange)
-    assert range.save
-    assert range.reload
-    assert_equal range.date_range, daterange
-  end
-
-  def test_update_daterange
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    new_daterange = Date.new(2012, 2, 3)...Date.new(2012, 2, 10)
-    assert @first_range.date_range = new_daterange
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.date_range, new_daterange
-    assert @first_range.date_range = Date.new(2012, 2, 3)...Date.new(2012, 2, 3)
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.date_range, nil
-  end
-
-  def test_create_int4range
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    int4range = Range.new(3, 50, true)
-    range = PostgresqlRange.new(:int4_range => int4range)
-    assert range.save
-    assert range.reload
-    assert_equal range.int4_range, int4range
-  end
-
-  def test_update_int4range
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    new_int4range = 6...10
-    assert @first_range.int4_range = new_int4range
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.int4_range, new_int4range
-    assert @first_range.int4_range = 3...3
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.int4_range, nil
-  end
-
-  def test_create_int8range
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    int8range = Range.new(30, 50, true)
-    range = PostgresqlRange.new(:int8_range => int8range)
-    assert range.save
-    assert range.reload
-    assert_equal range.int8_range, int8range
-  end
-
-  def test_update_int8range
-    skip "PostgreSQL 9.2 required for range datatypes" unless @connection.supports_ranges?
-    new_int8range = 60000...10000000
-    assert @first_range.int8_range = new_int8range
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.int8_range, new_int8range
-    assert @first_range.int8_range = 39999...39999
-    assert @first_range.save
-    assert @first_range.reload
-    assert_equal @first_range.int8_range, nil
+  def test_money_type_cast
+    column = PostgresqlMoney.columns.find { |c| c.name == 'wealth' }
+    assert_equal(12345678.12, column.type_cast("$12,345,678.12"))
+    assert_equal(12345678.12, column.type_cast("$12.345.678,12"))
+    assert_equal(-1.15, column.type_cast("-$1.15"))
+    assert_equal(-2.25, column.type_cast("($2.25)"))
   end
 
   def test_update_tsvector
     new_text_vector = "'new' 'text' 'vector'"
-    assert @first_tsvector.text_vector = new_text_vector
+    @first_tsvector.text_vector = new_text_vector
     assert @first_tsvector.save
     assert @first_tsvector.reload
-    assert @first_tsvector.text_vector = new_text_vector
+    @first_tsvector.text_vector = new_text_vector
     assert @first_tsvector.save
     assert @first_tsvector.reload
-    assert_equal @first_tsvector.text_vector, new_text_vector
+    assert_equal new_text_vector, @first_tsvector.text_vector
   end
 
   def test_number_values
@@ -479,31 +188,31 @@ _SQL
 
   def test_update_integer_array
     new_value = [32800,95000,29350,17000]
-    assert @first_array.commission_by_quarter = new_value
+    @first_array.commission_by_quarter = new_value
     assert @first_array.save
     assert @first_array.reload
-    assert_equal @first_array.commission_by_quarter, new_value
-    assert @first_array.commission_by_quarter = new_value
+    assert_equal new_value, @first_array.commission_by_quarter
+    @first_array.commission_by_quarter = new_value
     assert @first_array.save
     assert @first_array.reload
-    assert_equal @first_array.commission_by_quarter, new_value
+    assert_equal new_value, @first_array.commission_by_quarter
   end
 
   def test_update_text_array
     new_value = ['robby','robert','rob','robbie']
-    assert @first_array.nicknames = new_value
+    @first_array.nicknames = new_value
     assert @first_array.save
     assert @first_array.reload
-    assert_equal @first_array.nicknames, new_value
-    assert @first_array.nicknames = new_value
+    assert_equal new_value, @first_array.nicknames
+    @first_array.nicknames = new_value
     assert @first_array.save
     assert @first_array.reload
-    assert_equal @first_array.nicknames, new_value
+    assert_equal new_value, @first_array.nicknames
   end
 
   def test_update_money
     new_value = BigDecimal.new('123.45')
-    assert @first_money.wealth = new_value
+    @first_money.wealth = new_value
     assert @first_money.save
     assert @first_money.reload
     assert_equal new_value, @first_money.wealth
@@ -512,28 +221,28 @@ _SQL
   def test_update_number
     new_single = 789.012
     new_double = 789012.345
-    assert @first_number.single = new_single
-    assert @first_number.double = new_double
+    @first_number.single = new_single
+    @first_number.double = new_double
     assert @first_number.save
     assert @first_number.reload
-    assert_equal @first_number.single, new_single
-    assert_equal @first_number.double, new_double
+    assert_equal new_single, @first_number.single
+    assert_equal new_double, @first_number.double
   end
 
   def test_update_time
-    assert @first_time.time_interval = '2 years 3 minutes'
+    @first_time.time_interval = '2 years 3 minutes'
     assert @first_time.save
     assert @first_time.reload
-    assert_equal @first_time.time_interval, '2 years 00:03:00'
+    assert_equal '2 years 00:03:00', @first_time.time_interval
   end
 
   def test_update_network_address
     new_inet_address = '10.1.2.3/32'
     new_cidr_address = '10.0.0.0/8'
     new_mac_address = 'bc:de:f0:12:34:56'
-    assert @first_network_address.cidr_address = new_cidr_address
-    assert @first_network_address.inet_address = new_inet_address
-    assert @first_network_address.mac_address = new_mac_address
+    @first_network_address.cidr_address = new_cidr_address
+    @first_network_address.inet_address = new_inet_address
+    @first_network_address.mac_address = new_mac_address
     assert @first_network_address.save
     assert @first_network_address.reload
     assert_equal @first_network_address.cidr_address, new_cidr_address
@@ -544,61 +253,65 @@ _SQL
   def test_update_bit_string
     new_bit_string = '11111111'
     new_bit_string_varying = '0xFF'
-    assert @first_bit_string.bit_string = new_bit_string
-    assert @first_bit_string.bit_string_varying = new_bit_string_varying
+    @first_bit_string.bit_string = new_bit_string
+    @first_bit_string.bit_string_varying = new_bit_string_varying
     assert @first_bit_string.save
     assert @first_bit_string.reload
-    assert_equal @first_bit_string.bit_string, new_bit_string
+    assert_equal new_bit_string, @first_bit_string.bit_string
     assert_equal @first_bit_string.bit_string, @first_bit_string.bit_string_varying
   end
-	
+
   def test_invalid_hex_string
     new_bit_string = 'FF'
     @first_bit_string.bit_string = new_bit_string
     assert_raise(ActiveRecord::StatementInvalid) { assert @first_bit_string.save }
   end
 
+  def test_invalid_network_address
+    @first_network_address.cidr_address = 'invalid addr'
+    assert_nil @first_network_address.cidr_address
+    assert_equal 'invalid addr', @first_network_address.cidr_address_before_type_cast
+    assert @first_network_address.save
+
+    @first_network_address.reload
+
+    @first_network_address.inet_address = 'invalid addr'
+    assert_nil @first_network_address.inet_address
+    assert_equal 'invalid addr', @first_network_address.inet_address_before_type_cast
+    assert @first_network_address.save
+  end
+
   def test_update_oid
     new_value = 567890
-    assert @first_oid.obj_id = new_value
+    @first_oid.obj_id = new_value
     assert @first_oid.save
     assert @first_oid.reload
-    assert_equal @first_oid.obj_id, new_value
+    assert_equal new_value, @first_oid.obj_id
   end
 
   def test_timestamp_with_zone_values_with_rails_time_zone_support
-    old_tz         = ActiveRecord::Base.time_zone_aware_attributes
-    old_default_tz = ActiveRecord::Base.default_timezone
-
-    ActiveRecord::Base.time_zone_aware_attributes = true
-    ActiveRecord::Base.default_timezone = :utc
+    with_timezone_config default: :utc, aware_attributes: true do
+      @connection.reconnect!
 
-    @connection.reconnect!
-
-    @first_timestamp_with_zone = PostgresqlTimestampWithZone.find(1)
-    assert_equal Time.utc(2010,1,1, 11,0,0), @first_timestamp_with_zone.time
-    assert_instance_of Time, @first_timestamp_with_zone.time
+      @first_timestamp_with_zone = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010,1,1, 11,0,0), @first_timestamp_with_zone.time
+      assert_instance_of Time, @first_timestamp_with_zone.time
+    end
   ensure
-    ActiveRecord::Base.default_timezone = old_default_tz
-    ActiveRecord::Base.time_zone_aware_attributes = old_tz
     @connection.reconnect!
   end
 
   def test_timestamp_with_zone_values_without_rails_time_zone_support
-    old_tz         = ActiveRecord::Base.time_zone_aware_attributes
-    old_default_tz = ActiveRecord::Base.default_timezone
-
-    ActiveRecord::Base.time_zone_aware_attributes = false
-    ActiveRecord::Base.default_timezone = :local
-
-    @connection.reconnect!
-
-    @first_timestamp_with_zone = PostgresqlTimestampWithZone.find(1)
-    assert_equal Time.utc(2010,1,1, 11,0,0), @first_timestamp_with_zone.time
-    assert_instance_of Time, @first_timestamp_with_zone.time
+    with_timezone_config default: :local, aware_attributes: false do
+      @connection.reconnect!
+      # make sure to use a non-UTC time zone
+      @connection.execute("SET time zone 'America/Jamaica'", 'SCHEMA')
+
+      @first_timestamp_with_zone = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010,1,1, 11,0,0), @first_timestamp_with_zone.time
+      assert_instance_of Time, @first_timestamp_with_zone.time
+    end
   ensure
-    ActiveRecord::Base.default_timezone = old_default_tz
-    ActiveRecord::Base.time_zone_aware_attributes = old_tz
     @connection.reconnect!
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index e434b4861c..d8782f5eaa 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -7,15 +7,13 @@ require 'active_record/connection_adapters/postgresql_adapter'
 class PostgresqlHstoreTest < ActiveRecord::TestCase
   class Hstore < ActiveRecord::Base
     self.table_name = 'hstores'
+
+    store_accessor :settings, :language, :timezone
   end
 
   def setup
     @connection = ActiveRecord::Base.connection
 
-    unless @connection.supports_extensions?
-      return skip "do not test on PG without hstore"
-    end
-
     unless @connection.extension_enabled?('hstore')
       @connection.enable_extension 'hstore'
       @connection.commit_db_transaction
@@ -26,6 +24,7 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
     @connection.transaction do
       @connection.create_table('hstores') do |t|
         t.hstore 'tags', :default => ''
+        t.hstore 'settings'
       end
     end
     @column = Hstore.columns.find { |c| c.name == 'tags' }
@@ -35,166 +34,220 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
     @connection.execute 'drop table if exists hstores'
   end
 
-  def test_hstore_included_in_extensions
-    assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
-    assert @connection.extensions.include?('hstore'), "extension list should include hstore"
-  end
+  if ActiveRecord::Base.connection.supports_extensions?
+    def test_hstore_included_in_extensions
+      assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
+      assert @connection.extensions.include?('hstore'), "extension list should include hstore"
+    end
 
-  def test_disable_enable_hstore
-    assert @connection.extension_enabled?('hstore')
-    @connection.disable_extension 'hstore'
-    assert_not @connection.extension_enabled?('hstore')
-    @connection.enable_extension 'hstore'
-    assert @connection.extension_enabled?('hstore')
-  ensure
-    # Restore column(s) dropped by `drop extension hstore cascade;`
-    load_schema
-  end
+    def test_disable_enable_hstore
+      assert @connection.extension_enabled?('hstore')
+      @connection.disable_extension 'hstore'
+      assert_not @connection.extension_enabled?('hstore')
+      @connection.enable_extension 'hstore'
+      assert @connection.extension_enabled?('hstore')
+    ensure
+      # Restore column(s) dropped by `drop extension hstore cascade;`
+      load_schema
+    end
 
-  def test_column
-    assert_equal :hstore, @column.type
-  end
+    def test_column
+      assert_equal :hstore, @column.type
+    end
 
-  def test_change_table_supports_hstore
-    @connection.transaction do
-      @connection.change_table('hstores') do |t|
-        t.hstore 'users', default: ''
+    def test_change_table_supports_hstore
+      @connection.transaction do
+        @connection.change_table('hstores') do |t|
+          t.hstore 'users', default: ''
+        end
+        Hstore.reset_column_information
+        column = Hstore.columns.find { |c| c.name == 'users' }
+        assert_equal :hstore, column.type
+
+        raise ActiveRecord::Rollback # reset the schema change
       end
+    ensure
       Hstore.reset_column_information
-      column = Hstore.columns.find { |c| c.name == 'users' }
-      assert_equal :hstore, column.type
+    end
+
+    def test_hstore_migration
+      hstore_migration = Class.new(ActiveRecord::Migration) do
+        def change
+          change_table("hstores") do |t|
+            t.hstore :keys
+          end
+        end
+      end
 
-      raise ActiveRecord::Rollback # reset the schema change
+      hstore_migration.new.suppress_messages do
+        hstore_migration.migrate(:up)
+        assert_includes @connection.columns(:hstores).map(&:name), "keys"
+        hstore_migration.migrate(:down)
+        assert_not_includes @connection.columns(:hstores).map(&:name), "keys"
+      end
     end
-  ensure
-    Hstore.reset_column_information
-  end
 
-  def test_type_cast_hstore
-    assert @column
+    def test_cast_value_on_write
+      x = Hstore.new tags: {"bool" => true, "number" => 5}
+      assert_equal({"bool" => "true", "number" => "5"}, x.tags)
+      x.save
+      assert_equal({"bool" => "true", "number" => "5"}, x.reload.tags)
+    end
 
-    data = "\"1\"=>\"2\""
-    hash = @column.class.string_to_hstore data
-    assert_equal({'1' => '2'}, hash)
-    assert_equal({'1' => '2'}, @column.type_cast(data))
+    def test_type_cast_hstore
+      assert @column
 
-    assert_equal({}, @column.type_cast(""))
-    assert_equal({'key'=>nil}, @column.type_cast('key => NULL'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast(%q(c=>"}", "\"a\""=>"b \"a b")))
-  end
+      data = "\"1\"=>\"2\""
+      hash = @column.class.string_to_hstore data
+      assert_equal({'1' => '2'}, hash)
+      assert_equal({'1' => '2'}, @column.type_cast(data))
 
-  def test_gen1
-    assert_equal(%q(" "=>""), @column.class.hstore_to_string({' '=>''}))
-  end
+      assert_equal({}, @column.type_cast(""))
+      assert_equal({'key'=>nil}, @column.type_cast('key => NULL'))
+      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast(%q(c=>"}", "\"a\""=>"b \"a b")))
+    end
 
-  def test_gen2
-    assert_equal(%q(","=>""), @column.class.hstore_to_string({','=>''}))
-  end
+    def test_with_store_accessors
+      x = Hstore.new(language: "fr", timezone: "GMT")
+      assert_equal "fr", x.language
+      assert_equal "GMT", x.timezone
 
-  def test_gen3
-    assert_equal(%q("="=>""), @column.class.hstore_to_string({'='=>''}))
-  end
+      x.save!
+      x = Hstore.first
+      assert_equal "fr", x.language
+      assert_equal "GMT", x.timezone
 
-  def test_gen4
-    assert_equal(%q(">"=>""), @column.class.hstore_to_string({'>'=>''}))
-  end
+      x.language = "de"
+      x.save!
 
-  def test_parse1
-    assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @column.type_cast('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
-  end
+      x = Hstore.first
+      assert_equal "de", x.language
+      assert_equal "GMT", x.timezone
+    end
 
-  def test_parse2
-    assert_equal({" " => " "},  @column.type_cast("\\ =>\\ "))
-  end
+    def test_gen1
+      assert_equal(%q(" "=>""), @column.class.hstore_to_string({' '=>''}))
+    end
 
-  def test_parse3
-    assert_equal({"=" => ">"},  @column.type_cast("==>>"))
-  end
+    def test_gen2
+      assert_equal(%q(","=>""), @column.class.hstore_to_string({','=>''}))
+    end
 
-  def test_parse4
-    assert_equal({"=a"=>"q=w"},   @column.type_cast('\=a=>q=w'))
-  end
+    def test_gen3
+      assert_equal(%q("="=>""), @column.class.hstore_to_string({'='=>''}))
+    end
 
-  def test_parse5
-    assert_equal({"=a"=>"q=w"},   @column.type_cast('"=a"=>q\=w'))
-  end
+    def test_gen4
+      assert_equal(%q(">"=>""), @column.class.hstore_to_string({'>'=>''}))
+    end
 
-  def test_parse6
-    assert_equal({"\"a"=>"q>w"},  @column.type_cast('"\"a"=>q>w'))
-  end
+    def test_parse1
+      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @column.type_cast('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+    end
 
-  def test_parse7
-    assert_equal({"\"a"=>"q\"w"}, @column.type_cast('\"a=>q"w'))
-  end
+    def test_parse2
+      assert_equal({" " => " "},  @column.type_cast("\\ =>\\ "))
+    end
 
-  def test_rewrite
-    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
-    x = Hstore.first
-    x.tags = { '"a\'' => 'b' }
-    assert x.save!
-  end
+    def test_parse3
+      assert_equal({"=" => ">"},  @column.type_cast("==>>"))
+    end
 
+    def test_parse4
+      assert_equal({"=a"=>"q=w"},   @column.type_cast('\=a=>q=w'))
+    end
 
-  def test_select
-    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
-    x = Hstore.first
-    assert_equal({'1' => '2'}, x.tags)
-  end
+    def test_parse5
+      assert_equal({"=a"=>"q=w"},   @column.type_cast('"=a"=>q\=w'))
+    end
 
-  def test_select_multikey
-    @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
-    x = Hstore.first
-    assert_equal({'1' => '2', '2' => '3'}, x.tags)
-  end
+    def test_parse6
+      assert_equal({"\"a"=>"q>w"},  @column.type_cast('"\"a"=>q>w'))
+    end
 
-  def test_create
-    assert_cycle('a' => 'b', '1' => '2')
-  end
+    def test_parse7
+      assert_equal({"\"a"=>"q\"w"}, @column.type_cast('\"a=>q"w'))
+    end
 
-  def test_nil
-    assert_cycle('a' => nil)
-  end
+    def test_rewrite
+      @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+      x = Hstore.first
+      x.tags = { '"a\'' => 'b' }
+      assert x.save!
+    end
 
-  def test_quotes
-    assert_cycle('a' => 'b"ar', '1"foo' => '2')
-  end
+    def test_select
+      @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+      x = Hstore.first
+      assert_equal({'1' => '2'}, x.tags)
+    end
 
-  def test_whitespace
-    assert_cycle('a b' => 'b ar', '1"foo' => '2')
-  end
+    def test_select_multikey
+      @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
+      x = Hstore.first
+      assert_equal({'1' => '2', '2' => '3'}, x.tags)
+    end
 
-  def test_backslash
-    assert_cycle('a\\b' => 'b\\ar', '1"foo' => '2')
-  end
+    def test_create
+      assert_cycle('a' => 'b', '1' => '2')
+    end
 
-  def test_comma
-    assert_cycle('a, b' => 'bar', '1"foo' => '2')
-  end
+    def test_nil
+      assert_cycle('a' => nil)
+    end
 
-  def test_arrow
-    assert_cycle('a=>b' => 'bar', '1"foo' => '2')
-  end
+    def test_quotes
+      assert_cycle('a' => 'b"ar', '1"foo' => '2')
+    end
 
-  def test_quoting_special_characters
-    assert_cycle('ca' => 'cà', 'ac' => 'àc')
-  end
+    def test_whitespace
+      assert_cycle('a b' => 'b ar', '1"foo' => '2')
+    end
+
+    def test_backslash
+      assert_cycle('a\\b' => 'b\\ar', '1"foo' => '2')
+    end
 
-  def test_multiline
-    assert_cycle("a\nb" => "c\nd")
+    def test_comma
+      assert_cycle('a, b' => 'bar', '1"foo' => '2')
+    end
+
+    def test_arrow
+      assert_cycle('a=>b' => 'bar', '1"foo' => '2')
+    end
+
+    def test_quoting_special_characters
+      assert_cycle('ca' => 'cà', 'ac' => 'àc')
+    end
+
+    def test_multiline
+      assert_cycle("a\nb" => "c\nd")
+    end
+
+    def test_update_all
+      hstore = Hstore.create! tags: { "one" => "two" }
+
+      Hstore.update_all tags: { "three" => "four" }
+      assert_equal({ "three" => "four" }, hstore.reload.tags)
+
+      Hstore.update_all tags: { }
+      assert_equal({ }, hstore.reload.tags)
+    end
   end
 
   private
-  def assert_cycle hash
-    # test creation
-    x = Hstore.create!(:tags => hash)
-    x.reload
-    assert_equal(hash, x.tags)
-
-    # test updating
-    x = Hstore.create!(:tags => {})
-    x.tags = hash
-    x.save!
-    x.reload
-    assert_equal(hash, x.tags)
-  end
+
+    def assert_cycle(hash)
+      # test creation
+      x = Hstore.create!(:tags => hash)
+      x.reload
+      assert_equal(hash, x.tags)
+
+      # test updating
+      x = Hstore.create!(:tags => {})
+      x.tags = hash
+      x.save!
+      x.reload
+      assert_equal(hash, x.tags)
+    end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index f45c7afcc0..01e7334aad 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -7,6 +7,8 @@ require 'active_record/connection_adapters/postgresql_adapter'
 class PostgresqlJSONTest < ActiveRecord::TestCase
   class JsonDataType < ActiveRecord::Base
     self.table_name = 'json_data_type'
+
+    store_accessor :settings, :resolution
   end
 
   def setup
@@ -15,6 +17,7 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
       @connection.transaction do
         @connection.create_table('json_data_type') do |t|
           t.json 'payload', :default => {}
+          t.json 'settings'
         end
       end
     rescue ActiveRecord::StatementInvalid
@@ -46,6 +49,13 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
     JsonDataType.reset_column_information
   end
 
+  def test_cast_value_on_write
+    x = JsonDataType.new payload: {"string" => "foo", :symbol => :bar}
+    assert_equal({"string" => "foo", "symbol" => "bar"}, x.payload)
+    x.save
+    assert_equal({"string" => "foo", "symbol" => "bar"}, x.reload.payload)
+  end
+
   def test_type_cast_json
     assert @column
 
@@ -97,4 +107,28 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
     assert x.save!
   end
 
+  def test_with_store_accessors
+    x = JsonDataType.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    x.save!
+    x = JsonDataType.first
+    assert_equal "320×480", x.resolution
+
+    x.resolution = "640×1136"
+    x.save!
+
+    x = JsonDataType.first
+    assert_equal "640×1136", x.resolution
+  end
+
+  def test_update_all
+    json = JsonDataType.create! payload: { "one" => "two" }
+
+    JsonDataType.update_all payload: { "three" => "four" }
+    assert_equal({ "three" => "four" }, json.reload.payload)
+
+    JsonDataType.update_all payload: { }
+    assert_equal({ }, json.reload.payload)
+  end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index fb88ab7c09..131080913c 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -10,6 +10,14 @@ module ActiveRecord
         @connection.exec_query('create table ex(id serial primary key, number integer, data character varying(255))')
       end
 
+      def test_bad_connection
+        assert_raise ActiveRecord::NoDatabaseError do
+          configuration = ActiveRecord::Base.configurations['arunit'].merge(database: 'should_not_exist-cinco-dog-db')
+          connection = ActiveRecord::Base.postgresql_connection(configuration)
+          connection.exec_query('drop table if exists ex')
+        end
+      end
+
       def test_valid_column
         column = @connection.columns('ex').find { |col| col.name == 'id' }
         assert @connection.valid_type?(column.type)
@@ -62,6 +70,18 @@ module ActiveRecord
         assert_equal expect, id
       end
 
+      def test_multiline_insert_sql
+        id = @connection.insert_sql(<<-SQL)
+        insert into ex(
+          number)
+        values(
+          5152
+        )
+        SQL
+        expect = @connection.query('select max(id) from ex').first.first
+        assert_equal expect, id
+      end
+
       def test_insert_sql_with_returning_disabled
         connection = connection_without_insert_returning
         id = connection.insert_sql("insert into postgresql_partitioned_table_parent (number) VALUES (1)")
@@ -225,65 +245,26 @@ module ActiveRecord
         assert_equal "(number > 100)", index.where
       end
 
-      def test_distinct_zero_orders
-        assert_deprecated do
-          assert_equal "DISTINCT posts.id",
-            @connection.distinct("posts.id", [])
-        end
-      end
-
       def test_columns_for_distinct_zero_orders
         assert_equal "posts.id",
           @connection.columns_for_distinct("posts.id", [])
       end
 
-      def test_distinct_one_order
-        assert_deprecated do
-          assert_equal "DISTINCT posts.id, posts.created_at AS alias_0",
-            @connection.distinct("posts.id", ["posts.created_at desc"])
-        end
-      end
-
       def test_columns_for_distinct_one_order
         assert_equal "posts.id, posts.created_at AS alias_0",
           @connection.columns_for_distinct("posts.id", ["posts.created_at desc"])
       end
 
-      def test_distinct_few_orders
-        assert_deprecated do
-          assert_equal "DISTINCT posts.id, posts.created_at AS alias_0, posts.position AS alias_1",
-            @connection.distinct("posts.id", ["posts.created_at desc", "posts.position asc"])
-        end
-      end
-
       def test_columns_for_distinct_few_orders
         assert_equal "posts.id, posts.created_at AS alias_0, posts.position AS alias_1",
           @connection.columns_for_distinct("posts.id", ["posts.created_at desc", "posts.position asc"])
       end
 
-      def test_distinct_blank_not_nil_orders
-        assert_deprecated do
-          assert_equal "DISTINCT posts.id, posts.created_at AS alias_0",
-            @connection.distinct("posts.id", ["posts.created_at desc", "", "   "])
-        end
-      end
-
       def test_columns_for_distinct_blank_not_nil_orders
         assert_equal "posts.id, posts.created_at AS alias_0",
           @connection.columns_for_distinct("posts.id", ["posts.created_at desc", "", "   "])
       end
 
-      def test_distinct_with_arel_order
-        order = Object.new
-        def order.to_sql
-          "posts.created_at desc"
-        end
-        assert_deprecated do
-          assert_equal "DISTINCT posts.id, posts.created_at AS alias_0",
-            @connection.distinct("posts.id", [order])
-        end
-      end
-
       def test_columns_for_distinct_with_arel_order
         order = Object.new
         def order.to_sql
@@ -293,13 +274,6 @@ module ActiveRecord
           @connection.columns_for_distinct("posts.id", [order])
       end
 
-      def test_distinct_with_nulls
-        assert_deprecated do
-          assert_equal "DISTINCT posts.title, posts.updater_id AS alias_0", @connection.distinct("posts.title", ["posts.updater_id desc nulls first"])
-          assert_equal "DISTINCT posts.title, posts.updater_id AS alias_0", @connection.distinct("posts.title", ["posts.updater_id desc nulls last"])
-        end
-      end
-
       def test_columns_for_distinct_with_nulls
         assert_equal "posts.title, posts.updater_id AS alias_0", @connection.columns_for_distinct("posts.title", ["posts.updater_id desc nulls first"])
         assert_equal "posts.title, posts.updater_id AS alias_0", @connection.columns_for_distinct("posts.title", ["posts.updater_id desc nulls last"])
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index b3429648ee..1122f8b9a1 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -47,11 +47,16 @@ module ActiveRecord
 
         def test_quote_cast_numeric
           fixnum = 666
-          c = Column.new(nil, nil, 'string')
+          c = Column.new(nil, nil, 'varchar')
           assert_equal "'666'", @conn.quote(fixnum, c)
           c = Column.new(nil, nil, 'text')
           assert_equal "'666'", @conn.quote(fixnum, c)
         end
+
+        def test_quote_time_usec
+          assert_equal "'1970-01-01 00:00:00.000000'", @conn.quote(Time.at(0))
+          assert_equal "'1970-01-01 00:00:00.000000'", @conn.quote(Time.at(0).to_datetime)
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
new file mode 100644
index 0000000000..a56b8ac791
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -0,0 +1,245 @@
+require "cases/helper"
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+if ActiveRecord::Base.connection.supports_ranges?
+  class PostgresqlRange < ActiveRecord::Base
+    self.table_name = "postgresql_ranges"
+  end
+
+  class PostgresqlRangeTest < ActiveRecord::TestCase
+    def teardown
+      @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.connection
+      begin
+        @connection.transaction do
+          @connection.create_table('postgresql_ranges') do |t|
+            t.daterange :date_range
+            t.numrange :num_range
+            t.tsrange :ts_range
+            t.tstzrange :tstz_range
+            t.int4range :int4_range
+            t.int8range :int8_range
+          end
+        end
+      rescue ActiveRecord::StatementInvalid
+        return skip "do not test on PG without range"
+      end
+
+      insert_range(id: 101,
+                   date_range: "[''2012-01-02'', ''2012-01-04'']",
+                   num_range: "[0.1, 0.2]",
+                   ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'']",
+                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']",
+                   int4_range: "[1, 10]",
+                   int8_range: "[10, 100]")
+
+      insert_range(id: 102,
+                   date_range: "(''2012-01-02'', ''2012-01-04'')",
+                   num_range: "[0.1, 0.2)",
+                   ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'')",
+                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')",
+                   int4_range: "(1, 10)",
+                   int8_range: "(10, 100)")
+
+      insert_range(id: 103,
+                   date_range: "(''2012-01-02'',]",
+                   num_range: "[0.1,]",
+                   ts_range: "[''2010-01-01 14:30'',]",
+                   tstz_range: "[''2010-01-01 14:30:00+05'',]",
+                   int4_range: "(1,]",
+                   int8_range: "(10,]")
+
+      insert_range(id: 104,
+                   date_range: "[,]",
+                   num_range: "[,]",
+                   ts_range: "[,]",
+                   tstz_range: "[,]",
+                   int4_range: "[,]",
+                   int8_range: "[,]")
+
+      insert_range(id: 105,
+                   date_range: "(''2012-01-02'', ''2012-01-02'')",
+                   num_range: "(0.1, 0.1)",
+                   ts_range: "(''2010-01-01 14:30'', ''2010-01-01 14:30'')",
+                   tstz_range: "(''2010-01-01 14:30:00+05'', ''2010-01-01 06:30:00-03'')",
+                   int4_range: "(1, 1)",
+                   int8_range: "(10, 10)")
+
+      @new_range = PostgresqlRange.new
+      @first_range = PostgresqlRange.find(101)
+      @second_range = PostgresqlRange.find(102)
+      @third_range = PostgresqlRange.find(103)
+      @fourth_range = PostgresqlRange.find(104)
+      @empty_range = PostgresqlRange.find(105)
+    end
+
+    def test_data_type_of_range_types
+      assert_equal :daterange, @first_range.column_for_attribute(:date_range).type
+      assert_equal :numrange, @first_range.column_for_attribute(:num_range).type
+      assert_equal :tsrange, @first_range.column_for_attribute(:ts_range).type
+      assert_equal :tstzrange, @first_range.column_for_attribute(:tstz_range).type
+      assert_equal :int4range, @first_range.column_for_attribute(:int4_range).type
+      assert_equal :int8range, @first_range.column_for_attribute(:int8_range).type
+    end
+
+    def test_int4range_values
+      assert_equal 1...11, @first_range.int4_range
+      assert_equal 2...10, @second_range.int4_range
+      assert_equal 2...Float::INFINITY, @third_range.int4_range
+      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int4_range)
+      assert_nil @empty_range.int4_range
+    end
+
+    def test_int8range_values
+      assert_equal 10...101, @first_range.int8_range
+      assert_equal 11...100, @second_range.int8_range
+      assert_equal 11...Float::INFINITY, @third_range.int8_range
+      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int8_range)
+      assert_nil @empty_range.int8_range
+    end
+
+    def test_daterange_values
+      assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 5), @first_range.date_range
+      assert_equal Date.new(2012, 1, 3)...Date.new(2012, 1, 4), @second_range.date_range
+      assert_equal Date.new(2012, 1, 3)...Float::INFINITY, @third_range.date_range
+      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.date_range)
+      assert_nil @empty_range.date_range
+    end
+
+    def test_numrange_values
+      assert_equal BigDecimal.new('0.1')..BigDecimal.new('0.2'), @first_range.num_range
+      assert_equal BigDecimal.new('0.1')...BigDecimal.new('0.2'), @second_range.num_range
+      assert_equal BigDecimal.new('0.1')...BigDecimal.new('Infinity'), @third_range.num_range
+      assert_equal BigDecimal.new('-Infinity')...BigDecimal.new('Infinity'), @fourth_range.num_range
+      assert_nil @empty_range.num_range
+    end
+
+    def test_tsrange_values
+      tz = ::ActiveRecord::Base.default_timezone
+      assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 0)..Time.send(tz, 2011, 1, 1, 14, 30, 0), @first_range.ts_range
+      assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 1, 1, 14, 30, 0), @second_range.ts_range
+      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.ts_range)
+      assert_nil @empty_range.ts_range
+    end
+
+    def test_tstzrange_values
+      assert_equal Time.parse('2010-01-01 09:30:00 UTC')..Time.parse('2011-01-01 17:30:00 UTC'), @first_range.tstz_range
+      assert_equal Time.parse('2010-01-01 09:30:00 UTC')...Time.parse('2011-01-01 17:30:00 UTC'), @second_range.tstz_range
+      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.tstz_range)
+      assert_nil @empty_range.tstz_range
+    end
+
+    def test_create_tstzrange
+      tstzrange = Time.parse('2010-01-01 14:30:00 +0100')...Time.parse('2011-02-02 14:30:00 CDT')
+      round_trip(@new_range, :tstz_range, tstzrange)
+      assert_equal @new_range.tstz_range, tstzrange
+      assert_equal @new_range.tstz_range, Time.parse('2010-01-01 13:30:00 UTC')...Time.parse('2011-02-02 19:30:00 UTC')
+    end
+
+    def test_update_tstzrange
+      assert_equal_round_trip(@first_range, :tstz_range,
+                              Time.parse('2010-01-01 14:30:00 CDT')...Time.parse('2011-02-02 14:30:00 CET'))
+      assert_nil_round_trip(@first_range, :tstz_range,
+                            Time.parse('2010-01-01 14:30:00 +0100')...Time.parse('2010-01-01 13:30:00 +0000'))
+    end
+
+    def test_create_tsrange
+      tz = ::ActiveRecord::Base.default_timezone
+      assert_equal_round_trip(@new_range, :ts_range,
+                              Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 2, 2, 14, 30, 0))
+    end
+
+    def test_update_tsrange
+      tz = ::ActiveRecord::Base.default_timezone
+      assert_equal_round_trip(@first_range, :ts_range,
+                              Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 2, 2, 14, 30, 0))
+      assert_nil_round_trip(@first_range, :ts_range,
+                            Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2010, 1, 1, 14, 30, 0))
+    end
+
+    def test_create_numrange
+      assert_equal_round_trip(@new_range, :num_range,
+                              BigDecimal.new('0.5')...BigDecimal.new('1'))
+    end
+
+    def test_update_numrange
+      assert_equal_round_trip(@first_range, :num_range,
+                              BigDecimal.new('0.5')...BigDecimal.new('1'))
+      assert_nil_round_trip(@first_range, :num_range,
+                            BigDecimal.new('0.5')...BigDecimal.new('0.5'))
+    end
+
+    def test_create_daterange
+      assert_equal_round_trip(@new_range, :date_range,
+                              Range.new(Date.new(2012, 1, 1), Date.new(2013, 1, 1), true))
+    end
+
+    def test_update_daterange
+      assert_equal_round_trip(@first_range, :date_range,
+                              Date.new(2012, 2, 3)...Date.new(2012, 2, 10))
+      assert_nil_round_trip(@first_range, :date_range,
+                            Date.new(2012, 2, 3)...Date.new(2012, 2, 3))
+    end
+
+    def test_create_int4range
+      assert_equal_round_trip(@new_range, :int4_range, Range.new(3, 50, true))
+    end
+
+    def test_update_int4range
+      assert_equal_round_trip(@first_range, :int4_range, 6...10)
+      assert_nil_round_trip(@first_range, :int4_range, 3...3)
+    end
+
+    def test_create_int8range
+      assert_equal_round_trip(@new_range, :int8_range, Range.new(30, 50, true))
+    end
+
+    def test_update_int8range
+      assert_equal_round_trip(@first_range, :int8_range, 60000...10000000)
+      assert_nil_round_trip(@first_range, :int8_range, 39999...39999)
+    end
+
+    private
+      def assert_equal_round_trip(range, attribute, value)
+        round_trip(range, attribute, value)
+        assert_equal value, range.public_send(attribute)
+      end
+
+      def assert_nil_round_trip(range, attribute, value)
+        round_trip(range, attribute, value)
+        assert_nil range.public_send(attribute)
+      end
+
+      def round_trip(range, attribute, value)
+        range.public_send "#{attribute}=", value
+        assert range.save
+        assert range.reload
+      end
+
+      def insert_range(values)
+        @connection.execute <<-SQL
+          INSERT INTO postgresql_ranges (
+            id,
+            date_range,
+            num_range,
+            ts_range,
+            tstz_range,
+            int4_range,
+            int8_range
+          ) VALUES (
+            #{values[:id]},
+            '#{values[:date_range]}',
+            '#{values[:num_range]}',
+            '#{values[:ts_range]}',
+            '#{values[:tstz_range]}',
+            '#{values[:int4_range]}',
+            '#{values[:int8_range]}'
+          )
+        SQL
+      end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
index f1c4b85126..1497b0abc7 100644
--- a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
@@ -1,38 +1,40 @@
 require 'cases/helper'
 
-module ActiveRecord::ConnectionAdapters
-  class PostgreSQLAdapter < AbstractAdapter
-    class InactivePGconn
-      def query(*args)
-        raise PGError
-      end
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      class InactivePGconn
+        def query(*args)
+          raise PGError
+        end
 
-      def status
-        PGconn::CONNECTION_BAD
+        def status
+          PGconn::CONNECTION_BAD
+        end
       end
-    end
 
-    class StatementPoolTest < ActiveRecord::TestCase
-      def test_cache_is_per_pid
-        return skip('must support fork') unless Process.respond_to?(:fork)
+      class StatementPoolTest < ActiveRecord::TestCase
+        if Process.respond_to?(:fork)
+          def test_cache_is_per_pid
+            cache = StatementPool.new nil, 10
+            cache['foo'] = 'bar'
+            assert_equal 'bar', cache['foo']
 
-        cache = StatementPool.new nil, 10
-        cache['foo'] = 'bar'
-        assert_equal 'bar', cache['foo']
+            pid = fork {
+              lookup = cache['foo'];
+              exit!(!lookup)
+            }
 
-        pid = fork {
-          lookup = cache['foo'];
-          exit!(!lookup)
-        }
-
-        Process.waitpid pid
-        assert $?.success?, 'process should exit successfully'
-      end
+            Process.waitpid pid
+            assert $?.success?, 'process should exit successfully'
+          end
+        end
 
-      def test_dealloc_does_not_raise_on_inactive_connection
-        cache = StatementPool.new InactivePGconn.new, 10
-        cache['foo'] = 'bar'
-        assert_nothing_raised { cache.clear }
+        def test_dealloc_does_not_raise_on_inactive_connection
+          cache = StatementPool.new InactivePGconn.new, 10
+          cache['foo'] = 'bar'
+          assert_nothing_raised { cache.clear }
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
index dbc69a529c..89210866f0 100644
--- a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
@@ -12,10 +12,6 @@ class TimestampTest < ActiveRecord::TestCase
   end
 
   def test_load_infinity_and_beyond
-    unless current_adapter?(:PostgreSQLAdapter)
-      return skip("only tested on postgresql")
-    end
-
     d = Developer.find_by_sql("select 'infinity'::timestamp as updated_at")
     assert d.first.updated_at.infinite?, 'timestamp should be infinite'
 
@@ -26,10 +22,6 @@ class TimestampTest < ActiveRecord::TestCase
   end
 
   def test_save_infinity_and_beyond
-    unless current_adapter?(:PostgreSQLAdapter)
-      return skip("only tested on postgresql")
-    end
-
     d = Developer.create!(:name => 'aaron', :updated_at => 1.0 / 0.0)
     assert_equal(1.0 / 0.0, d.updated_at)
 
@@ -85,9 +77,6 @@ class TimestampTest < ActiveRecord::TestCase
   end
 
   def test_bc_timestamp
-    unless current_adapter?(:PostgreSQLAdapter)
-      return skip("only tested on postgresql")
-    end
     date = Date.new(0) - 1.second
     Developer.create!(:name => "aaron", :updated_at => date)
     assert_equal date, Developer.find_by_name("aaron").updated_at
@@ -109,5 +98,4 @@ class TimestampTest < ActiveRecord::TestCase
       end
       result && result.send(option)
     end
-
 end
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index b573d48807..3f5d981444 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -12,10 +12,6 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
   def setup
     @connection = ActiveRecord::Base.connection
 
-    unless @connection.supports_extensions?
-      return skip "do not test on PG without uuid-ossp"
-    end
-
     unless @connection.extension_enabled?('uuid-ossp')
       @connection.enable_extension 'uuid-ossp'
       @connection.commit_db_transaction
@@ -24,7 +20,7 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
     @connection.reconnect!
 
     @connection.transaction do
-      @connection.create_table('pg_uuids', id: :uuid) do |t|
+      @connection.create_table('pg_uuids', id: :uuid, default: 'uuid_generate_v1()') do |t|
         t.string 'name'
         t.uuid 'other_uuid', default: 'uuid_generate_v4()'
       end
@@ -35,32 +31,35 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
     @connection.execute 'drop table if exists pg_uuids'
   end
 
-  def test_id_is_uuid
-    assert_equal :uuid, UUID.columns_hash['id'].type
-    assert UUID.primary_key
-  end
+  if ActiveRecord::Base.connection.supports_extensions?
+    def test_id_is_uuid
+      assert_equal :uuid, UUID.columns_hash['id'].type
+      assert UUID.primary_key
+    end
 
-  def test_id_has_a_default
-    u = UUID.create
-    assert_not_nil u.id
-  end
+    def test_id_has_a_default
+      u = UUID.create
+      assert_not_nil u.id
+    end
 
-  def test_auto_create_uuid
-    u = UUID.create
-    u.reload
-    assert_not_nil u.other_uuid
-  end
+    def test_auto_create_uuid
+      u = UUID.create
+      u.reload
+      assert_not_nil u.other_uuid
+    end
 
-  def test_pk_and_sequence_for_uuid_primary_key
-    pk, seq = @connection.pk_and_sequence_for('pg_uuids')
-    assert_equal 'id', pk
-    assert_equal nil, seq
-  end
+    def test_pk_and_sequence_for_uuid_primary_key
+      pk, seq = @connection.pk_and_sequence_for('pg_uuids')
+      assert_equal 'id', pk
+      assert_equal nil, seq
+    end
 
-  def test_schema_dumper_for_uuid_primary_key
-    schema = StringIO.new
-    ActiveRecord::SchemaDumper.dump(@connection, schema)
-    assert_match(/\bcreate_table "pg_uuids", id: :uuid\b/, schema.string)
+    def test_schema_dumper_for_uuid_primary_key
+      schema = StringIO.new
+      ActiveRecord::SchemaDumper.dump(@connection, schema)
+      assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: "uuid_generate_v1\(\)"/, schema.string)
+      assert_match(/t\.uuid   "other_uuid", default: "uuid_generate_v4\(\)"/, schema.string)
+    end
   end
 end
 
@@ -73,6 +72,11 @@ class PostgresqlUUIDTestNilDefault < ActiveRecord::TestCase
     @connection = ActiveRecord::Base.connection
     @connection.reconnect!
 
+    unless @connection.extension_enabled?('uuid-ossp')
+      @connection.enable_extension 'uuid-ossp'
+      @connection.commit_db_transaction
+    end
+
     @connection.transaction do
       @connection.create_table('pg_uuids', id: false) do |t|
         t.primary_key :id, :uuid, default: nil
@@ -85,11 +89,60 @@ class PostgresqlUUIDTestNilDefault < ActiveRecord::TestCase
     @connection.execute 'drop table if exists pg_uuids'
   end
 
-  def test_id_allows_default_override_via_nil
-    col_desc = @connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
+  if ActiveRecord::Base.connection.supports_extensions?
+    def test_id_allows_default_override_via_nil
+      col_desc = @connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
                                     FROM pg_attribute a
                                     LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
                                     WHERE a.attname='id' AND a.attrelid = 'pg_uuids'::regclass").first
-    assert_nil col_desc["default"]
+      assert_nil col_desc["default"]
+    end
+  end
+end
+
+class PostgresqlUUIDTestInverseOf < ActiveRecord::TestCase
+  class UuidPost < ActiveRecord::Base
+    self.table_name = 'pg_uuid_posts'
+    has_many :uuid_comments, inverse_of: :uuid_post
+  end
+
+  class UuidComment < ActiveRecord::Base
+    self.table_name = 'pg_uuid_comments'
+    belongs_to :uuid_post
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.reconnect!
+
+    unless @connection.extension_enabled?('uuid-ossp')
+      @connection.enable_extension 'uuid-ossp'
+      @connection.commit_db_transaction
+    end
+
+    @connection.transaction do
+      @connection.create_table('pg_uuid_posts', id: :uuid) do |t|
+        t.string 'title'
+      end
+      @connection.create_table('pg_uuid_comments', id: :uuid) do |t|
+        t.uuid :uuid_post_id, default: 'uuid_generate_v4()'
+        t.string 'content'
+      end
+    end
+  end
+
+  def teardown
+    @connection.transaction do
+      @connection.execute 'drop table if exists pg_uuid_comments'
+      @connection.execute 'drop table if exists pg_uuid_posts'
+    end
+  end
+
+  if ActiveRecord::Base.connection.supports_extensions?
+    def test_collection_association_with_uuid
+      post    = UuidPost.create!
+      comment = post.uuid_comments.create!
+      assert post.uuid_comments.find(comment.id)
+    end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/xml_test.rb b/activerecord/test/cases/adapters/postgresql/xml_test.rb
new file mode 100644
index 0000000000..bf14b378d8
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/xml_test.rb
@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'cases/helper'
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+class PostgresqlXMLTest < ActiveRecord::TestCase
+  class XmlDataType < ActiveRecord::Base
+    self.table_name = 'xml_data_type'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    begin
+      @connection.transaction do
+        @connection.create_table('xml_data_type') do |t|
+          t.xml 'payload', default: {}
+        end
+      end
+    rescue ActiveRecord::StatementInvalid
+      return skip "do not test on PG without xml"
+    end
+    @column = XmlDataType.columns.find { |c| c.name == 'payload' }
+  end
+
+  def teardown
+    @connection.execute 'drop table if exists xml_data_type'
+  end
+
+  def test_column
+    assert_equal :xml, @column.type
+  end
+
+  def test_null_xml
+    @connection.execute %q|insert into xml_data_type (payload) VALUES(null)|
+    assert_nil XmlDataType.first.payload
+  end
+end