bigrecord 0.0.5

data/lib/big_record/br_associations/cached_item_proxy.rb

@@ -0,0 +1,194 @@
+module BigRecord
+  module BrAssociations
+    module CachedItemProxy #:nodoc:
+
+      CACHE_ATTRIBUTE = "attribute:associations_cache"
+
+      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 proxy_cache
+        @owner[CACHE_ATTRIBUTE] ||= {}
+        @owner[CACHE_ATTRIBUTE]["#{@reflection.klass.name}:#{id}"] ||= {}
+      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
+
+#      # Returns the contents of the record as a nicely formatted string.
+#      def inspect
+#        if loaded?
+#          @target.inspect
+#        else
+#          attributes_as_nice_string = @reflection.options[:cache].collect { |name|
+#            column = @owner.column_for_attribute("attribute:#{name}")
+#            "#{name}: #{column.type_cast(proxy_cache[name])}" if column
+#          }.compact.join(", ")
+#          "#<Cached#{@reflection.klass} #{attributes_as_nice_string}>"
+#        end
+#      end
+
+#      def is_a?(klass)
+#        @reflection.klass <= klass
+#      end
+#
+#      def kind_of?(klass)
+#        @reflection.klass <= klass
+#      end
+#
+#      def to_param
+#        @id
+#      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_id, *args, &block)
+#          if !loaded? and @reflection.options[:cache].include?(method_id)
+#            # FIXME: shouldn't be hard coded
+#            column = @owner.column_for_attribute("attribute:#{method_id}")
+#            if column
+#              if proxy_cache.has_key?(method_id)
+#                column.type_cast(proxy_cache[method_id])
+#              elsif load_target
+#                proxy_cache[method_id] = @target.send(method_id, *args, &block)
+#              end
+#            else
+#              @target.send(method_id, *args, &block)
+#            end
+#          elsif load_target
+#            value = @target.send(method_id, *args, &block)
+#            proxy_cache[method_id] = value if @reflection.options[:cache].include?(method_id)
+#            value
+#          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
+
+        def find_target
+          @reflection.klass.find(self.id)
+        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 BigRecordRecord::AssociationTypeMismatch, "#{@reflection.class_name} expected, got #{record.class}"
+#          end
+#        end
+
+    end
+  end
+end

data/lib/big_record/br_associations/cached_item_proxy_factory.rb

@@ -0,0 +1,62 @@
+module BigRecord
+  module BrAssociations
+    class CachedItemProxyFactory
+
+      include Singleton
+
+      def create(id, owner, reflection)
+        cache = owner[CachedItemProxy::CACHE_ATTRIBUTE]
+        cached_attributes = cache["#{reflection.klass.name}:#{id}"] if cache
+        cached_attributes ||= {}
+        cached_attributes["id"] = id
+        proxy = reflection.klass.instantiate(cached_attributes)
+        proxy.extend CachedItemProxy
+        proxy.instance_variable_set(:@owner, owner)
+        proxy.instance_variable_set(:@reflection, reflection)
+        proxy.reset
+
+        # Overload the cached methods
+        reflection.options[:cache].each do |attribute_name|
+          eval "def proxy.#{attribute_name}\n"+
+               "  proxy_cache[\"#{attribute_name}\"] ||= super\n"+
+               "end"
+        end
+
+        proxy
+      end
+
+#      def extended_class(reflection)
+#        @extended_classes ||= {}
+#        @extended_classes[reflection.klass.name] ||= create_extended_class(reflection)
+#      end
+#
+#      def create_extended_class(reflection)
+#        extended_class = Class.new(reflection.klass)
+#        extended_class.class_eval do
+#          include CachedItemProxy
+#
+#          attr_reader :reflection
+#          alias_method :proxy_respond_to?, :respond_to?
+#          alias_method :proxy_extend, :extend
+##          delegate :to_param, :to => :proxy_target
+#
+#          # Overload the methods
+#          instance_methods.each do |m|
+#            if reflection.options[:cache].include?(m.to_sym)
+#              define_method m do
+#                proxy_cache[m.to_s] ||= super
+#              end
+#            end
+#          end
+#
+#          def class
+#            reflection.klass
+#          end
+#
+#        end
+#        extended_class
+#      end
+
+    end
+  end
+end

data/lib/big_record/br_associations/has_and_belongs_to_many_association.rb

