ORM (Object-Relational Mapping)

What is ORM in Ruby on Rails?

In Ruby on Rails, ORM is implemented through Active Record, which maps database tables to Ruby classes and rows to objects.

This means instead of writing SQL queries, developers can use Ruby methods to create, read, update, and delete data. Each model in a Rails application represents a table in the database, and each instance of that model represents a record (row).

ORM abstracts database interactions, making code more readable and easier to maintain while still allowing powerful querying capabilities.

In short, ORM lets Rails developers work with databases using Ruby objects instead of SQL.

Why is ORM Useful?

Writing raw SQL for every database interaction can be time-consuming and error-prone.

ORM is useful because it:

• Reduces the need to write raw SQL

• Makes database interactions more intuitive using Ruby

• Improves code readability and maintainability

• Provides built-in methods for common operations (CRUD)

• Helps prevent SQL injection through abstraction

• Works seamlessly with Rails conventions

• It enables developers to focus more on application logic rather than database syntax.

How ORM Works?

ORM maps database structures to Ruby objects and provides methods to interact with them.

Key components:

• Models: Ruby classes that represent database tables

• Attributes: Columns in the table mapped to object properties

• CRUD Operations: Methods like create, find, update, and destroy

• Query Interface: Methods like where, order, and limit

• Associations: Relationships between models (has_many, belongs_to)

• Migrations: Define and modify database schema

Example

Scenario 1: Creating and retrieving records using ORM

Model (app/models/user.rb)

class User < ApplicationRecord 

end 

This model represents the users table in the database.

Creating a record

user = User.create(name: "John", email: "john@example.com") 

This inserts a new row into the database without writing SQL.

Fetching records

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

This retrieves users with the name “John” using a Ruby method instead of a SQL query.

Scenario 2: Updating and deleting records

Updating a record

user = User.find(1) 
 
user.update(email: "newemail@example.com") 

This updates the user’s email in the database.

Deleting a record

user.destroy 

This removes the record from the database.

These examples show how ORM replaces raw SQL with intuitive Ruby methods for database operations.

Where to Use ORM?

• Managing application data in Rails models

• Performing CRUD operations without raw SQL

• Handling relationships between tables

• Building queries using Ruby methods

• Rapid application development with databases

• Maintaining clean and readable database logic

In Summary

ORM (Object-Relational Mapping) in Ruby on Rails allows developers to interact with databases using Ruby objects instead of SQL. Through Active Record, it simplifies data handling, improves code readability, and accelerates development while maintaining powerful database capabilities.