**Course Title:** Mastering Ruby on Rails: Building Scalable Web Applications **Section Title:** Working with Databases and Active Record **Topic:** Using Active Record for database interactions **Introduction** In the previous topic, we covered Rails migrations and schema management. Now, it's time to dive deeper into interacting with our databases using Active Record. Active Record is the Object-Relational Mapping (ORM) system provided by Rails that simplifies the way we interact with our databases. In this topic, we'll explore the basics of Active Record, its methods, and how to use it to perform common database operations. **What is Active Record?** Active Record is a gem provided by Rails that provides a simple and intuitive interface to interact with our databases. It abstracts away the underlying database implementation, allowing us to write database-agnostic code. With Active Record, we can perform common database operations such as creating, reading, updating, and deleting records using Ruby objects. **Defining Models with Active Record** In Active Record, models are represented as classes that inherit from ApplicationRecord. For example, let's say we have a table called `users` in our database: ```ruby class User < ApplicationRecord # model code here end ``` In this example, the `User` class represents the `users` table in our database. We can use this class to perform database operations on the `users` table. **Active Record Methods** Active Record provides a wide range of methods for performing database operations. Here are some of the most commonly used methods: * **create**: Creates a new record in the database. ```ruby user = User.create(name: "John Doe", email: "johndoe@example.com") ``` * **find**: Finds a record in the database by its ID. ```ruby user = User.find(1) ``` * **all**: Retrieves all records from the database. ```ruby users = User.all ``` * **where**: Retrieves records from the database based on conditions. ```ruby users = User.where(email: "johndoe@example.com") ``` * **update**: Updates a record in the database. ```ruby user.update(name: "Jane Doe") ``` * **destroy**: Deletes a record from the database. ```ruby user.destroy ``` **Executing Queries with Active Record** Active Record provides a wide range of query methods for executing database queries. Here are some examples: ```ruby # Retrieve all users with a specific email users = User.where(email: "johndoe@example.com") # Retrieve all users with a name that starts with "J" users = User.where("name LIKE ?", "J%") # Retrieve the first user with a specific email user = User.find_by(email: "johndoe@example.com") # Retrieve the user with the maximum age user = User.maximum(:age) ``` **Callbacks and Validations** Active Record provides callbacks and validations for ensuring data integrity and enforcing business logic. Here are some examples: ```ruby class User < ApplicationRecord before_create :set_default_status validates :name, presence: true validates :email, uniqueness: true private def set_default_status self.status = "active" end end ``` In this example, the `User` model has a callback that sets the default status to "active" before creating a new record. It also has validations that ensure the `name` and `email` fields are present and unique. **Takeaways** In this topic, we covered the basics of Active Record and its methods for performing common database operations. We also explored how to define models, execute queries, and use callbacks and validations to ensure data integrity. Here are some practical takeaways: * Use Active Record to simplify your database interactions and write database-agnostic code. * Define models that inherit from ApplicationRecord to represent your database tables. * Use Active Record methods such as `create`, `find`, `all`, and `where` to perform database operations. * Use query methods such as `where` and `find_by` to execute database queries. * Use callbacks and validations to ensure data integrity and enforce business logic. **Resources** * [Active Record API Documentation](https://api.rubyonrails.org/classes/ActiveRecord/Base.html) * [Rails Guide: Active Record Basics](https://guides.rubyonrails.org/active_record_basics.html) **Next Topic** In the next topic, we'll cover understanding associations in Active Record (belongs_to, has_many, etc.). **Leave a Comment or Ask for Help** If you have any questions or need help with any of the concepts covered in this topic, please leave a comment below.