activerecord 2.3.18 → 3.2.22

data/lib/active_record/persistence.rb

@@ -0,0 +1,376 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  # = Active Record Persistence
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Creates 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.
+      #
+      # The +attributes+ parameter can be either be a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be created.
+      #
+      # +create+ respects mass-assignment security and accepts either +:as+ or +:without_protection+ options
+      # in the +options+ parameter.
+      #
+      # ==== Examples
+      #   # Create a single new object
+      #   User.create(:first_name => 'Jamie')
+      #
+      #   # Create a single new object using the :admin mass-assignment security role
+      #   User.create({ :first_name => 'Jamie', :is_admin => true }, :as => :admin)
+      #
+      #   # Create a single new object bypassing mass-assignment security
+      #   User.create({ :first_name => 'Jamie', :is_admin => true }, :without_protection => true)
+      #
+      #   # Create an Array of new objects
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }])
+      #
+      #   # Create a single object and pass it into a block to set other attributes.
+      #   User.create(:first_name => 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      #   # Creating an Array of new objects using a block, where the block is executed for each object:
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) do |u|
+      #     u.is_admin = false
+      #   end
+      def create(attributes = nil, options = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, options, &block) }
+        else
+          object = new(attributes, options, &block)
+          object.save
+          object
+        end
+      end
+    end
+
+    # Returns true if this object hasn't been saved yet -- that is, a record
+    # for the object doesn't exist in the data store yet; otherwise, returns false.
+    def new_record?
+      @new_record
+    end
+
+    # Returns true if this object has been destroyed, otherwise returns false.
+    def destroyed?
+      @destroyed
+    end
+
+    # Returns if the record is persisted, i.e. it's not a new record and it was
+    # not destroyed.
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise
+    # the existing record gets updated.
+    #
+    # By default, save always run validations. If any of them fail the action
+    # is cancelled and +save+ returns +false+. However, if you supply
+    # :validate => false, validations are bypassed altogether. See
+    # ActiveRecord::Validations for more information.
+    #
+    # There's a series of callbacks associated with +save+. If any of the
+    # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
+    # +save+ returns +false+. See ActiveRecord::Callbacks for further
+    # details.
+    def save(*)
+      begin
+        create_or_update
+      rescue ActiveRecord::RecordInvalid
+        false
+      end
+    end
+
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise
+    # the existing record gets updated.
+    #
+    # With <tt>save!</tt> validations always run. If any of them fail
+    # ActiveRecord::RecordInvalid gets raised. See ActiveRecord::Validations
+    # for more information.
+    #
+    # There's a series of callbacks associated with <tt>save!</tt>. If any of
+    # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
+    # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
+    # ActiveRecord::Callbacks for further details.
+    def save!(*)
+      create_or_update || raise(RecordNotSaved)
+    end
+
+    # Deletes the record in the database and freezes this instance to
+    # reflect that no changes should be made (since they can't be
+    # persisted). Returns the frozen instance.
+    #
+    # The row is simply removed with an SQL +DELETE+ statement on the
+    # record's primary key, and no callbacks are executed.
+    #
+    # To enforce the object's +before_destroy+ and +after_destroy+
+    # callbacks, Observer methods, or any <tt>:dependent</tt> association
+    # options, use <tt>#destroy</tt>.
+    def delete
+      if persisted?
+        self.class.delete(id)
+        IdentityMap.remove(self) if IdentityMap.enabled?
+      end
+      @destroyed = true
+      freeze
+    end
+
+    # Deletes the record in the database and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    def destroy
+      destroy_associations
+
+      if persisted?
+        IdentityMap.remove(self) if IdentityMap.enabled?
+        pk         = self.class.primary_key
+        column     = self.class.columns_hash[pk]
+        substitute = connection.substitute_at(column, 0)
+
+        relation = self.class.unscoped.where(
+          self.class.arel_table[pk].eq(substitute))
+
+        relation.bind_values = [[column, id]]
+        relation.delete_all
+      end
+
+      @destroyed = true
+      freeze
+    end
+
+    # Returns an instance of the specified +klass+ with the attributes of the
+    # current record. This is mostly useful in relation to single-table
+    # inheritance structures where you want a subclass to appear as the
+    # superclass. This can be used along with record identification in
+    # Action Pack to allow, say, <tt>Client < Company</tt> to do something
+    # like render <tt>:partial => @client.becomes(Company)</tt> to render that
+    # instance using the companies/company partial instead of clients/client.
+    #
+    # Note: The new instance will share a link to the same attributes as the original class.
+    # So any change to the attributes in either instance will affect the other.
+    def becomes(klass)
+      became = klass.new
+      became.instance_variable_set("@attributes", @attributes)
+      became.instance_variable_set("@attributes_cache", @attributes_cache)
+      became.instance_variable_set("@new_record", new_record?)
+      became.instance_variable_set("@destroyed", destroyed?)
+      became.instance_variable_set("@errors", errors)
+      became.send("#{klass.inheritance_column}=", klass.name) unless self.class.descends_from_active_record?
+      became
+    end
+
+    # Updates a single attribute and saves the record.
+    # This is especially useful for boolean flags on existing records. Also note that
+    #
+    # * Validation is skipped.
+    # * Callbacks are invoked.
+    # * updated_at/updated_on column is updated if that column is available.
+    # * Updates all the attributes that are dirty in this object.
+    #
+    def update_attribute(name, value)
+      name = name.to_s
+      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
+      send("#{name}=", value)
+      save(:validate => false)
+    end
+
+    # Updates a single attribute of an object, without calling save.
+    #
+    # * Validation is skipped.
+    # * Callbacks are skipped.
+    # * updated_at/updated_on column is not updated if that column is available.
+    #
+    # Raises an +ActiveRecordError+ when called on new objects, or when the +name+
+    # attribute is marked as readonly.
+    def update_column(name, value)
+      name = name.to_s
+      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
+      raise ActiveRecordError, "can not update on a new record object" unless persisted?
+
+      updated_count = self.class.unscoped.update_all({ name => value }, self.class.primary_key => id)
+
+      raw_write_attribute(name, value)
+
+      updated_count == 1
+    end
+
+    # Updates the attributes of the model from the passed-in hash and saves the
+    # record, all wrapped in a transaction. If the object is invalid, the saving
+    # will fail and false will be returned.
+    #
+    # When updating model attributes, mass-assignment security protection is respected.
+    # If no +:as+ option is supplied then the +:default+ role will be used.
+    # If you want to bypass the protection given by +attr_protected+ and
+    # +attr_accessible+ then you can do so using the +:without_protection+ option.
+    def update_attributes(attributes, options = {})
+      # The following transaction covers any possible database side-effects of the
+      # attributes assignment. For example, setting the IDs of a child collection.
+      with_transaction_returning_status do
+        self.assign_attributes(attributes, options)
+        save
+      end
+    end
+
+    # Updates its receiver just like +update_attributes+ but calls <tt>save!</tt> instead
+    # of +save+, so an exception is raised if the record is invalid.
+    def update_attributes!(attributes, options = {})
+      # The following transaction covers any possible database side-effects of the
+      # attributes assignment. For example, setting the IDs of a child collection.
+      with_transaction_returning_status do
+        self.assign_attributes(attributes, options)
+        save!
+      end
+    end
+
+    # Initializes +attribute+ to zero if +nil+ and adds the value passed as +by+ (default is 1).
+    # The increment is performed directly on the underlying attribute, no setter is invoked.
+    # Only makes sense for number-based attributes. Returns +self+.
+    def increment(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] += by
+      self
+    end
+
+    # Wrapper around +increment+ that saves the record. This method differs from
+    # its non-bang version in that it passes through the attribute setter.
+    # Saving is not subjected to validation checks. Returns +true+ if the
+    # record could be saved.
+    def increment!(attribute, by = 1)
+      increment(attribute, by).update_attribute(attribute, self[attribute])
+    end
+
+    # Initializes +attribute+ to zero if +nil+ and subtracts the value passed as +by+ (default is 1).
+    # The decrement is performed directly on the underlying attribute, no setter is invoked.
+    # Only makes sense for number-based attributes. Returns +self+.
+    def decrement(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] -= by
+      self
+    end
+
+    # Wrapper around +decrement+ that saves the record. This method differs from
+    # its non-bang version in that it passes through the attribute setter.
+    # Saving is not subjected to validation checks. Returns +true+ if the
+    # record could be saved.
+    def decrement!(attribute, by = 1)
+      decrement(attribute, by).update_attribute(attribute, self[attribute])
+    end
+
+    # Assigns to +attribute+ the boolean opposite of <tt>attribute?</tt>. So
+    # if the predicate returns +true+ the attribute will become +false+. This
+    # method toggles directly the underlying value without calling any setter.
+    # Returns +self+.
+    def toggle(attribute)
+      self[attribute] = !send("#{attribute}?")
+      self
+    end
+
+    # Wrapper around +toggle+ that saves the record. This method differs from
+    # its non-bang version in that it passes through the attribute setter.
+    # Saving is not subjected to validation checks. Returns +true+ if the
+    # record could be saved.
+    def toggle!(attribute)
+      toggle(attribute).update_attribute(attribute, self[attribute])
+    end
+
+    # Reloads the attributes of this object from the database.
+    # The optional options argument is passed to find when reloading so you
+    # may do e.g. record.reload(:lock => true) to reload the same record with
+    # an exclusive row lock.
+    def reload(options = nil)
+      clear_aggregation_cache
+      clear_association_cache
+
+      IdentityMap.without do
+        fresh_object = self.class.unscoped { self.class.find(self.id, options) }
+        @attributes.update(fresh_object.instance_variable_get('@attributes'))
+      end
+
+      @attributes_cache = {}
+      self
+    end
+
+    # Saves the record with the updated_at/on attributes set to the current time.
+    # Please note that no validation is performed and no callbacks are executed.
+    # If an attribute name is passed, that attribute is updated along with
+    # updated_at/on attributes.
+    #
+    #   product.touch               # updates updated_at/on
+    #   product.touch(:designed_at) # updates the designed_at attribute and updated_at/on
+    #
+    # If used along with +belongs_to+ then +touch+ will invoke +touch+ method on associated object.
+    #
+    #   class Brake < ActiveRecord::Base
+    #     belongs_to :car, :touch => true
+    #   end
+    #
+    #   class Car < ActiveRecord::Base
+    #     belongs_to :corporation, :touch => true
+    #   end
+    #
+    #   # triggers @brake.car.touch and @brake.car.corporation.touch
+    #   @brake.touch
+    def touch(name = nil)
+      attributes = timestamp_attributes_for_update_in_model
+      attributes << name if name
+
+      unless attributes.empty?
+        current_time = current_time_from_proper_timezone
+        changes = {}
+
+        attributes.each do |column|
+          changes[column.to_s] = write_attribute(column.to_s, current_time)
+        end
+
+        changes[self.class.locking_column] = increment_lock if locking_enabled?
+
+        @changed_attributes.except!(*changes.keys)
+        primary_key = self.class.primary_key
+        self.class.unscoped.update_all(changes, { primary_key => self[primary_key] }) == 1
+      end
+    end
+
+  private
+
+    # A hook to be overridden by association modules.
+    def destroy_associations
+    end
+
+    def create_or_update
+      raise ReadOnlyRecord if readonly?
+      result = new_record? ? create : update
+      result != false
+    end
+
+    # Updates the associated record with values matching those of the instance attributes.
+    # Returns the number of affected rows.
+    def update(attribute_names = @attributes.keys)
+      attributes_with_values = arel_attributes_values(false, false, attribute_names)
+      return 0 if attributes_with_values.empty?
+      klass = self.class
+      stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id)).arel.compile_update(attributes_with_values)
+      klass.connection.update stmt
+    end
+
+    # Creates a record with values matching those of the instance attributes
+    # and returns its id.
+    def create
+      attributes_values = arel_attributes_values(!id.nil?)
+
+      new_id = self.class.unscoped.insert attributes_values
+
+      self.id ||= new_id if self.class.primary_key
+
+      IdentityMap.add(self) if IdentityMap.enabled?
+      @new_record = false
+      id
+    end
+  end
+end

