postgres_ext 2.1.3 → 2.2.0

data/lib/postgres_ext/arel/predications.rb

@@ -21,5 +21,15 @@ module Arel
     def overlap(other)
       Nodes::Overlap.new self, other
     end
+
+    def any(other)
+      any_tags_function = Arel::Nodes::NamedFunction.new('ANY', [self])
+      Arel::Nodes::Equality.new(other, any_tags_function)
+    end
+
+    def all(other)
+      any_tags_function = Arel::Nodes::NamedFunction.new('ALL', [self])
+      Arel::Nodes::Equality.new(other, any_tags_function)
+    end
   end
 end

data/lib/postgres_ext/arel/visitors/to_sql.rb

@@ -4,7 +4,7 @@ module Arel
   module Visitors
     class ToSql
       def visit_Array o, a
-        column = a.relation.engine.columns.find { |col| col.name == a.name.to_s } if a
+        column = a.relation.engine.connection.columns(a.relation.name).find { |col| col.name == a.name.to_s } if a
         if column && column.respond_to?(:array) && column.array
           quoted o, a
         else

data/lib/postgres_ext/version.rb

@@ -1,3 +1,3 @@
 module PostgresExt
-  VERSION = '2.1.3'
+  VERSION = '2.2.0'
 end

data/postgres_ext.gemspec

@@ -20,10 +20,12 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'arel', '~> 4.0.1'
   gem.add_dependency 'pg_array_parser', '~> 0.0.9'
 
-  gem.add_development_dependency 'rails', '~> 4.0.0'
-  gem.add_development_dependency 'rspec-rails', '~> 2.12.0'
+  gem.add_development_dependency 'rake', '~> 10.1.0'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'm'
   gem.add_development_dependency 'bourne', '~> 1.3.0'
   gem.add_development_dependency 'database_cleaner'
+  gem.add_development_dependency 'dotenv'
   if RUBY_PLATFORM =~ /java/
       gem.add_development_dependency 'activerecord-jdbcpostgresql-adapter', '1.3.0.beta2'
   else

