ar_jdbc_pg_array 0.1.0-java

data/lib/ar_jdbc_pg_array/references_by.rb

@@ -0,0 +1,154 @@
+module PGArrays
+  module ReferencesBy
+    if defined? ::Arel
+      HAS_AREL=true
+      NAMED_SCOPE='scope'
+    else
+      NAMED_SCOPE='named_scope'
+      if defined? ::FakeArel
+        HAS_AREL= true
+      else
+        HAS_AREL=false
+      end
+    end
+
+    class RelationHolder < Struct.new(:relation, :field, :klass)
+
+      def referenced(obj)
+        ids = (obj[field] || []).map{|i| i.to_i}
+        objs = klass.find_all_by_id( ids.sort )
+        if ids.size < 20
+          objs.sort_by{|o| ids.index(o.id)}
+        else
+          to_ind = ids.each_with_index.inject({}){|h, (v,i)| h[v]=i; h}
+          objs.sort_by{|o| to_ind[o.id]}
+        end
+      end
+
+      def set_referenced(obj, value)
+        obj[field] = map_to_ids(value)
+      end
+
+      if HAS_AREL
+        def validate(obj)
+          has_ids = klass.where(:id=>obj.read_attribute(field)).
+                    select('id').all.map(&:id)
+          unless has_ids.sort == obj.read_attribute(field).sort
+            obj.errors.add(relation, :wrong_array_reference)
+          end
+        end
+
+        def for_referenced(obj_klass)
+          myself = self
+          obj_klass.class_exec do
+            puts "named_scope #{NAMED_SCOPE} #{myself.relation}_include"
+            self.send NAMED_SCOPE, "#{myself.relation}_include", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_all)
+            }
+
+            self.send NAMED_SCOPE, "#{myself.relation}_have_all", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_all)
+            }
+
+            self.send NAMED_SCOPE, "#{myself.relation}_have_any", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_any)
+            }
+
+            self.send NAMED_SCOPE, "#{myself.relation}_included_into", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_subarray)
+            }
+          end
+        end
+      else
+        def validate(obj)
+          has_ids = klass.find(:all,
+              :select=>'id',
+              :conditions=>{:id=>obj.read_attribute(field)}
+              ).map(&:id)
+          unless has_ids.sort == obj.read_attribute(field).sort
+            obj.errors.add(relation, :wrong_array_reference)
+          end
+        end
+
+        def for_referenced(obj_klass)
+          myself = self
+          obj_klass.class_exec do
+            named_scope "#{myself.relation}_include", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_all } }
+            }
+
+            named_scope "#{myself.relation}_have_all", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_all } }
+            }
+
+            named_scope "#{myself.relation}_have_any", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_any } }
+            }
+
+            named_scope "#{myself.relation}_included_into", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_subarray } }
+            }
+          end
+        end
+      end
+
+      def val_to_id(val)
+        case val
+        when ActiveRecord::Base then val.id
+        when nil then nil
+        else val.to_i
+        end
+      end
+
+      def map_to_ids(vals)
+        (r = vals.map{|v| val_to_id(v)}).compact!
+        r
+      end
+    end
+
+    module ClassMethods
+      def references_by_array( relation, options = {} )
+        unless ActiveSupport::Memoizable === self
+          extend ActiveSupport::Memoizable
+        end
+
+        relation = relation.to_s.pluralize
+        field = "#{relation.singularize}_ids"
+        klass_name = (options[:class_name] || relation).to_s.singularize.camelize
+        klass = klass_name.constantize
+        holder = RelationHolder.new(relation, field, klass )
+
+        meths =  Module.new do
+          define_method(relation) do
+            holder.referenced(self)
+          end
+
+          define_method("#{relation}=") do |value|
+            flush_cache(relation)
+            holder.set_referenced(self, value)
+          end
+        end
+        include meths
+
+        memoize relation
+
+        if options[:validate]
+          validate {|o| holder.validate(o)}
+        end
+
+        holder.for_referenced(self)
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.extend PGArrays::ReferencesBy::ClassMethods

data/lib/ar_jdbc_pg_array/schema.rb

