postgres_ext 0.1.0 → 0.2.0

data/docs/type_casting.md

@@ -0,0 +1,51 @@
+# Type Casting support
+
+## INET and CIDR
+INET and CIDR values are converted to
+[IPAddr](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/ipaddr/rdoc/IPAddr.html)
+objects when retrieved from the database, or set as a string.
+
+```ruby
+create_table :inet_examples do |t|
+  t.inet :ip_address
+end
+
+class InetExample < ActiveRecord::Base
+end
+
+inetExample = InetExample.new
+inetExample.ip_address = '127.0.0.0/24'
+inetExample.ip_address
+# => #<IPAddr: IPv4:127.0.0.0/255.255.255.0> 
+inetExample.save
+
+inet_2 = InetExample.first
+inet_2.ip_address
+# => #<IPAddr: IPv4:127.0.0.0/255.255.255.0> 
+```
+
+## Arrays
+Array values can be set with Array objects. Any array stored in the
+database will be converted to a properly casted array of values on the
+way out.
+
+```ruby
+create_table :people do |t|
+  t.integer :favorite_numbers, :array => true
+end
+
+class Person < ActiveRecord::Base
+end
+
+person = Person.new
+person.favorite_numbers = [1,2,3]
+person.favorite_numbers
+# => [1,2,3]
+person.save
+
+person_2 = Person.first
+person_2.favorite_numbers
+# => [1,2,3]
+person_2.favorite_numbers.first.class
+# => Fixnum
+```

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

@@ -56,7 +56,7 @@ module ActiveRecord
           value
         else
           string_array = parse_pg_array value
-          if type == :string
+          if type == :string || type == :text
             force_character_encoding(string_array)
           else
             type_cast_array(string_array)
@@ -108,6 +108,8 @@ module ActiveRecord
         case field_type
         when 'uuid'
           :uuid
+        when 'citext'
+          :citext
         when 'inet'
           :inet
         when 'cidr'
@@ -125,7 +127,7 @@ module ActiveRecord
     class PostgreSQLAdapter
       class UnsupportedFeature < Exception; end
 
-      EXTENDED_TYPES = {:inet => {:name => 'inet'}, :cidr => {:name => 'cidr'}, :macaddr => {:name => 'macaddr'}, :uuid => {:name => 'uuid'}}
+      EXTENDED_TYPES = {:inet => {:name => 'inet'}, :cidr => {:name => 'cidr'}, :macaddr => {:name => 'macaddr'}, :uuid => {:name => 'uuid'}, :citext => {:citext => 'citext'}}
 
       class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
         attr_accessor :array
@@ -256,7 +258,7 @@ module ActiveRecord
         end
       end
 
-      def type_cast_with_extended_types(value, column, part_array = false)
+      def type_cast_extended(value, column, part_array = false)
         case value
         when NilClass
           if column.array && part_array
@@ -278,6 +280,10 @@ module ActiveRecord
           type_cast_without_extended_types(value, column)
         end
       end
+
+      def type_cast_with_extended_types(value, column)
+        type_cast_extended(value, column)
+      end
       alias_method_chain :type_cast, :extended_types
 
       def quote_with_extended_types(value, column = nil)
@@ -366,7 +372,7 @@ module ActiveRecord
       def item_to_string(value, column, encode_single_quotes = false)
         return 'NULL' if value.nil?
 
-        casted_value = type_cast(value, column, true)
+        casted_value = type_cast_extended(value, column, true)
 
         if casted_value.is_a? String
           casted_value = casted_value.dup

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

