torque-postgresql 3.4.1 → 4.0.0.rc1

data/spec/tests/period_spec.rb

@@ -75,26 +75,26 @@ RSpec.describe 'Period' do
 
     let(:cast_type) { '::timestamp' }
     let(:cast_db_value) { "#{db_value}#{cast_type}" }
-    let(:empty_condition) { "#{type}(NULL, NULL)" }
-    let(:nullif_condition) { "nullif(#{db_field}, #{empty_condition})" }
+    let(:empty_condition) { "#{type.to_s.upcase}(NULL, NULL)" }
+    let(:nullif_condition) { "NULLIF(#{db_field}, #{empty_condition})" }
 
     let(:date_type) { :daterange }
-    let(:lower_date) { "lower(#{db_field})::date" }
-    let(:upper_date) { "upper(#{db_field})::date" }
-    let(:date_db_field) { "#{date_type}(#{lower_date}, #{upper_date}, '[]')" }
+    let(:lower_date) { "LOWER(#{db_field})::date" }
+    let(:upper_date) { "UPPER(#{db_field})::date" }
+    let(:date_db_field) { "#{date_type.to_s.upcase}(#{lower_date}, #{upper_date}, '[]')" }
 
     context 'on model' do
       before { decorate(model, :period) }
 
       it 'queries current on period' do
         expect(model.period_on(value).to_sql).to include(<<-SQL.squish)