data/test/arel/array_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+describe 'Array Column Predicates' do
+  let(:arel_table) { Person.arel_table }
+  describe 'Array Any' do
+    context 'string value' do
+      it 'creates any predicates' do
+        arel_table.where(arel_table[:tags].any('tag')).to_sql.must_match /'tag' = ANY\("people"\."tags"\)/
+      end
+    end
+
+    context 'integer value' do
+      it 'creates any predicates' do
+        arel_table.where(arel_table[:tag_ids].any(1)).to_sql.must_match /1 = ANY\("people"\."tag_ids"\)/
+      end
+    end
+  end
+
+  describe 'Array All' do
+    context 'string value' do
+      it 'creates all predicates' do
+        arel_table.where(arel_table[:tags].all('tag')).to_sql.must_match /'tag' = ALL\("people"\."tags"\)/
+      end
+    end
+
+    context 'integer value' do
+      it 'creates all predicates' do
+        arel_table.where(arel_table[:tag_ids].all(1)).to_sql.must_match /1 = ALL\("people"\."tag_ids"\)/
+      end
+    end
+  end
+
+  describe 'Array Overlap' do
+    it 'converts Arel overlap statement' do
+      arel_table.where(arel_table[:tags].overlap(['tag','tag 2'])).to_sql.must_match /&& '\{"tag","tag 2"\}'/
+    end
+
+    it 'converts Arel overlap statement' do
+      arel_table.where(arel_table[:tag_ids].overlap([1,2])).to_sql.must_match /&& '\{1,2\}'/
+    end
+
+    it 'works with count (and other predicates)' do
+      Person.where(arel_table[:tag_ids].overlap([1,2])).count.must_equal 0
+    end
+
+    it 'returns matched records' do
+      one = Person.create!(:tags => ['one'])
+      two = Person.create!(:tags => ['two'])
+
+      query = arel_table.where(arel_table[:tags].overlap(['one'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).must_include(one)
+
+      query = arel_table.where(arel_table[:tags].overlap(['two'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).must_include(two)
+
+      query = arel_table.where(arel_table[:tags].overlap(['two','one'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).must_include(two)
+      Person.find_by_sql(query.to_sql).must_include(one)
+    end
+  end
+
+  describe 'Array Contains' do
+    it 'converts Arel contains statement and escapes strings' do
+      arel_table.where(arel_table[:tags].contains(['tag','tag 2'])).to_sql.must_match /@> '\{"tag","tag 2"\}'/
+    end
+
+    it 'converts Arel contains statement with numbers' do
+      arel_table.where(arel_table[:tag_ids].contains([1,2])).to_sql.must_match /@> '\{1,2\}'/
+    end
+
+    it 'works with count (and other predicates)' do
+      Person.where(arel_table[:tag_ids].contains([1,2])).count.must_equal 0
+    end
+
+    it 'returns matched records' do
+      one = Person.create!(:tags => ['one', 'two', 'three'])
+      two = Person.create!(:tags => ['one', 'three'])
+
+      query = arel_table.where(arel_table[:tags].contains(['one', 'two'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).must_include one
+      Person.find_by_sql(query.to_sql).wont_include two
+
+      query = arel_table.where(arel_table[:tags].contains(['one', 'three'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).must_include one
+      Person.find_by_sql(query.to_sql).must_include two
+
+      query = arel_table.where(arel_table[:tags].contains(['two'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).must_include one
+      Person.find_by_sql(query.to_sql).wont_include two
+    end
+  end
+end

data/{spec/arel/inet_spec.rb → test/arel/inet_test.rb}

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require 'test_helper'
 
 describe 'INET related AREL functions' do
   describe 'quoting IPAddr in sql statement' do
     it 'properly converts IPAddr to quoted strings when passed as an argument to a where clause' do
-      Person.where(:ip => IPAddr.new('127.0.0.1')).to_sql.should include("'127.0.0.1/32'")
+      Person.where(:ip => IPAddr.new('127.0.0.1')).to_sql.must_include("'127.0.0.1/32'")
     end
   end
 
@@ -11,7 +11,7 @@ describe 'INET related AREL functions' do
     it 'converts Arel contained_within statements to <<' do
       arel_table = Person.arel_table
 
-      arel_table.where(arel_table[:ip].contained_within(IPAddr.new('127.0.0.1/24'))).to_sql.should match /<< '127.0.0.0\/24'/
+      arel_table.where(arel_table[:ip].contained_within(IPAddr.new('127.0.0.1/24'))).to_sql.must_match /<< '127.0.0.0\/24'/
     end
   end
 
@@ -19,14 +19,14 @@ describe 'INET related AREL functions' do
     it 'converts Arel contained_within_or_equals statements to  <<=' do
       arel_table  = Person.arel_table
 
-      arel_table.where(arel_table[:ip].contained_within_or_equals(IPAddr.new('127.0.0.1/24'))).to_sql.should match /<<= '127.0.0.0\/24'/
+      arel_table.where(arel_table[:ip].contained_within_or_equals(IPAddr.new('127.0.0.1/24'))).to_sql.must_match /<<= '127.0.0.0\/24'/
     end
   end
   describe 'contains (>>) operator' do
     it 'converts Arel contains statements to >>' do
       arel_table = Person.arel_table
 
-      arel_table.where(arel_table[:ip].contains(IPAddr.new('127.0.0.1/24'))).to_sql.should match />> '127.0.0.0\/24'/
+      arel_table.where(arel_table[:ip].contains(IPAddr.new('127.0.0.1/24'))).to_sql.must_match />> '127.0.0.0\/24'/
     end
   end
 
@@ -34,7 +34,7 @@ describe 'INET related AREL functions' do
     it 'converts Arel contains_or_equals statements to  >>=' do
       arel_table  = Person.arel_table
 
-      arel_table.where(arel_table[:ip].contains_or_equals(IPAddr.new('127.0.0.1/24'))).to_sql.should match />>= '127.0.0.0\/24'/
+      arel_table.where(arel_table[:ip].contains_or_equals(IPAddr.new('127.0.0.1/24'))).to_sql.must_match />>= '127.0.0.0\/24'/
     end
   end
 end

data/{spec/queries/array_queries_spec.rb → test/queries/array_queries_test.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'test_helper'
 
 describe 'Array queries' do
   let(:equality_regex) { %r{\"people\"\.\"tags\" = '\{\"working\"\}'} }
@@ -10,63 +10,71 @@ describe 'Array queries' do
   describe '.where(:array_column => [])' do
     it 'returns an array string instead of IN ()' do
       query = Person.where(:tags => ['working']).to_sql
-      query.should match equality_regex
+      query.must_match equality_regex
+    end
+  end
+
+  describe '.where(joins: { array_column: [] })' do
+    it 'returns an array string instead of IN ()' do
+      skip
+      query = Person.joins(:hm_tags).where(tags: { categories: ['working'] }).to_sql
+      query.must_match equality_regex
     end
   end
 
   describe '.where.overlap(:column => value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.overlap(:tag_ids => [1,2])
-      query.to_sql.should match overlap_regex
+      query.to_sql.must_match overlap_regex
     end
 
     it 'allows chaining' do
       query = Person.where.overlap(:tag_ids => [1,2]).where(:tags => ['working']).to_sql
 
-      query.should match overlap_regex
-      query.should match equality_regex
+      query.must_match overlap_regex
+      query.must_match equality_regex
     end
   end
 
   describe '.where.contains(:column => value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.contains(:tag_ids => [1,2])
-      query.to_sql.should match contains_regex
+      query.to_sql.must_match contains_regex
     end
 
     it 'allows chaining' do
       query = Person.where.contains(:tag_ids => [1,2]).where(:tags => ['working']).to_sql
 
-      query.should match contains_regex
-      query.should match equality_regex
+      query.must_match contains_regex
+      query.must_match equality_regex
     end
   end
 
   describe '.where.any(:column => value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.any(:tag_ids => 2)
-      query.to_sql.should match any_regex
+      query.to_sql.must_match any_regex
     end
 
     it 'allows chaining' do
       query = Person.where.any(:tag_ids => 2).where(:tags => ['working']).to_sql
 
-      query.should match any_regex
-      query.should match equality_regex
+      query.must_match any_regex
+      query.must_match equality_regex
     end
   end
 
   describe '.where.all(:column => value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.all(:tag_ids => 2)
-      query.to_sql.should match all_regex
+      query.to_sql.must_match all_regex
     end
 
     it 'allows chaining' do
       query = Person.where.all(:tag_ids => 2).where(:tags => ['working']).to_sql
 
-      query.should match all_regex
-      query.should match equality_regex
+      query.must_match all_regex
+      query.must_match equality_regex
     end
   end
 end

data/test/queries/common_table_expression_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+describe 'Common Table Expression queries' do
+  describe '.with(common_table_expression_hash)' do
+    it 'generates an expression with the CTE' do
+      query = Person.with(lucky_number_seven: Person.where(lucky_number: 7)).joins('JOIN lucky_number_seven ON lucky_number_seven.id = people.id')
+      query.to_sql.must_equal 'WITH lucky_number_seven AS (SELECT "people".* FROM "people"  WHERE "people"."lucky_number" = 7) SELECT "people".* FROM "people" JOIN lucky_number_seven ON lucky_number_seven.id = people.id'
+    end
+
+    it 'generates an expression with multiple CTEs' do
+      query = Person.with(lucky_number_seven: Person.where(lucky_number: 7), lucky_number_three: Person.where(lucky_number: 3)).joins('JOIN lucky_number_seven ON lucky_number_seven.id = people.id').joins('JOIN lucky_number_three ON lucky_number_three.id = people.id')
+      query.to_sql.must_equal 'WITH lucky_number_seven AS (SELECT "people".* FROM "people"  WHERE "people"."lucky_number" = 7), lucky_number_three AS (SELECT "people".* FROM "people"  WHERE "people"."lucky_number" = 3) SELECT "people".* FROM "people" JOIN lucky_number_seven ON lucky_number_seven.id = people.id JOIN lucky_number_three ON lucky_number_three.id = people.id'
+    end
+
+    it 'generates an expression with multiple with calls' do
+      query = Person.with(lucky_number_seven: Person.where(lucky_number: 7)).with(lucky_number_three: Person.where(lucky_number: 3)).joins('JOIN lucky_number_seven ON lucky_number_seven.id = people.id').joins('JOIN lucky_number_three ON lucky_number_three.id = people.id')
+      query.to_sql.must_equal 'WITH lucky_number_seven AS (SELECT "people".* FROM "people"  WHERE "people"."lucky_number" = 7), lucky_number_three AS (SELECT "people".* FROM "people"  WHERE "people"."lucky_number" = 3) SELECT "people".* FROM "people" JOIN lucky_number_seven ON lucky_number_seven.id = people.id JOIN lucky_number_three ON lucky_number_three.id = people.id'
+    end
+
+    it 'generates an expression with recursive' do
+      query = Person.with.recursive(lucky_number_seven: Person.where(lucky_number: 7)).joins('JOIN lucky_number_seven ON lucky_number_seven.id = people.id')
+      query.to_sql.must_equal 'WITH RECURSIVE lucky_number_seven AS (SELECT "people".* FROM "people"  WHERE "people"."lucky_number" = 7) SELECT "people".* FROM "people" JOIN lucky_number_seven ON lucky_number_seven.id = people.id'
+    end
+
+    it 'accepts Arel::SelectMangers' do
+      arel_table = Arel::Table.new 'test'
+      arel_manager = arel_table.project arel_table[:foo]
+
+      query = Person.with(testing: arel_manager)
+      query.to_sql.must_equal 'WITH testing AS (SELECT "test"."foo" FROM "test") SELECT "people".* FROM "people"'
+    end
+  end
+
+  describe '.from_cte(common_table_expression_hash)' do
+    it 'generates an expression with the CTE as the main table' do
+      query = Person.from_cte('lucky_number_seven', Person.where(lucky_number: 7)).where(id: 5)
+      query.to_sql.must_equal 'WITH lucky_number_seven AS (SELECT "people".* FROM "people"  WHERE "people"."lucky_number" = 7) SELECT "lucky_number_seven".* FROM "lucky_number_seven"  WHERE "lucky_number_seven"."id" = 5'
+    end
+
+    it 'returns instances of the model' do
+      3.times { Person.create! lucky_number: 7 }
+      3.times { Person.create! lucky_number: 3 }
+      people = Person.from_cte('lucky_number_seven', Person.where(lucky_number: 7))
+
+      people.count.must_equal 3
+      people.first.lucky_number.must_equal 7
+    end
+  end
+end

data/{spec/queries/contains_querie_spec.rb → test/queries/contains_test.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'test_helper'
 
 describe 'Contains queries' do
   let(:contained_within_regex)        { %r{\"people\"\.\"ip\" << '127.0.0.1/24'} }
@@ -9,28 +9,28 @@ describe 'Contains queries' do
   describe '.where.contained_within(:column, value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.contained_within(:ip => '127.0.0.1/24')
-      query.to_sql.should match contained_within_regex
+      query.to_sql.must_match contained_within_regex
     end
   end
 
   describe '.where.contained_within_or_equals(:column, value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.contained_within_or_equals(:ip => '127.0.0.1/24')
-      query.to_sql.should match contained_within_equals_regex
+      query.to_sql.must_match contained_within_equals_regex
     end
   end
 
   describe '.where.contains(:column, value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.contains(:ip => '127.0.0.1')
-      query.to_sql.should match contains_regex
+      query.to_sql.must_match contains_regex
     end
   end
 
   describe '.where.contained_within_or_equals(:column, value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.contains_or_equals(:ip => '127.0.0.1')
-      query.to_sql.should match contains_equals_regex
+      query.to_sql.must_match contains_equals_regex
     end
   end
 end

data/test/queries/sanity_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+describe 'Ensure that we don\'t stomp on Active Record\'s queries' do
+  describe '.where' do
+    it 'generates IN clauses for non array columns' do
+      query = Person.where(:id => [1,2,3]).to_sql
+
+      query.must_match /IN \(1, 2, 3\)/
+    end
+
+    it 'generates IN clauses for non array columns' do
+      query = Person.where(:id => []).to_sql
+
+      query.must_match /WHERE 1=0/
+    end
+  end
+
+  describe '.where(joins: { column: [] })' do
+    it 'generates IN clause for non array columns' do
+      query = Person.joins(:hm_tags).where(tags: { id: ['working'] }).to_sql
+      query.must_match /WHERE "tags"\."id" IN \('working'\)/
+    end
+  end
+
+  describe '#habtm_association_ids=' do
+    it 'properly deletes records through HABTM association method' do
+      person = Person.create(habtm_tag_ids: [Tag.create.id])
+      person.update_attributes(habtm_tag_ids: [])
+      person.habtm_tag_ids.must_be_empty
+    end
+  end
+end

data/test/queries/window_functions_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+describe 'Window functions' do
+  describe 'ranked' do
+    it 'uses the order when no order is passed to ranked' do
+      query = Person.order(lucky_number: :desc).ranked
+      query.to_sql.must_equal 'SELECT "people".*, rank() OVER (ORDER BY "people"."lucky_number" DESC) FROM "people"   ORDER BY "people"."lucky_number" DESC'
+    end
+
+    it 'uses the order when no order is passed to ranked, swapped calls' do
+      query = Person.ranked.order(lucky_number: :desc)
+      query.to_sql.must_equal 'SELECT "people".*, rank() OVER (ORDER BY "people"."lucky_number" DESC) FROM "people"   ORDER BY "people"."lucky_number" DESC'
+    end
+
+    it 'uses the rank value when there is an order passed to it' do
+      query = Person.ranked(lucky_number: :desc)
+      query.to_sql.must_equal 'SELECT "people".*, rank() OVER (ORDER BY "people"."lucky_number" DESC) FROM "people"'
+    end
+
+    it 'uses the rank value when a symbol passed to it' do
+      query = Person.ranked(:lucky_number)
+      query.to_sql.must_equal 'SELECT "people".*, rank() OVER (ORDER BY "people"."lucky_number" ASC) FROM "people"'
+    end
+
+    it 'uses the rank value when a string passed to it' do
+      query = Person.ranked('ORDER BY lucky_number DESC')
+      query.to_sql.must_equal 'SELECT "people".*, rank() OVER (ORDER BY lucky_number DESC) FROM "people"'
+    end
+
+    it 'combines the order and rank' do
+      query = Person.ranked(lucky_number: :desc).order(id: :asc)
+      query.to_sql.must_equal 'SELECT "people".*, rank() OVER (ORDER BY "people"."lucky_number" DESC) FROM "people"   ORDER BY "people"."id" ASC'
+    end
+
+    it 'executes the query with the rank' do
+      Person.create!
+      Person.create!
+
+      ranked_people = Person.ranked(:id)
+      ranked_people[0].rank.must_equal 1
+      ranked_people[1].rank.must_equal 2
+    end
+
+    it 'does not apply the rank when performing a count' do
+      query = Person.ranked(lucky_number: :desc).count
+      query.must_equal 0
+
+      Person.create!
+
+      query = Person.ranked(lucky_number: :desc).count
+      query.must_equal 1
+    end
+
+    it 'does not apply the rank when checking presence' do
+      query = Person.ranked(lucky_number: :desc).present?
+      query.must_equal false
+
+      Person.create!
+
+      query = Person.ranked(lucky_number: :desc).present?
+      query.must_equal true
+    end
+  end
+end