@@ -0,0 +1,71 @@
+require 'active_record/relation/predicate_builder'
+
+module ActiveRecord
+  class PredicateBuilder # :nodoc:
+    def self.build_from_hash(engine, attributes, default_table, allow_table_name = true)
+      predicates = attributes.map do |column, value|
+        table = default_table
+
+        if allow_table_name && value.is_a?(Hash)
+          table = Arel::Table.new(column, engine)
+
+          if value.empty?
+            '1 = 2'
+          else
+            build_from_hash(engine, value, table, false)
+          end
+        else
+          column = column.to_s
+
+          if allow_table_name && column.include?('.')
+            table_name, column = column.split('.', 2)
+            table = Arel::Table.new(table_name, engine)
+          end
+
+          attribute = table[column.to_sym]
+
+          case value
+          when ActiveRecord::Relation
+            value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+            attribute.in(value.arel.ast)
+          when Array, ActiveRecord::Associations::CollectionProxy
+            column_definition = engine.columns.find { |col| col.name == column }
+
+            if column_definition.respond_to?(:array) && column_definition.array
+              attribute.eq(value)
+            else
+              values = value.to_a.map {|x| x.is_a?(ActiveRecord::Base) ? x.id : x}
+              ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+
+              array_predicates = ranges.map {|range| attribute.in(range)}
+
+              if values.include?(nil)
+                values = values.compact
+                if values.empty?
+                  array_predicates << attribute.eq(nil)
+                else
+                  array_predicates << attribute.in(values.compact).or(attribute.eq(nil))
+                end
+              else
+                array_predicates << attribute.in(values)
+              end
+
+              array_predicates.inject {|composite, predicate| composite.or(predicate)}
+            end
+          when Range, Arel::Relation
+            attribute.in(value)
+          when ActiveRecord::Base
+            attribute.eq(value.id)
+          when Class
+            # FIXME: I think we need to deprecate this behavior
+            attribute.eq(value.name)
+          else
+            attribute.eq(value)
+          end
+        end
+      end
+
+      predicates.flatten
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'active_record/relation/query_methods'
+
+module ActiveRecord
+  module QueryMethods
+    class WhereChain
+      def initialize(scope)
+        @scope = scope
+      end
+
+      def overlap(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].array_overlap(value))
+        end
+        @scope
+      end
+
+      def contained_within(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contained_within(value))
+        end
+
+        @scope
+      end
+
+      def contained_within_or_equals(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contained_within_or_equals(value))
+        end
+
+        @scope
+      end
+
+      def contains(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contains(value))
+        end
+
+        @scope
+      end
+
+      def contains_or_equals(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contains_or_equals(value))
+        end
+
+        @scope
+      end
+
+      def any(opts)
+        equality_to_function('ANY', opts)
+      end
+
+      def all(opts)
+        equality_to_function('ALL', opts)
+      end
+
+      private
+
+      def arel_table
+        @arel_table ||= @scope.engine.arel_table
+      end
+
+      def equality_to_function(function_name, opts)
+        opts.each do |key, value|
+          any_function = Arel::Nodes::NamedFunction.new(function_name, [arel_table[key]])
+          predicate = Arel::Nodes::Equality.new(value, any_function)
+          @scope = @scope.where(predicate)
+        end
+
+        @scope
+      end
+    end
+
+    def where_with_chaining(opts = :chaining, *rest)
+      if opts == :chaining
+        WhereChain.new(self)
+      else
+        where_without_chaining(opts, *rest)
+      end
+    end
+
+    alias_method_chain :where, :chaining
+  end
+end

data/lib/postgres_ext/active_record/relation.rb

@@ -0,0 +1,2 @@
+require 'postgres_ext/active_record/relation/query_methods'
+require 'postgres_ext/active_record/relation/predicate_builder'

data/lib/postgres_ext/active_record.rb

@@ -1,3 +1,4 @@
 require 'postgres_ext/active_record/sanitization'
 require 'postgres_ext/active_record/connection_adapters'
 require 'postgres_ext/active_record/schema_dumper'
+require 'postgres_ext/active_record/relation'

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

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

data/lib/postgres_ext/arel/predications.rb

@@ -6,6 +6,18 @@ module Arel
       Nodes::ContainedWithin.new self, other
     end
 
+    def contained_within_or_equals(other)
+      Nodes::ContainedWithinEquals.new self, other
+    end
+
+    def contains(other)
+      Nodes::Contains.new self, other
+    end
+
+    def contains_or_equals(other)
+      Nodes::ContainsEquals.new self, other
+    end
+
     def array_overlap(other)
       Nodes::ArrayOverlap.new self, other
     end

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

@@ -0,0 +1,15 @@
+require 'arel/visitors/to_sql'
+
+module Arel
+  module Visitors
+    class ToSql
+      def visit_Array o
+        if last_column.respond_to?(:array) && last_column.array
+          quoted o
+        else
+          o.map { |x| visit x }.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -8,10 +8,21 @@ module Arel
         "#{visit o.left} << #{visit o.right}"
       end
 
