ar_jdbc_pg_array 0.1.0-java

data/.gitignore

@@ -0,0 +1,6 @@
+*.lock
+*.swo
+*.swp
+rdoc
+pkg
+*~

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Sokolov Yura aka funny_falcon
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+PostgresArrays
+==============
+
+This library adds ability to use PostgreSQL array types with ActiveRecord.
+
+    > User.find(:all, :conditions=>['arr @> ?', [1,2,3].pg])
+      SELECT * FROM "users" WHERE ('arr' @> E'{"1", "2", "3"}')
+    > User.find(:all, :conditions=>['arr @> ?', [1,2,3].pg(:integer)])
+      SELECT * FROM "users" WHERE (arr @> '{1,2,3}')
+    > User.find(:all, :conditions=>['arr @> ?', [1,2,3].pg(:float)])
+      SELECT * FROM "users" WHERE (arr @> '{1.0,2.0,3.0}')
+    > u = User.find(1)
+      SELECT * FROM "users" WHERE ("users"."id" = 1)
+      => #<User id: 1, ..., arr: [1,2]>
+    > u.arr = [3,4]
+    > u.save
+      UPDATE "users" SET "db_ar" = '{3.0,4.0}' WHERE "id" = 19
+    > User.find(:all, :conditions=>{:arr=>[3,4].pg})
+      SELECT * FROM "users" WHERE ("users"."arr" = E'{"3", "4"}')
+    > User.find(:all, :conditions=>{:arr=>[3,4].search_any(:float)})
+      SELECT * FROM "users" WHERE ("users"."arr" && '{3.0,4.0}')
+    > User.find(:all, :conditions=>{:arr=>[3,4].search_all(:integer)})
+      SELECT * FROM "users" WHERE ("users"."arr" @> '{3,4}')
+    > User.find(:all, :conditions=>{:arr=>[3,4].search_subarray(:safe)})
+      SELECT * FROM "users" WHERE ("users"."arr" <@ '{3,4}')
+
+      class U < ActiveRecord::Migration
+        def self.up
+          create_table :users do |t|
+            t.integer_array :int_ar
+          end
+          add_column :users, :fl_ar, :float_array
+        end
+      end
+
+Installation
+============
+
+    gem install ar_jdbc_pg_array
+
+Changelog
+=========
+
+  0.1.0
+
+    Initial jdbc support
+
+Copyright (c) 2010 Sokolov Yura aka funny_falcon, released under the MIT license

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/ar_jdbc_pg_array.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+Gem::Specification.new do |gem|
+  gem.name          = 'ar_jdbc_pg_array'
+  gem.version       = '0.1.0'
+  gem.platform      = 'java'
+
+  gem.authors       = ['Sokolov Yura', 'Dimko']
+  gem.email         = ['deemox@gmail.com']
+  gem.description   = "ar_jdbc_pg_array includes support of PostgreSQL's int[], float[], text[], timestamptz[] etc. into ActiveRecord. You could define migrations for array columns, query on array columns."
+  gem.summary       = 'Use power of PostgreSQL Arrays in ActiveRecord'
+  gem.homepage      = 'https://github.com/dimko/activerecord-jdbc-postgresql-arrays'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'activerecord', '~> 3.1'
+  gem.add_dependency 'activerecord-jdbcpostgresql-adapter', '~> 1.2.9'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'cancan'
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'rspec',   '~> 2.5'
+end

data/lib/ar_jdbc_pg_array.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'arjdbc/postgresql'
+
+require 'ar_jdbc_pg_array/schema'
+require 'ar_jdbc_pg_array/schema_cacheable'
+require 'ar_jdbc_pg_array/querying'
+require 'ar_jdbc_pg_array/allways_save'
+require 'ar_jdbc_pg_array/references_by'
+require 'ar_jdbc_pg_array/schema_arel'
+require 'ar_jdbc_pg_array/querying_arel'