@@ -0,0 +1,168 @@
+module BigRecord
+  module BrAssociations
+    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        super
+        construct_sql
+      end
+
+      def build(attributes = {})
+        load_target
+        build_record(attributes)
+      end
+
+      def create(attributes = {})
+        create_record(attributes) { |record| insert_record(record) }
+      end
+
+      def create!(attributes = {})
+        create_record(attributes) { |record| insert_record(record, true) }
+      end
+
+      def find_first
+        load_target.first
+      end
+
+      def find(*args)
+        options = args.extract_options!
+
+        # If using a custom finder_sql, scan the entire collection.
+        if @reflection.options[:finder_sql]
+          expects_array = args.first.kind_of?(Array)
+          ids = args.flatten.compact.uniq
+
+          if ids.size == 1
+            id = ids.first.to_i
+            record = load_target.detect { |record| id == record.id }
+            expects_array ? [record] : record
+          else
+            load_target.select { |record| ids.include?(record.id) }
+          end
+        else
+          # Generate the sql query. The join table has to be in mysql.
+          conditions = "#{@finder_sql}"
+
+          if sanitized_conditions = ActiveRecord::Base.send(:sanitize_sql, options[:conditions])
+            conditions << " AND (#{sanitized_conditions})"
+          end
+
+          if options[:order] && @reflection.options[:order]
+            order = "#{options[:order]}, #{@reflection.options[:order]}"
+          elsif @reflection.options[:order]
+            order = @reflection.options[:order]
+          end
+
+          query = "SELECT #{@reflection.association_foreign_key} FROM #{@reflection.options[:join_table]} WHERE #{conditions} #{order};"
+
+          # Execute the query
+          ids = []
+          ActiveRecord::Base.connection.execute(query).each do |result|
+            ids << result.first
+          end
+
+          # Find the big_record entries by id. Find them one at a time because duplicate entries must appear in
+          # the result set if it's the case. The default find by ids in big_record does the same thing anyway...
+          ids.collect{|id| @reflection.klass.find(id)}
+        end
+      end
+
+      protected
+        def count_records
+          load_target.size
+        end
+
+        def insert_record(record, force=true)
+          if record.new_record?
+            if force
+              record.save!
+            else
+              return false unless record.save
+            end
+          end
+
+          if @reflection.options[:insert_sql]
+            ar_connection.execute(interpolate_sql(@reflection.options[:insert_sql], record))
+          else
+            columns = ar_connection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
+
+            attributes = columns.inject({}) do |attributes, column|
+              case column.name
+                when @reflection.primary_key_name
+                  attributes[column.name] = @owner.quoted_id
+                when @reflection.association_foreign_key
+                  attributes[column.name] = record.quoted_id
+                else
+                  if record.attributes.has_key?(column.name)
+                    value = @owner.send(:quote_value, record[column.name], column)
+                    attributes[column.name] = value unless value.nil?
+                  end
+              end
+              attributes
+            end
+
+            sql =
+              "INSERT INTO #{@reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+              "VALUES (#{attributes.values.join(', ')})"
+
+            ar_connection.execute(sql)
+          end
+
+          return true
+        end
+
+        def delete_records(records)
+          if sql = @reflection.options[:delete_sql]
+            records.each { |record| ar_connection.execute(interpolate_sql(sql, record)) }
+          else
+            ids = quoted_record_ids(records)
+            sql = "DELETE FROM #{@reflection.options[:join_table]} WHERE #{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.association_foreign_key} IN (#{ids})"
+            ar_connection.execute(sql)
+          end
+        end
+
+        def construct_sql
+#          interpolate_sql_options!(@reflection.options, :finder_sql)
+
+          if @reflection.options[:finder_sql]
+            @finder_sql = @reflection.options[:finder_sql]
+          else
+            @finder_sql = "#{@reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{@owner.quoted_id} "
+#            @finder_sql << " AND (#{conditions})" if conditions
+          end
+#          @join_sql = "INNER JOIN #{@reflection.options[:join_table]} ON #{@reflection.klass.table_name}.#{@reflection.klass.primary_key} = #{@reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
+        end
+
+        def construct_scope
+          { :find => {  :conditions => @finder_sql,
+#                        :joins => @join_sql,
+                        :readonly => false,
+                        :order => @reflection.options[:order],
+                        :limit => @reflection.options[:limit] } }
+        end
+
+        # Join tables with additional columns on top of the two foreign keys must be considered ambiguous unless a select
+        # clause has been explicitly defined. Otherwise you can get broken records back, if, for example, the join column also has
+        # an id column. This will then overwrite the id column of the records coming back.
+        def finding_with_ambiguous_select?(select_clause)
+          !select_clause && ar_connection.columns(@reflection.options[:join_table], "Join Table Columns").size != 2
+        end
+
+      private
+        def create_record(attributes)
+          # Can't use Base.create because the foreign key may be a protected attribute.
+          ensure_owner_is_not_new
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create(attr) }
+          else
+            record = build(attributes)
+            yield(record)
+            record
+          end
+        end
+
+        def ar_connection
+          (@owner.class < ActiveRecord::Base) ? @owner.connection : ActiveRecord::Base.connection
+        end
+    end
+  end
+end

data/lib/big_record/br_associations/has_one_association.rb

@@ -0,0 +1,80 @@
+module BigRecord
+  module BrAssociations
+    class HasOneAssociation < BelongsToAssociation #:nodoc:
+      def initialize(owner, reflection)
+        super
+        construct_sql
+      end
+
+      def create(attributes = {}, replace_existing = true)
+        record = build(attributes, replace_existing)
+        record.save
+        record
+      end
+
+      def build(attributes = {}, replace_existing = true)
+        record = @reflection.klass.new(attributes)
+
+        if replace_existing
+          replace(record, true)
+        else
+          record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+          self.target = record
+        end
+
+        record
+      end
+
+      def replace(obj, dont_save = false)
+        load_target
+
+        unless @target.nil?
+          if dependent? && !dont_save && @target != obj
+            @target.destroy unless @target.new_record?
+            @owner.clear_association_cache
+          else
+            @target[@reflection.primary_key_name] = nil
+            @target.save unless @owner.new_record? || @target.new_record?
+          end
+        end
+
+        if obj.nil?
+          @target = nil
+        else
+          raise_on_type_mismatch(obj)
+          set_belongs_to_association_for(obj)
+          @target = (AssociationProxy === obj ? obj.target : obj)
+        end
+
+        @loaded = true
+
+        unless @owner.new_record? or obj.nil? or dont_save
+          return (obj.save ? self : false)
+        else
+          return (obj.nil? ? nil : self)
+        end
+      end
+
+      private
+        def find_target
+          @reflection.klass.find(:first,
+            :conditions => @finder_sql,
+            :order      => @reflection.options[:order],
+            :include    => @reflection.options[:include]
+          )
+        end
+
+#        def construct_sql
+#          case
+#            when @reflection.options[:as]
+#              @finder_sql =
+#                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " +
+#                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
+#            else
+#              @finder_sql = "#{@reflection.table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
+#          end
+#          @finder_sql << " AND (#{conditions})" if conditions
+#        end
+    end
+  end
+end