+      def visit_Arel_Nodes_ContainedWithinEquals o
+        "#{visit o.left} <<= #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_Contains o
+        "#{visit o.left} >> #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_ContainsEquals o
+        "#{visit o.left} >>= #{visit o.right}"
+      end
+
       def visit_Arel_Nodes_ArrayOverlap o
-        if Array === o.right 
-          right = "{#{o.right.map{|v| change_string(visit(v))}.join(',')}}"
-          "#{visit o.left} && '#{right}'"
+        if Array === o.right
+          "#{visit o.left} && #{visit o.right}"
         else
           "#{visit o.left} && #{visit o.right}"
         end
@@ -20,11 +31,6 @@ module Arel
       def visit_IPAddr value
         "'#{value.to_s}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}'"
       end
-
-      def change_string value
-        return value unless value.is_a?(String)
-        value.gsub(/^\'/, '"').gsub(/\'$/, '"')
-      end
     end
   end
 end

data/lib/postgres_ext/arel/visitors.rb

@@ -1 +1,2 @@
 require 'postgres_ext/arel/visitors/visitor'
+require 'postgres_ext/arel/visitors/to_sql'

data/lib/postgres_ext/version.rb

@@ -1,3 +1,3 @@
 module PostgresExt
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/postgres_ext.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'pg_array_parser', '~> 0.0.8'
 
   gem.add_development_dependency 'rails', '~> 3.2.0'
-  gem.add_development_dependency 'rspec-rails', '~> 2.9.0'
-  gem.add_development_dependency 'bourne', '~> 1.1.2'
+  gem.add_development_dependency 'rspec-rails', '~> 2.12.0'
+  gem.add_development_dependency 'bourne', '~> 1.3.0'
   if RUBY_PLATFORM =~ /java/
     gem.add_development_dependency 'activerecord-jdbcpostgresql-adapter'
   else

data/spec/arel/inet_spec.rb

@@ -23,11 +23,34 @@ describe 'INET related AREL functions' do
     end
   end
 
-  describe 'cotained with (<<) operator' do
-    it 'converts Arel contained_within statemnts to <<' do
+  describe 'contained with (<<) operator' do
+    it 'converts Arel contained_within statements to <<' do
       arel_table = IpAddress.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'/
     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.where(arel_table[:address].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.where(arel_table[:address].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.where(arel_table[:address].contains_or_equals(IPAddr.new('127.0.0.1/24'))).to_sql.should match />>= '127.0.0.0\/24'/
+    end
+  end
 end

data/spec/columns/array_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 describe 'Array column' do
   let!(:integer_array_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'integer[]'}
   let!(:string_array_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'character varying(255)[]'}
+  let!(:text_array_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'text[]'}
   let!(:adapter) { ActiveRecord::Base.connection }
 
   context 'string array' do
@@ -45,6 +46,44 @@ describe 'Array column' do
     end
   end
 
+  context 'text array' do
+    describe '#type_class' do
+      context 'has null value' do
+        it 'converts the PostgreSQL value to an array with a nil value' do
+          text_array_column.type_cast('{1,NULL,"NULL"}').should eq ['1',nil,'NULL']
+        end
+      end
+
+      context 'utf8' do
+        it "handles incoming UTF8 as UTF8" do
+          text_array_column.type_cast('{"Аркалио"}').should eq ['Аркалио']
+        end
+      end
+
+      context 'corner cases, strings with commas and quotations' do
+        it 'converts the PostgreSQL value containing escaped " to an array' do
+          text_array_column.type_cast('{"has \" quote",another value}').should eq ['has " quote', 'another value']
+        end
+
+        it 'converts the PostgreSQL value containing commas to an array' do
+          text_array_column.type_cast('{"has , comma",another value,"more, commas"}').should eq ['has , comma', 'another value', 'more, commas']
+        end
+
+        it 'converts strings containing , to the proper value' do
+          adapter.type_cast(['c,'], text_array_column).should eq '{"c,"}'
+        end
+
+        it "handles strings with double quotes" do
+          adapter.type_cast(['a"b'], text_array_column).should eq '{"a\\"b"}'
+        end
+
+        it 'converts arrays of strings containing nil to the proper value' do
+          adapter.type_cast(['one', nil, 'two'], text_array_column).should eq '{"one",NULL,"two"}'
+        end
+      end
+    end
+  end
+
   context 'integer array' do
     describe '#type_class' do
       context 'has null value' do