data/lib/active_record/query_cache.rb

@@ -1,21 +1,24 @@
+require 'active_support/core_ext/object/blank'
+
 module ActiveRecord
+  # = Active Record Query Cache
   class QueryCache
     module ClassMethods
       # Enable the query cache within the block if Active Record is configured.
       def cache(&block)
-        if ActiveRecord::Base.configurations.blank?
-          yield
-        else
+        if ActiveRecord::Base.connected?
           connection.cache(&block)
+        else
+          yield
         end
       end
 
       # Disable the query cache within the block if Active Record is configured.
       def uncached(&block)
-        if ActiveRecord::Base.configurations.blank?
-          yield
-        else
+        if ActiveRecord::Base.connected?
           connection.uncached(&block)
+        else
+          yield
         end
       end
     end
@@ -24,10 +27,48 @@ module ActiveRecord
       @app = app
     end
 
+    class BodyProxy # :nodoc:
+      def initialize(original_cache_value, target, connection_id)
+        @original_cache_value = original_cache_value
+        @target               = target
+        @connection_id        = connection_id
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        @target.send(method_sym, *arguments, &block)
+      end
+
+      def respond_to?(method_sym, include_private = false)
+        super || @target.respond_to?(method_sym)
+      end
+
+      def each(&block)
+        @target.each(&block)
+      end
+
+      def close
+        @target.close if @target.respond_to?(:close)
+      ensure
+        ActiveRecord::Base.connection_id = @connection_id
+        ActiveRecord::Base.connection.clear_query_cache
+        unless @original_cache_value
+          ActiveRecord::Base.connection.disable_query_cache!
+        end
+      end
+    end
+
     def call(env)
