Many-to-many relationships in Flask - Performance & Optimization

Performance: Many-to-many relationships

MEDIUM IMPACT

This affects how quickly the page loads and updates when displaying or modifying related data across multiple tables.

Displaying related items in a many-to-many relationship

Flask

from sqlalchemy.orm import joinedload
posts = Post.query.options(joinedload(Post.tags)).all()
for post in posts:
    tags = post.tags  # loaded in one query
    for tag in tags:
        print(tag.name)

Loads all posts and their tags in a single query, avoiding repeated database hits.

📈 Performance GainReduces queries from N+1 to 1, improving LCP and reducing server response time.

Displaying related items in a many-to-many relationship

Flask

posts = Post.query.all()
for post in posts:
    tags = post.tags  # lazy loading inside loop
    for tag in tags:
        print(tag.name)

Triggers a database query for each post to load tags, causing N+1 query problem.

📉 Performance CostBlocks rendering due to multiple sequential database queries, increasing LCP.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Lazy loading in loop (N+1 queries)	Minimal DOM nodes	1 reflow after data load	Low paint cost	[X] Bad
Eager loading with joinedload	Minimal DOM nodes	1 reflow after data load	Low paint cost	[OK] Good

Rendering Pipeline

Many-to-many relationships require fetching related data from multiple tables, which affects the data retrieval stage before rendering. Inefficient queries delay data availability, blocking the rendering pipeline.

→Data Fetching

→Rendering

→Layout

⚠️ BottleneckData Fetching due to multiple database queries

Core Web Vital Affected

LCP

This affects how quickly the page loads and updates when displaying or modifying related data across multiple tables.

Optimization Tips

1Avoid lazy loading related data inside loops to prevent multiple database queries.

2Use eager loading (e.g., joinedload) to fetch many-to-many related data in one query.

3Reducing database queries improves Largest Contentful Paint and overall page speed.

Performance Quiz - 3 Questions

What is the main performance problem with lazy loading many-to-many relationships inside a loop?

A It increases the number of DOM nodes unnecessarily.

B It causes multiple database queries, slowing down page load.

C It blocks CSS from loading.

D It causes excessive JavaScript execution.

DevTools: Network

How to check: Open DevTools, go to Network tab, reload the page, and count the number of API/database calls made to fetch related data.

What to look for: Multiple repeated calls for related data indicate N+1 query problem; a single combined call indicates good performance.

Practice

1. What is the main purpose of using an association table in a many-to-many relationship in Flask SQLAlchemy?

easy

A. To link two tables that can have multiple related records each

B. To store user login information securely

C. To create a one-to-one relationship between models

D. To optimize database queries by caching results

Solution

1. Step 1: Understand many-to-many relationships

   Many-to-many means each record in one table can relate to many records in another table, and vice versa.

2. Step 2: Role of association table

   An association table connects these two tables by holding pairs of related record IDs, enabling the many-to-many link.

3. Final Answer:

   To link two tables that can have multiple related records each -> Option A

4. Quick Check:

   Association table = link many-to-many tables [OK]

Hint: Association tables connect two models with many links [OK]

Common Mistakes:

• Thinking association tables store user credentials
• Confusing many-to-many with one-to-one relationships
• Assuming association tables optimize queries automatically

2. Which of the following is the correct way to define an association table in Flask SQLAlchemy?

easy

A. association = db.Model('association', db.Column('left_id', db.Integer), db.Column('right_id', db.Integer))

B. association = db.Model('association', db.ForeignKey('left.id'), db.ForeignKey('right.id'))

C. association = db.Table('association', db.Column('left_id', db.String), db.Column('right_id', db.String))

D. association = db.Table('association', db.Column('left_id', db.Integer, db.ForeignKey('left.id')), db.Column('right_id', db.Integer, db.ForeignKey('right.id')))

Solution

1. Step 1: Identify correct association table syntax

   Association tables use db.Table with columns having foreign keys to related tables.

