As described in Chapter 2, we're going to use MySQL as the database back-end for the Intranet application. If you followed the installation instructions, you should have MySQL available on your machine.

The first step is to initialise the MySQL database. You could use one of the MySQL GUI clients to do this, but we'll use the command line as this works the same regardless of your platform. Use this command to login to the database server on your local machine:

$ mysql -u root -p

Note that -u root specifies we are logging in as the root user: you need to use an account with sufficient privileges to create a new database. -p indicates that we intend to use a password to login. If your login is successful, you should see:

Welcome to the MySQL monitor. Commands end with ; or g.
Your MySQL connection id is 1 to server version: 5.0.24a
Type 'help;' or 'h' for help. Type 'c' to clear the buffer.
mysql>

Once you've logged in successfully, create a database called intranet_development with:

mysql> CREATE DATABASE intranet_development;
Query OK, 1 row affected (0.05 sec)

This is the database we'll be using during the development of our application. The next step is to create a user account for our Rails application. This is a good practice: instead of using a real person's account (or even worse, the root account) to connect our Rails application to MySQL, we will use a dedicated system account. This gives us a handful of security advantages:

Again, you can use either a GUI tool or the command line to create the system account. Here's how to do it on the command line (once you are logged in to MySQL):

mysql> GRANT ALL ON intranet_development.* TO intranet@localhost IDENTIFIED BY 'police73';
Query OK, 0 rows affected (0.01 sec)
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

This simultaneously creates the intranet user account and gives that user all permissions (known as privileges in MySQL) on the intranet database. The IDENTIFIED BY clause specifies the account password ('police73'). @localhost specifies the host name from which this user can access the database. If the database server is on a separate physical box from the application server, the application server's IP address or domain name should be used here. FLUSH PRIVILEGES applies the permissions to the server.

The database connection settings for a Rails application are stored in a single file called database.yml, inside the config directory (which is in turn inside the RAILS_ROOT). The freshly-minted database.yml file (produced by the rails command) can seem a bit confusing, mainly because it contains a lot of examples and hints. However, after removing comments, it boils down to this:

development:
adapter: mysql
database: Intranet_development
username: root
password:
host: localhost
test:
adapter: mysql
database: Intranet_test
username: root
password:
host: localhost
production:
adapter: mysql
database: Intranet_production
username: root
password:
host: localhost

This is a YAML (rhymes with "camel") file, which configures the database settings for each of the three Rails' environments: development, test, and production—which is explained in the next section).

YAML, ( "YAML Ain't a Markup Language"), is officially described as a "data serialization language" (see, http://yaml.org/). Its purpose is comparable to that of XML: both YAML and XML are used to define configuration settings, log file formats, or other kinds of structured data. However, YAML has the following benefits over XML:

The YAML syntax used in the database.yml file defines a YAML mapping from keys to values. (If you've ever worked with a configuration file, the key-value concept should be familiar.) When the file is read by Rails, it is converted into a Ruby hash (c.f. a dictionary or associative array in other languages). The words which are flush with the left of the file ('development', 'test', 'production') are the keys of this top-level hash; in Ruby syntax, the hash looks like this:

{
'development' => {...},
'test' => {...},
'production' => {...}
}

Underneath each of these top-level keys is a series of name-value pairs; each series is also converted into a hash. The parent key has this hash as a value. In Ruby syntax, the resulting "hash of hashes" looks like this:

{
'development' => {
'adapter' => 'mysql',
'database' => 'Intranet_development',
'username' => 'root',
'password' => nil,
'host' => 'localhost'
},
'test' => {...},
'production' => {...}
}

(The 'test' and 'production' sections are truncated for brevity.)

Each sub-hash specifies a database configuration for one of the Rails environments, as described in the next section.

development:
adapter: mysql
database: 'intranet_development'
username: intranet
password: police73
socket: /var/run/mysqld/mysqld.sock

ruby script/console

Loading development environment
>>

>> ActiveRecord::Base.connection

=> #<ActiveRecord::ConnectionAdapters::MysqlAdapter:0xb74dbe34 ...>

Mysql::Error: Can't connect to local MySQL server through socket '/var/run/mysql/mysqld.sock' (2)

Mysql::Error: Access denied for user 'intranet'@'localhost' (using password: YES)