-      ActiveRecord::Base.cache do
-        @app.call(env)
+      old = ActiveRecord::Base.connection.query_cache_enabled
+      ActiveRecord::Base.connection.enable_query_cache!
+
+      status, headers, body = @app.call(env)
+      [status, headers, BodyProxy.new(old, body, ActiveRecord::Base.connection_id)]
+    rescue Exception => e
+      ActiveRecord::Base.connection.clear_query_cache
+      unless old
+        ActiveRecord::Base.connection.disable_query_cache!
       end
+      raise e
     end
   end
 end

data/lib/active_record/querying.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActiveRecord
+  module Querying
+    delegate :find, :first, :first!, :last, :last!, :all, :exists?, :any?, :many?, :to => :scoped
+    delegate :first_or_create, :first_or_create!, :first_or_initialize, :to => :scoped
+    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, :to => :scoped
+    delegate :find_each, :find_in_batches, :to => :scoped
+    delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins,
+             :where, :preload, :eager_load, :includes, :from, :lock, :readonly,
+             :having, :create_with, :uniq, :to => :scoped
+    delegate :count, :average, :minimum, :maximum, :sum, :calculate, :pluck, :to => :scoped
+
+    # Executes a custom SQL query against your database and returns all the results. The results will
+    # be returned as an array with columns requested encapsulated as attributes of the model you call
+    # this method from. If you call <tt>Product.find_by_sql</tt> then the results will be returned in
+    # a Product object with the attributes you specified in the SQL query.
+    #
+    # If you call a complicated SQL query which spans multiple tables the columns specified by the
+    # SELECT will be attributes of the model, whether or not they are columns of the corresponding
+    # table.
+    #
+    # The +sql+ parameter is a full SQL query as a string. It will be called as is, there will be
+    # no database agnostic conversions performed. This should be a last resort because using, for example,
+    # MySQL specific terms will lock you to using that particular database engine or require you to
+    # change your call if you switch engines.
+    #
+    # ==== Examples
+    #   # A simple SQL query spanning multiple tables
+    #   Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
+    #   > [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
+    #
+    #   # You can use the same string replacement techniques as you can with ActiveRecord#find
+    #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
+    #   > [#<Post:0x36bff9c @attributes={"title"=>"The Cheap Man Buys Twice"}>, ...]
+    def find_by_sql(sql, binds = [])
+      logging_query_plan do
+        connection.select_all(sanitize_sql(sql), "#{name} Load", binds).collect! { |record| instantiate(record) }
+      end
+    end
+
+    # Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part.
+    # The use of this method should be restricted to complicated SQL queries that can't be executed
+    # using the ActiveRecord::Calculations class methods. Look into those before using this.
+    #
+    # ==== Parameters
+    #
+    # * +sql+ - An SQL statement which should return a count query from the database, see the example below.
+    #
+    # ==== Examples
+    #
+    #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
+    def count_by_sql(sql)
+      sql = sanitize_conditions(sql)
+      connection.select_value(sql, "#{name} Count").to_i
+    end
+  end
+end

