Congratulations on reaching this crucial stage of your journey in making your Ruby on Rails ToDo application enterprise-ready! In this lesson, you'll learn how to integrate a database into your application. If you've ever stored data manually in a file or used a spreadsheet for data tracking, then you can imagine the benefits of using a structured database to handle these tasks efficiently.

We'll start by showing you how to create and manage a database within a Rails application. This process allows you to store user data reliably and access it efficiently.

In this lesson, we will guide you through the creation of a database table specifically for storing ToDo items. You'll discover how to define the structure of your database using Rails migrations. Here is a brief look at the code that helps to achieve this:

Ruby
Copy to clipboard
1class CreateTodos < ActiveRecord::Migration[6.1]
2  def change
3    create_table :todos do |t|
4      t.string :title, default: 'Untitled'
5      t.text :description
6
7      t.timestamps
8    end
9  end
10end

This code outlines a migration file, a core component of Rails that allows for managing the evolution of your database schema over time. In this example, we have set a default value of 'Untitled' for the title column, which will be used whenever a new record is created without specifying a title. Developers typically use a generator to create such migration files. For the CreateTodos migration, you can use the following Rails command:

Bash
Copy to clipboard
1rails generate migration CreateTodos title:string description:text

This command will automatically create a migration file with the structure for a todos table, including the specified title and description fields.

Once the migration file is generated, you need to apply it to update your database schema. Run the following command:

Bash
Copy to clipboard
1rails db:migrate

This will execute the migration, creating the todos table in your database with the specified columns. You will get hands-on experience creating a migration that builds a todos table with columns for a title and description as well as essential timestamp fields.

If you need to rollback or undo the migration, perhaps due to a mistake or a change in design, you can run:

Bash
Copy to clipboard
1rails db:rollback

This command will revert the last migration run, removing the todos table from the database. You can specify the step option to rollback multiple migrations:

Bash
Copy to clipboard
1rails db:rollback STEP=2

This will rollback the last two migrations. Understanding how to rollback migrations is crucial for efficiently managing changes to your database schema.

After applying your migrations to update the database schema, you might want to populate your database with initial data. Rails provides a convenient way to achieve this through seeding. The db/seeds.rb file allows you to define data that can be loaded into your database with a single command.

Here's an example of how you might seed your database with some initial ToDo items:

Ruby
Copy to clipboard
1# db/seeds.rb
2Todo.create(title: 'Buy groceries', description: 'Milk, Eggs, Bread, and Butter')
3Todo.create(title: 'Read a book', description: 'Finish reading "Ruby on Rails Tutorial"')

To load the seed data, run the following command:

Bash
Copy to clipboard
1rails db:seed

Seeding your database is particularly useful for setting up development and test environments with baseline data, ensuring consistency and reliability as you build and test new features.

Now that you have a database integrated with your Rails application, it's essential to learn how to interact with it using Active Record, Rails' powerful ORM (Object-Relational Mapping) tool. Active Record allows you to perform operations on your database directly from your Rails application.

Here are some basic Active Record methods that will come in handy:

• Creating Records: You can create a new record and save it to the database with:

  Ruby
  Copy to clipboard
  1todo = Todo.new(title: 'Clean the house', description: 'Vacuum and dust all rooms')
  2todo.save

  Alternatively, you can use the create method to do both at once:

  Ruby
  Copy to clipboard
  1Todo.create(title: 'Pay bills', description: 'Electricity, water, and internet')

• Retrieving Records: To retrieve all records from a table:

  Ruby
  Copy to clipboard
  1todos = Todo.all

  Or to find a specific record by its ID:

  Ruby
  Copy to clipboard
  1todo = Todo.find(1)

• Querying with Conditions: You can filter records using the where method:

  Ruby
  Copy to clipboard
  1todos = Todo.where(title: 'Buy groceries')

  This will return all ToDo items with the title 'Buy groceries'.

• Updating Records: You update an existing record by first retrieving it and then modifying its attributes:

  Ruby
  Copy to clipboard
  1todo = Todo.find(1)
  2todo.update(title: 'Go grocery shopping')

• Deleting Records: To remove a record from the database:

  Ruby
  Copy to clipboard
  1todo = Todo.find(1)
  2todo.destroy

These operations allow you to manipulate your application's data effectively. Familiarizing yourself with Active Record is essential as it provides a bridge between your Rails code and the database, enabling seamless data management and interaction.

As your application evolves, you might want to encapsulate database operations within service objects to maintain clean and organized code. Here's an example of how you might use Active Record methods within a service class to manage ToDo items:

Ruby
Copy to clipboard
1# app/services/todo_service.rb
2class TodoService
3  def self.create_todo(title, description)
4    Todo.create(title: title, description: description)
5  end
6
7  def self.update_todo(id, title, description)
8    todo = Todo.find(id)
9    todo.update(title: title, description: description)
10  end
11
12  def self.delete_todo(id)
13    todo = Todo.find(id)
14    todo.destroy
15  end
16
17  def self.find_todo_by_title(title)
18    Todo.where(title: title)
19  end
20end

By encapsulating the Active Record logic within a service like TodoService, you create a single point of control for all ToDo-related operations, enhancing the maintainability and scalability of your application. This approach promotes the separation of concerns, making your code base easier to manage and understand.

Integrating a database into your Rails application elevates it from a simple static program to a dynamic, data-driven powerhouse. It allows you to store, retrieve, and manipulate user data in real time, which is crucial for any enterprise application. This step not only enhances the functionality of your application but also prepares it for scaling to handle more complex business needs.

You'll find that understanding how to integrate and manage a database is a skill that's highly sought after in the tech industry. Get excited to apply what you've learned so far and extend your application's capabilities significantly. Let's jump into the practice section and bring your app to life!