Model Creation in Flask using SQLAlchemy

Introduction

In this tutorial, we will walk through the process of creating models in Flask using SQLAlchemy. A model in Flask represents a database table and can be used to interact with the table in a more Pythonic way.

Learning Outcomes
- Understand what Flask models are and how they are used with SQLAlchemy.
- Learn how to create and work with Flask models.

Prerequisites
- Basic understanding of Python
- Familiarity with Flask and SQLAlchemy

Step-by-Step Guide

Flask models are classes in Python that extend the SQLAlchemy model class. These models represent a table in the database and the attributes of the class represent the columns in the table.

1. Setting up Flask-SQLAlchemy: Before creating the models, it is important to set up SQLAlchemy in your Flask application.

   ```python
   from flask import Flask
   from flask_sqlalchemy import SQLAlchemy

   app = Flask(name)
   app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db'
   db = SQLAlchemy(app)
   ```

   In the above code, we first import the necessary modules, create an instance of Flask, configure the database, and initialize SQLAlchemy with the Flask app.

2. Creating a Model: Now that SQLAlchemy is set up, we can create a model. Let's create a User model with id, username, and email as the fields.

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

   Each field is created as an instance of db.Column and is given a type. primary_key, unique, and nullable are optional parameters that specify the characteristics of the column.

Code Examples

Let's walk through some examples of creating and interacting with a model.

1. Creating a Model

   ```python
   from flask_sqlalchemy import SQLAlchemy

   db = SQLAlchemy()

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

   In this example, a User model is created with id, username, and email fields. The id field is the primary key, and username and email are unique and non-nullable.

2. Adding a Record to the Model

   ```python
   from app import User, db

   user = User(username='John', email='john@example.com')
   db.session.add(user)
   db.session.commit()
   ```

   In this example, a new User instance is created, added to the session, and committed to the database.

Summary

In this tutorial, we learned how to set up Flask-SQLAlchemy, create a Flask model that represents a database table, and add a record to the table using the model.

To further your learning, consider exploring how to query the data from the table using the model and how to update and delete records.

Practice Exercises

1. Create a Post model with id, title, content, and user_id fields. The user_id field should be a foreign key to the id field in the User model.

2. Add a Post to the Post table.

3. Query all posts made by a specific user.

Solutions

1. Creating a Post model.

   python class Post(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(140), nullable=False) content = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

2. Adding a Post to the Post table.

   python post = Post(title='My First Post', content='This is my first post.', user_id=1) db.session.add(post) db.session.commit()

3. Querying all posts made by a specific user.

   ```python
   from app import User, Post

   user = User.query.filter_by(username='John').first()
   posts = Post.query.filter_by(user_id=user.id).all()
   ```

In these exercises, you learned how to create a model with a foreign key, add a record to the table using the model, and query the data using the model. For further practice, try updating and deleting records using the model.