Model definition in Flask - Step-by-Step Execution

Concept Flow - Model definition

Import Flask and SQLAlchemy

↓

Create Flask app instance

↓

Configure database URI

↓

Create SQLAlchemy db object

↓

Define Model class with fields

↓

Use model to create tables or query data

This flow shows how to set up a Flask app with SQLAlchemy, define a model class, and prepare it for database use.

Execution Sample

Flask

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)

This code creates a Flask app, sets up a database connection, and defines a User model with id and name fields.

Execution Table

Step	Action	Evaluation	Result
1	Import Flask and SQLAlchemy	Modules imported	Flask and SQLAlchemy ready
2	Create Flask app instance	app = Flask(__name__)	app object created
3	Configure database URI	app.config['SQLALCHEMY_DATABASE_URI'] set	Database URI set to sqlite:///test.db
4	Create SQLAlchemy db object	db = SQLAlchemy(app)	db object linked to app
5	Define User model class	class User(db.Model): ...	User model with id and name fields created
6	Model ready for use	User model can create tables or query	Model definition complete

💡 Model class defined and ready for database operations

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
app	None	Flask app instance	Flask app instance	Flask app instance	Flask app instance
db	None	None	SQLAlchemy object linked to app	SQLAlchemy object linked to app	SQLAlchemy object linked to app
User	None	None	None	User model class defined	User model class defined

Key Moments - 2 Insights

Why do we set app.config['SQLALCHEMY_DATABASE_URI'] before creating the db object?

Because SQLAlchemy needs the database URI to connect properly when the db object is created, as shown in steps 3 and 4 of the execution_table.

What does db.Model mean in the User class definition?

db.Model is the base class from SQLAlchemy that tells Flask this class is a database model, as seen in step 5 where User inherits from db.Model.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of the 'db' variable after step 4?

A SQLAlchemy object linked to app

B None

C Flask app instance

D User model class defined

💡 Hint

Check the variable_tracker row for 'db' after step 4

At which step is the User model class defined?

A Step 2

B Step 3

C Step 5

D Step 6

💡 Hint

Look at the execution_table row describing model class definition

If we set the database URI after creating the db object, what would happen?

A The db object would connect to the correct database

B The db object might not connect properly

C The app would crash immediately

D The User model would not be defined

💡 Hint

Refer to key_moments about configuration order and step 3 vs step 4

Concept Snapshot

Flask Model Definition:
1. Import Flask and SQLAlchemy
2. Create Flask app instance
3. Set app.config['SQLALCHEMY_DATABASE_URI']
4. Create db = SQLAlchemy(app)
5. Define model class inheriting db.Model
6. Use model for DB operations

Full Transcript

This example shows how to define a model in Flask using SQLAlchemy. First, we import the necessary modules. Then, we create a Flask app instance. Next, we configure the database URI so SQLAlchemy knows where to connect. After that, we create the SQLAlchemy db object linked to the app. Then, we define a model class called User that inherits from db.Model and has fields id and name. Finally, the model is ready to create tables or query data. The order is important: setting the database URI before creating the db object ensures proper connection. The User class inherits from db.Model to tell Flask it is a database model.

Practice

1. What is the main purpose of defining a model in a Flask application?

easy

A. To represent and manage data structure in the database

B. To create the user interface layout

C. To handle HTTP requests and responses

D. To style the web pages with CSS

Solution

1. Step 1: Understand what a model represents

   A model in Flask defines how data is stored and structured in the database.

2. Step 2: Identify the role of models in the app

   Models help manage data easily by mapping Python classes to database tables.

3. Final Answer:

   To represent and manage data structure in the database -> Option A

4. Quick Check:

   Model = Data structure representation [OK]

Hint: Models map classes to database tables for data storage [OK]

Common Mistakes:

• Confusing models with UI components
• Thinking models handle HTTP requests
• Mixing models with styling or CSS

2. Which of the following is the correct way to define a model class named User with an integer primary key id in Flask-SQLAlchemy?

easy

