postgres_ext 0.2.2 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 78f29ab859ad31017d1173ec07e12a0b5603b823
+  data.tar.gz: 3ae3cbc58fc1cdf7018721d01078855cc4fcc089
+SHA512:
+  metadata.gz: 995ffd20fefb645371140742c7742cee1ebb9bc1cdbc9bd9bd7f9b32fa8057ac83fc661daed70bffb311700cb9c5e1b87ad64102008509ddf93ec6a7e2f11d14
+  data.tar.gz: ae873dde5e07a41dee3b5ccccbbdd6f06443f7a0ccb0e65ff3f2678a7a8fcb91d5323afb6bbcbf17be03a30dd9278ff6fee71b96b5e0bc7e863ef9274615d992

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.3.0
+
+ * Adds support to create indexes concurrently  -  Dan McClain
+ * Changes using syntax, updates specs  -  Dan McClain
+ * Empty strings are converted to nil by string_to_cidr_address -  Dan McClain
+ * Replaced .symbolize with .to_sym in arel nodes.  -  OMCnet Development Team
+ * Removes array_contains in favor of a column aware contains  -  Dan McClain
+ * Renames Arel array_overlap to overlap  -  Dan McClain
+ * Merge pull request #67 from jagregory/array_contains Array contains operator support -  Dan McClain
+ * Update querying doc to include array_contains  -  James Gregory
+ * Array contains operator ( @> ) support -  James Gregory
+ * how to use SQL to convert string-delimited arrays in docs -  Turadg Aleahmad
+ * Check if connection responds to #support_extensions? before invoking it  -  Dirk von Grünigen
+
 ## 0.2.2
 
  * Fixes issue with visit_Array monkey patch - Dan McClain (@danmcclain)

data/Gemfile

@@ -5,8 +5,8 @@ gemspec
 unless ENV['CI']
   if RUBY_PLATFORM =~ /java/
     gem 'ruby-debug'
-  elsif RUBY_VERSION == '1.9.3'
-    gem 'debugger', '~> 1.1.2'
+  elsif RUBY_VERSION == '1.9.3' || RUBY_VERSION == '2.0.0'
+    gem 'debugger'
   end
 end
 gem 'fivemat'

data/docs/indexes.md

@@ -6,8 +6,8 @@ Postgres\_ext allows you to specify index type and index operator
 class at index creation.
 
 ```ruby
-add_index :table_name, :column, :index_type => :gin
-add_index :table_name, :column, :index_type => :gin, :index_opclass => :gin_trgm_ops
+add_index :table_name, :column, :using => :gin
+add_index :table_name, :column, :using => :gin, :index_opclass => :gin_trgm_ops
 ```
 
 ## Where clauses
@@ -17,3 +17,12 @@ Postgres\_ext allows you to specify a where clause at index creation.
 ```ruby
 add_index :table_name, :column, :where => 'column < 50'
 ```
+
+## Concurrent Indexes
+
+Postgres\_ext allows you to create indexes concurrently using the
+`:algorithm` option
+
+```ruby
+add_index :table_name, :column, :algorithm => :concurrently
+```

data/docs/migrations.md

@@ -74,3 +74,19 @@ create_table :testing do |t|
   # char varying(30)[]
 end
 ```
+
+### Converting to Arrays
+
+If you have an existing column with a string-delimited array (e.g. 'val1 val2 val3') convert that data using SQL in your migration.
+
+```ruby
+class AddLinkedArticleIdsToLinkSet < ActiveRecord::Migration
+  def change
+    add_column :link_sets, :linked_article_ids, :integer, :array => true, :default => []
+    execute <<-eos
+    UPDATE link_sets
+    SET linked_article_ids = cast (string_to_array(linked_articles_string, ' ') as integer[])
+    eos
+  end
+end
+````

data/docs/querying.md