data/lib/ar_jdbc_pg_array/allways_save.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+    module CheckArrayBeforeUpdate
+      def mark_arrays_for_update
+        @attributes_cache.each do |name, value|
+          attribute_will_change!(name) if Array === value && _read_attribute(name) != value
+        end
+      end
+    end
+  if VERSION::MAJOR < 3
+    module CheckArrayBeforeUpdate
+      def self.included(base)
+        base.alias_method_chain :update, :check_array
+        base.send(:alias_method, :_read_attribute, :read_attribute)
+      end
+
+      def update_with_check_array
+        mark_arrays_for_update
+        update_without_check_array
+      end
+    end
+  else
+    module CheckArrayBeforeUpdate
+      include ActiveSupport::Concern
+
+      if VERSION::MAJOR == 3 && VERSION::MINOR >= 2
+        def _read_attribute(attr_name)
+          column_for_attribute(attr_name).type_cast(@attributes[attr_name])
+        end
+      end
+
+      def update(*)
+        mark_arrays_for_update
+        super
+      end
+    end
+  end
+  Base.__send__ :include, CheckArrayBeforeUpdate
+end

data/lib/ar_jdbc_pg_array/parser.rb

@@ -0,0 +1,174 @@
+require 'json'
+
+module PgArrayParser
+  CURLY_BRACKETS = '{}'.freeze
+  SQUARE_BRACKETS = '[]'.freeze
+  NULL = 'NULL'.freeze
+  NIL = 'nil'.freeze
+  ESCAPE_HASH={'\\'.freeze=>'\\\\'.freeze, '"'.freeze=>'\\"'.freeze}
+
+  def parse_numeric_pgarray(text)
+    text = text.tr(CURLY_BRACKETS, SQUARE_BRACKETS)
+    text.downcase!
+    JSON.load(text)
+  end
+
+  def parse_safe_pgarray(text, &block)
+    if text =~ /^\{([^\}]*)\}$/
+      $1.split(/,\s*/).map!{|v| v == NULL ? nil : yield(v)}
+    else
+      raise "Mailformed array" unless text =~ /^\{\s*/
+      ar, rest = _parse_safe_pgarray($')
+      ar
+    end
+  end
+
+  def _parse_safe_pgarray(text, &block)
+    values = []
+    return values  if text =~ /^\}\s*/
+    if text =~ /^\{\s*/
+      text = $'
+      while true
+        ar, rest = _parse_safe_pgarray(text, &block)
+        values << ar
+        if rest =~ /^\}\s*/
+          return values, $'
+        elsif rest =~ /^,\s*/
+          rest = $'
+        else
+          raise "Mailformed postgres array"
+        end
+        text = rest
+      end
+    else
+      while true
+        raise 'Mailformed Array' unless text =~ /^([^,\}]*)([,\}])\s*/
+        val, sep, rest = $1, $2, $'
+        values << (val == NULL ? nil : yield(val))
+        if sep == '}'
+          return values, rest
+        end
+        text = rest
+      end
+    end
+  end
+
+  def parse_pgarray(text, &block)
+    raise "Mailformed postgres array" unless text =~ /^\{\s*/
+    ar, rest = _parse_pgarray($', &block)
+    ar
+  end
+
+  def _parse_pgarray(text, &block)
+    values = []
+    return values  if text =~ /^\}\s*/
+    if text =~ /^\{\s*/
+      text = $'
+      while true
+        ar, rest = _parse_pgarray(text, &block)
+        values << ar
+        if rest =~ /^\}\s*/
+          return values, $'
+        elsif rest =~ /^,\s*\{\s*/
+          rest = $'
+        else
+          raise "Mailformed postgres array"
+        end
+        text = rest
+      end
+    else
+      while true
+        if text =~ /^"((?:\\.|[^"\\])*)"([,}])\s*/
+          val, sep, rest = $1, $2, $'
+          val.gsub!(/\\(.)/, '\1')
+          val = yield val
+        elsif text =~ /^([^,\}]*)([,}])\s*/
+          val, sep, rest = $1, $2, $'
+          val = val == NULL ? nil : yield(val)
+        else
+          raise "Mailformed postgres array"
+        end
+        values << val
+        if sep == '}'
+          return values, rest
+        end
+        text = rest
+      end
+    end
+  end
+
+  def _remap_array(array, &block)
+    array.map{|v|
+      case v
+      when Array
+        _remap_array(v, &block)
+      when nil
+        nil
+      else
+        yield v
+      end
+    }
+  end
+
+  def prepare_pg_integer_array(value)
+    val = _remap_array(value){|v| v.to_i}.inspect
+    val.gsub!(NIL, NULL)
+    val.tr!(SQUARE_BRACKETS, CURLY_BRACKETS)
+    val
+  end
+
+  def prepare_pg_float_array(value)
+    val = _remap_array(value){|v| v.to_f}.inspect
+    val.gsub!(NIL, NULL)
+    val.tr!(SQUARE_BRACKETS, CURLY_BRACKETS)
+    val
+  end
+
+  def prepare_pg_safe_array(value)
+    value = value.map{|val|
+        case val
+        when Array
+          prepare_pg_safe_array(val)
+        when nil
+          NULL
+        else
+          val.to_s
+        end
+    }.join(',')
+    "{#{value}}"
+  end
+
+  def prepare_pg_text_array(value)
+    value = value.map{|val|
+      case val
+      when Array
+        prepare_pg_text_array(val)
+      when nil
+        NULL
+      else
+         "\"#{val.to_s.gsub(/\\|"/){|s| ESCAPE_HASH[s]}}\""
+      end
+    }.join(',')
+    "{#{value}}"
+  end
+
+  def _prepare_pg_string_array(value, &block)
+    value = value.map{|val|
+      case val
+      when Array
+        _prepare_pg_string_array(val, &block)
+      when nil
+        NULL
+      else
+        val = yield val
+        if val =~ /^'(.*)'$/m
+          "\"#{ $1.gsub(/\\|"/){|s| ESCAPE_HASH[s]} }\""
+        else
+          val
+        end
+      end
+    }.join(',')
+    "{#{value}}"
+  end
+  alias prepare_pg_string_array _prepare_pg_string_array
+end

