square-activerecord 3.0.7

data/lib/active_record/reflection.rb

@@ -0,0 +1,411 @@
+module ActiveRecord
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    # Reflection enables to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    #
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
+    module ClassMethods
+      def create_reflection(macro, name, options, active_record)
+        case macro
+          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+            klass = options[:through] ? ThroughReflection : AssociationReflection
+            reflection = klass.new(macro, name, options, active_record)
+          when :composed_of
+            reflection = AggregateReflection.new(macro, name, options, active_record)
+        end
+        write_inheritable_hash :reflections, name => reflection
+        reflection
+      end
+
+      # Returns a hash containing all AssociationReflection objects for the current class.
+      # Example:
+      #
+      #   Invoice.reflections
+      #   Account.reflections
+      #
+      def reflections
+        read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
+      end
+
+      # Returns an array of AggregateReflection objects for all the aggregations in the class.
+      def reflect_on_all_aggregations
+        reflections.values.select { |reflection| reflection.is_a?(AggregateReflection) }
+      end
+
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
+      #
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
+      #
+      def reflect_on_aggregation(aggregation)
+        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
+      end
+
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.select { |reflection| reflection.is_a?(AssociationReflection) }
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+      end
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
+      end
+    end
+
+
+    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    class MacroReflection
+      attr_reader :active_record
+
+      def initialize(macro, name, options, active_record)
+        @macro, @name, @options, @active_record = macro, name, options, active_record
+      end
+
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= options[:class_name] || derive_class_name
+      end
+
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        other_aggregation.kind_of?(self.class) && name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
+      end
+
+      def sanitized_conditions #:nodoc:
+        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+      end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+
+    # Holds all the meta-data about an aggregation as it was specified in the
+    # Active Record class.
+    class AggregateReflection < MacroReflection #:nodoc:
+    end
+
+    # Holds all the meta-data about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection #:nodoc:
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+        @klass ||= active_record.send(:compute_type, class_name)
+      end
+
+      def initialize(macro, name, options, active_record)
+        super
+        @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+      end
+
+      # Returns a new, unsaved instance of the associated class. +options+ will
+      # be passed to the class's constructor.
+      def build_association(*options)
+        klass.new(*options)
+      end
+
+      # Creates a new instance of the associated class, and immediately saves it
+      # with ActiveRecord::Base#save. +options+ will be passed to the class's
+      # creation method. Returns the newly created object.
+      def create_association(*options)
+        klass.create(*options)
+      end
+
+      # Creates a new instance of the associated class, and immediately saves it
+      # with ActiveRecord::Base#save!. +options+ will be passed to the class's
+      # creation method. If the created record doesn't pass validations, then an
+      # exception will be raised.
+      #
+      # Returns the newly created object.
+      def create_association!(*options)
+        klass.create!(*options)
+      end
+
+      def table_name
+        @table_name ||= klass.table_name
+      end
+
+      def quoted_table_name
+        @quoted_table_name ||= klass.quoted_table_name
+      end
+
+      def primary_key_name
+        @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
+      end
+
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      end
+
+      def association_foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      def association_primary_key
+        @association_primary_key ||= options[:primary_key] || klass.primary_key
+      end
+
+      def active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || active_record.primary_key
+      end
+
+      def counter_cache_column
+        if options[:counter_cache] == true
+          "#{active_record.name.demodulize.underscore.pluralize}_count"
+        elsif options[:counter_cache]
+          options[:counter_cache]
+        end
+      end
+
+      def columns(tbl_name, log_msg)
+        @columns ||= klass.connection.columns(tbl_name, log_msg)
+      end
+
+      def reset_column_information
+        @columns = nil
+      end
+
+      def check_validity!
+        check_validity_of_inverse!
+      end
+
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
+      end
+
+      def through_reflection
+        false
+      end
+
+      def through_reflection_primary_key_name
+      end
+
+      def source_reflection
+        nil
+      end
+
+      def has_inverse?
+        !@options[:inverse_of].nil?
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
+      def polymorphic_inverse_of(associated_class)
+        if has_inverse?
+          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+            inverse_relationship
+          else
+            raise InverseOfAssociationNotFoundError.new(self, associated_class)
+          end
+        end
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        @collection
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>:validate => false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>:validate => true</tt>
+      # * you use autosave; <tt>:autosave => true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+      end
+
+      def dependent_conditions(record, base_class, extra_conditions)
+        dependent_conditions = []
+        dependent_conditions << "#{primary_key_name} = #{record.send(name).send(:owner_quoted_id)}"
+        dependent_conditions << "#{options[:as]}_type = '#{base_class.name}'" if options[:as]
+        dependent_conditions << klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+        dependent_conditions << extra_conditions if extra_conditions
+        dependent_conditions = dependent_conditions.collect {|where| "(#{where})" }.join(" AND ")
+        dependent_conditions = dependent_conditions.gsub('@', '\@')
+        dependent_conditions
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
+      end
+
+      private
+        def derive_class_name
+          class_name = name.to_s.camelize
+          class_name = class_name.singularize if collection?
+          class_name
+        end
+
+        def derive_primary_key_name
+          if belongs_to?
+            "#{name}_id"
+          elsif options[:as]
+            "#{options[:as]}_id"
+          else
+            active_record.name.foreign_key
+          end
+        end
+    end
+
+    # Holds all the meta-data about a :through association as it was specified
+    # in the Active Record class.
+    class ThroughReflection < AssociationReflection #:nodoc:
+      # Gets the source of the through reflection.  It checks both a singularized
+      # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      def source_reflection
+        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+      end
+
+      # Returns the AssociationReflection object specified in the <tt>:through</tt> option
+      # of a HasManyThrough or HasOneThrough association.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   taggings_reflection = tags_reflection.through_reflection
+      #
+      def through_reflection
+        @through_reflection ||= active_record.reflect_on_association(options[:through])
+      end
+
+      # Gets an array of possible <tt>:through</tt> source reflection names:
+      #
+      #   [:singularized, :pluralized]
+      #
+      def source_reflection_names
+        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+      end
+
+      def check_validity!
+        if through_reflection.nil?
+          raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
+        end
+
+        if source_reflection.nil?
+          raise HasManyThroughSourceAssociationNotFoundError.new(self)
+        end
+
+        if options[:source_type] && source_reflection.options[:polymorphic].nil?
+          raise HasManyThroughAssociationPointlessSourceTypeError.new(active_record.name, self, source_reflection)
+        end
+
+        if source_reflection.options[:polymorphic] && options[:source_type].nil?
+          raise HasManyThroughAssociationPolymorphicError.new(active_record.name, self, source_reflection)
+        end
+
+        unless [:belongs_to, :has_many, :has_one].include?(source_reflection.macro) && source_reflection.options[:through].nil?
+          raise HasManyThroughSourceAssociationMacroError.new(self)
+        end
+
+        check_validity_of_inverse!
+      end
+
+      def through_reflection_primary_key
+        through_reflection.belongs_to? ? through_reflection.klass.primary_key : through_reflection.primary_key_name
+      end
+
+      def through_reflection_primary_key_name
+        through_reflection.primary_key_name if through_reflection.belongs_to?
+      end
+
+      private
+        def derive_class_name
+          # get the class_name of the belongs_to association of the through reflection
+          options[:source_type] || source_reflection.class_name
+        end
+    end
+  end
+end

