ActiveRecord: Object-Relational Mapping for Rails

Lecture Notes for CS349W
Fall Quarter 2008
John Ousterhout

Migrations:
- Managing database schemas is a pain:
  - They tend to evolve over the life of an application (new tables, fields, etc.)
  - When the schema changes, need to upgrade existing databases (preferably automatically); some customers may be several revisions behind.
  - Sometimes want to downgrade to a previous schema, e.g., to reproduce a bug in an older version of the software.
  - In the past, not much support for managing shema evolution; every application builds its own mechanisms (e.g., upgrade scripts).
- Migrations in Rails provide a framework that makes schema evolution much easier to manage:
  - Assume from the start that the schema will go through a series of versions.
  - A migration provides code that will update the database schema from one version to the next, and back again.
  - Rails keeps track of the database's current version and will apply appropriate migrations to switch it to any other version.
- Migration to create a new table:
```
class CreateStudents < ActiveRecord::Migration
    def self.up
        create_table :students do |t|
            t.column :last,        :string
            t.column :first,       :string
            t.column :gpa,         :float
        end
    end
    
    def self.down
        drop_table :students
    end
end
```
  - Primary key id created by default.
- Migration to add a new column to the table:
```
class AddEmail < ActiveRecord::Migration
    def self.up
        add_column :students, :email, :string
    end
    
    def self.down
        remove_column :students, :email
    end
end
```
CRUD with ActiveRecord:
- Example:
```
ruby script/generate model student
```
  Creates file models/student.rb:
```
Class Student < ActiveRecord::Base
end
```
- Conventions:
  - Database table named Students
  - Records in Students can be accessed via instances of the Student class.
  - Use the name "student" for an instance of this class.
  - ActiveRecord will examine the database schema to find all of the fields in records of Students; each field will be available as an instance variable of the Student class, with the same name.
  - Notice the automatic pluralization (from class Student to database table Students). This is a feature of Rails, intended to make code read more naturally.
- Create:
```
student = Student.new
student.name = "Smith"
student.email = "smith@cs.stanford.edu"
student.gpa = 3.21
student.save
```
  - Primary key id assigned automatically.
  - Nothing reflected on disk until you invoke save.
- Read: use the find method in various forms:
  - Find a single record with a given primary key:
```
student = Student.find(21463)
student = Student.find_by_name("Smith")
```
    - Note the automatic creation of methods in the "Student" class
  - Find a collection of records:
```
smarties = Student.find (:all, :conditions => "gpa >= 3.0");
smarties = Student.find(:all, :limit => 10, :order => "gpa DESC");
```
- Update:
```
student = Student.find(21463)
student.gpa = 4.0
student.save
```
- Delete:
```
Student.find(21463).destroy
```
Relationships between tables:
- Many-to-one (e.g. students -> advisor):
  - Create foreign key advisor_id in Students table
  - Additional declarations in the models
```
class Student < ActiveRecord::Base
    belongs_to :advisor
    ...
end
class Advisor < ActiveRecord::Base
    has_many :students
    ...
end
```
  - Can now reference the tables as if their objects are connected:
```
ouster = Advisor.find_by_name("Ousterhout")
students = ouster.students()
Student student = Student.find_by_name("Smith")
student.advisor = ouster
student.save
```
  - ActiveRecord automatically created new methods in the various classes, (such as Advisor.students) which query information from the database as needed.
- Many-to-many (e.g. students -> courses):
  - You must define the database table CoursesStudents (names of classes in alphabetic order).
  - No need to define a CourseStudent model.
  - Additional declarations in the Student and Course models:
```
class Student < ActiveRecord::Base
    has_and_belongs_to_many :courses
    ...
end
class Course < ActiveRecord::Base
    has_and_belongs_to_many :students
    ...
end
```
  - Again, ActiveRecord creates additional methods in the two classes so you can reference back and forth between Student and Course instances:
```
smith = Student.find_by_name("Smith")
smith_courses = smith.courses()
cs142 = Course.find_by_name("CS142")
smith_courses << cs142
```