data/lib/active_record/railtie.rb

@@ -0,0 +1,131 @@
+require "active_record"
+require "rails"
+require "active_model/railtie"
+
+# For now, action_controller must always be present with
+# rails, so let's make sure that it gets required before
+# here. This is needed for correctly setting up the middleware.
+# In the future, this might become an optional require.
+require "action_controller/railtie"
+
+module ActiveRecord
+  # = Active Record Railtie
+  class Railtie < Rails::Railtie
+    config.active_record = ActiveSupport::OrderedOptions.new
+
+    config.app_generators.orm :active_record, :migration => true,
+                                              :timestamps => true
+
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::QueryCache"
+
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::ConnectionAdapters::ConnectionManagement"
+
+    config.action_dispatch.rescue_responses.merge!(
+      'ActiveRecord::RecordNotFound'   => :not_found,
+      'ActiveRecord::StaleObjectError' => :conflict,
+      'ActiveRecord::RecordInvalid'    => :unprocessable_entity,
+      'ActiveRecord::RecordNotSaved'   => :unprocessable_entity
+    )
+
+    rake_tasks do
+      require "active_record/base"
+      load "active_record/railties/databases.rake"
+    end
+
+    # When loading console, force ActiveRecord::Base to be loaded
+    # to avoid cross references when loading a constant for the
+    # first time. Also, make it output to STDERR.
+    console do |app|
+      require "active_record/railties/console_sandbox" if app.sandbox?
+      require "active_record/base"
+      ActiveRecord::Base.logger = Logger.new(STDERR)
+    end
+
+    runner do |app|
+      require "active_record/base"
+    end
+
+    initializer "active_record.initialize_timezone" do
+      ActiveSupport.on_load(:active_record) do
+        self.time_zone_aware_attributes = true
+        self.default_timezone = :utc
+      end
+    end
+
+    initializer "active_record.logger" do
+      ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
+    end
+
+    initializer "active_record.identity_map" do |app|
+      config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+        "ActiveRecord::IdentityMap::Middleware" if config.active_record.delete(:identity_map)
+    end
+
+    initializer "active_record.set_configs" do |app|
+      ActiveSupport.on_load(:active_record) do
+        if app.config.active_record.delete(:whitelist_attributes)
+          attr_accessible(nil)
+        end
+        app.config.active_record.each do |k,v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    # This sets the database configuration from Configuration#database_configuration
+    # and then establishes the connection.
+    initializer "active_record.initialize_database" do |app|
+      ActiveSupport.on_load(:active_record) do
+        db_connection_type = "DATABASE_URL"
+        unless ENV['DATABASE_URL']
+          db_connection_type  = "database.yml"
+          self.configurations = app.config.database_configuration
+        end
+        Rails.logger.info "Connecting to database specified by #{db_connection_type}"
+
+        establish_connection
+      end
+    end
+
+    # Expose database runtime to controller for logging.
+    initializer "active_record.log_runtime" do |app|
+      require "active_record/railties/controller_runtime"
+      ActiveSupport.on_load(:action_controller) do
+        include ActiveRecord::Railties::ControllerRuntime
+      end
+    end
+
+    initializer "active_record.set_reloader_hooks" do |app|
+      hook = lambda do
+        ActiveRecord::Base.clear_reloadable_connections!
+        ActiveRecord::Base.clear_cache!
+      end
+
+      if app.config.reload_classes_only_on_change
+        ActiveSupport.on_load(:active_record) do
+          ActionDispatch::Reloader.to_prepare(&hook)
+        end
+      else
+        ActiveSupport.on_load(:active_record) do
+          ActionDispatch::Reloader.to_cleanup(&hook)
+        end
+      end
+    end
+
+    initializer "active_record.add_watchable_files" do |app|
+      config.watchable_files.concat ["#{app.root}/db/schema.rb", "#{app.root}/db/structure.sql"]
+    end
+
+    config.after_initialize do
+      ActiveSupport.on_load(:active_record) do
+        instantiate_observers
+
+        ActionDispatch::Reloader.to_prepare do
+          ActiveRecord::Base.instantiate_observers
+        end
+      end
+    end
+  end
+end

data/lib/active_record/railties/console_sandbox.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Base.connection.increment_open_transactions
+ActiveRecord::Base.connection.begin_db_transaction
+at_exit do
+  ActiveRecord::Base.connection.rollback_db_transaction
+  ActiveRecord::Base.connection.decrement_open_transactions
+end