2. Step 2: Check options for correct use of db.Table and foreign keys

   association = db.Table('association', db.Column('left_id', db.Integer, db.ForeignKey('left.id')), db.Column('right_id', db.Integer, db.ForeignKey('right.id'))) correctly uses db.Table and defines columns with foreign keys to 'left.id' and 'right.id'.

3. Final Answer:

   association = db.Table('association', db.Column('left_id', db.Integer, db.ForeignKey('left.id')), db.Column('right_id', db.Integer, db.ForeignKey('right.id'))) -> Option D

4. Quick Check:

   Association table = db.Table + foreign keys [OK]

Hint: Use db.Table with foreign keys for association tables [OK]

Common Mistakes:

• Using db.Model instead of db.Table for association tables
• Missing foreign key constraints in columns
• Using wrong data types like String for IDs

3. Given the following models, what will print(user.groups[0].name) output?

association = db.Table('association',
    db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
    db.Column('group_id', db.Integer, db.ForeignKey('group.id'))
)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))
    groups = db.relationship('Group', secondary=association, back_populates='users')

class Group(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))
    users = db.relationship('User', secondary=association, back_populates='groups')

user = User(name='Alice')
group = Group(name='Admins')
user.groups.append(group)
print(user.groups[0].name)

medium

A. None

B. Admins

C. Alice

D. Error: AttributeError

Solution

1. Step 1: Understand relationship setup

   User and Group are linked many-to-many via association table. User.groups holds Group objects.

2. Step 2: Analyze code behavior

   User 'Alice' has 'Admins' group appended. Accessing user.groups[0].name returns 'Admins'.

3. Final Answer:

   Admins -> Option B

4. Quick Check:

   user.groups[0].name = 'Admins' [OK]

Hint: Access related objects via relationship lists [OK]

Common Mistakes:

• Confusing user name with group name
• Expecting None if not committed to DB
• Assuming error due to missing session commit

4. Identify the error in this many-to-many relationship setup:

association = db.Table('association',
    db.Column('user_id', db.Integer),
    db.Column('group_id', db.Integer)
)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    groups = db.relationship('Group', secondary=association, back_populates='users')

class Group(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    users = db.relationship('User', secondary=association, back_populates='groups')

medium

A. Incorrect use of back_populates attribute

B. Missing primary key in User model

C. Missing foreign key constraints in association table columns

D. Using db.Model instead of db.Table for association

Solution

1. Step 1: Check association table columns

   Columns lack foreign key constraints linking to User and Group tables.

2. Step 2: Importance of foreign keys

   Foreign keys are required to enforce relationships and enable SQLAlchemy to join tables properly.

3. Final Answer:

   Missing foreign key constraints in association table columns -> Option C

4. Quick Check:

   Foreign keys required in association table [OK]

Hint: Always add foreign keys in association tables [OK]

Common Mistakes:

• Omitting foreign keys in association table
• Confusing back_populates usage
• Thinking primary key is missing in User model

5. You want to add a role attribute to the association between User and Group models to store the user's role in each group. Which approach correctly implements this in Flask SQLAlchemy?

hard

A. Create a new model class for the association with user_id, group_id, and role columns

B. Add a role column to the association table defined with db.Table

C. Add role as a property in the User model

D. Add role as a property in the Group model

Solution

1. Step 1: Understand limitation of db.Table

   db.Table is a simple table without a model class, so it cannot hold extra attributes like 'role'.

2. Step 2: Use association object pattern

   Create a new model class representing the association with foreign keys and extra columns like 'role'. This allows storing additional data per relationship.

3. Final Answer:

   Create a new model class for the association with user_id, group_id, and role columns -> Option A

4. Quick Check:

   Extra data in many-to-many needs association model class [OK]

Hint: Use association model class for extra fields in many-to-many [OK]

Common Mistakes:

• Trying to add extra columns to db.Table association
• Adding role to User or Group instead of association
• Not using a model class for complex associations