@@ -42,6 +42,38 @@ User.where(user_arel[:tags].array_overlap(['one','two']))
 # => SELECT \"users\".* FROM \"users\" WHERE \"users\".\"tags\" && '{one,two}'
 ```
 
+### @> - Array Contains operator
+
+PostgreSQL has a contains (`@>`) operator for querying whether all the
+elements of an array are within another.
+
+```sql
+ARRAY[1,2,3] @> ARRAY[3,4]
+-- f
+
+ARRAY[1,2,3] @> ARRAY[2,3]
+-- t
+```
+
+Postgres\_ext extends the `ActiveRecord::Relation.where` method by
+adding a `contains` method. To make a contains query, you can do:
+
+```ruby
+User.where.contains(:nick_names => ['Bob', 'Fred'])
+```
+
+Postgres\_ext defines `array_contains`, an [Arel](https://github.com/rails/arel)
+predicate for the `@>` operator. This is utilized by the
+`where.array_contains` call above.
+
+```ruby
+user_arel = User.arel_table
+
+# Execute the query
+User.where(user_arel[:tags].array_contains(['one','two']))
+# => SELECT "users".* FROM "users" WHERE "users"."tags" @> '{"one","two"}'
+```
+
 ### ANY or ALL functions
 
 When querying array columns, you have the ability to see if a predicate

data/lib/postgres_ext/active_record/connection_adapters/postgres_adapter.rb

@@ -5,7 +5,7 @@ require 'pg_array_parser'
 module ActiveRecord
   module ConnectionAdapters
     class IndexDefinition
-      attr_accessor :index_type, :where, :index_opclass
+      attr_accessor :using, :where, :index_opclass
     end
 
     class PostgreSQLColumn
@@ -92,7 +92,10 @@ module ActiveRecord
       class << self
         def string_to_cidr_address(string)
           return string unless String === string
-          return IPAddr.new(string)
+
+          if string.present?
+            IPAddr.new(string)
+          end
         end
       end
 
@@ -217,11 +220,16 @@ module ActiveRecord
       def add_index(table_name, column_name, options = {})
         index_name, unique, index_columns, _ = add_index_options(table_name, column_name, options)
         if options.is_a? Hash
-          index_type = options[:index_type] ? " USING #{options[:index_type]} " : ""
+          index_type = options[:using] ? " USING #{options[:using]} " : ""
           index_options = options[:where] ? " WHERE #{options[:where]}" : ""
           index_opclass = options[:index_opclass]
+          index_algorithm = options[:algorithm] == :concurrently ? ' CONCURRENTLY' : ''
+
+          if options[:algorithm].present? && options[:algorithm] != :concurrently
+            raise ArgumentError.new 'Algorithm must be one of the following: :concurrently'
+          end
         end
-        execute "CREATE #{unique} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}#{index_type}(#{index_columns} #{index_opclass})#{index_options}"
+        execute "CREATE #{unique} INDEX#{index_algorithm} #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}#{index_type}(#{index_columns} #{index_opclass})#{index_options}"
       end
 
       def add_extension(extension_name, options={})
@@ -339,16 +347,16 @@ module ActiveRecord
           orders = desc_order_columns.any? ? Hash[desc_order_columns.map {|order_column| [order_column, :desc]}] : {}
           #changed from rails 3.2
           where = inddef.scan(/WHERE (.+)$/).flatten[0]
-          index_type = inddef.scan(/USING (.+?) /).flatten[0].to_sym
-          if index_type
+          using = inddef.scan(/USING (.+?) /).flatten[0].to_sym
+          if using
             index_op = inddef.scan(/USING .+? \(.+? (#{opclasses.join('|')})\)/).flatten
             index_op = index_op[0].to_sym if index_op.present?
           end
           if column_names.present?
             index_def = IndexDefinition.new(table_name, index_name, unique, column_names, [], orders)
             index_def.where = where
-            index_def.index_type = index_type if index_type && index_type != :btree
-            index_def.index_opclass = index_op if index_type && index_type != :btree && index_op
+            index_def.using = using if using && using != :btree
+            index_def.index_opclass = index_op if using && using != :btree && index_op
             index_def
           # else nil
           end

data/lib/postgres_ext/active_record/relation/query_methods.rb

@@ -9,7 +9,7 @@ module ActiveRecord
 
       def overlap(opts)
         opts.each do |key, value|
-          @scope = @scope.where(arel_table[key].array_overlap(value))
+          @scope = @scope.where(arel_table[key].overlap(value))
         end
         @scope
       end

data/lib/postgres_ext/active_record/schema_dumper.rb

@@ -10,7 +10,8 @@ module ActiveRecord
     def dump(stream)
       header(stream)
       # added
-      extensions(stream) if @connection.supports_extensions?
+      extensions(stream) if @connection.respond_to?(:supports_extensions?) && 
+                            @connection.supports_extensions?
       # /added
       tables(stream)
       trailer(stream)
@@ -118,7 +119,7 @@ module ActiveRecord
 
           # changed from rails 2.3
           statement_parts << (':where => ' + index.where.inspect) if index.where
-          statement_parts << (':index_type => ' + index.index_type.inspect) if index.index_type
+          statement_parts << (':using => ' + index.using.inspect) if index.using
           statement_parts << (':index_opclass => ' + index.index_opclass.inspect) if index.index_opclass.present?
           # /changed
 

data/lib/postgres_ext/arel/nodes.rb

@@ -1 +1,2 @@
+require 'postgres_ext/arel/nodes/array_nodes'
 require 'postgres_ext/arel/nodes/contained_within'

data/lib/postgres_ext/arel/nodes/array_nodes.rb

@@ -0,0 +1,9 @@
+require 'arel/nodes/binary'
+
+module Arel
+  module Nodes
+    class Overlap < Arel::Nodes::Binary
+      def operator; '&&' end
+    end
+  end
+end

data/lib/postgres_ext/arel/nodes/contained_within.rb

@@ -6,7 +6,7 @@ module Arel
     end
 
     class ContainedWithinEquals < Arel::Nodes::Binary
-      def operator; '<<='.symbolize end
+      def operator; '<<='.to_sym end
     end
 
     class Contains < Arel::Nodes::Binary
@@ -14,11 +14,7 @@ module Arel
     end
 
     class ContainsEquals < Arel::Nodes::Binary
-      def operator; '>>='.symbolize end
-    end
-
-    class ArrayOverlap < Arel::Nodes::Binary
-      def operator; '&&' end
+      def operator; '>>='.to_sym end
     end
   end
 end

data/lib/postgres_ext/arel/predications.rb

@@ -18,8 +18,8 @@ module Arel
       Nodes::ContainsEquals.new self, other
     end
 
-    def array_overlap(other)
-      Nodes::ArrayOverlap.new self, other
+    def overlap(other)
+      Nodes::Overlap.new self, other
     end
   end
 end

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

@@ -13,19 +13,21 @@ module Arel
       end
 
       def visit_Arel_Nodes_Contains o
-        "#{visit o.left} >> #{visit o.right}"
+        left_column = o.left.relation.engine.columns.find { |col| col.name == o.left.name.to_s }
+
+        if left_column && left_column.respond_to?(:array) && left_column.array
+          "#{visit o.left} @> #{visit o.right}"
+        else
+          "#{visit o.left} >> #{visit o.right}"
+        end
       end
 
       def visit_Arel_Nodes_ContainsEquals o
         "#{visit o.left} >>= #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_ArrayOverlap o
-        if Array === o.right
-          "#{visit o.left} && #{visit o.right}"
-        else
-          "#{visit o.left} && #{visit o.right}"
-        end
+      def visit_Arel_Nodes_Overlap o
+        "#{visit o.left} && #{visit o.right}"
       end
 
       def visit_IPAddr value

data/lib/postgres_ext/version.rb

@@ -1,3 +1,3 @@
 module PostgresExt
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/spec/arel/array_spec.rb

@@ -1,57 +1,77 @@
 require 'spec_helper'
 
 describe 'Array Column Predicates' do
-  let!(:adapter) { ActiveRecord::Base.connection }
+  describe 'Array Overlap' do
+    it 'converts Arel overlap statment' do
+      arel_table = Person.arel_table
 
-  before do
-    adapter.create_table :arel_arrays, :force => true do |t|
-      t.string :tags, :array => true
-      t.integer :tag_ids, :array => true
+      arel_table.where(arel_table[:tags].overlap(['tag','tag 2'])).to_sql.should match /&& '\{"tag","tag 2"\}'/
     end
 
-    class ArelArray < ActiveRecord::Base
-      attr_accessible :tags
+    it 'converts Arel overlap statment' do
+      arel_table = Person.arel_table
+
+      arel_table.where(arel_table[:tag_ids].overlap([1,2])).to_sql.should match /&& '\{1,2\}'/
+    end
+
+    it 'works with count (and other predicates)' do
+      arel_table = Person.arel_table
+
+      Person.where(arel_table[:tag_ids].overlap([1,2])).count.should eq 0
     end
-  end
 
-  after do
-    adapter.drop_table :arel_arrays
-    Object.send(:remove_const, :ArelArray)
+    it 'returns matched records' do
+      one = Person.create!(:tags => ['one'])
+      two = Person.create!(:tags => ['two'])
+      arel_table = Person.arel_table
+
+      query = arel_table.where(arel_table[:tags].overlap(['one'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).should include(one)
+
+      query = arel_table.where(arel_table[:tags].overlap(['two'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).should include(two)
+
+      query = arel_table.where(arel_table[:tags].overlap(['two','one'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).should include(two)
+      Person.find_by_sql(query.to_sql).should include(one)
+    end
   end
 
-  describe 'Array Overlap' do
-    it 'converts Arel array_overlap statment' do
-      arel_table = ArelArray.arel_table
+  describe 'Array Contains' do
+    it 'converts Arel contains statement and escapes strings' do
+      arel_table = Person.arel_table
 
-      arel_table.where(arel_table[:tags].array_overlap(['tag','tag 2'])).to_sql.should match /&& '\{"tag","tag 2"\}'/
+      arel_table.where(arel_table[:tags].contains(['tag','tag 2'])).to_sql.should match /@> '\{"tag","tag 2"\}'/
     end
 
-    it 'converts Arel array_overlap statment' do
-      arel_table = ArelArray.arel_table
+    it 'converts Arel contains statement with numbers' do
+      arel_table = Person.arel_table
 
-      arel_table.where(arel_table[:tag_ids].array_overlap([1,2])).to_sql.should match /&& '\{1,2\}'/
+      arel_table.where(arel_table[:tag_ids].contains([1,2])).to_sql.should match /@> '\{1,2\}'/
     end
 
     it 'works with count (and other predicates)' do
-      arel_table = ArelArray.arel_table
+      arel_table = Person.arel_table
 
-      ArelArray.where(arel_table[:tag_ids].array_overlap([1,2])).count.should eq 0
+      Person.where(arel_table[:tag_ids].contains([1,2])).count.should eq 0
     end
 
     it 'returns matched records' do
-      one = ArelArray.create!(:tags => ['one'])
-      two = ArelArray.create!(:tags => ['two'])
-      arel_table = ArelArray.arel_table
+      one = Person.create!(:tags => ['one', 'two', 'three'])
+      two = Person.create!(:tags => ['one', 'three'])
+      arel_table = Person.arel_table
 
-      query = arel_table.where(arel_table[:tags].array_overlap(['one'])).project(Arel.sql('*'))
-      ArelArray.find_by_sql(query.to_sql).should include(one)
+      query = arel_table.where(arel_table[:tags].contains(['one', 'two'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).should include one
+      Person.find_by_sql(query.to_sql).should_not include two
 
-      query = arel_table.where(arel_table[:tags].array_overlap(['two'])).project(Arel.sql('*'))
-      ArelArray.find_by_sql(query.to_sql).should include(two)
+      query = arel_table.where(arel_table[:tags].contains(['one', 'three'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).should include one
+      Person.find_by_sql(query.to_sql).should include two
 
-      query = arel_table.where(arel_table[:tags].array_overlap(['two','one'])).project(Arel.sql('*'))
-      ArelArray.find_by_sql(query.to_sql).should include(two)
-      ArelArray.find_by_sql(query.to_sql).should include(one)
+      query = arel_table.where(arel_table[:tags].contains(['two'])).project(Arel.sql('*'))
+      Person.find_by_sql(query.to_sql).should include one
+      Person.find_by_sql(query.to_sql).should_not include two
     end
   end
 end

data/spec/arel/inet_spec.rb

@@ -1,56 +1,40 @@
 require 'spec_helper'
 
 describe 'INET related AREL functions' do
-  let!(:adapter) { ActiveRecord::Base.connection }
-  before do
-    adapter.create_table :ip_addresses, :force => true do |t|
-      t.inet :address
-    end
-
-    class IpAddress < ActiveRecord::Base
-      attr_accessible :address
-    end
-  end
-
-  after do
-    adapter.drop_table :ip_addresses
-    Object.send(:remove_const, :IpAddress)
-  end
-
   describe 'quoting IPAddr in sql statement' do
     it 'properly converts IPAddr to quoted strings when passed as an argument to a where clause' do
-      IpAddress.where(:address => 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.should include("'127.0.0.1/32'")
     end
   end
 
   describe 'contained with (<<) operator' do
     it 'converts Arel contained_within statements to <<' do
-      arel_table = IpAddress.arel_table
+      arel_table = Person.arel_table
 
-      arel_table.where(arel_table[:address].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.should match /<< '127.0.0.0\/24'/
     end
   end
 
   describe 'contained within or equals (<<=) operator' do
     it 'converts Arel contained_within_or_equals statements to  <<=' do
-      arel_table  = IpAddress.arel_table
+      arel_table  = Person.arel_table
 
-      arel_table.where(arel_table[:address].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.should match /<<= '127.0.0.0\/24'/
     end
   end
   describe 'contains (>>) operator' do
     it 'converts Arel contains statements to >>' do
-      arel_table = IpAddress.arel_table
+      arel_table = Person.arel_table
 
-      arel_table.where(arel_table[:address].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.should match />> '127.0.0.0\/24'/
     end
   end
 
   describe 'contains or equals (>>=) operator' do
     it 'converts Arel contains_or_equals statements to  >>=' do
-      arel_table  = IpAddress.arel_table
+      arel_table  = Person.arel_table
 
-      arel_table.where(arel_table[:address].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.should match />>= '127.0.0.0\/24'/
     end
   end
 end

data/spec/dummy/app/models/person.rb

@@ -1,3 +1,3 @@
 class Person < ActiveRecord::Base
-  attr_accessible :ip
+  attr_accessible :ip, :tags
 end

data/spec/dummy/db/migrate/20120501163758_create_people.rb

@@ -1,10 +1,12 @@
 class CreatePeople < ActiveRecord::Migration
   def change
     create_table :people do |t|
-      t.inet :ip
-      t.cidr :subnet
-      t.inet :tag_ids, :array => true
-      t.string :tags, :array => true
+      t.inet    :ip
+      t.cidr    :subnet
+      t.integer :tag_ids, :array => true
+      t.string  :tags, :array => true
+      t.text    :biography
+      t.integer :lucky_number
 
       t.timestamps
     end

data/spec/dummy/db/schema.rb

@@ -13,22 +13,15 @@
 
 ActiveRecord::Schema.define(:version => 20120501163758) do
 
-  add_extension "hstore"
-  add_extension "pg_trgm"
-  add_extension "citext"
-
   create_table "people", :force => true do |t|
     t.inet     "ip"
     t.cidr     "subnet"
-    t.inet     "tag_ids",                    :array => true
-    t.string   "tags",                       :array => true
-    t.datetime "created_at", :null => false
-    t.datetime "updated_at", :null => false
-  end
-
-  create_table "sanity_tests", :force => true do |t|
-    t.string  "tags",    :array => true
-    t.integer "tag_ids", :array => true
+    t.integer  "tag_ids",                      :array => true
+    t.string   "tags",                         :array => true
+    t.text     "biography"
+    t.integer  "lucky_number"
+    t.datetime "created_at",   :null => false
+    t.datetime "updated_at",   :null => false
   end
 
 end

data/spec/migrations/index_spec.rb

@@ -2,48 +2,66 @@ require 'spec_helper'
 
 describe 'Index migrations' do
   let!(:connection) { ActiveRecord::Base.connection }
-
+  let!(:stream) { StringIO.new }
   before do
-    connection.create_table :index_types do |t|
-      t.integer :col1, :array => true
-      t.integer :col2
-      t.text    :col3
-    end
+    ActiveRecord::Base.logger = ActiveSupport::TaggedLogging.new(Logger.new stream)
   end
 
-  after { connection.drop_table :index_types }
+  after do
+    [:tag_ids, :lucky_number, :biography].each do |column|
+      begin
+        connection.remove_index :people, column
+      rescue ArgumentError
+      end
+    end
+  end
 
   it 'creates special index' do
     lambda do
-      connection.add_index(:index_types, :col1, :index_type => :gin)
+      connection.add_index(:people, :tag_ids, :using => :gin)
     end.should_not raise_exception
 
-    indexes = connection.indexes(:index_types)
-    index_1 = indexes.detect { |c| c.columns.map(&:to_s) == ['col1']}
+    indexes = connection.indexes(:people)
+    index_1 = indexes.detect { |c| c.columns.map(&:to_s) == ['tag_ids']}
 
-    index_1.index_type.to_s.should  eq    'gin'
+    index_1.using.should eq :gin
   end
 
   it 'creates indexes with where clauses' do
     lambda do
-      connection.add_index(:index_types, :col2, :where => '(col2 > 50)')
+      connection.add_index(:people, :lucky_number, :where => '(lucky_number > 50)')
+    end.should_not raise_exception
+
+    indexes = connection.indexes(:people)
+    index_2 = indexes.detect { |c| c.columns.map(&:to_s) == ['lucky_number']}
+
+    index_2.where.should match /lucky_number > 50/
+  end
+
+  it 'creates index concurrently' do
+    lambda do
+      connection.add_index(:people, :lucky_number, :algorithm => :concurrently)
     end.should_not raise_exception
 
-    indexes = connection.indexes(:index_types)
-    index_2 = indexes.detect { |c| c.columns.map(&:to_s) == ['col2']}
+    output = stream.string
+    output.should match /CREATE INDEX CONCURRENTLY "index_people_on_lucky_number" ON "people"\(\"lucky_number\" \)/
+  end
 
-    index_2.where.should            match /col2 > 50/
+  it 'rejects bad algorithm arguments' do
+    lambda do
+      connection.add_index(:people, :lucky_number, :algorithm => :conurrently)
+    end.should raise_exception
   end
 
   it 'creates indexes with operator classes', :if => ActiveRecord::Base.connection.supports_extensions? do
     lambda do
-      connection.add_index(:index_types, :col3, :index_type => :gin, :index_opclass => :gin_trgm_ops)
+      connection.add_index(:people, :biography, :using => :gin, :index_opclass => :gin_trgm_ops)
     end.should_not raise_exception
 
-    indexes = connection.indexes(:index_types)
-    index_3 = indexes.detect { |c| c.columns.map(&:to_s) == ['col3']}
+    indexes = connection.indexes(:people)
+    index_3 = indexes.detect { |c| c.columns.map(&:to_s) == ['biography']}
 
-    index_3.index_type.should       eq    :gin
-    index_3.index_opclass.should    eq    :gin_trgm_ops
+    index_3.using.should         eq    :gin
+    index_3.index_opclass.should eq    :gin_trgm_ops
   end
 end

data/spec/models/array_spec.rb

@@ -222,14 +222,14 @@ describe 'Models with array columns' do
       end
     end
 
-    describe 'array_overlap' do
+    describe 'overlap' do
       it "works" do
         arel = User.arel_table
         User.create(:nick_names => ['this'])
         x = User.create
         x.nick_names = ["s'o{m}e", 'thing']
         x.save
-        u = User.where(arel[:nick_names].array_overlap(["s'o{m}e"]))
+        u = User.where(arel[:nick_names].overlap(["s'o{m}e"]))
         u.first.should_not be_nil
         u.first.nick_names.should eq ["s'o{m}e", 'thing']
       end

data/spec/models/inet_spec.rb

@@ -50,6 +50,15 @@ describe 'Models with inet columns' do
           address.ip_address.should eq IPAddr.new('192.168.1.2')
         end
 
+        it 'converts empty strings to nil' do
+          address = Address.create
+          address.ip_address = ''
+          address.save
+
+          address.reload
+          address.ip_address.should eq nil
+        end
+
         it 'updates an address with an IPAddr' do
           ip_addr_1 = IPAddr.new('192.168.0.1')
           ip_addr_2 = IPAddr.new('192.168.1.2')

data/spec/queries/array_queries_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe 'Array queries' do
   let(:equality_regex) { %r{\"people\"\.\"tags\" = '\{\"working\"\}'} }
   let(:overlap_regex)  { %r{\"people\"\.\"tag_ids\" && '\{1,2\}'} }
+  let(:contains_regex) { %r{\"people\"\.\"tag_ids\" @> '\{1,2\}'} }
   let(:any_regex)      { %r{2 = ANY\(\"people\"\.\"tag_ids\"\)} }
   let(:all_regex)      { %r{2 = ALL\(\"people\"\.\"tag_ids\"\)} }
 
@@ -27,6 +28,20 @@ describe 'Array queries' do
     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
+    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
+    end
+  end
+
   describe '.where.any(:column => value)' do
     it 'generates the appropriate where clause' do
       query = Person.where.any(:tag_ids => 2)

data/spec/schema_dumper/index_spec.rb

@@ -3,45 +3,44 @@ require 'spec_helper'
 describe 'Index schema dumper' do
   let!(:connection) { ActiveRecord::Base.connection }
 
-  before do
-    connection.create_table :index_types do |t|
-      t.integer :col1, :array => true
-      t.integer :col2
-      t.text    :col3
+  after do
+    [:tag_ids, :lucky_number, :biography].each do |column|
+      begin
+        connection.remove_index :people, column
+      rescue ArgumentError
+      end
     end
   end
 
-  after { connection.drop_table :index_types }
-
   it 'handles index type parameters' do
-    connection.add_index(:index_types, :col1, :index_type => :gin)
+    connection.add_index(:people, :tag_ids, :using => :gin)
 
     stream = StringIO.new
     ActiveRecord::SchemaDumper.dump(connection, stream)
     output = stream.string
 
-    output.should match /:index_type => :gin/
-    output.should_not match /:index_type => :btree/
+    output.should match /:using => :gin/
+    output.should_not match /:using => :btree/
     output.should_not match /:index_opclass =>/
   end
 
   it 'handles index where clauses' do
-    connection.add_index(:index_types, :col2, :where => '(col2 > 50)')
+    connection.add_index(:people, :lucky_number, :where => '(lucky_number > 50)')
 
     stream = StringIO.new
     ActiveRecord::SchemaDumper.dump(connection, stream)
     output = stream.string
 
-    output.should match /:where => "\(col2 > 50\)"/
+    output.should match /:where => "\(lucky_number > 50\)"/
   end
 
   it 'dumps index operator classes', :if => ActiveRecord::Base.connection.supports_extensions? do
-    connection.add_index(:index_types, :col3, :index_type => :gin, :index_opclass => :gin_trgm_ops)
+    connection.add_index(:people, :biography, :using => :gin, :index_opclass => :gin_trgm_ops)
 
     stream = StringIO.new
     ActiveRecord::SchemaDumper.dump(connection, stream)
     output = stream.string
 
-    output.should match /:index_type => :gin,\s+:index_opclass => :gin_trgm_ops/
+    output.should match /:using => :gin,\s+:index_opclass => :gin_trgm_ops/
   end
 end

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ require File.expand_path('../dummy/config/environment.rb',  __FILE__)
 require 'rspec/rails'
 require 'rspec/autorun'
 require 'bourne'
-require 'debugger' unless ENV['CI'] || (RUBY_PLATFORM =~ /java/)
+#require 'debugger' unless ENV['CI'] || (RUBY_PLATFORM =~ /java/)
 
 ENGINE_RAILS_ROOT=File.join(File.dirname(__FILE__), '../')
 

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: postgres_ext
 version: !ruby/object:Gem::Version
-  version: 0.2.2
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Dan McClain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2013-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -46,7 +41,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -54,7 +48,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -62,7 +55,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -70,7 +62,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -78,7 +69,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: bourne
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -86,7 +76,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -94,7 +83,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -102,7 +90,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -138,6 +125,7 @@ files:
 - lib/postgres_ext/active_record/schema_dumper.rb
 - lib/postgres_ext/arel.rb
 - lib/postgres_ext/arel/nodes.rb
+- lib/postgres_ext/arel/nodes/array_nodes.rb
 - lib/postgres_ext/arel/nodes/contained_within.rb
 - lib/postgres_ext/arel/predications.rb
 - lib/postgres_ext/arel/visitors.rb
@@ -225,33 +213,26 @@ files:
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3137999377489191858
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3137999377489191858
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Extends ActiveRecord to handle native PostgreSQL data types
 test_files:
 - spec/arel/arel_spec.rb