-          coalesce(#{nullif_condition} @> #{cast_db_value}, #{true_value})
+          COALESCE(#{nullif_condition} @> #{cast_db_value}, #{true_value})
         SQL
       end
 
       it 'queries current period' do
         expect(model.current_period.to_sql).to include(<<-SQL.squish)
-          coalesce(#{nullif_condition} @>
+          COALESCE(#{nullif_condition} @>
         SQL
 
         expect(model.current_period.to_sql).to include(<<-SQL.squish)
@@ -104,7 +104,7 @@ RSpec.describe 'Period' do
 
       it 'queries not current period' do
         expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
-          NOT (coalesce(#{nullif_condition} @>
+          NOT (COALESCE(#{nullif_condition} @>
         SQL
 
         expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
@@ -138,7 +138,7 @@ RSpec.describe 'Period' do
         SQL
 
         expect(model.period_overlapping(value, value).to_sql).to include(<<-SQL.squish)
-          #{db_field} && #{type}(#{db_value}, #{db_value})
+          #{db_field} && #{type.to_s.upcase}(#{db_value}, #{db_value})
         SQL
       end
 
@@ -148,47 +148,47 @@ RSpec.describe 'Period' do
         SQL
 
         expect(model.period_not_overlapping(value, value).to_sql).to include(<<-SQL.squish)
-          NOT (#{db_field} && #{type}(#{db_value}, #{db_value}))
+          NOT (#{db_field} && #{type.to_s.upcase}(#{db_value}, #{db_value}))
         SQL
       end
 
       it 'queries starting after period' do
         expect(model.period_starting_after(:test).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) > "time_keepers"."test"
+          LOWER(#{db_field}) > "time_keepers"."test"
         SQL
 
         expect(model.period_starting_after(value).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) > #{db_value}
+          LOWER(#{db_field}) > #{db_value}
         SQL
       end
 
       it 'queries starting before period' do
         expect(model.period_starting_before(:test).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) < "time_keepers"."test"
+          LOWER(#{db_field}) < "time_keepers"."test"
         SQL
 
         expect(model.period_starting_before(value).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) < #{db_value}
+          LOWER(#{db_field}) < #{db_value}
         SQL
       end
 
       it 'queries finishing after period' do
         expect(model.period_finishing_after(:test).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) > "time_keepers"."test"
+          UPPER(#{db_field}) > "time_keepers"."test"
         SQL
 
         expect(model.period_finishing_after(value).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) > #{db_value}
+          UPPER(#{db_field}) > #{db_value}
         SQL
       end
 
       it 'queries finishing before period' do
         expect(model.period_finishing_before(:test).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) < "time_keepers"."test"
+          UPPER(#{db_field}) < "time_keepers"."test"
         SQL
 
         expect(model.period_finishing_before(value).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) < #{db_value}
+          UPPER(#{db_field}) < #{db_value}
         SQL
       end
 
@@ -234,7 +234,7 @@ RSpec.describe 'Period' do
         SQL
 
         expect(model.period_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
-          #{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+          #{date_db_field} && #{date_type.to_s.upcase}(#{db_value}::date, #{db_value}::date)
         SQL
       end
 
@@ -244,7 +244,7 @@ RSpec.describe 'Period' do
         SQL
 
         expect(model.period_not_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
-          NOT (#{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date))
+          NOT (#{date_db_field} && #{date_type.to_s.upcase}(#{db_value}::date, #{db_value}::date))
         SQL
       end
 
@@ -305,25 +305,25 @@ RSpec.describe 'Period' do
     context 'with field threshold' do
       before { decorate(model, :period, threshold: :th) }
 
-      let(:lower_db_field) { "(lower(#{db_field}) - #{threshold_value})" }
-      let(:upper_db_field) { "(upper(#{db_field}) + #{threshold_value})" }
+      let(:lower_db_field) { "(LOWER(#{db_field}) - #{threshold_value})" }
+      let(:upper_db_field) { "(UPPER(#{db_field}) + #{threshold_value})" }
       let(:threshold_value) { '"time_keepers"."th"' }
-      let(:threshold_db_field) { "#{type}(#{lower_db_field}, #{upper_db_field})" }
-      let(:nullif_condition) { "nullif(#{threshold_db_field}, #{empty_condition})" }
+      let(:threshold_db_field) { "#{type.to_s.upcase}(#{lower_db_field}, #{upper_db_field})" }
+      let(:nullif_condition) { "NULLIF(#{threshold_db_field}, #{empty_condition})" }
       let(:threshold_date_db_field) do
-        "daterange(#{lower_db_field}::date, #{upper_db_field}::date, '[]')"
+        "DATERANGE(#{lower_db_field}::date, #{upper_db_field}::date, '[]')"
       end
 
       context 'on model' do
         it 'queries current on period' do
           expect(model.period_on(value).to_sql).to include(<<-SQL.squish)
-            coalesce(#{nullif_condition} @> #{cast_db_value}, #{true_value})
+            COALESCE(#{nullif_condition} @> #{cast_db_value}, #{true_value})
           SQL
         end
 
         it 'queries current period' do
           expect(model.current_period.to_sql).to include(<<-SQL.squish)
-            coalesce(#{nullif_condition} @>
+            COALESCE(#{nullif_condition} @>
           SQL
 
           expect(model.current_period.to_sql).to include(<<-SQL.squish)
@@ -333,7 +333,7 @@ RSpec.describe 'Period' do
 
         it 'queries not current period' do
           expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
-            NOT (coalesce(#{nullif_condition} @>
+            NOT (COALESCE(#{nullif_condition} @>
           SQL
 
           expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
@@ -357,7 +357,7 @@ RSpec.describe 'Period' do
           SQL
 
           expect(model.period_real_overlapping(value, value).to_sql).to include(<<-SQL.squish)
-            #{threshold_db_field} && #{type}(#{db_value}, #{db_value})
+            #{threshold_db_field} && #{type.to_s.upcase}(#{db_value}, #{db_value})
           SQL
         end
 
@@ -427,7 +427,7 @@ RSpec.describe 'Period' do
           SQL
 
           expect(model.period_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
-            #{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+            #{date_db_field} && #{date_type.to_s.upcase}(#{db_value}::date, #{db_value}::date)
           SQL
         end
 
@@ -437,7 +437,7 @@ RSpec.describe 'Period' do
           SQL
 
           expect(model.period_not_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
-            NOT (#{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date))
+            NOT (#{date_db_field} && #{date_type.to_s.upcase}(#{db_value}::date, #{db_value}::date))
           SQL
         end
 
@@ -457,7 +457,7 @@ RSpec.describe 'Period' do
           SQL
 
           expect(model.period_real_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
-            #{threshold_date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+            #{threshold_date_db_field} && #{date_type.to_s.upcase}(#{db_value}::date, #{db_value}::date)
           SQL
         end
       end
@@ -512,22 +512,22 @@ RSpec.describe 'Period' do
     context 'with value threshold' do
       before { decorate(model, :period, threshold: 5.minutes) }
 
-      let(:lower_db_field) { "(lower(#{db_field}) - #{threshold_value})" }
-      let(:upper_db_field) { "(upper(#{db_field}) + #{threshold_value})" }
+      let(:lower_db_field) { "(LOWER(#{db_field}) - #{threshold_value})" }
+      let(:upper_db_field) { "(UPPER(#{db_field}) + #{threshold_value})" }
       let(:threshold_value) { "'300 seconds'::interval" }
-      let(:threshold_db_field) { "#{type}(#{lower_db_field}, #{upper_db_field})" }
-      let(:nullif_condition) { "nullif(#{threshold_db_field}, #{empty_condition})" }
+      let(:threshold_db_field) { "#{type.to_s.upcase}(#{lower_db_field}, #{upper_db_field})" }
+      let(:nullif_condition) { "NULLIF(#{threshold_db_field}, #{empty_condition})" }
 
       context 'on model' do
         it 'queries current on period' do
           expect(model.period_on(value).to_sql).to include(<<-SQL.squish)
-            coalesce(#{nullif_condition} @> #{cast_db_value}, #{true_value})
+            COALESCE(#{nullif_condition} @> #{cast_db_value}, #{true_value})
           SQL
         end
 
         it 'queries current period' do
           expect(model.current_period.to_sql).to include(<<-SQL.squish)
-            coalesce(#{nullif_condition} @>
+            COALESCE(#{nullif_condition} @>
           SQL
 
           expect(model.current_period.to_sql).to include(<<-SQL.squish)
@@ -537,7 +537,7 @@ RSpec.describe 'Period' do
 
         it 'queries not current period' do
           expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
-            NOT (coalesce(#{nullif_condition} @>
+            NOT (COALESCE(#{nullif_condition} @>
           SQL
 
           expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
@@ -561,7 +561,7 @@ RSpec.describe 'Period' do
           SQL
 
           expect(model.period_real_overlapping(value, value).to_sql).to include(<<-SQL.squish)
-            #{threshold_db_field} && #{type}(#{db_value}, #{db_value})
+            #{threshold_db_field} && #{type.to_s.upcase}(#{db_value}, #{db_value})
           SQL
         end
 
@@ -631,7 +631,7 @@ RSpec.describe 'Period' do
           SQL
 
           expect(model.period_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
-            #{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+            #{date_db_field} && #{date_type.to_s.upcase}(#{db_value}::date, #{db_value}::date)
           SQL
         end
 
@@ -641,7 +641,7 @@ RSpec.describe 'Period' do
           SQL
 
           expect(model.period_not_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
-            NOT (#{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date))
+            NOT (#{date_db_field} && #{date_type.to_s.upcase}(#{db_value}::date, #{db_value}::date))
           SQL
         end
       end
@@ -701,26 +701,26 @@ RSpec.describe 'Period' do
 
     let(:cast_type) { '::date' }
     let(:cast_db_value) { "#{db_value}#{cast_type}" }
-    let(:empty_condition) { "#{type}(NULL, NULL)" }
-    let(:nullif_condition) { "nullif(#{threshold_db_field}, #{empty_condition})" }
+    let(:empty_condition) { "#{type.to_s.upcase}(NULL, NULL)" }
+    let(:nullif_condition) { "NULLIF(#{threshold_db_field}, #{empty_condition})" }
 
-    let(:lower_db_field) { "(lower(#{db_field}) - #{threshold_value})::date" }
-    let(:upper_db_field) { "(upper(#{db_field}) + #{threshold_value})::date" }
+    let(:lower_db_field) { "(LOWER(#{db_field}) - #{threshold_value})::date" }
+    let(:upper_db_field) { "(UPPER(#{db_field}) + #{threshold_value})::date" }
     let(:threshold_value) { "'86400 seconds'::interval" }
-    let(:threshold_db_field) { "#{type}(#{lower_db_field}, #{upper_db_field})" }
+    let(:threshold_db_field) { "#{type.to_s.upcase}(#{lower_db_field}, #{upper_db_field})" }
 
     before { decorate(model, :available, pessimistic: true, threshold: 1.day) }
 
     context 'on model' do
       it 'queries current on available' do
         expect(model.available_on(value).to_sql).to include(<<-SQL.squish)
-          coalesce(#{nullif_condition} @> #{cast_db_value}, #{false_value})
+          COALESCE(#{nullif_condition} @> #{cast_db_value}, #{false_value})
         SQL
       end
 
       it 'queries current available' do
         expect(model.current_available.to_sql).to include(<<-SQL.squish)
-          coalesce(#{nullif_condition} @>
+          COALESCE(#{nullif_condition} @>
         SQL
 
         expect(model.current_available.to_sql).to include(<<-SQL.squish)
@@ -730,7 +730,7 @@ RSpec.describe 'Period' do
 
       it 'queries not current available' do
         expect(model.not_current_available.to_sql).to include(<<-SQL.squish)
-          NOT (coalesce(#{nullif_condition} @>
+          NOT (COALESCE(#{nullif_condition} @>
         SQL
 
         expect(model.not_current_available.to_sql).to include(<<-SQL.squish)
@@ -764,7 +764,7 @@ RSpec.describe 'Period' do
         SQL
 
         expect(model.available_overlapping(value, value).to_sql).to include(<<-SQL.squish)
-          #{db_field} && #{type}(#{db_value}, #{db_value})
+          #{db_field} && #{type.to_s.upcase}(#{db_value}, #{db_value})
         SQL
       end
 
@@ -774,47 +774,47 @@ RSpec.describe 'Period' do
         SQL
 
         expect(model.available_not_overlapping(value, value).to_sql).to include(<<-SQL.squish)
-          NOT (#{db_field} && #{type}(#{db_value}, #{db_value}))
+          NOT (#{db_field} && #{type.to_s.upcase}(#{db_value}, #{db_value}))
         SQL
       end
 
       it 'queries starting after available' do
         expect(model.available_starting_after(:test).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) > "time_keepers"."test"
+          LOWER(#{db_field}) > "time_keepers"."test"
         SQL
 
         expect(model.available_starting_after(value).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) > #{db_value}
+          LOWER(#{db_field}) > #{db_value}
         SQL
       end
 
       it 'queries starting before available' do
         expect(model.available_starting_before(:test).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) < "time_keepers"."test"
+          LOWER(#{db_field}) < "time_keepers"."test"
         SQL
 
         expect(model.available_starting_before(value).to_sql).to include(<<-SQL.squish)
-          lower(#{db_field}) < #{db_value}
+          LOWER(#{db_field}) < #{db_value}
         SQL
       end
 
       it 'queries finishing after available' do
         expect(model.available_finishing_after(:test).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) > "time_keepers"."test"
+          UPPER(#{db_field}) > "time_keepers"."test"
         SQL
 
         expect(model.available_finishing_after(value).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) > #{db_value}
+          UPPER(#{db_field}) > #{db_value}
         SQL
       end
 
       it 'queries finishing before available' do
         expect(model.available_finishing_before(:test).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) < "time_keepers"."test"
+          UPPER(#{db_field}) < "time_keepers"."test"
         SQL
 
         expect(model.available_finishing_before(value).to_sql).to include(<<-SQL.squish)
-          upper(#{db_field}) < #{db_value}
+          UPPER(#{db_field}) < #{db_value}
         SQL
       end
 
@@ -834,7 +834,7 @@ RSpec.describe 'Period' do
         SQL
 
         expect(model.available_real_overlapping(value, value).to_sql).to include(<<-SQL.squish)
-          #{threshold_db_field} && #{type}(#{db_value}, #{db_value})
+          #{threshold_db_field} && #{type.to_s.upcase}(#{db_value}, #{db_value})
         SQL
       end
 

data/spec/tests/predicate_builder_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+RSpec.describe 'PredicateBuilder' do
+  describe 'on enumerator lazy' do
+    let(:timed_out_error) do
+      Torque::PostgreSQL::PredicateBuilder::EnumeratorLazyHandler::Timeout
+    end
+
+    subject { Video.all }
+
+    after do
+      Torque::PostgreSQL.config.predicate_builder.lazy_timeout = 0.02
+      Torque::PostgreSQL.config.predicate_builder.lazy_limit = 2_000
+    end
+
+    it 'works with provided value' do
+      sql = subject.where(id: [1,2,3].lazy).to_sql
+      expect(sql).to include("WHERE \"videos\".\"id\" IN (1, 2, 3)")
+    end
+
+    it 'handles gracefully a timeout' do
+      Torque::PostgreSQL.config.predicate_builder.lazy_timeout = 0.01
+      Torque::PostgreSQL.config.predicate_builder.lazy_limit = nil
+      expect { subject.where(id: (1..).lazy).to_sql }.to raise_error(timed_out_error)
+    end
+
+    it 'handles properly a limit' do
+      Torque::PostgreSQL.config.predicate_builder.lazy_timeout = nil
+      Torque::PostgreSQL.config.predicate_builder.lazy_limit = 2
+
+      sql = subject.where(id: [1,2,3].lazy).to_sql
+      expect(sql).to include("WHERE \"videos\".\"id\" IN (1, 2)")
+    end
+  end
+
+  describe 'on arel attribute' do
+    subject { Item.all }
+
+    it 'works with both plain attributes' do
+      sql = subject.where(id: Item.arel_table[:id]).to_sql
+      expect(sql).to include("WHERE \"items\".\"id\" = \"items\".\"id\"")
+    end
+
+    it 'works when when the left side is an array' do
+      sql = subject.where(tag_ids: Item.arel_table[:id]).to_sql
+      expect(sql).to include("WHERE \"items\".\"id\" = ANY(\"items\".\"tag_ids\")")
+    end
+
+    it 'works when the right side is an array' do
+      sql = subject.where(id: Item.arel_table[:tag_ids]).to_sql
+      expect(sql).to include("WHERE \"items\".\"id\" = ANY(\"items\".\"tag_ids\")")
+    end
+
+    it 'works when both are arrays' do
+      sql = subject.where(tag_ids: Item.arel_table[:tag_ids]).to_sql
+      expect(sql).to include("WHERE \"items\".\"tag_ids\" && \"items\".\"tag_ids\"")
+    end
+  end
+
+  describe 'on array' do
+    subject { Item.all }
+
+    before { Torque::PostgreSQL.config.predicate_builder.handle_array_attributes = true }
+    after { Torque::PostgreSQL.config.predicate_builder.handle_array_attributes = false }
+
+    it 'works with plain array when disabled' do
+      Torque::PostgreSQL.config.predicate_builder.handle_array_attributes = false
+
+      sql = subject.where(tag_ids: 1).to_sql
+      expect(sql).to include("WHERE \"items\".\"tag_ids\" = 1")
+
+      sql = subject.where(tag_ids: [1, 2, 3]).to_sql
+      expect(sql).to include("WHERE \"items\".\"tag_ids\" = '{1,2,3}'")
+    end
+
+    it 'works with a single value' do
+      sql = subject.where(tag_ids: 1).to_sql
+      expect(sql).to include("WHERE 1 = ANY(\"items\".\"tag_ids\")")
+    end
+
+    it 'works with an array value' do
+      sql = subject.where(tag_ids: [1, 2, 3]).to_sql
+      expect(sql).to include("WHERE \"items\".\"tag_ids\" && '{1,2,3}'")
+    end
+
+    it 'works with an empty array' do
+      sql = subject.where(tag_ids: []).to_sql
+      expect(sql).to include("WHERE CARDINALITY(\"items\".\"tag_ids\") = 0")
+    end
+
+    it 'properly binds the provided values' do
+      sql, binds = get_query_with_binds { subject.where(tag_ids: 1).load }
+      expect(sql).to include("WHERE $1 = ANY(\"items\".\"tag_ids\")")
+      expect(binds.first.value).to eq(1)
+
+      sql, binds = get_query_with_binds { subject.where(tag_ids: [1, 2, 3]).load }
+      expect(sql).to include("WHERE \"items\".\"tag_ids\" && $1")
+      expect(binds.first.value).to eq([1, 2, 3])
+
+      sql, binds = get_query_with_binds { subject.where(tag_ids: []).load }
+      expect(sql).to include("WHERE CARDINALITY(\"items\".\"tag_ids\") = 0")
+      expect(binds).to be_empty
+    end
+  end
+
+  describe 'on regexp' do
+    subject { Video.all }
+
+    it 'works with a basic regular expression' do
+      sql = subject.where(title: /(a|b)/).to_sql
+      expect(sql).to include("WHERE \"videos\".\"title\" ~ '(a|b)'")
+    end
+
+    it 'works with a case-insensitive regular expression' do
+      sql = subject.where(title: /(a|b)/i).to_sql
+      expect(sql).to include("WHERE \"videos\".\"title\" ~* '(a|b)'")
+    end
+
+    it 'works with characters that need escape' do
+      sql = subject.where(title: %r{a|'|"|\\}).to_sql
+      expect(sql).to include("WHERE \"videos\".\"title\" ~ 'a|''|\"|\\\\'")
+    end
+
+    it 'properly binds the provided value' do
+      query = subject.where(title: /(a|b)/)
+
+      sql, binds = get_query_with_binds { query.load }
+      expect(sql).to include("WHERE \"videos\".\"title\" ~ $1")
+      expect(binds.first.value).to eq('(a|b)')
+    end
+  end
+end

data/spec/tests/schema_spec.rb

@@ -2,13 +2,7 @@ require 'spec_helper'
 
 RSpec.describe 'Schema' do
   let(:connection) { ActiveRecord::Base.connection }
-  let(:source) do
-    if Torque::PostgreSQL::AR720
-      ActiveRecord::Base.connection_pool
-    else
-      ActiveRecord::Base.connection
-    end
-  end
+  let(:source) { ActiveRecord::Base.connection_pool }
 
   before do
     connection.instance_variable_set(:@schemas_blacklist, nil)
@@ -16,7 +10,7 @@ RSpec.describe 'Schema' do
   end
 
   context 'on migration' do
-    it 'can check for existance' do
+    it 'can check for existence' do
       expect(connection.schema_exists?(:information_schema)).to be_falsey
       expect(connection.schema_exists?(:information_schema, filtered: false)).to be_truthy
     end

data/spec/tests/table_inheritance_spec.rb

@@ -73,14 +73,7 @@ RSpec.describe 'TableInheritance' do
   end
 
   context 'on schema' do
-    let(:source) do
-      if Torque::PostgreSQL::AR720
-        ActiveRecord::Base.connection_pool
-      else
-        ActiveRecord::Base.connection
-      end
-    end
-
+    let(:source) { ActiveRecord::Base.connection_pool }
     let(:dump_result) do
       ActiveRecord::SchemaDumper.dump(source, (dump_result = StringIO.new))
       dump_result.string
@@ -89,24 +82,24 @@ RSpec.describe 'TableInheritance' do
     it 'dumps single inheritance with body' do
       parts = '"activity_books"'
       parts << ', id: false'
-      parts << ', force: :cascade'
       parts << ', inherits: "activities"'
+      parts << ', force: :cascade'
       expect(dump_result).to match(/create_table #{parts} do /)
     end
 
     it 'dumps single inheritance without body' do
       parts = '"activity_post_samples"'
       parts << ', id: false'
-      parts << ', force: :cascade'
       parts << ', inherits: "activity_posts"'
+      parts << ', force: :cascade'
       expect(dump_result).to match(/create_table #{parts}(?! do \|t\|)/)
     end
 
     it 'dumps multiple inheritance' do
       parts = '"activity_posts"'
       parts << ', id: false'
-      parts << ', force: :cascade'
       parts << ', inherits: (\["images", "activities"\]|\["activities", "images"\])'
+      parts << ', force: :cascade'
       expect(dump_result).to match(/create_table #{parts}/)
     end
   end
@@ -115,12 +108,9 @@ RSpec.describe 'TableInheritance' do
     let(:schema_cache) { ActiveRecord::Base.connection.schema_cache }
     let(:schema_cache_reflection) { schema_cache.instance_variable_get(:@schema_reflection) }
     let(:new_schema_cache) { schema_cache_reflection.send(:cache, schema_cache_source) }
+    let(:schema_cache_source) { schema_cache.instance_variable_get(:@pool) }
 
-    let(:schema_cache_source) do
-      schema_cache.instance_variable_get(Torque::PostgreSQL::AR720 ? :@pool : :@connection)
-    end
-
-    subject { Torque::PostgreSQL::AR710 ? new_schema_cache : schema_cache }
+    subject { new_schema_cache }
 
     it 'correctly defines the associations' do
       scenario = {
@@ -148,8 +138,8 @@ RSpec.describe 'TableInheritance' do
     end
 
     context 'on looking up models' do
-      let(:prepare_arguments) { Torque::PostgreSQL::AR710 ? [schema_cache_source] : nil }
-      let(:prepare_method) { Torque::PostgreSQL::AR720 ? :add_all : :prepare_data_sources }
+      let(:prepare_arguments) { [schema_cache_source] }
+      let(:prepare_method) { :add_all }
 
       after(:all) do
         schema_cache = ActiveRecord::Base.connection.schema_cache
@@ -375,28 +365,37 @@ RSpec.describe 'TableInheritance' do
         ActivityPost::Sample.create(title: 'Activity post')
         records = base.cast_records.order(:id).load.to_a
 
-        expect(records[0].class).to eql(Activity)
-        expect(records[1].class).to eql(ActivityBook)
-        expect(records[2].class).to eql(ActivityPost)
-        expect(records[3].class).to eql(ActivityPost::Sample)
+        expect(records[0]).to be_instance_of(Activity)
+        expect(records[1]).to be_instance_of(ActivityBook)
+        expect(records[2]).to be_instance_of(ActivityPost)
+        expect(records[3]).to be_instance_of(ActivityPost::Sample)
       end
 
       it 'does not cast unnecessary records' do
         ActivityPost.create(title: 'Activity post')
         records = base.cast_records(ActivityBook).order(:id).load.to_a
 
-        expect(records[0].class).to eql(Activity)
-        expect(records[1].class).to eql(ActivityBook)
-        expect(records[2].class).to eql(Activity)
+        expect(records[0]).to be_instance_of(Activity)
+        expect(records[1]).to be_instance_of(ActivityBook)
+        expect(records[2]).to be_instance_of(Activity)
       end
 
-      it 'correctly identify same name attributes' do
+      it 'correctly identifies same name attributes' do
         ActivityPost.create(title: 'Activity post', url: 'posturl1')
         records = base.cast_records.order(:id).load.to_a
 
         expect(records[1].url).to eql('bookurl1')
         expect(records[2].url).to eql('posturl1')
       end
+
+      # TODO: Maybe in the future
+      xit 'does not make internal inheritance attributes accessible' do
+        record = base.cast_records.order(:id).load.last
+
+        expect(record).to be_instance_of(ActivityBook)
+        expect(record).not_to respond_to(:_record_class)
+        expect(record).not_to respond_to(:_auto_cast)
+      end
     end
 
     context 'cast record' do