bigrecord 0.0.5

data/lib/big_record/br_associations/association_collection.rb

@@ -0,0 +1,194 @@
+require 'set'
+
+module BigRecord
+  module BrAssociations
+    class AssociationCollection < AssociationProxy #:nodoc:
+      def to_ary
+        load_target
+        @target.to_ary
+      end
+
+      def reset
+        @loaded = false
+        reset_target!
+      end
+
+      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
+      # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
+      def <<(*records)
+        result = true
+        load_target
+
+        # HbaseAdapter doesn't support transactions
+        @owner.transaction do
+          flatten_deeper(records).each do |record|
+            raise_on_type_mismatch(record)
+            callback(:before_add, record)
+            result &&= insert_record(record) unless @owner.new_record?
+            @target << record
+            callback(:after_add, record)
+          end
+        end
+
+        result && self
+      end
+
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      # Remove all records from this association
+      def delete_all
+        load_target
+        delete(@target)
+        reset_target!
+      end
+
+      # Calculate sum using SQL, not Enumerable
+      def sum(*args, &block)
+        calculate(:sum, *args, &block)
+      end
+
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.each { |record| raise_on_type_mismatch(record) }
+        records.reject! { |record| @target.delete(record) if record.new_record? }
+        return if records.empty?
+
+        # HbaseAdapter doesn't support transactions
+        @owner.transaction do
+          records.each { |record| callback(:before_remove, record) }
+          delete_records(records)
+          records.each do |record|
+            @target.delete(record)
+            callback(:after_remove, record)
+          end
+        end
+      end
+
+      # Removes all records from this association.  Returns +self+ so method calls may be chained.
+      def clear
+        return self if length.zero? # forces load_target if hasn't happened already
+
+        if @reflection.options[:dependent] && @reflection.options[:dependent] == :delete_all
+          destroy_all
+        else
+          delete_all
+        end
+
+        self
+      end
+
+      def destroy_all
+        # HbaseAdapter doesn't support transactions
+        @owner.transaction do
+          each { |record| record.destroy }
+        end
+
+        reset_target!
+      end
+
+      def create(attributes = {})
+        # Can't use Base.create since the foreign key may be a protected attribute.
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          record = build(attributes)
+          record.save unless @owner.new_record?
+          record
+        end
+      end
+
+      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
+      # calling collection.size if it has. If it's more likely than not that the collection does have a size larger than zero
+      # and you need to fetch that collection afterwards, it'll take one less SELECT query if you use length.
+      def size
+        if loaded? && !@reflection.options[:uniq]
+          @target.size
+        elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
+          unsaved_records = Array(@target.detect { |r| r.new_record? })
+          unsaved_records.size + count_records
+        else
+          count_records
+        end
+      end
+
+      # Returns the size of the collection by loading it and calling size on the array. If you want to use this method to check
+      # whether the collection is empty, use collection.length.zero? instead of collection.empty?
+      def length
+        load_target.size
+      end
+
+      def empty?
+        size.zero?
+      end
+
+      def uniq(collection = self)
+        seen = Set.new
+        collection.inject([]) do |kept, record|
+          unless seen.include?(record.id)
+            kept << record
+            seen << record.id
+          end
+          kept
+        end
+      end
+
+      # Replace this collection with +other_array+
+      # This will perform a diff and delete/add only records that have changed.
+      def replace(other_array)
+        other_array.each { |val| raise_on_type_mismatch(val) }
+
+        load_target
+        other   = other_array.size < 100 ? other_array : other_array.to_set
+        current = @target.size < 100 ? @target : @target.to_set
+
+        # HbaseAdapter doesn't support transactions
+        @owner.transaction do
+          delete(@target.select { |v| !other.include?(v) })
+          concat(other_array.select { |v| !current.include?(v) })
+        end
+      end
+
+      protected
+        def reset_target!
+          @target = Array.new
+        end
+
+        def find_target
+          records =
+            if @reflection.options[:finder_sql]
+              @reflection.klass.find_by_sql(@finder_sql)
+            else
+              find(:all)
+            end
+
+          @reflection.options[:uniq] ? uniq(records) : records
+        end
+
+      private
+        def callback(method, record)
+          callbacks_for(method).each do |callback|
+            case callback
+              when Symbol
+                @owner.send(callback, record)
+              when Proc, Method
+                callback.call(@owner, record)
+              else
+                if callback.respond_to?(method)
+                  callback.send(method, @owner, record)
+                else
+                  raise ActiveRecordError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
+                end
+            end
+          end
+        end
+
+        def callbacks_for(callback_name)
+          full_callback_name = "#{callback_name}_for_#{@reflection.name}"
+          @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
+        end
+
+    end
+  end
+end

