Phase 4 Blog - Flask SQL-Alchemy

I’ve successfully completed Phase 4 of the Flask-SQLAlchemy course, where I learned how to integrate relational databases into Flask applications. During the course, I gained hands-on experience defining models, setting up table relationships, and performing various database operations. I also explored how to manage database migrations with Flask-Migrate. With a strong understanding of SQLAlchemy’s features, I am now confident in building data-driven Flask applications and managing databases efficiently. This phase has provided me with valuable skills for web development and working with databases in Python.

Flask is a lightweight web framework for Python that allows developers to build web applications quickly and easily. It provides essential features like routing and request handling, while leaving the rest up to extensions, giving developers flexibility to choose tools for things like databases and authentication. Flask's simplicity, scalability, and extensibility make it an ideal choice for both small projects and larger, more complex applications.

Flask-SQLAlchemy is an extension that simplifies integrating SQLAlchemy with Flask. It enables developers to interact with databases using Python objects instead of writing raw SQL. By streamlining database connections, schema definitions, and query management, Flask-SQLAlchemy makes it easier to build and manage data-driven Flask applications. It also supports a variety of databases, which makes it highly adaptable.

We use Flask-SQLAlchemy because it simplifies working with databases in Flask. It handles the setup and lets developers create models, run queries, and manage data with Python code. This saves time, reduces errors, and allows developers to focus on building app features instead of dealing with complex SQL.

Here’s an example of a simple Flask app using Flask-SQLAlchemy:

in app.py

from flask import Flask, render_template, request, redirect
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

// Configure the SQLite database

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

// Define a User model (table)

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

    def __repr__(self):
        return f'<User {self.name}>'

// Create the database

with app.app_context():
    db.create_all()

@app.route('/')
def index():
    users = User.query.all()  # Get all users from the database
    return render_template('index.html', users=users)

@app.route('/add', methods=['POST'])
def add_user():
    name = request.form.get('name')
    email = request.form.get('email')

    # Create a new User
    new_user = User(name=name, email=email)
    db.session.add(new_user)
    db.session.commit()

    return redirect('/')

if __name__ == '__main__':
    app.run(debug=True)

To create and manage database migrations, you can use Flask-Migrate, which integrates Alembic for handling schema changes. First, install Flask-Migrate using pipenv install Flask-Migrate, and then set it up in your app:

in app.py

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'your-database-uri'
db = SQLAlchemy(app)
migrate = Migrate(app, db)

Next, initialize the migration repository by running this in your terminal:

flask db init

After making changes to your models, generate migration scripts with:

flask db migrate -m "description of changes"

Finally, apply the migrations to the database with:

flask db upgrade

This workflow allows you to efficiently manage database schema changes over time.

Entering a new phase marks an exciting opportunity for growth and learning. As I move forward, I’m eager to apply the knowledge gained so far, while also tackling new concepts and expanding my understanding. The next step that I'm about to take is building my final project.

Building my final project is an exciting opportunity to combine everything I've learned throughout the course. It’s the chance to apply the concepts, tools, and techniques I've mastered—from JavaScript, React, Python, SQL, and now database management with Flask-SQLAlchemy to handling migrations with Flask-Migrate, and structuring dynamic, data-driven applications. By integrating all these elements into one project, I hopefully can showcase my skills, solve real-world problems, and bring together the full scope of knowledge gained. This project serves as a culmination of my learning and a stepping stone toward further growth in web development.