A. class User():\n id = Column(Integer, primary_key=True)

B. class User(db.Model):\n id = Column(Integer)

C. def User(db.Model):\n id = db.Column(db.Integer, primary_key=True)

D. class User(db.Model):\n id = db.Column(db.Integer, primary_key=True)

Solution

1. Step 1: Check class definition syntax

   Model classes inherit from db.Model in Flask-SQLAlchemy.

2. Step 2: Verify column definition

   Columns use db.Column with type and primary key flag.

3. Final Answer:

   class User(db.Model):\n id = db.Column(db.Integer, primary_key=True) -> Option D

4. Quick Check:

   Model class inherits db.Model and uses db.Column [OK]

Hint: Model classes inherit db.Model; columns use db.Column [OK]

Common Mistakes:

• Forgetting to inherit from db.Model
• Using Column without db prefix
• Defining model as a function instead of class

3. Given this model definition:

class Product(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))

p = Product(id=1, name='Book')
print(p.name)

What will be the output?

medium

A. Product object

B. 1

C. Book

D. Error: missing __init__ method

Solution

1. Step 1: Understand model instance creation

   Creating p = Product(id=1, name='Book') sets attributes directly.

2. Step 2: Check what print(p.name) outputs

   It prints the name attribute value, which is 'Book'.

3. Final Answer:

   Book -> Option C

4. Quick Check:

   Accessing attribute prints its value [OK]

Hint: Instance attributes print their assigned values [OK]

Common Mistakes:

• Assuming print shows object type
• Expecting error due to no explicit __init__
• Confusing id and name values

4. What is wrong with this model definition?

class Employee(db.Model):
    id = db.Column(db.Integer)
    name = db.Column(db.String, primary_key=True)

medium

A. db.String requires a length argument

B. Columns must be defined inside a method, not directly

C. Model class must have a __tablename__ attribute

D. Primary key should be on the id column, not name

Solution

1. Step 1: Check db.String usage

   db.String requires a length argument like db.String(100).

2. Step 2: Verify other parts

   Primary key can be on any column; __tablename__ is optional; columns are defined directly.

3. Final Answer:

   db.String requires a length argument -> Option A

4. Quick Check:

   db.String must have length [OK]

Hint: Always specify length in db.String(length) [OK]

Common Mistakes:

• Assuming primary key must be id
• Thinking __tablename__ is mandatory
• Defining columns inside methods

5. You want to define a model Order with a composite primary key consisting of order_id (integer) and product_id (integer). Which is the correct way to define this in Flask-SQLAlchemy?

hard

A. class Order(db.Model):\n order_id = db.Column(db.Integer, primary_key=True)\n product_id = db.Column(db.Integer, primary_key=True, autoincrement=True)

B. class Order(db.Model):\n order_id = db.Column(db.Integer)\n product_id = db.Column(db.Integer)\n __table_args__ = (db.PrimaryKeyConstraint('order_id', 'product_id'),)

C. class Order(db.Model):\n order_id = db.Column(db.Integer, primary_key=True)\n product_id = db.Column(db.Integer)

D. class Order(db.Model):\n order_id = db.Column(db.Integer)\n product_id = db.Column(db.Integer)

Solution

1. Step 1: Understand composite primary keys

   Composite keys require defining multiple columns as primary keys together.

2. Step 2: Check Flask-SQLAlchemy syntax for composite keys

   Use __table_args__ with db.PrimaryKeyConstraint listing columns.

3. Final Answer:

   class Order(db.Model):\n order_id = db.Column(db.Integer)\n product_id = db.Column(db.Integer)\n __table_args__ = (db.PrimaryKeyConstraint('order_id', 'product_id'),) -> Option B

4. Quick Check:

   Composite keys use __table_args__ with PrimaryKeyConstraint [OK]

Hint: Use __table_args__ with PrimaryKeyConstraint for composite keys [OK]

Common Mistakes:

• Setting primary_key=True on multiple columns separately
• Not using __table_args__ for composite keys
• Defining only one column as primary key