squeel 1.1.1 → 1.2.1

data/spec/squeel/adapters/active_record/join_dependency_extensions_spec.rb

@@ -3,66 +3,151 @@ require 'spec_helper'
 module Squeel
   module Adapters
     module ActiveRecord
-      describe JoinDependencyExtensions do
-        before do
-          @jd = new_join_dependency(Person, {}, [])
-        end
-
+      describe "JoinDependencyExtensions" do
         it 'joins with symbols' do
-          @jd.send(:build, :articles => :comments)
-          @jd.join_associations.should have(2).associations
-          @jd.join_associations.each do |association|
-            association.join_type.should eq Arel::InnerJoin
+          @jd = new_join_dependency(Person, { :articles => :comments }, [])
+
+          if activerecord_version_at_least('4.2.0')
+            @jd.join_constraints([]).should have(2).join_info
+            @jd.join_constraints([]).map(&:joins).flatten.each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+          elsif activerecord_version_at_least('4.1.0')
+            @jd.join_constraints([]).should have(2).joins
+            @jd.join_constraints([]).each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+          else
+            @jd.join_associations.should have(2).associations
+            @jd.join_associations.each do |association|
+              association.join_type.should eq Squeel::InnerJoin
+            end
           end
         end
 
         it 'joins has_many :through associations' do
-          @jd.send(:build, :authored_article_comments)
-          @jd.join_associations.should have(1).association
-          @jd.join_associations.first.table_name.should eq 'comments'
+          @jd = new_join_dependency(Person, :authored_article_comments, [])
+
+          if activerecord_version_at_least('4.2.0')
+            @jd.join_constraints([]).should have(1).join_info
+            @jd.join_root.children.first.table_name.should eq 'comments'
+          elsif activerecord_version_at_least('4.1.0')
+            @jd.join_constraints([]).should have(2).joins
+            @jd.join_root.children.first.table_name.should eq 'comments'
+          else
+            @jd.join_associations.should have(1).association
+            @jd.join_associations.first.table_name.should eq 'comments'
+          end
         end
 
         it 'joins with stubs' do
-          @jd.send(:build, Nodes::Stub.new(:articles) => Nodes::Stub.new(:comments))
-          @jd.join_associations.should have(2).associations
-          @jd.join_associations.each do |association|
-            association.join_type.should eq Arel::InnerJoin
+          @jd = new_join_dependency(Person, { Squeel::Nodes::Stub.new(:articles) => Squeel::Nodes::Stub.new(:comments) }, [])
+
+          if activerecord_version_at_least('4.2.0')
+            @jd.join_constraints([]).should have(2).join_info
+            @jd.join_constraints([]).map(&:joins).flatten.each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+            @jd.join_root.children.first.table_name.should eq 'articles'
+            @jd.join_root.children.first.children.first.table_name.should eq 'comments'
+          elsif activerecord_version_at_least('4.1.0')
+            @jd.join_constraints([]).should have(2).joins
+            @jd.join_constraints([]).each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+            @jd.join_root.children.first.table_name.should eq 'articles'
+            @jd.join_root.children.first.children.first.table_name.should eq 'comments'
+          else
+            @jd.join_associations.should have(2).associations
+            @jd.join_associations.each do |association|
+              association.join_type.should eq Squeel::InnerJoin
+            end
+            @jd.join_associations[0].table_name.should eq 'articles'
+            @jd.join_associations[1].table_name.should eq 'comments'
           end
-          @jd.join_associations[0].table_name.should eq 'articles'
-          @jd.join_associations[1].table_name.should eq 'comments'
         end
 
         it 'joins with key paths' do
-          @jd.send(:build, dsl{children.children.parent})
-          @jd.join_associations.should have(3).associations
-          @jd.join_associations.each do |association|
-            association.join_type.should eq Arel::InnerJoin
+          @jd = new_join_dependency(Person, dsl{ children.children.parent }, [])
+
+          if activerecord_version_at_least('4.2.0')
+            @jd.join_constraints([]).should have(3).join_info
+            @jd.join_constraints([]).map(&:joins).flatten.each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+            (children_people = @jd.join_root.children.first).aliased_table_name.should eq 'children_people'
+            (children_people2 = children_people.children.first).aliased_table_name.should eq 'children_people_2'
+            children_people2.children.first.aliased_table_name.should eq 'parents_people'
+          elsif activerecord_version_at_least('4.1.0')
+            @jd.join_constraints([]).should have(3).joins
+            @jd.join_constraints([]).each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+            (children_people = @jd.join_root.children.first).aliased_table_name.should eq 'children_people'
+            (children_people2 = children_people.children.first).aliased_table_name.should eq 'children_people_2'
+            children_people2.children.first.aliased_table_name.should eq 'parents_people'
+          else
+            @jd.join_associations.should have(3).associations
+            @jd.join_associations.each do |association|
+              association.join_type.should eq Squeel::InnerJoin
+            end
+            @jd.join_associations[0].aliased_table_name.should eq 'children_people'
+            @jd.join_associations[1].aliased_table_name.should eq 'children_people_2'
+            @jd.join_associations[2].aliased_table_name.should eq 'parents_people'
           end
-          @jd.join_associations[0].aliased_table_name.should eq 'children_people'
-          @jd.join_associations[1].aliased_table_name.should eq 'children_people_2'
-          @jd.join_associations[2].aliased_table_name.should eq 'parents_people'
         end
 
         it 'joins with key paths as keys' do
-          @jd.send(:build, dsl{{children.parent => parent}})
-          @jd.join_associations.should have(3).associations
-          @jd.join_associations.each do |association|
-            association.join_type.should eq Arel::InnerJoin
+          @jd = new_join_dependency(Person, dsl{ { children.parent => parent } }, [])
+
+          if activerecord_version_at_least('4.2.0')
+            @jd.join_constraints([]).should have(3).join_info
+            @jd.join_constraints([]).map(&:joins).flatten.each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+            (children_people = @jd.join_root.children.first).aliased_table_name.should eq 'children_people'
+            (parents_people = children_people.children.first).aliased_table_name.should eq 'parents_people'
+            parents_people.children.first.aliased_table_name.should eq 'parents_people_2'
+          elsif activerecord_version_at_least('4.1.0')
+            @jd.join_constraints([]).should have(3).joins
+            @jd.join_constraints([]).each do |join|
+              join.class.should eq Squeel::InnerJoin
+            end
+            (children_people = @jd.join_root.children.first).aliased_table_name.should eq 'children_people'
+            (parents_people = children_people.children.first).aliased_table_name.should eq 'parents_people'
+            parents_people.children.first.aliased_table_name.should eq 'parents_people_2'
+          else
+            @jd.join_associations.should have(3).associations
+            @jd.join_associations.each do |association|
+              association.join_type.should eq Squeel::InnerJoin
+            end
+            @jd.join_associations[0].aliased_table_name.should eq 'children_people'
+            @jd.join_associations[1].aliased_table_name.should eq 'parents_people'
+            @jd.join_associations[2].aliased_table_name.should eq 'parents_people_2'
           end