data/lib/active_record/relation.rb

@@ -0,0 +1,394 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  # = Active Record Relation
+  class Relation
+    JoinOperation = Struct.new(:relation, :join_class, :on)
+    ASSOCIATION_METHODS = [:includes, :eager_load, :preload]
+    MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having]
+    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :create_with, :from]
+
+    include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches
+
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to => :to_a
+    delegate :insert, :to => :arel
+
+    attr_reader :table, :klass, :loaded
+    attr_accessor :extensions
+    alias :loaded? :loaded
+
+    def initialize(klass, table)
+      @klass, @table = klass, table
+
+      @implicit_readonly = nil
+      @loaded            = false
+
+      SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
+      (ASSOCIATION_METHODS + MULTI_VALUE_METHODS).each {|v| instance_variable_set(:"@#{v}_values", [])}
+      @extensions = []
+    end
+
+    def new(*args, &block)
+      scoping { @klass.new(*args, &block) }
+    end
+
+    def initialize_copy(other)
+      reset
+    end
+
+    alias build new
+
+    def create(*args, &block)
+      scoping { @klass.create(*args, &block) }
+    end
+
+    def create!(*args, &block)
+      scoping { @klass.create!(*args, &block) }
+    end
+
+    def respond_to?(method, include_private = false)
+      return true if arel.respond_to?(method, include_private) || Array.method_defined?(method) || @klass.respond_to?(method, include_private)
+
+      if match = DynamicFinderMatch.match(method)
+        return true if @klass.send(:all_attributes_exists?, match.attribute_names)
+      elsif match = DynamicScopeMatch.match(method)
+        return true if @klass.send(:all_attributes_exists?, match.attribute_names)
+      else
+        super
+      end
+    end
+
+    def to_a
+      return @records if loaded?
+
+      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql)
+
+      preload = @preload_values
+      preload +=  @includes_values unless eager_loading?
+      preload.each {|associations| @klass.send(:preload_associations, @records, associations) }
+
+      # @readonly_value is true only if set explicitly. @implicit_readonly is true if there
+      # are JOINS and no explicit SELECT.
+      readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value
+      @records.each { |record| record.readonly! } if readonly
+
+      @loaded = true
+      @records
+    end
+
+    def as_json(options = nil) #:nodoc:
+      to_a.as_json(options)
+    end
+
+    # Returns size of the records.
+    def size
+      loaded? ? @records.length : count
+    end
+
+    # Returns true if there are no records.
+    def empty?
+      return @records.empty? if loaded?
+
+      c = count
+      c.respond_to?(:zero?) ? c.zero? : c.empty?
+    end
+
+    def any?
+      if block_given?
+        to_a.any? { |*block_args| yield(*block_args) }
+      else
+        !empty?
+      end
+    end
+
+    def many?
+      if block_given?
+        to_a.many? { |*block_args| yield(*block_args) }
+      else
+        @limit_value ? to_a.many? : size > 1
+      end
+    end
+
+    # Scope all queries to the current scope.
+    #
+    # ==== Example
+    #
+    #   Comment.where(:post_id => 1).scoping do
+    #     Comment.first # SELECT * FROM comments WHERE post_id = 1
+    #   end
+    #
+    # Please check unscoped if you want to remove all previous scopes (including
+    # the default_scope) during the execution of a block.
+    def scoping
+      @klass.scoped_methods << self
+      begin
+        yield
+      ensure
+        @klass.scoped_methods.pop
+      end
+    end
+
+    # Updates all records with details given if they match a set of conditions supplied, limits and order can
+    # also be supplied. This method constructs a single SQL UPDATE statement and sends it straight to the
+    # database. It does not instantiate the involved models and it does not trigger Active Record callbacks
+    # or validations.
+    #
+    # ==== Parameters
+    #
+    # * +updates+ - A string, array, or hash representing the SET part of an SQL statement.
+    # * +conditions+ - A string, array, or hash representing the WHERE part of an SQL statement.
+    #   See conditions in the intro.
+    # * +options+ - Additional options are <tt>:limit</tt> and <tt>:order</tt>, see the examples for usage.
+    #
+    # ==== Examples
+    #
+    #   # Update all customers with the given attributes
+    #   Customer.update_all :wants_email => true
+    #
+    #   # Update all books with 'Rails' in their title
+    #   Book.update_all "author = 'David'", "title LIKE '%Rails%'"
+    #
+    #   # Update all avatars migrated more than a week ago
+    #   Avatar.update_all ['migrated_at = ?', Time.now.utc], ['migrated_at > ?', 1.week.ago]
+    #
+    #   # Update all books that match conditions, but limit it to 5 ordered by date
+    #   Book.update_all "author = 'David'", "title LIKE '%Rails%'", :order => 'created_at', :limit => 5
+    def update_all(updates, conditions = nil, options = {})
+      if conditions || options.present?
+        where(conditions).apply_finder_options(options.slice(:limit, :order)).update_all(updates)
+      else
+        # Apply limit and order only if they're both present
+        if @limit_value.present? == @order_values.present?
+          arel.update(Arel::SqlLiteral.new(@klass.send(:sanitize_sql_for_assignment, updates)))
+        else
+          except(:limit, :order).update_all(updates)
+        end
+      end
+    end
+
+    # Updates an object (or multiple objects) and saves it to the database, if validations pass.
+    # The resulting object is returned whether the object was saved successfully to the database or not.
+    #
+    # ==== Parameters
+    #
+    # * +id+ - This should be the id or an array of ids to be updated.
+    # * +attributes+ - This should be a hash of attributes or an array of hashes.
+    #
+    # ==== Examples
+    #
+    #   # Updates one record
+    #   Person.update(15, :user_name => 'Samuel', :group => 'expert')
+    #
+    #   # Updates multiple records
+    #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
+    #   Person.update(people.keys, people.values)
+    def update(id, attributes)
+      if id.is_a?(Array)
+        idx = -1
+        id.collect { |one_id| idx += 1; update(one_id, attributes[idx]) }
+      else
+        object = find(id)
+        object.update_attributes(attributes)
+        object
+      end
+    end
+
+    # Destroys the records matching +conditions+ by instantiating each
+    # record and calling its +destroy+ method. Each object's callbacks are
+    # executed (including <tt>:dependent</tt> association options and
+    # +before_destroy+/+after_destroy+ Observer methods). Returns the
+    # collection of objects that were destroyed; each will be frozen, to
+    # reflect that no changes should be made (since they can't be
+    # persisted).
+    #
+    # Note: Instantiation, callback execution, and deletion of each
+    # record can be time consuming when you're removing many records at
+    # once. It generates at least one SQL +DELETE+ query per record (or
+    # possibly more, to enforce your callbacks). If you want to delete many
+    # rows quickly, without concern for their associations or callbacks, use
+    # +delete_all+ instead.
+    #
+    # ==== Parameters
+    #
+    # * +conditions+ - A string, array, or hash that specifies which records
+    #   to destroy. If omitted, all records are destroyed. See the
+    #   Conditions section in the introduction to ActiveRecord::Base for
+    #   more information.
+    #
+    # ==== Examples
+    #
+    #   Person.destroy_all("last_login < '2004-04-04'")
+    #   Person.destroy_all(:status => "inactive")
+    def destroy_all(conditions = nil)
+      if conditions
+        where(conditions).destroy_all
+      else
+        to_a.each {|object| object.destroy }.tap { reset }
+      end
+    end
+
+    # Destroy an object (or multiple objects) that has the given id, the object is instantiated first,
+    # therefore all callbacks and filters are fired off before the object is deleted.  This method is
+    # less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run.
+    #
+    # This essentially finds the object (or multiple objects) with the given id, creates a new object
+    # from the attributes, and then calls destroy on it.
+    #
+    # ==== Parameters
+    #
+    # * +id+ - Can be either an Integer or an Array of Integers.
+    #
+    # ==== Examples
+    #
+    #   # Destroy a single object
+    #   Todo.destroy(1)
+    #
+    #   # Destroy multiple objects
+    #   todos = [1,2,3]
+    #   Todo.destroy(todos)
+    def destroy(id)
+      if id.is_a?(Array)
+        id.map { |one_id| destroy(one_id) }
+      else
+        find(id).destroy
+      end
+    end
+
+    # Deletes the records matching +conditions+ without instantiating the records first, and hence not
+    # calling the +destroy+ method nor invoking callbacks. This is a single SQL DELETE statement that
+    # goes straight to the database, much more efficient than +destroy_all+. Be careful with relations
+    # though, in particular <tt>:dependent</tt> rules defined on associations are not honored.  Returns
+    # the number of rows affected.
+    #
+    # ==== Parameters
+    #
+    # * +conditions+ - Conditions are specified the same way as with +find+ method.
+    #
+    # ==== Example
+    #
+    #   Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
+    #   Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])
+    #
+    # Both calls delete the affected posts all at once with a single DELETE statement.
+    # If you need to destroy dependent associations or call your <tt>before_*</tt> or
+    # +after_destroy+ callbacks, use the +destroy_all+ method instead.
+    def delete_all(conditions = nil)
+      conditions ? where(conditions).delete_all : arel.delete.tap { reset }
+    end
+
+    # Deletes the row with a primary key matching the +id+ argument, using a
+    # SQL +DELETE+ statement, and returns the number of rows deleted. Active
+    # Record objects are not instantiated, so the object's callbacks are not
+    # executed, including any <tt>:dependent</tt> association options or
+    # Observer methods.
+    #
+    # You can delete multiple rows at once by passing an Array of <tt>id</tt>s.
+    #
+    # Note: Although it is often much faster than the alternative,
+    # <tt>#destroy</tt>, skipping callbacks might bypass business logic in
+    # your application that ensures referential integrity or performs other
+    # essential jobs.
+    #
+    # ==== Examples
+    #
+    #   # Delete a single row
+    #   Todo.delete(1)
+    #
+    #   # Delete multiple rows
+    #   Todo.delete([2,3,4])
+    def delete(id_or_array)
+      where(@klass.primary_key => id_or_array).delete_all
+    end
+
+    def reload
+      reset
+      to_a # force reload
+      self
+    end
+
+    def reset
+      @first = @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
+      @should_eager_load = @join_dependency = nil
+      @records = []
+      self
+    end
+
+    def primary_key
+      @primary_key ||= table[@klass.primary_key]
+    end
+
+    def to_sql
+      @to_sql ||= arel.to_sql
+    end
+
+    def where_values_hash
+      Hash[@where_values.find_all { |w|
+        w.respond_to?(:operator) && w.operator == :== && w.left.relation.name == table_name
+      }.map { |where|
+        [
+          where.left.name,
+          where.right.respond_to?(:value) ? where.right.value : where.right
+        ]
+      }]
+    end
+
+    def scope_for_create
+      @scope_for_create ||= begin
+        if @create_with_value
+          @create_with_value.reverse_merge(where_values_hash)
+        else
+          where_values_hash
+        end
+      end
+    end
+
+    def eager_loading?
+      @should_eager_load ||= (@eager_load_values.any? || (@includes_values.any? && references_eager_loaded_tables?))
+    end
+
+    def ==(other)
+      case other
+      when Relation
+        other.to_sql == to_sql
+      when Array
+        to_a == other.to_a
+      end
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      if Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      elsif @klass.scopes[method]
+        merge(@klass.send(method, *args, &block))
+      elsif @klass.respond_to?(method)
+        scoping { @klass.send(method, *args, &block) }
+      elsif arel.respond_to?(method)
+        arel.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    private
+
+    def references_eager_loaded_tables?
+      # always convert table names to downcase as in Oracle quoted table names are in uppercase
+      joined_tables = (tables_in_string(arel.join_sql) + [table.name, table.table_alias]).compact.map{ |t| t.downcase }.uniq
+      (tables_in_string(to_sql) - joined_tables).any?
+    end
+
+    def tables_in_string(string)
+      return [] if string.blank?
+      # always convert table names to downcase as in Oracle quoted table names are in uppercase
+      # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
+      string.scan(/([a-zA-Z_][\.\w]+).?\./).flatten.map{ |s| s.downcase }.uniq - ['raw_sql_']
+    end
+
+  end
+end