Building a Database
If you don’t already know what a database is, refer to my previous post from Week 5. Today, we are going to walkthrough creating a database and associated tables inside of the Rails framework, so buckle up!
First things first, we need to create a new Rails project. To do this, go to your terminal and navigate to the directory you would like the project to exist. Once you have done that, type in the following:
rails new blog-project. Now, if you go to your text editor (I use Atom) and open up the directory for
blog-project you will see a whole slew of files and folders automatically generated for you!
We are now on the right track! Now, go find a folder in there called
db this should have a file inside of it called,
seed.rb. There is a couple of problems here:
- There is no database!
- There are no migrations!
- The seeds file is empty!
Let’s fix this real quick. Navigate to the
config folder and look for a file called
database.yml and then look for the
development section, there you will find a line that reads as follows:
This is the name of your database. Now go back to your terminal and type in the following
This command will generate a new database, the name of which is located in your
database.yml file we just looked at. Unfortunately, our database doesn’t have anything in it right now – it’s empty! Let’s fill it up with some tables.
ActiveRecord we have things called tables which represent a collection of database objects that are similar. An example would be a table called
cars which could have many different types of cars inside of that table.
Additionally, our tables have columns – these represent specific attributes of our database objects. We could have columns for
color and so on.
For the purposes of this exercise we are going to want our users to be able to create a new blog post and post it online. So let’s do it! Go back to your terminal and type in the following command:
rails generate migration create_articles.
Now, go back to your
db folder and you will notice something really cool, Rails has automatically created a new folder for you called
migrate which has a migration file inside of it – open that up!
This is where we will be creating our table in
ActiveRecord. Pay attention to the line,
create_table :articles do |t|. This is saying,
create_table – this is a specific
ActiveRecord method for creating a new table,
:articles – the name of the table following by
do |t|– this iterating through and generating all of the columns we want to be created for our table, called
:articles. Let’s do that now.
What kind of things do we want our user to have access to? We should want them to be able to type in the
Title of the blog post as well as the
Body, which is the meat of the article. So, modify your migration file to look like this:
This will now create a table with 2 columns:
t. part is just the syntax for
ActiveRecord to iterate through using this method – don’t get too hung up on it, just know it works and we need it. Secondly, the
null: false part is saying, this field is necessary, it cannot be blank – we will do further validations in our
Now, in order to actually run this and then save these changes to the database we need to hop back over to our terminal and run the following command:
rake db:migrate. This should result in the following:
Great! We now have a table, but we need a way to interface with it using Ruby. We do this by creating a ruby class that that acts as a mediator between our
controller and our database object. So, go into your
models folder and create a file called
article.rb. Inside of that files type in the following:
You may be wondering what this nonsense is with inheritance. Inside of your
models folder find your file –
application_record.rb, you will find that it inherits from
ActiveRecord::Base, and in turn our model classes inherit from
ApplicationRecord, this is the Rails convention way of inheritance. It is something you will always do.
validates: ... sections are simply checking to see if the user inputted information into these fields. This is good if we want to set up
flash error messages to prompt the user to correct their input, but that is for another day.
Now, we have both a database as well as a table! Let’s confirm this by loading up our Rails application into
PRY by going into our terminal and running the following command:
This gives us behind-the-scenes access to our rails application – from here we can check on our database and its objects and tables, so let’s do just that. Type the following into the terminal:
Article.create!(title: 'How to Create a Database', body: 'Insert lengthy blog post about making databases'). This should look something like this:
Here you can see, we used the
create! method to not only create but persist (save) the data to the database table. We can confirm this by running the following command while still inside of
Here, we have a newly created
Article object with the following attributes:
body and 2 timestamps for
It may not seem like much but you just created a database in
ActiveRecord! Congratulation, you are well on your way to creating a full-on blogging website! From here, you would need to set up your
routes.rb file, create controllers to handle
HTTP requests and set up a few
view files for displaying our information to the end user.
All of that will be covered a later blog post so stay tuned!