Object Relational Models (ORM)

What is ORM?

Object-Relational Mapping (ORM) is a programming technique that allows developers to interact with databases using the programming language they are familiar with, rather than writing complex SQL queries.

In simple terms, ORM helps us to use our code (objects in programming languages) to interact with our database tables, which are traditionally handled by SQL.

Why Use ORM?

When working on a web application, you often need to interact with a database. Traditionally, this means writing SQL queries to insert, update, delete, or retrieve data. However, SQL can be verbose and error-prone, especially for beginners.

ORM simplifies this by allowing you to work with your database using the programming language you're already using for your application, such as Python, JavaScript, or Ruby. This not only makes your code cleaner and easier to understand but also helps prevent common SQL errors.

The Problem ORM Solves

Let’s say you’re building a simple blog application. You have a database table called posts that stores blog posts. Here’s what a traditional SQL query might look like to get all the posts from the database:

SELECT * FROM posts;

This query is simple, but what if you need to get all the posts written by a specific author, ordered by the date they were created? The SQL query might start to look something like this:

SELECT * FROM posts WHERE author_id = 1 ORDER BY created_at DESC;

As your application grows, your SQL queries become more complex, and it can be challenging to maintain them alongside your application code.

Key Concepts of ORM

To better understand how ORMs work, let’s explore some key concepts:

1. Model

• A model in ORM represents a table in the database. Each model is typically a class in your programming language, and each instance of the class represents a row in the table.
• Models define the structure of your database tables, including columns and their data types.

2. Session

• A session is a temporary connection between your application and the database. It’s used to perform operations like querying, adding, updating, or deleting records.
• The session handles the interaction between the objects in your code and the corresponding records in the database.

3. Query

• A query is how you retrieve data from the database. ORMs provide a way to write queries using the programming language’s syntax, which the ORM then translates into SQL.
• Queries can filter, sort, and join data from multiple tables, just like SQL.

4. Migration

• Migration is the process of making changes to the database schema (like adding or removing tables or columns) in a systematic way.
• ORMs often provide tools to manage database migrations, ensuring that your database structure evolves alongside your application code.

5. Relationship

• Relationships in ORM describe how different tables (or models) are related to each other. For example, a User model might have a one-to-many relationship with a Post model (one user can have many posts).
• These relationships are defined in the models and managed by the ORM, which makes it easier to work with related data.

How ORM Works

With ORM, instead of writing SQL queries, you work with classes and objects in your code. These classes represent tables in your database, and objects of these classes represent rows in the tables.

Let’s take an example in Python using a popular ORM library called SQLAlchemy:

Defining a Model

First, you define a model (a Python class) that represents a table in your database. Here’s how you might define a Post model for your blog application:

from sqlalchemy import Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

Base = declarative_base()

class Post(Base):
    __tablename__ = 'posts'

    id = Column(Integer, primary_key=True)
    title = Column(String)
    content = Column(String)
    author_id = Column(Integer)
    created_at = Column(DateTime, default=datetime.utcnow)

    def __repr__(self):
        return f"<Post(title='{self.title}', author_id={self.author_id})>"

What’s Happening Here?

• Post Class: This class represents the posts table in your database.
• Columns: The class attributes (id, title, content, author_id, created_at) represent the columns of the posts table.
• Base: This is the base class for all your models. It provides functionality that allows the ORM to interact with the database.

Interacting with the Database

Now that we’ve defined our Post model, we can interact with the posts table in our database using Python code.

Inserting Data

Let’s say you want to add a new blog post to the database. Instead of writing an SQL INSERT query, you do this:

new_post = Post(title="My First Blog Post", content="Hello World!", author_id=1)

session.add(new_post)
session.commit()

Querying Data

If you want to retrieve all blog posts, you can do this:

posts = session.query(Post).all()
for post in posts:
    print(post.title)

This will print the titles of all blog posts in the database.

Updating Data

To update an existing post, you might do this:

post = session.query(Post).filter_by(id=1).first()
post.title = "Updated Title"
session.commit()

Deleting Data

And to delete a post, you would do:

post = session.query(Post).filter_by(id=1).first()
session.delete(post)
session.commit()

Benefits of ORM

1. Simplified Code: ORM allows you to write database queries using your programming language, which is often more readable and easier to write than SQL.
2. Reduced Errors: By working with objects and methods, you reduce the chance of making syntax errors in your SQL queries.
3. Database Independence: ORM can make your application more flexible by allowing you to switch between different database systems (like PostgreSQL, MySQL, SQLite) with minimal changes to your code.
4. Security: ORM helps prevent SQL injection attacks by using parameterized queries behind the scenes.

Limitations of ORM

1. Performance: In some cases, ORM can generate less efficient SQL queries than you would write by hand. This can lead to performance issues in very large or complex applications.
2. Learning Curve: While ORM simplifies database interaction, it introduces its own concepts and patterns that you need to learn.

Conclusion

ORM is a powerful tool that bridges the gap between your application code and your database. It allows you to interact with the database using objects in your programming language, making your code more maintainable and easier to understand. While there are some trade-offs in terms of performance, for most applications, the benefits of using ORM far outweigh the drawbacks.

As you continue your journey in web development, you’ll find that ORM can significantly simplify the way you interact with databases, allowing you to focus more on building features and less on managing database queries.

---

Contributors

• Jessie Liu