-          @jd.join_associations[0].aliased_table_name.should eq 'children_people'
-          @jd.join_associations[1].aliased_table_name.should eq 'parents_people'
-          @jd.join_associations[2].aliased_table_name.should eq 'parents_people_2'
         end
 
         it 'joins using outer joins' do
-          @jd.send(:build, :articles.outer => :comments.outer)
-          @jd.join_associations.should have(2).associations
-          @jd.join_associations.each do |association|
-            association.join_type.should eq Arel::OuterJoin
+          @jd = new_join_dependency(Person, { :articles.outer => :comments.outer }, [])
+
+          if activerecord_version_at_least('4.2.0')
+            @jd.join_constraints([]).should have(2).join_info
+            @jd.join_constraints([]).map(&:joins).flatten.each do |join|
+              join.class.should eq Squeel::OuterJoin
+            end
+          elsif activerecord_version_at_least('4.1.0')
+            @jd.join_constraints([]).should have(2).joins
+            @jd.join_constraints([]).each do |join|
+              join.class.should eq Squeel::OuterJoin
+            end
+          else
+            @jd.join_associations.should have(2).associations
+            @jd.join_associations.each do |association|
+              association.join_type.should eq Squeel::OuterJoin
+            end
           end
         end
-
       end
     end
   end
-end
+end

data/spec/squeel/adapters/active_record/relation_extensions_spec.rb

@@ -15,8 +15,21 @@ module Squeel
             queries = queries_for do
               Person.find_by_id('')
             end
-            queries.should have(1).query
-            queries.first.should match /"people"."id" = 0/
+            if activerecord_version_at_least('3.1.0')
+              queries.should have(1).query
+            else
+              puts 'skips count of queries expectation'
+            end
+
+            if activerecord_version_at_least('4.2.0')
+              if PG_ENV
+                queries.last.should match /#{Q}people#{Q}.#{Q}id#{Q} = \$1/
+              else
+                queries.last.should match /#{Q}people#{Q}.#{Q}id#{Q} = ?/
+              end
+            else
+              queries.last.should match /#{Q}people#{Q}.#{Q}id#{Q} = 0/
+            end
           end
 
         end
@@ -34,8 +47,12 @@ module Squeel
 
             arel = relation.build_arel
 
-            relation.join_dependency.join_associations.should have(4).items
-            arel.to_sql.should match /INNER JOIN "people" "parents_people_2" ON "parents_people_2"."id" = "parents_people"."parent_id"/
+            if activerecord_version_at_least('4.1.0')
+              relation.join_dependency.join_constraints([]).should have(4).items
+            else
+              relation.join_dependency.join_associations.should have(4).items
+            end
+            arel.to_sql.should match /INNER JOIN #{Q}people#{Q} #{Q}parents_people_2#{Q} ON #{Q}parents_people_2#{Q}.#{Q}id#{Q} = #{Q}parents_people#{Q}.#{Q}parent_id#{Q}/
           end
 
           it 'joins associations with custom join types' do
@@ -49,9 +66,13 @@ module Squeel
 
             arel = relation.build_arel
 
-            relation.join_dependency.join_associations.should have(4).items
-            arel.to_sql.should match /LEFT OUTER JOIN "people" "children_people"/
-            arel.to_sql.should match /LEFT OUTER JOIN "people" "parents_people_2" ON "parents_people_2"."id" = "parents_people"."parent_id"/
+            if activerecord_version_at_least('4.1.0')
+              relation.join_dependency.join_constraints([]).should have(4).items
+            else
+              relation.join_dependency.join_associations.should have(4).items
+            end
+            arel.to_sql.should match /LEFT OUTER JOIN #{Q}people#{Q} #{Q}children_people#{Q}/
+            arel.to_sql.should match /LEFT OUTER JOIN #{Q}people#{Q} #{Q}parents_people_2#{Q} ON #{Q}parents_people_2#{Q}.#{Q}id#{Q} = #{Q}parents_people#{Q}.#{Q}parent_id#{Q}/
           end
 
           it 'only joins an association once, even if two overlapping joins_values hashes are given' do
@@ -70,8 +91,12 @@ module Squeel
             })
 
             arel = relation.build_arel
-            relation.join_dependency.join_associations.should have(6).items
-            arel.to_sql.should match /INNER JOIN "people" "parents_people_3" ON "parents_people_3"."id" = "children_people_3"."parent_id"/
+            if activerecord_version_at_least('4.1.0')
+              relation.join_dependency.join_constraints([]).should have(6).items
+            else
+              relation.join_dependency.join_associations.should have(6).items
+            end
+            arel.to_sql.should match /INNER JOIN #{Q}people#{Q} #{Q}parents_people_3#{Q} ON #{Q}parents_people_3#{Q}.#{Q}id#{Q} = #{Q}children_people_3#{Q}.#{Q}parent_id#{Q}/
           end
 
           it 'respects :uniq option on associations' do
@@ -81,15 +106,15 @@ module Squeel
           it 'visits wheres with a PredicateVisitor, converting them to Arel nodes' do
             relation = Person.where(:name.matches => '%bob%')
             arel = relation.build_arel
-            arel.to_sql.should match /"people"."name" LIKE '%bob%'/
+            arel.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE '%bob%'/
           end
 
-	  it 'handles multiple wheres using a keypath' do
-	    relation = Person.joins{articles}.where{articles.title == 'Hello'}.
-	                      where{articles.body == 'World'}
-	    arel = relation.build_arel
-	    arel.to_sql.should match /articles/
-	  end
+          it 'handles multiple wheres using a keypath' do
+             relation = Person.joins{articles}.where{articles.title == 'Hello'}.
+                               where{articles.body == 'World'}
+             arel = relation.build_arel
+             arel.to_sql.should match /articles/
+          end
 
           it 'maps wheres inside a hash to their appropriate association table' do
             relation = Person.joins({
@@ -109,15 +134,14 @@ module Squeel
             })
 
             arel = relation.build_arel