@@ -0,0 +1,248 @@
+require 'ar_jdbc_pg_array/parser'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLColumn
+      include PgArrayParser
+      extend PgArrayParser
+
+      BASE_TYPE_COLUMNS = Hash.new { |h, base_type|
+        base_column = new(nil, nil, base_type.to_s, true)
+        h[base_type] = h[base_column.type] = base_column
+      }
+      attr_reader :base_column
+
+      def initialize(name, default, sql_type = nil, null = true)
+        if sql_type =~ /^(.+)\[\]$/
+          @base_sql_type = $1
+          @base_column = BASE_TYPE_COLUMNS[@base_sql_type]
+        end
+
+        if Hash === name
+          super
+        else
+          super(nil, name, default, sql_type, null)
+        end
+      end
+
+      def simplified_type_with_postgresql_arrays(field_type)
+        if field_type =~ /^(.+)\[\]$/
+          :"#{simplified_type_without_postgresql_arrays($1)}_array"
+        else
+          simplified_type_without_postgresql_arrays(field_type)
+        end
+      end
+      alias_method_chain :simplified_type, :postgresql_arrays
+
+      def klass
+        if type.to_s =~ /_array$/
+          Array
+        else
+          super
+        end
+      end
+
+      def type_cast(value)
+        return nil if value.nil?
+        case type
+          when :integer_array, :float_array
+            string_to_num_array(value)
+          when :decimal_array, :date_array, :boolean_array
+            safe_string_to_array(value)
+          when :timestamp_array, :time_array, :datetime_array, :binary_array
+            string_to_array(value)
+          when :text_array, :string_array
+            string_to_text_array(value)
+          else super
+        end
+      end
+
+      def type_cast_code(var_name)
+        case type
+          when :integer_array, :float_array
+            "#{self.class.name}.string_to_num_array(#{var_name})"
+          when :decimal_array, :date_array, :boolean_array
+            "#{self.class.name}.safe_string_to_array(#{var_name}, #{@base_sql_type.inspect})"
+          when :timestamp_array, :time_array, :datetime_array, :binary_array
+            "#{self.class.name}.string_to_array(#{var_name}, #{@base_sql_type.inspect})"
+          when :text_array, :string_array
+            "#{self.class.name}.string_to_text_array(#{var_name})"
+          else super
+        end
+      end
+
+      def default
+        res = super
+        Array === res ? res.dup : res
+      end
+
+      def self._string_to_array(string)
+        return string unless string.is_a? String
+        return nil if string.empty?
+
+        yield
+      end
+
+      def _string_to_array(string)
+        return string unless string.is_a? String
+        return nil if string.empty?
+
+        yield
+      end
+
+      def safe_string_to_array(string)
+        _string_to_array(string) do
+          parse_safe_pgarray(string){|v| @base_column.type_cast(v)}
+        end
+      end
+
+      def self.safe_string_to_array(string, sql_type)
+        _string_to_array(string) do
+          base_column = BASE_TYPE_COLUMNS[sql_type]
+          parse_safe_pgarray(string){|v| base_column.type_cast(v)}
+        end
+      end
+
+      def string_to_array(string)
+        _string_to_array(string) do
+          parse_pgarray(string){|v| @base_column.type_cast(v)}
+        end
+      end
+
+      def self.string_to_array(string, sql_type)
+        _string_to_array(string) do
+          base_column = BASE_TYPE_COLUMNS[sql_type]
+          parse_pgarray(string){|v| base_column.type_cast(v)}
+        end
+      end
+
+      def string_to_num_array(string)
+        _string_to_array(string) do
+          parse_numeric_pgarray(string)
+        end
+      end
+
+      def self.string_to_num_array(string)
+        _string_to_array(string) do
+          parse_numeric_pgarray(string)
+        end
+      end
+
+      def string_to_text_array(string)
+        _string_to_array(string) do
+          parse_pgarray(string){|v| v}
+        end
+      end
+
+      def self.string_to_text_array(string)
+        _string_to_array(string) do
+          parse_pgarray(string){|v| v}
+        end
+      end
+    end
+
+    class PostgreSQLAdapter #:nodoc:
+      include PgArrayParser
+      def quote_with_postgresql_arrays(value, column = nil)
+        if Array === value && column && "#{column.type}" =~ /^(.+)_array$/
+          quote_array_by_base_type(value, $1, column)
+        else
+          quote_without_postgresql_arrays(value, column)
+        end
+      end
+      alias_method_chain :quote, :postgresql_arrays
+
+      def quote_array_by_base_type(value, base_type, column = nil)
+        case base_type.to_sym
+        when :integer, :float, :decimal, :boolean, :date, :safe, :datetime, :timestamp, :time
+          "'#{ prepare_array_for_arel_by_base_type(value, base_type) }'"
+        when :string, :text, :other
+          pa = prepare_array_for_arel_by_base_type(value, base_type)
+          "'#{ quote_string(pa) }'"
+        else
+          "'#{ prepare_pg_string_array(value, base_type, column) }'"
+        end
+      end
+
+      def prepare_array_for_arel_by_base_type(value, base_type)
+        case base_type.to_sym
+          when :integer
+            prepare_pg_integer_array(value)
+          when :float
+            prepare_pg_float_array(value)
+          when :string, :text, :other
+            prepare_pg_text_array(value)
+          when :datetime, :timestamp, :time
+            prepare_pg_string_array(value, base_type)
+          when :decimal, :boolean, :date, :safe
+            prepare_pg_safe_array(value)
+          else
+            raise "Unsupported array base type #{base_type} for arel"
+        end
+      end
+
+      def prepare_pg_string_array(value, base_type, column = nil)
+        base_column = if column
+                        column.base_column
+                      else
+                        PostgreSQLColumn::BASE_TYPE_COLUMNS[base_type.to_sym]
+                      end
+        _prepare_pg_string_array(value) { |v| quote_without_postgresql_arrays(v, base_column) }
+      end
+
+      NATIVE_DATABASE_TYPES.keys.each do |key|
+        unless key == :primary_key
+          base = NATIVE_DATABASE_TYPES[key].dup
+          base[:name] = base[:name] + '[]'
+          NATIVE_DATABASE_TYPES[:"#{key}_array"] = base
+          TableDefinition.class_eval <<-EOV
+            def #{key}_array(*args)                                               # def string_array(*args)
+              options = args.extract_options!                                     #   options = args.extract_options!
+              column_names = args                                                 #   column_names = args
+                                                                                  #
+              column_names.each { |name| column(name, :'#{key}_array', options) } #   column_names.each { |name| column(name, :string_array, options) }
+            end                                                                   # end
+          EOV
+          Table.class_eval <<-EOV
+            def #{key}_array(*args)                                               # def string_array(*args)
+              options = args.extract_options!                                     #   options = args.extract_options!
+              column_names = args                                                 #   column_names = args
+                                                                                  #
+              column_names.each { |name|                                          #   column_names.each { |name|
+                @base.add_column(@table_name, name, :'#{key}_array', options)     #     @base.add_column(@table_name, name, :string_array, options) }
+              }                                                                   #   }
+            end                                                                   # end
+          EOV
+        end
+      end
+
+      def add_column_with_postgresql_arrays(table, column, type, options = {})
+        if type.to_s =~ /^(.+)_array$/ && options[:default].is_a?(Array)
+          options = options.merge(:default => prepare_array_for_arel_by_base_type(options[:default], $1))
+        end
+        add_column_without_postgresql_arrays(table, column, type, options)
+      end
+      alias_method_chain :add_column, :postgresql_arrays
+
+      def type_to_sql_with_postgresql_arrays(type, limit = nil, precision = nil, scale = nil)
+        if type.to_s =~ /^(.+)_array$/
+          type_to_sql_without_postgresql_arrays($1.to_sym, limit, precision, scale) + '[]'
+        else
+          type_to_sql_without_postgresql_arrays(type, limit, precision, scale)
+        end
+      end
+      alias_method_chain :type_to_sql, :postgresql_arrays
+
+      if method_defined?(:type_cast)
+        def type_cast_with_postgresql_arrays(value, column)
+          if Array === value && column && "#{column.type}" =~ /^(.+)_array$/
+            prepare_array_for_arel_by_base_type(value, $1)
+          else
+            type_cast_without_postgresql_arrays(value, column)
+          end
+        end
+        alias_method_chain :type_cast, :postgresql_arrays
+      end
+    end
+  end
+end

