3 m read
March 28, 2024 Ruby

Rails Migrations: A Simple Approach

Image by Freepik

As we continue on our exploration of the Ruby on Rails framework, we encounter one of its most potent features: Rails Migrations. It serves as a dynamic tool to help modify your database schema over time without the need for raw SQL commands.

What are Rails Migrations?

Essentially, migrations are a feature of Rails’ Active Record, designed to allow developers to alter their database schema over time. The magic of Rails Migrations lies in its usage of Ruby DSL (domain-specific language) over pure SQL, making changes to tables a simpler affair for developers of all levels and backgrounds.

How Rails Migrations Work

Migrations in Rails work by constructing each modification as a new ‘version’ of the database. When a change is successful, the migration updates the schema and stamps it with a UTC timestamp. This timestamped macro will create two columns, namely “created_at” and “updated_at“, which are maintained automatically by the Active Record.

Storing Migrations

All migrations in Ruby on Rails are stored as files in the db/migrate directory. Each of these files corresponds with a unique timestamp, and Rails uses this timestamp to determine which migration to run and what sequence to follow. The filename usually takes the form of “YYYYMMDDHHMMSS_create_products.rb“.

Migrations Failure Scenario

What happens if a migration fails? In this event, any parts of the migration that were successful will not be rolled back. Thus, it’s crucial only to proceed once you’re sure that the new migration won’t conflict with your existing schema.

Manipulating Migrations

Managing Rails Migrations can be as straightforward as crafting the right command. Let’s delve into how to manipulate them effectively and their significance in database management within the Rails framework.

Creating Tables: An Example

Our first interaction is with creating tables within the database. There are multiple methodologies that Rails Migrations use for table creation, one of which is the create_table method. For example, you might use the following code:

    create_table :products do |t|
      t.string :name
      t.decimal :price
    end

This creates a table named ‘products’ with two columns: ‘name’ and ‘price’. The create_table method is fundamental, and most of the time, it will be generated for you with a model, resource, or scaffold generator.

Adding Columns

The schema modifications can also include adding and removing columns. You can add or remove columns in the same way you generate migrations:

    add_column :products, :sku, :string
    remove_column :products, :price

The above example adds a new column called ‘sku’ to the ‘products’ table and removes the ‘price’ column from the same table.

Using Index

When creating columns within the create_table block, an index can be created by passing index: true. Adding an index helps speed up retrieving rows from your database and is a crucial part of optimizing your Rails applications.

Executing Rails Migrations

The simplest way to run migrations is to use the bin/rails db:migrate command. When you execute this command, Rails will run migrations that have not yet been run, in the order, their timestamps were created.

Rolling back is also made straightforward with Rails Migrations. By simply running bin/rails db:rollback, you can revert to earlier versions of your database schema. You can also specifically indicate the version you want to rollback to by appending the version value to the rollback command.

Setup and Seed Data

Another handy command is bin/rails db:setup. This command has a threefold function: it creates the database, loads the schema, and seeds the database with initial data.

Conclusion

Ruby on Rails provides a powerful mechanism for managing database changes with Rails Migrations. Not only does this system provide you with a way to generate and modify database structure using the Ruby language, but it also retains a built-in tracking system for your changes and allows for straightforward reversal should the need arise.

In the next part of this series, we’ll dive into another essential element of Ruby on Rails, so stay tuned!

If you’ve missed the previous article, feel free to check it out here.

Benji
Latest posts by Benji (see all)

Leave a Reply