-
-            arel.to_sql.should match /"parents_people_2"."name" = 'bob'/
+            arel.to_sql.should match /#{Q}parents_people_2#{Q}.#{Q}name#{Q} = 'bob'/
           end
 
           it 'combines multiple conditions of the same type against the same column with AND' do
             relation = Person.where(:name.matches => '%bob%')
             relation = relation.where(:name.matches => '%joe%')
             arel = relation.build_arel
-            arel.to_sql.should match /"people"."name" LIKE '%bob%' AND "people"."name" LIKE '%joe%'/
+            arel.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE '%bob%' AND #{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE '%joe%'/
           end
 
           it 'handles ORs between predicates' do
@@ -129,7 +153,7 @@ module Squeel
           it 'maintains groupings as given' do
             relation = Person.where(dsl{(name == 'Ernie') | ((name =~ 'Bob%') & (name =~ '%by'))})
             arel = relation.build_arel
-            arel.to_sql.should match /"people"."name" = 'Ernie' OR \("people"."name" LIKE 'Bob%' AND "people"."name" LIKE '%by'\)/
+            arel.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'Ernie' OR \(#{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE 'Bob%' AND #{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE '%by'\)/
           end
 
           it 'maps havings inside a hash to their appropriate association table' do
@@ -150,8 +174,7 @@ module Squeel
             })
 
             arel = relation.build_arel
-
-            arel.to_sql.should match /HAVING "parents_people_2"."name" = 'joe'/
+            arel.to_sql.should match /HAVING #{Q}parents_people_2#{Q}.#{Q}name#{Q} = 'joe'/
           end
 
           it 'maps orders inside a hash to their appropriate association table' do
@@ -173,8 +196,7 @@ module Squeel
               })
 
               arel = relation.build_arel
-
-              arel.to_sql.should match /ORDER BY "parents_people_2"."id" ASC/
+              arel.to_sql.should match /ORDER BY #{Q}parents_people_2#{Q}.#{Q}id#{Q} ASC/
             else
               pending 'Unsupported in ActiveRecord 4.0.0+'
             end
@@ -191,7 +213,6 @@ module Squeel
 
           it 'reverses order of Arel::Attributes when #last is called' do
             sorted_people = Person.all.to_a.sort {|a, b| a.name.downcase <=> b.name.downcase}
-
             Person.order{name}.last.should eq sorted_people.last
           end
 
@@ -245,46 +266,77 @@ module Squeel
 
           it 'eager loads belongs_to associations' do
             queries = queries_for do
-              Article.includes(:person).
-                      where{person.name == 'Ernie'}.to_a
+              if activerecord_version_at_least('4.1.0')
+                Article.includes(:person).references(:person).
+                        where{person.name == 'Ernie'}.to_a
+              else
+                Article.includes(:person).
+                        where{person.name == 'Ernie'}.to_a
+              end
             end
-            queries.should have(1).item
-            queries.first.should match /LEFT OUTER JOIN "people"/
-            queries.first.should match /"people"."name" = 'Ernie'/
+
+            if activerecord_version_at_least('4.1.0')
+              queries.should have(1).item
+            else
+              puts 'skips count of queries expectation.'
+            end
+
+            queries.last.should match /LEFT OUTER JOIN #{Q}people#{Q}/
+            queries.last.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'Ernie'/
           end
 
           it 'eager loads belongs_to associations on models with default_scopes' do
             queries = queries_for do
-              PersonNamedBill.includes(:parent).
-                              where{parent.name == 'Ernie'}.to_a
+              if activerecord_version_at_least('4.1.0')
+                PersonNamedBill.includes(:parent).references(:parent).
+                                where{parent.name == 'Ernie'}.to_a
+              else
+                PersonNamedBill.includes(:parent).
+                                where{parent.name == 'Ernie'}.to_a
+              end
+
+            end
+
+            if activerecord_version_at_least('4.1.0')
+              queries.should have(1).item
+            else
+              puts 'skips count of queries expectation.'
             end
-            queries.should have(1).item
-            queries.first.should match /LEFT OUTER JOIN "people"/
-            queries.first.should match /"people"."name" = 'Bill'/
-            queries.first.should match /"parents_people"."name" = 'Ernie'/
+
+            queries.last.should match /LEFT OUTER JOIN #{Q}people#{Q}/
+            queries.last.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'Bill'/
+            queries.last.should match /#{Q}parents_people#{Q}.#{Q}name#{Q} = 'Ernie'/
           end
 
           it 'eager loads polymorphic belongs_to associations' do
             relation = Note.includes{notable(Article)}.where{{notable(Article) => {title => 'hey'}}}
-            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
+            relation.debug_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article'/
           end
 
           it 'eager loads multiple polymorphic belongs_to associations' do
             relation = Note.includes{[notable(Article), notable(Person)]}.
                             where{{notable(Article) => {title => 'hey'}}}.
                             where{{notable(Person) => {name => 'joe'}}}
-            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
-            relation.debug_sql.should match /"notes"."notable_type" = 'Person'/
+            relation.debug_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article'/
+            relation.debug_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Person'/
           end
 
-          it "only includes once, even if two join types are used" do
+          it 'only includes once, even if two join types are used' do
             relation = Person.includes(:articles.inner, :articles.outer).where(:articles => {:title => 'hey'})
-            relation.debug_sql.scan("JOIN").size.should eq 1
+            if activerecord_version_at_least('4.1.0')
+              pending ":article != :article.inner != :article.outer, you shouldn't pass two same tables into includes again"
+            else
+              relation.debug_sql.scan("JOIN").size.should eq 1
+            end
           end
 
           it 'includes a keypath' do