data/lib/big_record/br_associations/association_proxy.rb

@@ -0,0 +1,153 @@
+module BigRecord
+  module BrAssociations
+    class AssociationProxy #:nodoc:
+      attr_reader :reflection
+      alias_method :proxy_respond_to?, :respond_to?
+      alias_method :proxy_extend, :extend
+      delegate :to_param, :to => :proxy_target
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_)/ }
+
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+        reset
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def proxy_reflection
+        @reflection
+      end
+
+      def proxy_target
+        @target
+      end
+
+      def respond_to?(symbol, include_priv = false)
+        proxy_respond_to?(symbol, include_priv) || (load_target && @target.respond_to?(symbol, include_priv))
+      end
+
+      # Explicitly proxy === because the instance method removal above
+      # doesn't catch it.
+      def ===(other)
+        load_target
+        other === @target
+      end
+
+      def aliased_table_name
+        @reflection.klass.table_name
+      end
+
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      def reload
+        reset
+        load_target
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded
+        @loaded = true
+      end
+
+      def target
+        @target
+      end
+
+      def target=(target)
+        @target = target
+        loaded
+      end
+
+      protected
+        def dependent?
+          @reflection.options[:dependent] || false
+        end
+
+        def quoted_record_ids(records)
+          records.map { |record| record.quoted_id }.join(',')
+        end
+
+#        def interpolate_sql_options!(options, *keys)
+#          keys.each { |key| options[key] &&= interpolate_sql(options[key]) }
+#        end
+#
+#        def interpolate_sql(sql, record = nil)
+#          @owner.send(:interpolate_sql, sql, record)
+#        end
+#
+#        def sanitize_sql(sql)
+#          @reflection.klass.send(:sanitize_sql, sql)
+#        end
+
+        def extract_options_from_args!(args)
+          @owner.send(:extract_options_from_args!, args)
+        end
+
+        def set_belongs_to_association_for(record)
+          if @reflection.options[:as]
+            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+            record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
+          else
+            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+          end
+        end
+
+        def merge_options_from_reflection!(options)
+          options.reverse_merge!(
+            :group   => @reflection.options[:group],
+            :limit   => @reflection.options[:limit],
+            :offset  => @reflection.options[:offset],
+            :joins   => @reflection.options[:joins],
+            :include => @reflection.options[:include],
+            :select  => @reflection.options[:select]
+          )
+        end
+
+      private
+        def method_missing(method, *args, &block)
+          if load_target
+            @target.send(method, *args, &block)
+          end
+        end
+
+        def load_target
+          return nil unless defined?(@loaded)
+
+          if !loaded? and (!@owner.new_record? || foreign_key_present)
+            @target = find_target
+          end
+
+          @loaded = true
+          @target
+        rescue BigRecord::RecordNotFound
+          reset
+        end
+
+        # Can be overwritten by associations that might have the foreign key available for an association without
+        # having the object itself (and still being a new record). Currently, only belongs_to present this scenario.
+        def foreign_key_present
+          false
+        end
+
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(@reflection.klass)
+            raise BigRecord::AssociationTypeMismatch, "#{@reflection.class_name} expected, got #{record.class}"
+          end
+        end
+
+        # Array#flatten has problems with recursive arrays. Going one level deeper solves the majority of the problems.
+        def flatten_deeper(array)
+          array.collect { |element| element.respond_to?(:flatten) ? element.flatten : element }.flatten
+        end
+    end
+  end
+end

data/lib/big_record/br_associations/belongs_to_association.rb

