2.4. Basic Active Record Classes

Whether you use migrations or SQL scripts, you'll need to follow the naming conventions. The table name photos and the definition of the id column are both significant. (With our migration, Rails created the id column automatically.) Rails uses several naming conventions:

Class and table names

If the name of your database tables is the English plural of the name of your model class, Rails can usually infer the name of the database table from the name of the Active Record class. (Active Record will have trouble with some irregulars like sheep, but supports many popular irregulars like people.)

Identifiers

Similarly, Active Record automatically finds a column called id and uses it as a unique identifier. The id column should be an integer type, and the column should be populated by the database. In this case, we'll use an auto-increment sequence. Staying with these conventions saves you some configuration, and also makes your code much easier to understand.

Foreign keys

Foreign keys should be named <class>_id. For example, our slides table will have a foreign key named photo_id.

Capitalization

When you're defining a class, capitalize the first letter of each word and omit spaces between words (commonly called camel casing). But Rails methods, database table names, columns, attributes, and symbols use underscores to separate words. These conventions are mostly cosmetic, but Rails often uses symbols to refer to a class name, so make sure you follow these conventions. For example, to represent a class called ChunkyBacon, you'd use the symbol :chunky_bacon.

2.4.1. Wrapping the Table

Now we're ready to look at the Active Record model class we created earlier. In the app/models directory (which contains your project's model classes), Rails created the photo.rb file, along with some testing code, when we generated our model. Open it:

class Photo < ActiveRecord::Base
end

Active Record class has all of the information that it needs to wrap the photos table.

2.4.2. The Rails Console

You'll probably spend a good deal of time in the Rails console, one of the many tools created with each Rails project. The Rails console lets you interactively work with your database-backed models. When you start a console, Rails does the following:

• Connects you to the database

• Loads the Active Record classes in app/model

• Lets you interactively work with your model, including database operations

Let's start a console now to manipulate the Photo model we created:

ruby script/console

We'll use the console to create some new objects, and save them to the database: ^{"#rubyrails-chp-2-fn2">[*]}

^[*] After each statement you type, the console will print the value of object.inspect for the last object returned.

>> photo=Photo.new
=> #<Photo:0x35301d8 @attributes 
={"filename"=>""},
@new_record=true>
>> photo.filename = 'cat.jpg'
=> "cat.jpg"
>> photo.save
=> true

The new method on Active Record classes can take a code block:

>> Photo.new do |dog|
?>   dog.filename = 'dog.jpg'
>>   dog.save
>> end

Both techniques create a new model object and save it to the database. Each produces the same SQL, so the choice is entirely a matter of your personal preference.