-            relation = Note.includes{notable(Article).person.children}.where{notable(Article).person.children.name == 'Ernie'}
-            relation.debug_sql.should match /SELECT "notes".* FROM "notes" LEFT OUTER JOIN "articles" ON "articles"."id" = "notes"."notable_id" AND "notes"."notable_type" = 'Article' LEFT OUTER JOIN "people" ON "people"."id" = "articles"."person_id" LEFT OUTER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id"/
+            if activerecord_version_at_least('4.1.0')
+              relation = Note.includes{notable(Article).person.children}.references(:all).where{notable(Article).person.children.name == 'Ernie'}
+            else
+              relation = Note.includes{notable(Article).person.children}.where{notable(Article).person.children.name == 'Ernie'}
+            end
+            relation.debug_sql.should match /SELECT #{Q}notes#{Q}.* FROM #{Q}notes#{Q} LEFT OUTER JOIN #{Q}articles#{Q} ON #{Q}articles#{Q}.#{Q}id#{Q} = #{Q}notes#{Q}.#{Q}notable_id#{Q} AND #{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article' LEFT OUTER JOIN #{Q}people#{Q} ON #{Q}people#{Q}.#{Q}id#{Q} = #{Q}articles#{Q}.#{Q}person_id#{Q} LEFT OUTER JOIN #{Q}people#{Q} #{Q}children_people#{Q} ON #{Q}children_people#{Q}.#{Q}parent_id#{Q} = #{Q}people#{Q}.#{Q}id#{Q} WHERE #{Q}children_people#{Q}.#{Q}name#{Q} = 'Ernie'/
           end
 
         end
@@ -311,7 +363,6 @@ module Squeel
             }}
 
             queries_for {relation.to_a}.should have(4).items