data/lib/ar_jdbc_pg_array/schema_arel.rb

@@ -0,0 +1,47 @@
+module Arel
+  module Attributes
+    %w{Integer Float Decimal Boolean String Time}.each do |basetype|
+      module_eval <<-"END"
+        class #{basetype}Array < Attribute
+        end
+      END
+    end
+  end
+
+  module Attributes
+    class << self
+      def for_with_postgresql_arrays(column)
+        if column.type.to_s =~ /^(.+)_array$/
+          ('Arel::Attributes::' + for_without_postgresql_arrays(column.base_column).name.split('::').last + 'Array').constantize
+        else
+          for_without_postgresql_arrays(column)
+        end
+      end
+      alias_method_chain :for, :postgresql_arrays
+    end
+  end
+end
+
+module ActiveRecord
+  class << Base
+    if method_defined?(:column_defaults)
+      alias column_defaults_without_extradup column_defaults
+      def column_defaults_with_extradup
+        res = {}
+        column_defaults_without_extradup.each{|k, v|
+          res[k] = Array === v ? v.dup : v
+        }
+        res
+      end
+      def column_defaults
+        defaults = column_defaults_without_extradup
+        if defaults.values.grep(Array).empty?
+          alias column_defaults column_defaults_without_extradup
+        else
+          alias column_defaults column_defaults_with_extradup
+        end
+        column_defaults
+      end
+    end
+  end
+end