Column types and constraints in Flask - Step-by-Step Execution

Concept Flow - Column types and constraints

Define Model Class

↓

Add Column with Type

↓

Add Constraints (nullable, unique, primary_key)

↓

Create Table in DB

↓

Use Model for CRUD Operations

This flow shows how to define a database model in Flask with columns, specify their types and constraints, then create the table and use it.

Execution Sample

Flask

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(120), unique=True, nullable=False)

Defines a User model with an integer primary key and a unique, non-nullable email string column.

Execution Table

Step	Action	Column	Type	Constraints	Result
1	Define id column	id	Integer	primary_key=True	Primary key column created
2	Define email column	email	String(120)	unique=True, nullable=False	Unique and required column created
3	Create table in DB	-	-	-	Table 'user' created with columns and constraints
4	Insert user with email	-	-	-	Success if email unique and not null
5	Insert user with duplicate email	-	-	-	Fails due to unique constraint
6	Insert user with null email	-	-	-	Fails due to nullable=False constraint
7	Query user by id	-	-	-	Returns user with matching id
8	End	-	-	-	Execution stops

💡 Execution stops after table creation and sample insertions demonstrate constraints enforcement.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
id column	undefined	Integer, primary_key=True	Integer, primary_key=True	Defined in DB table	Used as PK	Used as PK	Used as PK	Defined
email column	undefined	undefined	String(120), unique=True, nullable=False	Defined in DB table	Inserted unique email	Duplicate email error	Null email error	Defined

Key Moments - 3 Insights

Why does inserting a user with a duplicate email fail?

Because the email column has unique=True constraint, the database rejects duplicate values as shown in execution_table step 5.

What happens if we try to insert a user without an email?

The insert fails due to nullable=False constraint on the email column, preventing null values as shown in execution_table step 6.

Why is the id column special?

The id column is marked primary_key=True, so it uniquely identifies each row and is required, as shown in execution_table step 1.

Visual Quiz - 3 Questions

Look at the execution table, what constraint is applied to the email column at step 2?

A primary_key=True

B nullable=True

C unique=True, nullable=False

D default='[e-mail]'

💡 Hint

Check the Constraints column in execution_table row for step 2.

At which step does inserting a user with a null email fail?

A Step 4

B Step 6

C Step 5

D Step 7

💡 Hint

Look for the row mentioning null email error in execution_table.

If we remove unique=True from email, what changes in the execution?

A Duplicate emails would be allowed

B Emails would have to be unique

C Emails would become nullable

D Primary key would change

💡 Hint

Refer to the unique constraint effect shown in execution_table step 5.

Concept Snapshot

Define columns in Flask models using db.Column(type, constraints).
Common types: Integer, String(length).
Constraints: primary_key, unique, nullable.
Primary key uniquely identifies rows.
Unique prevents duplicates.
Nullable=False means value is required.

Full Transcript

In Flask, when defining database models, you create columns using db.Column and specify their data types like Integer or String. You can add constraints such as primary_key to mark a column as the unique identifier, unique to prevent duplicate values, and nullable to control if the column can be empty. For example, an id column with primary_key=True uniquely identifies each record. An email column with unique=True and nullable=False means every user must have a unique email address. When the table is created, these constraints are enforced by the database. Trying to insert duplicate or missing emails will cause errors. This visual trace shows how columns and constraints are defined, how the table is created, and how these rules affect inserting data.