@@ -0,0 +1,52 @@
+module BigRecord
+  module BrAssociations
+    class BelongsToAssociation < AssociationProxy #:nodoc:
+      def create(attributes = {})
+        replace(@reflection.klass.create(attributes))
+      end
+
+      def build(attributes = {})
+        replace(@reflection.klass.new(attributes))
+      end
+
+      def replace(record)
+        counter_cache_name = @reflection.counter_cache_column
+
+        if record.nil?
+          if counter_cache_name && @owner[counter_cache_name] && !@owner.new_record?
+            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = @owner[@reflection.primary_key_name] = nil
+        else
+          raise_on_type_mismatch(record)
+
+          if counter_cache_name && !@owner.new_record?
+            @reflection.klass.increment_counter(counter_cache_name, record.id)
+            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = (AssociationProxy === record ? record.target : record)
+          @owner[@reflection.primary_key_name] = record.id unless record.new_record?
+          @updated = true
+        end
+
+        loaded
+        record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+        def find_target
+          @reflection.klass.find(@owner[@reflection.primary_key_name])
+        end
+
+        def foreign_key_present
+          !@owner[@reflection.primary_key_name].nil?
+        end
+    end
+  end
+end

data/lib/big_record/br_associations/belongs_to_many_association.rb

@@ -0,0 +1,293 @@
+module BigRecord
+  module BrAssociations
+    class BelongsToManyAssociation < AssociationProxy #:nodoc:
+      def to_ary
+        load_target
+        @target.to_ary
+      end
+
+      def reset
+        @loaded = false
+        reset_target!
+      end
+
+      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
+      # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
+      def <<(*records)
+        result = true
+        load_target
+
+        flatten_deeper(records).each do |record|
+          raise_on_type_mismatch(record)
+          callback(:before_add, record)
+          result &&= insert_record(record)
+          @target << record
+          callback(:after_add, record)
+        end
+
+        result && self
+      end
+
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      # Remove all records from this association
+      def delete_all
+        load_target
+        delete(@target)
+        reset_target!
+      end
+
+#      # Calculate sum using SQL, not Enumerable
+#      def sum(*args, &block)
+#        calculate(:sum, *args, &block)
+#      end
+
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.each { |record| raise_on_type_mismatch(record) }
+        records.reject! { |record| @target.delete(record) if record.new_record? }
+        return if records.empty?
+
+        records.each { |record| callback(:before_remove, record) }
+        delete_records(records)
+        records.each do |record|
+          @target.delete(record)
+          callback(:after_remove, record)
+        end
+      end
+
+      # Removes all records from this association.  Returns +self+ so method calls may be chained.
+      def clear
+        return self if length.zero? # forces load_target if hasn't happened already
+
+        if @reflection.options[:dependent] && @reflection.options[:dependent] == :delete_all
+          destroy_all
+        else
+          delete_all
+        end
+
+        self
+      end
+
+      def destroy_all
+        # HbaseAdapter doesn't support transactions
+#        @owner.transaction do
+          each { |record| record.destroy }
+#        end
+
+        reset_target!
+      end
+
+      def create(attributes = {})
+        # Can't use Base.create since the foreign key may be a protected attribute.
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          record = build(attributes)
+          record.save unless @owner.new_record?
+          record
+        end
+      end
+
+      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
+      # calling collection.size if it has. If it's more likely than not that the collection does have a size larger than zero
+      # and you need to fetch that collection afterwards, it'll take one less SELECT query if you use length.
+      def size
+        @target.size
+      end
+
+      # Returns the size of the collection by loading it and calling size on the array. If you want to use this method to check
+      # whether the collection is empty, use collection.length.zero? instead of collection.empty?
+      def length
+        load_target.size
+      end
+
+      def empty?
+        size.zero?
+      end
+
+      def uniq(collection = self)
+        seen = Set.new
+        collection.inject([]) do |kept, record|
+          unless seen.include?(record.id)
+            kept << record
+            seen << record.id
+          end
+          kept
+        end
+      end
+
+      # Replace this collection with +other_array+
+      # This will perform a diff and delete/add only records that have changed.
+      def replace(other_array)
+        if other_array.nil?
+          @target = @owner[@reflection.primary_key_name] = nil
+        elsif other_array.empty?
+          @target = @owner[@reflection.primary_key_name] = []
+        else
+          other_array.each { |val| raise_on_type_mismatch(val) }
+
+          load_target
+          other   = other_array.size < 100 ? other_array : other_array.to_set
+          current = @target.size < 100 ? @target : @target.to_set
+
+          delete(@target.select { |v| !other.include?(v) })
+          concat(other_array.select { |v| !current.include?(v) })
+          @updated = true
+        end
+        self
+      end
+
+      def updated?
+        @updated
+      end
+
+      protected
+        def reset_target!
+          @target = Array.new
+        end
+
+        def find_target
+          records = find(:all)
+          @reflection.options[:uniq] ? uniq(records) : records
+        end
+
+      private
+        def callback(method, record)
+          callbacks_for(method).each do |callback|
+            case callback
+              when Symbol
+                @owner.send(callback, record)
+              when Proc, Method
+                callback.call(@owner, record)
+              else
+                if callback.respond_to?(method)
+                  callback.send(method, @owner, record)
+                else
+                  raise ActiveRecordError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
+                end
+            end
+          end
+        end
+
+        def callbacks_for(callback_name)
+          full_callback_name = "#{callback_name}_for_#{@reflection.name}"
+          @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
+        end
+
+
+
+
+
+
+
+    public
+      def build(attributes = {})
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr) }
+        else
+          record = @reflection.klass.new(attributes)
+          set_belongs_to_association_for(record)
+
+          @target ||= [] unless loaded?
+          @target << record
+
+          record
+        end
+      end
+
+      # Count the number of associated records. All arguments are optional.
+      def count(*args)
+        load_target
+        @target.size
+      end
+
+      def find(*args)
+        raise ArgumentError, "Only find(:all) is supported" unless args == [:all]
+        return [] if @owner[@reflection.primary_key_name].blank?
+
+        if @reflection.options[:cache]
+          # Create the items proxies using the content that is cached
+          records = []
+          @owner[@reflection.primary_key_name].each do |id|
+            records << CachedItemProxyFactory.instance.create(id, @owner, @reflection)
+          end
+          records
+        else
+          # Don't throw an exception when the records are not found
+          records = []
+          @owner[@reflection.primary_key_name].each do |id|
+            begin
+              records << @reflection.klass.find(id)
+            rescue BigRecord::RecordNotFound
+              # do nothing
+            end
+          end
+          records
+        end
+      end
+
+      protected
+        def load_target
+          begin
+            if !loaded?
+              if @target.is_a?(Array) && @target.any?
+                @target = (find_target + @target).uniq
+              else
+                @target = find_target
+              end
+            end
+          rescue ActiveRecord::RecordNotFound, BigRecord::RecordNotFound
+            reset
+          end
+
+          loaded if target
+          target
+        end
+
+        def count_records
+          count = if has_cached_counter?
+            @owner.send(:read_attribute, cached_counter_attribute_name)
+          elsif @reflection.options[:counter_sql]
+            @reflection.klass.count_by_sql(@counter_sql)
+          else
+            @reflection.klass.count(:conditions => @counter_sql)
+          end
+
+          @target = [] and loaded if count == 0
+
+          if @reflection.options[:limit]
+            count = [ @reflection.options[:limit], count ].min
+          end
+
+          return count
+        end
+
+        def has_cached_counter?
+          @owner.attribute_present?(cached_counter_attribute_name)
+        end
+
+        def cached_counter_attribute_name
+          "#{@reflection.name}_count"
+        end
+
+        def insert_record(record)
+          @owner[@reflection.primary_key_name] ||= []
+          @owner[@reflection.primary_key_name] << record.id unless record.new_record?
+        end
+
+        def delete_records(records)
+          if @owner[@reflection.primary_key_name]
+            records.each{|r| @owner[@reflection.primary_key_name].delete(r.id)}
+          end
+        end
+
+        def target_obsolete?
+          false
+        end
+
+    end
+  end
+end