Many-to-many relationships in Flask - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the association table for a many-to-many relationship in Flask-SQLAlchemy.

Flask

association_table = db.Table('association',
    db.Column('left_id', db.Integer, db.ForeignKey('left.id')),
    db.Column('right_id', db.Integer, [1]('right.id'))
)

Drag options to blanks, or click blank then click option'

AForeignKey

Brelationship

CColumn

DInteger

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'relationship' instead of 'ForeignKey' in the association table columns.

Forgetting to use 'ForeignKey' causes errors linking tables.

The ForeignKey is used to link columns in the association table to the primary keys of the related tables.

2fill in blank

medium

Complete the code to define a many-to-many relationship in a Flask model using SQLAlchemy.

Flask

class Parent(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    children = db.relationship('[1]', secondary=association_table, back_populates='parents')

Drag options to blanks, or click blank then click option'

AParents

Bchild

Cchildren

DChild

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or plural names instead of the exact class name.

Confusing the attribute name with the class name.

The relationship function takes the name of the related model class as a string, which is case-sensitive and usually singular.

3fill in blank

hard

Fix the error in the relationship definition to correctly link both sides of a many-to-many relationship.

Flask

class Child(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    parents = db.relationship('Parent', secondary=association_table, [1]='children')

Drag options to blanks, or click blank then click option'

Abackref

Bforeign_keys

Cback_populates

Dlazy

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'backref' instead of 'back_populates' when both sides are declared.

Omitting the linking keyword causes relationship errors.

back_populates is used to explicitly link two relationship properties on different models for a many-to-many relationship.

4fill in blank

hard

Fill both blanks to create a many-to-many relationship with a custom association table and back_populates.

Flask

class Author(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    books = db.relationship('[1]', secondary=[2], back_populates='authors')

Drag options to blanks, or click blank then click option'

ABook

Bauthor_book

CAuthorBook

Dbook_author

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name of the association table instead of the table variable.

Mixing up the order of blanks.

The first blank is the related model class name 'Book'. The second blank is the name of the association table variable, here 'author_book'.

5fill in blank

hard

Fill all three blanks to define a many-to-many relationship with a custom association table and back_populates on both models.

Flask

class Book(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    authors = db.relationship('[1]', secondary=[2], back_populates='[3]')

Drag options to blanks, or click blank then click option'

AAuthor

Bauthor_book

Cbooks

Dauthors

Attempts:

3 left

💡 Hint

Common Mistakes

Using plural for the related model name.

Confusing the back_populates attribute name.

The related model is 'Author', the association table is 'author_book', and the back_populates attribute on Author is 'books'.

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