# module ActiveRecord::Persistence::ClassMethods

### Public Instance Methods

create(attributes = nil, &block) click to toggle source

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 a Hash or an Array of Hashes. These Hashes describe the attributes on the objects that are to be created.

#### Examples¶ ↑

    # Create a single new object
    User.create(first_name: 'Jamie')

    # 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

    # File lib/active_record/persistence.rb, line 29
    def create(attributes = nil, &block)
      if attributes.is_a?(Array)
        attributes.collect { |attr| create(attr, &block) }
      else
        object = new(attributes, &block)
        object.save
        object
      end
    end

create!(attributes = nil, &block) click to toggle source

Creates an object (or multiple objects) and saves it to the database, if validations pass. Raises a RecordInvalid error if validations fail, unlike Base#create.

The `attributes` parameter can be either a Hash or an Array of Hashes. These describe which attributes to be created on the object, or multiple objects when given an Array of Hashes.

    # File lib/active_record/persistence.rb, line 46
    def create!(attributes = nil, &block)
      if attributes.is_a?(Array)
        attributes.collect { |attr| create!(attr, &block) }
      else
        object = new(attributes, &block)
        object.save!
        object
      end
    end

instantiate(attributes, column_types = {}, &block) click to toggle source

Given an attributes hash, `instantiate` returns a new instance of the appropriate class. Accepts only keys as strings.

For example, `Post.all` may return Comments, Messages, and Emails by storing the record's subclass in a `type` attribute. By calling `instantiate` instead of `new`, finder methods ensure they get new instances of the appropriate class for each record.

See `ActiveRecord::Inheritance#discriminate_class_for_record` to see how this “single-table” inheritance mapping is implemented.

    # File lib/active_record/persistence.rb, line 66
    def instantiate(attributes, column_types = {}, &block)
      klass = discriminate_class_for_record(attributes)
      attributes = klass.attributes_builder.build_from_database(attributes, column_types)
      klass.allocate.init_with("attributes" => attributes, "new_record" => false, &block)
    end

### Private Instance Methods

discriminate_class_for_record(record) click to toggle source

Called by `instantiate` to decide which class to use for a new record instance.

See +ActiveRecord::Inheritance#discriminate_class_for_record+ for the single-table inheritance discriminator.

    # File lib/active_record/persistence.rb, line 78
    def discriminate_class_for_record(record)
      self
    end