Ruby on Rails is a popular web application framework known for its convention over configuration approach. One of the key components of Rails is Active Record, which provides an intuitive and powerful way to interact with relational databases. In this blog, we will explore the fundamentals of Rails Active Record and delve into querying data using a relational database. Code examples are alsp provided to help better understand code examples to help you understand and utilize Active Record effectively.

Understanding Active Record:
Active Record is the Object-Relational Mapping (ORM) layer in Ruby on Rails. It facilitates the interaction between Ruby objects and the underlying relational database. Active Record automatically maps database tables to Ruby classes and provides methods for data manipulation, querying, and establishing relationships between models.

Connecting to a Database:
To establish a connection with a relational database, Rails uses the config/database.yml file, which contains database configuration details. By default, Rails supports popular databases like PostgreSQL, MySQL, and SQLite.

Defining Models and Migrations:
Models in Rails represent database tables. They encapsulate business logic and provide an interface for querying and manipulating data. Migrations are used to define and modify the database schema. Here's an example of creating a User model and its corresponding migration:

# Create User model
rails generate model User name:string email:string

# Run migration
rails db:migrate

Querying Data with Active Record:
Active Record provides a concise and readable syntax for querying data from the database. It offers a wide range of querying methods to fetch records that match specific conditions. Let's look at some common querying scenarios using Active Record:

Retrieving All Records:
To fetch all records from the users table, you can use the following code:

users = User.all

Retrieving Specific Records:
To retrieve records that meet specific conditions, you can use the where method. For example, to get all users with the name "John":

johns = User.where(name: "John")

Chaining Conditions:
Active Record allows you to chain multiple conditions together. For example, to find users named "John" with an email ending in "@example.com":

johns = User.where(name: "John").where("email LIKE ?", "%@example.com")

Ordering Results:
You can order the query results using the order method. To retrieve users in ascending order of their names:

users = User.order(:name)

Limiting and Offsetting:
To limit the number of records returned or skip a certain number of records, you can use the limit and offset methods. For example, to fetch the first five users:

users = User.limit(5)

Aggregating Data:
Active Record provides methods for aggregating data, such as counting records, calculating averages, and summing values. For instance, to count the number of users:

count = User.count

Finding a Single Record:
To find a single record based on a specific condition, you can use the find_by method. For example, to find a user with the email "john@example.com":

user = User.find_by(email: "john@example.com")

• This will return the first user that matches the condition.

Selecting Specific Columns:
You can specify which columns to retrieve from the database using the select method. This is useful when you only need specific attributes of the records. For example, to get the names of all users:

names = User.select(:name)

• This will return an array of user objects with only the name attribute loaded.

Using OR Conditions:
Active Record allows you to construct complex queries with OR conditions using the or method. For example, to find users named "John" or "Jane":

johns_and_janes = User.where(name: "John").or(User.where(name: "Jane"))

• This will retrieve users with the name "John" or "Jane."

Count with Conditions:
You can count records that meet specific conditions using the where method in combination with count. For example, to count the number of users with the name "John":

count = User.where(name: "John").count

• This will return the count of users with the name "John."

Finding Records Within a Range:
You can find records within a numeric or date range using the where method. For instance, to find all users created between two dates:

start_date = Date.parse("2023-01-01")
end_date = Date.parse("2023-12-31")

users_in_range = User.where(created_at: start_date..end_date)

• This retrieves users whose creation dates fall within the specified range.

Grouping and Counting:
Active Record enables you to group records by a specific attribute and count the occurrences. For example, to count the number of users per email domain:

email_counts = User.group(:email_domain).count

• This will return a hash with email domains as keys and the corresponding count of users.

As you can see, Active Record simplifies database interactions in Ruby on Rails by providing a convenient and intuitive way to query and manipulate data. The examples above showcase the versatility of Active Record in querying data from relational databases. This blog only scratches the surface of what Active Record can do, but it should provide you with a foundation to start working with relational databases in Rails.

Happy coding!