Building a simple CRUD application with Flask and SQLAlchemy

Building a Simple CRUD Application with Flask and SQLAlchemy

Creating web applications can be a daunting task, especially if you're just starting out. However, with the right tools and frameworks, you can build a fully functional application in no time. In this article, we’ll walk you through the process of developing a simple CRUD (Create, Read, Update, Delete) application using Flask—a micro web framework for Python—and SQLAlchemy, an ORM (Object Relational Mapper) that simplifies database interactions.

What is CRUD?

CRUD is an acronym that stands for Create, Read, Update, and Delete. These four operations are fundamental to any application that interacts with a database. Understanding these concepts is crucial for developing web applications, as they define the basic functionalities users expect.

Use Cases of CRUD Applications

Task Management Systems: Users can create, view, edit, and delete tasks.
Inventory Management: Businesses can track products, suppliers, and orders.
Blog Platforms: Users can manage their posts, comments, and categories.

Setting Up Your Environment

Before diving into the code, let’s set up our development environment. You'll need:

Python (version 3.6 or later)
Flask: A lightweight framework to set up web applications.
SQLAlchemy: An ORM for database communication.
Flask-SQLAlchemy: Extension for adding SQLAlchemy support to Flask.

Step 1: Install Required Packages

First, make sure you have Python installed. Then, create a virtual environment and install Flask and SQLAlchemy.

# Create a virtual environment
python -m venv venv
# Activate the virtual environment
# On Windows
venv\Scripts\activate
# On macOS/Linux
source venv/bin/activate
# Install Flask and Flask-SQLAlchemy
pip install Flask Flask-SQLAlchemy

Building the Application

Step 2: Create the Flask App

Create a new directory for your project and create a file named app.py:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

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

# Run the application
if __name__ == "__main__":
    app.run(debug=True)

Step 3: Define Your Data Model

Let’s create a simple data model for our application. For this example, we’ll make a basic Item model.

class Item(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    description = db.Column(db.String(200), nullable=True)

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

Step 4: Initialize the Database

Once your model is defined, you need to create the database and tables. Run the following commands in your Python shell:

from app import db
db.create_all()

Step 5: Implement CRUD Operations

Now, let's implement the CRUD operations in our Flask app.

Create

To create a new item, you can set up a route and a simple HTML form.

from flask import request, redirect, url_for, render_template

@app.route('/item/new', methods=['GET', 'POST'])
def new_item():
    if request.method == 'POST':
        item_name = request.form['name']
        item_description = request.form['description']
        new_item = Item(name=item_name, description=item_description)
        db.session.add(new_item)
        db.session.commit()
        return redirect(url_for('list_items'))
    return render_template('new_item.html')

Read

To read and display all items, create a route:

@app.route('/items', methods=['GET'])
def list_items():
    items = Item.query.all()
    return render_template('list_items.html', items=items)

Update

For updating an item, you’ll need to fetch the existing data and render it in a form.

@app.route('/item/edit/<int:item_id>', methods=['GET', 'POST'])
def edit_item(item_id):
    item = Item.query.get_or_404(item_id)
    if request.method == 'POST':
        item.name = request.form['name']
        item.description = request.form['description']
        db.session.commit()
        return redirect(url_for('list_items'))
    return render_template('edit_item.html', item=item)

Delete

Finally, implement the delete functionality:

@app.route('/item/delete/<int:item_id>', methods=['POST'])
def delete_item(item_id):
    item = Item.query.get_or_404(item_id)
    db.session.delete(item)
    db.session.commit()
    return redirect(url_for('list_items'))

Step 6: Create HTML Templates

You'll need to create basic HTML templates for your forms and lists. Here’s an example of what you might have for new_item.html:

<!DOCTYPE html>
<html>
<head>
    <title>New Item</title>
</head>
<body>
    <h1>Create a New Item</h1>
    <form method="POST">
        <input type="text" name="name" placeholder="Item Name" required>
        <input type="text" name="description" placeholder="Description">
        <button type="submit">Add Item</button>
    </form>
</body>
</html>

Step 7: Run Your Application

Finally, run your application:

python app.py

Visit http://127.0.0.1:5000/items in your browser to see your CRUD application in action!

Conclusion

In this article, we explored how to build a simple CRUD application using Flask and SQLAlchemy. We covered the basics, from setting up your environment to implementing the core CRUD functionalities.

Key Takeaways

Flask is great for creating lightweight web applications.
SQLAlchemy simplifies database interactions.
Understanding CRUD operations is essential for any application that handles data.

By following this guide, you can begin building more complex applications and dive deeper into Flask and SQLAlchemy's powerful features. Happy coding!