data/lib/ar_jdbc_pg_array/querying.rb

@@ -0,0 +1,72 @@
+module ActiveRecord
+  class Base
+    class << self
+      def quote_bound_value_with_postgresql_arrays(value, c = connection)
+        if ::PGArrays::PgArray === value
+          c.quote_array_by_base_type(value, value.base_type)
+        else
+          quote_bound_value_without_postgresql_arrays(value, c)
+        end
+      end
+      alias_method_chain :quote_bound_value, :postgresql_arrays
+    end
+  end
+end
+
+module PGArrays
+  class PgArray < Array
+    attr_reader :base_type
+
+    def initialize(array, type=nil)
+      super(array)
+      @base_type = type if type
+    end
+
+    def base_type
+      @base_type || :other
+    end
+  end
+
+  class PgAny < PgArray; end
+  class PgAll < PgArray; end
+  class PgIncludes < PgArray; end
+
+  if defined? CanCan::Ability
+    class PgAny
+      def include?(v)
+        Array === v && !( v & self ).empty?
+      end
+    end
+
+    class PgAll
+      def include?(v)
+        Array === v && (self - v).empty?
+      end
+    end
+
+    class PgIncludes < PgArray
+      def include?(v)
+        Array === v && (v - self).empty?
+      end
+    end
+  end
+end
+
+class Array
+
+  def pg(type=nil)
+    ::PGArrays::PgArray.new(self, type)
+  end
+
+  def search_any(type=nil)
+    ::PGArrays::PgAny.new(self, type)
+  end
+
+  def search_all(type=nil)
+    ::PGArrays::PgAll.new(self, type)
+  end
+
+  def search_subarray(type=nil)
+    ::PGArrays::PgIncludes.new(self, type)
+  end
+end