-
             queries_for {
               relation.first.articles
               relation.first.articles.first.comments
@@ -327,8 +378,12 @@ module Squeel
             standard = Person.eager_load(:children => :children)
             block = Person.eager_load{{children => children}}
             block.debug_sql.should eq standard.debug_sql
-            queries_for {block.to_a}.should have(1).item
-            queries_for {block.first.children}.should have(0).items
+            if activerecord_version_at_least('3.2.0')
+              queries_for {block.to_a}.should have(1).item
+              queries_for {block.first.children}.should have(0).items
+            else
+              puts 'skips count of queries expectation.'
+            end
           end
 
           it 'eager loads multiple top-level associations with a block' do
@@ -339,23 +394,27 @@ module Squeel
 
           it 'eager loads polymorphic belongs_to associations' do
             relation = Note.eager_load{notable(Article)}
-            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
+            relation.debug_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article'/
           end
 
           it 'eager loads multiple polymorphic belongs_to associations' do
             relation = Note.eager_load{[notable(Article), notable(Person)]}
-            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
-            relation.debug_sql.should match /"notes"."notable_type" = 'Person'/
+            relation.debug_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article'/
+            relation.debug_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Person'/
           end
 
           it "only eager_load once, even if two join types are used" do
             relation = Person.eager_load(:articles.inner, :articles.outer)
-            relation.debug_sql.scan("JOIN").size.should eq 1
+            if activerecord_version_at_least('4.1.0')
+              pending ":article != :article.inner != :article.outer, you shouldn't pass two same tables into eager_load again"
+            else
+              relation.debug_sql.scan("JOIN").size.should eq 1
+            end
           end
 
           it 'eager_load a keypath' do
             relation = Note.eager_load{notable(Article).person.children}
-            relation.debug_sql.should match /SELECT "notes".* FROM "notes" LEFT OUTER JOIN "articles" ON "articles"."id" = "notes"."notable_id" AND "notes"."notable_type" = 'Article' LEFT OUTER JOIN "people" ON "people"."id" = "articles"."person_id" LEFT OUTER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id"/
+            relation.debug_sql.should match /SELECT #{Q}notes#{Q}.* FROM #{Q}notes#{Q} LEFT OUTER JOIN #{Q}articles#{Q} ON #{Q}articles#{Q}.#{Q}id#{Q} = #{Q}notes#{Q}.#{Q}notable_id#{Q} AND #{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article' LEFT OUTER JOIN #{Q}people#{Q} ON #{Q}people#{Q}.#{Q}id#{Q} = #{Q}articles#{Q}.#{Q}person_id#{Q} LEFT OUTER JOIN #{Q}people#{Q} #{Q}children_people#{Q} ON #{Q}children_people#{Q}.#{Q}parent_id#{Q} = #{Q}people#{Q}.#{Q}id#{Q}/
           end
 
         end
@@ -385,39 +444,52 @@ module Squeel
 
           it 'behaves as normal with standard parameters' do
             people = Person.select(:id)
-            people.should have(332).people
-            expect { people.first.name }.to raise_error ActiveModel::MissingAttributeError
+            people.should have(10).people
+            if ::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR == 0 && RUBY_VERSION >= '2.0.0'
+              people.first.name.should be_nil
+            else
+              expect { people.first.name }.to raise_error ActiveModel::MissingAttributeError
+            end
           end
 
           it 'works with multiple fields in select' do
-            Article.select("title, body").count.should eq 51
+            Article.select("title, body").size.should eq 31
           end
 
           it 'allows a function in the select values via Symbol#func' do
-            relation = Person.select(:max.func(:id).as('max_id'))
-            relation.first.max_id.should eq 332
+            relation = Person.select(:max.func(:id).as('max_id')).order('max_id')
+            relation.first.max_id.to_i.should eq 10
           end
 
           it 'allows a function in the select values via block' do
-            relation = Person.select{max(id).as(max_id)}
-            relation.first.max_id.should eq 332
+            relation = Person.select{max(id).as(max_id)}.order('max_id')
+            relation.first.max_id.to_i.should eq 10
           end
 
           it 'allows an operation in the select values via block' do
-            relation = Person.select{[id, (id + 1).as('id_plus_one')]}.where('id_plus_one = 2')
-            relation.first.id.should eq 1
+            relation =
+              if SQLITE_ENV
+                Person.select{[id, (id + 1).as('id_plus_one')]}.where('id_plus_one = 2')
+              else
+                Person.select{[id, (id + 1).as('id_plus_one')]}.where{(id + 1) == 2}
+              end
+              relation.first.id.should eq 1
           end
 
           it 'allows custom operators in the select values via block' do
-            relation = Person.select{name.op('||', '-diddly').as(flanderized_name)}
-            relation.first.flanderized_name.should eq Person.first.name + '-diddly'
+            if MYSQL_ENV
+              pending "MySQL doesn't support concating string with ||."
+            else
+              relation = Person.select{name.op('||', '-diddly').as(flanderized_name)}
+              relation.first.flanderized_name.should eq Person.first.name + '-diddly'
+            end
           end
 
           it 'allows a subquery in the select values' do
             subquery = Article.where(:person_id => 1).select(:id).order{id.desc}.limit(1)
             relation = Person.where(:id => 1).select{[id, name, subquery.as('last_article_id')]}
             aric = relation.first
-            aric.last_article_id.should eq Article.where(:person_id => 1).last.id
+            aric.last_article_id.to_i.should eq Article.where(:person_id => 1).last.id
           end
 
         end
@@ -425,7 +497,7 @@ module Squeel
         describe '#count' do
 
           it 'works with non-strings in select' do
-            Article.select{distinct(title)}.count.should eq 51
+            Article.select{distinct(title)}.count.should eq 31
           end
 
           it 'works with non-strings in wheres' do
@@ -463,17 +535,17 @@ module Squeel
 
           it 'builds compound conditions with a block' do
             block = Person.where{(name == 'bob') & (salary == 100000)}
-            block.to_sql.should match /"people"."name" = 'bob'/
+            block.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'bob'/
             block.to_sql.should match /AND/
-            block.to_sql.should match /"people"."salary" = 100000/
+            block.to_sql.should match /#{Q}people#{Q}.#{Q}salary#{Q} = 100000/
           end
 
           it 'allows mixing hash and operator syntax inside a block' do
             block = Person.joins(:comments).
                            where{(name == 'bob') & {comments => (body == 'First post!')}}
-            block.to_sql.should match /"people"."name" = 'bob'/
+            block.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'bob'/
             block.to_sql.should match /AND/
-            block.to_sql.should match /"comments"."body" = 'First post!'/
+            block.to_sql.should match /#{Q}comments#{Q}.#{Q}body#{Q} = 'First post!'/
           end
 
           it 'allows a condition on a function via block' do
@@ -496,6 +568,12 @@ module Squeel
             people_and_article_notes.should have(40).items
           end
 
+          it 'maps conditions onto their proper table with a polymorphic belongs_to join followed by a polymorphic has_many join' do
+            relation = Note.joins{notable(Article).notes}.
+              where{notable(Article).notes.note.eq('zomg')}
+            relation.to_sql.should match /#{Q}notes_articles#{Q}\.#{Q}note#{Q} = 'zomg'/
+          end
+
           it 'allows a subquery on the value side of a predicate' do
             names = [Person.first.name, Person.last.name]
             old_and_busted = Person.where(:name => names)
@@ -504,6 +582,21 @@ module Squeel
             old_and_busted.to_a.should eq new_hotness.to_a
           end
 
+          it 'allows a subquery from an association in a hash' do
+            scope = Person.first.articles
+            articles = scope.where(:id => scope)
+            articles.should have(3).articles
+
+            articles = Tag.all.second.articles.where(:id => scope)
+            articles.should have(1).articles
+          end
+
+          it 'allows a subquery from an association in a Squeel node' do
+            scope = Person.first.articles
+            articles = scope.where{id.in scope}
+            articles.should have(3).articles
+          end
+
           it 'is backwards-compatible with "where.not"' do
             if activerecord_version_at_least '4.0.0'
               name = Person.first.name
@@ -517,37 +610,61 @@ module Squeel
           it 'allows equality conditions against a belongs_to with an AR::Base value' do
             first_person = Person.first
             relation = Article.where { person.eq first_person }
-            relation.to_sql.should match /"articles"."person_id" = #{first_person.id}/
+            relation.to_sql.should match /#{Q}articles#{Q}.#{Q}person_id#{Q} = #{first_person.id}/
           end
 
           it 'allows equality conditions against a polymorphic belongs_to with an AR::Base value' do
             first_person = Person.first
             relation = Note.where { notable.eq first_person }
-            relation.to_sql.should match /"notes"."notable_id" = #{first_person.id} AND "notes"."notable_type" = 'Person'/
+            relation.to_sql.should match /#{Q}notes#{Q}.#{Q}notable_id#{Q} = #{first_person.id} AND #{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Person'/
           end
 
           it 'allows inequality conditions against a belongs_to with an AR::Base value' do
             first_person = Person.first
             relation = Article.where { person.not_eq first_person }
-            relation.to_sql.should match /"articles"."person_id" != #{first_person.id}/
+            relation.to_sql.should match /#{Q}articles#{Q}.#{Q}person_id#{Q} != #{first_person.id}/
           end
 
           it 'allows inequality conditions against a polymorphic belongs_to with an AR::Base value' do
             first_person = Person.first
             relation = Note.where { notable.not_eq first_person }
-            relation.to_sql.should match /\("notes"."notable_id" != #{first_person.id} OR "notes"."notable_type" != 'Person'\)/
+            relation.to_sql.should match /\(#{Q}notes#{Q}.#{Q}notable_id#{Q} != #{first_person.id} OR #{Q}notes#{Q}.#{Q}notable_type#{Q} != 'Person'\)/
           end
 
           it 'allows hash equality conditions against a belongs_to with an AR::Base value' do
             first_person = Person.first
             relation = Article.where(:person => first_person)
-            relation.to_sql.should match /"articles"."person_id" = #{first_person.id}/
+            relation.to_sql.should match /#{Q}articles#{Q}.#{Q}person_id#{Q} = #{first_person.id}/
           end
 
           it 'allows hash equality conditions against a polymorphic belongs_to with an AR::Base value' do
             first_person = Person.first
             relation = Note.where(:notable => first_person)
-            relation.to_sql.should match /"notes"."notable_id" = #{first_person.id} AND "notes"."notable_type" = 'Person'/
+            relation.to_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Person'/
+            relation.to_sql.should match /#{Q}notes#{Q}.#{Q}notable_id#{Q} = #{first_person.id}/
+          end
+
+          it 'keeps original AR hashes behavior' do
+            relation = Person.joins(:articles).where(articles: { person_id: Person.first })
+            relation.to_sql.should match /SELECT #{Q}people#{Q}.* FROM #{Q}people#{Q} INNER JOIN #{Q}articles#{Q} ON #{Q}articles#{Q}.#{Q}person_id#{Q} = #{Q}people#{Q}.#{Q}id#{Q} WHERE #{Q}articles#{Q}.#{Q}person_id#{Q} = 1/
+
+            relation = Person.joins(:articles).where(articles: { person_id: Person.all.to_a })
+            relation.to_sql.should match /SELECT #{Q}people#{Q}.\* FROM #{Q}people#{Q} INNER JOIN #{Q}articles#{Q} ON #{Q}articles#{Q}.#{Q}person_id#{Q} = #{Q}people#{Q}.#{Q}id#{Q} WHERE #{Q}articles#{Q}.#{Q}person_id#{Q} IN \(1, 2, 3, 4, 5, 6, 7, 8, 9, 10\)/
+          end
+
+          it 'returns ActiveRecord::Relation after complex associations, joins and wheres' do
+            relation = Note.first.notable.articles.joins(:comments).where{comments.article_id != nil}
+
+            relation.should be_kind_of(::ActiveRecord::Relation)
+            relation.first.should be_kind_of(Article)
+          end
+
+          it 'uses Squeel and Arel at the same time' do
+            relation = User.where{id.in([1,2,3]) & User.arel_table[:id].not_eq(nil) }
+            relation.to_sql.should match /SELECT #{Q}users#{Q}.\* FROM #{Q}users#{Q}\s+WHERE \(\(#{Q}users#{Q}.#{Q}id#{Q} IN \(1, 2, 3\) AND #{Q}users#{Q}.#{Q}id#{Q} IS NOT NULL\)\)/
+            relation = User.where{
+              (id.in([1,2,3]) | User.arel_table[:id].eq(1)) & ((id == 1) | User.arel_table[:id].not_eq(nil)) }
+            relation.to_sql.should match /SELECT #{Q}users#{Q}.\* FROM #{Q}users#{Q}\s+WHERE \(\(\(#{Q}users#{Q}.#{Q}id#{Q} IN \(1, 2, 3\) OR #{Q}users#{Q}.#{Q}id#{Q} = 1\) AND \(#{Q}users#{Q}.#{Q}id#{Q} = 1 OR #{Q}users#{Q}.#{Q}id#{Q} IS NOT NULL\)\)\)/
           end
 
         end
@@ -577,25 +694,66 @@ module Squeel
 
           it 'joins polymorphic belongs_to associations' do
             relation = Note.joins{notable(Article)}
-            relation.to_sql.should match /"notes"."notable_type" = 'Article'/
+            relation.to_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article'/
           end
 
           it 'joins multiple polymorphic belongs_to associations' do
             relation = Note.joins{[notable(Article), notable(Person)]}
-            relation.to_sql.should match /"notes"."notable_type" = 'Article'/
-            relation.to_sql.should match /"notes"."notable_type" = 'Person'/
+            relation.to_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article'/
+            relation.to_sql.should match /#{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Person'/
           end
 
           it "only joins once, even if two join types are used" do
-            relation = Person.joins(:articles.inner, :articles.outer)
-            relation.to_sql.scan("JOIN").size.should eq 1
+            if activerecord_version_at_least('4.1.0')
+              pending "It's unreasonable to join once only, in some cases, we need twice."
+            else
+              relation = Person.joins(:articles.inner, :articles.outer)
+              relation.to_sql.scan("JOIN").size.should eq 1
+            end
           end
 
           it 'joins a keypath' do
             relation = Note.joins{notable(Article).person.children}
-            relation.to_sql.should match /SELECT "notes".* FROM "notes" INNER JOIN "articles" ON "articles"."id" = "notes"."notable_id" AND "notes"."notable_type" = 'Article' INNER JOIN "people" ON "people"."id" = "articles"."person_id" INNER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id"/
+            relation.to_sql.should match /SELECT #{Q}notes#{Q}.* FROM #{Q}notes#{Q} INNER JOIN #{Q}articles#{Q} ON #{Q}articles#{Q}.#{Q}id#{Q} = #{Q}notes#{Q}.#{Q}notable_id#{Q} AND #{Q}notes#{Q}.#{Q}notable_type#{Q} = 'Article' INNER JOIN #{Q}people#{Q} ON #{Q}people#{Q}.#{Q}id#{Q} = #{Q}articles#{Q}.#{Q}person_id#{Q} INNER JOIN #{Q}people#{Q} #{Q}children_people#{Q} ON #{Q}children_people#{Q}.#{Q}parent_id#{Q} = #{Q}people#{Q}.#{Q}id#{Q}/
           end
 
+          it 'validates polymorphic relationship with source type' do
+            if activerecord_version_at_least '3.2.7'
+              Group.first.users.to_sql.should match /#{Q}memberships#{Q}.#{Q}member_type#{Q} = 'User'/
+            else
+              Group.first.users.size.should eq 1
+            end
+          end
+
+          it 'joins an ActiveRecord::Relation subquery' do
+            subquery = OrderItem.
+              group(:orderable_id).
+              select { [orderable_id, sum(quantity * unit_price).as(amount)] }
+
+            relation = Seat.
+              joins { [payment.outer,
+                       subquery.as('seat_order_items').on { id == seat_order_items.orderable_id}.outer] }.
+              select { [seat_order_items.amount, "seats.*"] }.
+              where { seat_order_items.amount > 0 }
+
+            relation.debug_sql.should match /SELECT #{Q}seat_order_items#{Q}.#{Q}amount#{Q}, seats.\* FROM #{Q}seats#{Q} LEFT OUTER JOIN #{Q}payments#{Q} ON #{Q}payments#{Q}.#{Q}id#{Q} = #{Q}seats#{Q}.#{Q}payment_id#{Q} LEFT OUTER JOIN \(SELECT #{Q}order_items#{Q}.#{Q}orderable_id#{Q}, sum\(#{Q}order_items#{Q}.#{Q}quantity#{Q} \* #{Q}order_items#{Q}.#{Q}unit_price#{Q}\) AS amount FROM #{Q}order_items#{Q}\s+GROUP BY #{Q}order_items#{Q}.#{Q}orderable_id#{Q}\) seat_order_items ON #{Q}seats#{Q}.#{Q}id#{Q} = #{Q}seat_order_items#{Q}.#{Q}orderable_id#{Q} WHERE #{Q}seat_order_items#{Q}.#{Q}amount#{Q} > 0/
+            relation.to_a.should have(10).seats
+            relation.to_a.second.amount.to_i.should eq(10)
+          end
+
+          it 'joins from an association with default scopes' do
+            if activerecord_version_at_least('3.1.0')
+              if MYSQL_ENV
+                User.first.groups.to_sql.should match /#{Q}memberships#{Q}.#{Q}active#{Q} = 1/
+              else
+                puts User.first.groups.to_sql
+                User.first.groups.to_sql.should match /#{Q}memberships#{Q}.#{Q}active#{Q} = 't'/
+              end
+
+            else
+              pending "Rails 3.0.x doesn't support to_sql in an association."
+            end
+          end
         end
 
         describe '#having' do
@@ -607,8 +765,12 @@ module Squeel
           end
 
           it 'allows complex conditions on aggregate columns' do
-            relation = Person.group(:parent_id).having{salary == max(salary)}
-            relation.first.name.should eq Person.last.name
+            if SQLITE_ENV
+              relation = Person.group(:parent_id).having{salary == max(salary)}
+              relation.first.name.should eq Person.last.name
+            else
+              pending "MySQL & PG don't support this type of group & having clauses, don't use it."
+            end
           end
 
           it 'allows a condition on a function via block' do
@@ -627,13 +789,13 @@ module Squeel
 
           it 'builds options with a block' do
             block = Person.order{name}
-            block.to_sql.should match /ORDER BY "people"\."name"/
+            block.to_sql.should match /ORDER BY #{Q}people#{Q}.#{Q}name#{Q}/
           end
 
           it 'allows AR 4.0-style hash options' do
             if activerecord_version_at_least '4.0.0'
               block = Person.order(:name => :desc)
-              block.to_sql.should match /ORDER BY "people"\."name" DESC/
+              block.to_sql.should match /ORDER BY #{Q}people#{Q}.#{Q}name#{Q} DESC/
             else
               pending 'Not required in AR versions < 4.0.0'
             end
@@ -641,7 +803,7 @@ module Squeel
 
           it 'allows ordering by an attributes of a joined table' do
             relation = Article.joins(:person).order { person.id.asc }
-            relation.to_sql.should match /ORDER BY "people"\."id" ASC/
+            relation.to_sql.should match /ORDER BY #{Q}people#{Q}.#{Q}id#{Q} ASC/
           end
 
         end
@@ -654,7 +816,7 @@ module Squeel
           it 'builds options with a block' do
             block = @standard.reorder{id}
             block.to_sql.should_not eq @standard.to_sql
-            block.to_sql.should match /ORDER BY "people"."id"/
+            block.to_sql.should match /ORDER BY #{Q}people#{Q}.#{Q}id#{Q}/
           end
 
           it 'drops order by clause when passed nil' do
@@ -673,7 +835,7 @@ module Squeel
 
         describe '#from' do
           it 'creates froms with a block' do
-            expected = /SELECT "sub"."name" AS aliased_name FROM \(SELECT "people"."name" FROM "people"\s*\) sub/
+            expected = /SELECT #{Q}sub#{Q}.#{Q}name#{Q} AS aliased_name FROM \(SELECT #{Q}people#{Q}.#{Q}name#{Q} FROM #{Q}people#{Q}\s*\) sub/
             block = Person.from{Person.select{name}.as('sub')}.
               select{sub.name.as('aliased_name')}
             sql = block.to_sql
@@ -681,7 +843,7 @@ module Squeel
           end
 
           it 'creates froms from literals' do
-            expected = /SELECT "people".* FROM sub/
+            expected = /SELECT #{Q}people#{Q}.* FROM sub/
             relation = Person.from('sub')
             sql = relation.to_sql
             sql.should match expected
@@ -689,7 +851,7 @@ module Squeel
 
           it 'creates froms from relations' do
             if activerecord_version_at_least '4.0.0'
-              expected = "SELECT \"people\".* FROM (SELECT \"people\".* FROM \"people\") alias"
+              expected = "SELECT #{Q}people#{Q}.* FROM (SELECT #{Q}people#{Q}.* FROM #{Q}people#{Q}) alias"
               relation = Person.from(Person.all, 'alias')
               sql = relation.to_sql
               sql.should == expected
@@ -697,6 +859,17 @@ module Squeel
               pending 'Unsupported before ActiveRecord 4.0'
             end
           end
+
+          it 'binds params from CollectionProxy subquery' do
+            if activerecord_version_at_least('3.1.0')
+              first_article = Article.first
+              expected_tags = Tag.where(id: [1,2,3]).order{name}.to_a
+
+              expected_tags.should == Tag.from{first_article.tags.as(Tag.table_name)}.order{tags.name}.to_a
+            else
+              pending "ActiveRecord 3.0.x doesn't support CollectionProxy chain."
+            end
+          end
         end
 
         describe '#build_where' do
@@ -718,7 +891,12 @@ module Squeel
 
           it 'adds hash where values without converting to Arel predicates' do
             wheres = Person.where({:name => 'bob'}).where_values
-            wheres.should eq [{:name => 'bob'}]
+            if activerecord_version_at_least('4.0.0')
+              wheres.flatten.should have(1).equality
+              wheres.flatten.last.should be_kind_of(Arel::Nodes::Equality)
+            else
+              wheres.should eq [{:name => 'bob'}]
+            end
           end
 
         end
@@ -729,8 +907,12 @@ module Squeel
             relation = Person.includes(:comments, :articles).
               where(:comments => {:body => 'First post!'}).
               where(:articles => {:title => 'Hello, world!'})
-            relation.debug_sql.should_not eq relation.to_sql
-            relation.debug_sql.should match /SELECT "people"."id" AS t0_r0/
+            if activerecord_version_at_least('4.1.0')
+              relation.debug_sql.should_not eq relation.arel.to_sql
+            else
+              relation.debug_sql.should_not eq relation.to_sql
+            end
+            relation.debug_sql.should match /SELECT #{Q}people#{Q}.#{Q}id#{Q} AS t0_r0/
           end
 
         end
@@ -802,22 +984,27 @@ module Squeel
           it 'merges relations with the same base' do
             relation = Person.where{name == 'bob'}.merge(Person.where{salary == 100000})
             sql = relation.to_sql
-            sql.should match /"people"."name" = 'bob'/
-            sql.should match /"people"."salary" = 100000/
+            sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'bob'/
+            sql.should match /#{Q}people#{Q}.#{Q}salary#{Q} = 100000/
           end
 
           it 'merges relations with a different base' do
             relation = Person.where{name == 'bob'}.joins(:articles).merge(Article.where{title == 'Hello world!'})
             sql = relation.to_sql
-            sql.should match /INNER JOIN "articles" ON "articles"."person_id" = "people"."id"/
-            sql.should match /"people"."name" = 'bob'/
-            sql.should match /"articles"."title" = 'Hello world!'/
+            sql.should match /INNER JOIN #{Q}articles#{Q} ON #{Q}articles#{Q}.#{Q}person_id#{Q} = #{Q}people#{Q}.#{Q}id#{Q}/
+            sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'bob'/
+            sql.should match /#{Q}articles#{Q}.#{Q}title#{Q} = 'Hello world!'/
           end
 
           it 'does not break hm:t with conditions' do
             relation = Person.first.condition_article_comments
-            sql = relation.scoped.to_sql
-            sql.should match /"articles"."title" = 'Condition'/
+            sql =
+              if activerecord_version_at_least('4.1.0')
+                relation.to_sql
+              else
+                relation.scoped.to_sql
+              end
+            sql.should match /#{Q}articles#{Q}.#{Q}title#{Q} = 'Condition'/
           end
 
           it 'uses the last condition in the case of a conflicting where' do
@@ -831,7 +1018,13 @@ module Squeel
 
           it 'uses the given equality condition in the case of a conflicting where from a default scope' do
             if activerecord_version_at_least '3.1'
-              relation = PersonNamedBill.where{name == 'Ernie'}
+              relation =
+                if activerecord_version_at_least('4.1.0')
+                  PersonNamedBill.rewhere(name: 'Ernie')
+                  # Or PersonNamedBill.unscope(where: :name).where { name == 'Ernie' }
+                else
+                  PersonNamedBill.where{name == 'Ernie'}
+                end
               sql = relation.to_sql
               sql.should_not match /Bill/
               sql.should match /Ernie/
@@ -844,53 +1037,82 @@ module Squeel
             relation = Person.with_article_title('hi').
                               with_article_condition_title('yo')
             sql = relation.to_sql
-            sql.should match /"articles"."title" = 'hi'/
-            sql.should match /"articles_with_conditions_people"."title" = 'yo'/
+            sql.should match /#{Q}articles#{Q}.#{Q}title#{Q} = 'hi'/
+            sql.should match /#{Q}articles_with_conditions_people#{Q}.#{Q}title#{Q} = 'yo'/
           end
 
           it "doesn't ruin everything when a scope returns nil" do
             relation = Person.nil_scope
-            relation.should eq Person.scoped
+            if activerecord_version_at_least('4.1.0')
+              relation.should eq Person.all
+            else
+              relation.should eq Person.scoped
+            end
           end
 
           it "doesn't ruin everything when a group exists" do
-            relation = Person.scoped.merge(Person.group{name})
             count_hash = {}
-            expect { count_hash = relation.count }.should_not raise_error
-            count_hash.size.should eq Person.scoped.size
+            if activerecord_version_at_least('4.1.0')
+              relation = Person.all.merge(Person.group{name})
+              expect { count_hash = relation.count }.should_not raise_error
+              count_hash.size.should eq Person.all.size
+            else
+              relation = Person.scoped.merge(Person.group{name})
+              expect { count_hash = relation.count }.should_not raise_error
+              count_hash.size.should eq Person.scoped.size
+            end
+
             count_hash.values.all? {|v| v == 1}.should be_true
             count_hash.keys.should =~ Person.select{name}.map(&:name)
           end
 
           it "doesn't merge the default scope more than once" do
-            relation = PersonNamedBill.scoped.highly_compensated.ending_with_ill
+            relation =
+              if activerecord_version_at_least('4.1.0')
+                PersonNamedBill.all.highly_compensated.ending_with_ill
+              else
+                PersonNamedBill.scoped.highly_compensated.ending_with_ill
+              end
             sql = relation.to_sql
-            sql.scan(/"people"."name" = 'Bill'/).should have(1).item
-            sql.scan(/"people"."name" LIKE '%ill'/).should have(1).item
-            sql.scan(/"people"."salary" > 200000/).should have(1).item
-            sql.scan(/"people"."id"/).should have(1).item
+            sql.scan(/#{Q}people#{Q}.#{Q}name#{Q} = 'Bill'/).should have(1).item
+            sql.scan(/#{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE '%ill'/).should have(1).item
+            sql.scan(/#{Q}people#{Q}.#{Q}salary#{Q} > 200000/).should have(1).item
+            sql.scan(/#{Q}people#{Q}.#{Q}id#{Q}/).should have(1).item
           end
 
           it "doesn't hijack the table name when merging a relation with different base and default_scope" do
-            relation = Article.joins(:person).merge(PersonNamedBill.scoped)
+            relation =
+              if activerecord_version_at_least('4.1.0')
+                Article.joins(:person).merge(PersonNamedBill.all)
+              else
+                Article.joins(:person).merge(PersonNamedBill.scoped)
+              end
             sql = relation.to_sql
-            sql.scan(/"people"."name" = 'Bill'/).should have(1).item
+            sql.scan(/#{Q}people#{Q}.#{Q}name#{Q} = 'Bill'/).should have(1).item
           end
 
           it 'merges scopes that contain functions' do
-            relation = PersonNamedBill.scoped.with_salary_equal_to(100)
+            relation =
+              if activerecord_version_at_least('4.1.0')
+                PersonNamedBill.all.with_salary_equal_to(100)
+              else
+                PersonNamedBill.scoped.with_salary_equal_to(100)
+              end
             sql = relation.to_sql
-            sql.should match /abs\("people"."salary"\) = 100/
+            sql.should match /abs\(#{Q}people#{Q}.#{Q}salary#{Q}\) = 100/
           end
 
           it 'uses last equality when merging two scopes with identical function equalities' do
-            relation = PersonNamedBill.scoped.with_salary_equal_to(100).
-                                              with_salary_equal_to(200)
-            sql = relation.to_sql
-            sql.should_not match /abs\("people"."salary"\) = 100/
-            sql.should match /abs\("people"."salary"\) = 200/
+            if activerecord_version_at_least('4.1.0')
+              pending "Named Functions can't be unscoped"
+            else
+              relation = PersonNamedBill.scoped.with_salary_equal_to(100).
+                                                with_salary_equal_to(200)
+              sql = relation.to_sql
+              sql.should_not match /abs\(#{Q}people#{Q}.#{Q}salary#{Q}\) = 100/
+              sql.should match /abs\(#{Q}people#{Q}.#{Q}salary#{Q}\) = 200/
+            end
           end
-
         end
 
         describe '#to_a' do
@@ -908,14 +1130,18 @@ module Squeel
             relation = UnidentifiedObject.where{person_id < 120}.includes(:person)
             queries = queries_for do
               vals = relation.to_a
-              vals.should have(8).items
+              vals.should have(20).items
             end
 
-            queries.should have(2).queries
+            if activerecord_version_at_least('3.1.0')
+              queries.should have(2).queries
+            else
+              puts 'skips count of queries expectation'
+            end
 
             matched_ids = queries.last.match(/IN \(([^)]*)/).captures.first
             matched_ids = matched_ids.split(/,\s*/).map(&:to_i)
-            matched_ids.should =~ [1, 34, 67, 100]
+            matched_ids.should =~ [1, 2, 3, 4, 5 ,6 ,7 ,8 ,9 ,10]
           end
 
         end