data/lib/ar_jdbc_pg_array/querying_arel.rb

@@ -0,0 +1,172 @@
+module Arel
+  module Nodes
+    class ArrayAny < Arel::Nodes::Binary
+    end
+
+    class ArrayAll < Arel::Nodes::Binary
+    end
+
+    class ArrayIncluded < Arel::Nodes::Binary
+    end
+  end
+
+  module Predications
+    def ar_any other
+      Nodes::ArrayAny.new self, other
+    end
+
+    def ar_all other
+      Nodes::ArrayAll.new self, other
+    end
+
+    def ar_included other
+      Nodes::ArrayIncluded.new self, other
+    end
+  end
+
+  module Visitors
+    class PostgreSQL
+      def visit_Arel_Nodes_ArrayAny o
+        "#{visit o.left} && #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_ArrayAll o
+        "#{visit o.left} @> #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_ArrayIncluded o
+        "#{visit o.left} <@ #{visit o.right}"
+      end
+
+      def visit_PGArrays_PgArray o
+        @connection.quote_array_by_base_type(o, o.base_type)
+      end
+
+      alias :visit_PGArrays_PgAny :visit_PGArrays_PgArray
+      alias :visit_PGArrays_PgAll :visit_PGArrays_PgArray
+      alias :visit_PGArrays_PgIncluded :visit_PGArrays_PgArray
+    end
+  end
+end
+
+if ActiveRecord::VERSION::STRING < '3.1'
+  module ActiveRecord
+    class PredicateBuilder
+      def build_from_hash(attributes, default_table)
+        predicates = attributes.map do |column, value|
+          table = default_table
+
+          if value.is_a?(Hash)
+            table = Arel::Table.new(column, :engine => @engine)
+            build_from_hash(value, table)
+          else
+            column = column.to_s
+
+            if column.include?('.')
+              table_name, column = column.split('.', 2)
+              table = Arel::Table.new(table_name, :engine => @engine)
+            end
+
+            attribute = table[column] || Arel::Attribute.new(table, column)
+
+            case value
+            when PGArrays::PgAny
+              attribute.ar_any(value)
+            when PGArrays::PgAll
+              attribute.ar_all(value)
+            when PGArrays::PgIncludes
+              attribute.ar_included(value)
+            when PGArrays::PgArray
+              attribute.eq(value)
+            when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
+              values = value.to_a.map { |x|
+                x.is_a?(ActiveRecord::Base) ? x.id : x
+              }
+              attribute.in(values)
+            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
+else
+  module ActiveRecord
+    class PredicateBuilder
+      def self.build_from_hash(engine, attributes, default_table)
+        predicates = attributes.map do |column, value|
+          table = default_table
+
+          if value.is_a?(Hash)
+            table = Arel::Table.new(column, engine)
+            build_from_hash(engine, value, table)
+          else
+            column = column.to_s
+
+            if column.include?('.')
+              table_name, column = column.split('.', 2)
+              table = Arel::Table.new(table_name, engine)
+            end
+
+            attribute = table[column.to_sym]
+
+            case value
+            when PGArrays::PgAny
+              attribute.ar_any(value)
+            when PGArrays::PgAll
+              attribute.ar_all(value)
+            when PGArrays::PgIncludes
+              attribute.ar_included(value)
+            when PGArrays::PgArray
+              attribute.eq(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
+              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)}
+              predicates = ranges.map{|range| attribute.in(range)}
+
+              predicates << if values.include?(nil)
+                values = values.compact
+                if values.empty?
+                  attribute.eq nil
+                else
+                  attribute.in(values.compact).or attribute.eq(nil)
+                end
+              else
+                attribute.in(values)
+              end
+
+              predicates.inject{|composite, predicate| composite.or(predicate)}
+            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
+end