ORM framework Flask-SQLAlchemy in Python in practice

ORM (Object-Relational Mapping) is a programming technology that maps table data in a relational database to objects in a programming language, allowing program developers to operate the database in an object-oriented manner. Flask-SQLAlchemy is a powerful ORM framework that can greatly simplify the operation of Python programs on relational databases.

This article will introduce the use of the Flask-SQLAlchemy framework in detail through an example.

1. Environment configuration

Before learning Flask-SQLAlchemy, we need to install Flask and SQLAlchemy modules first. You can install it using the pip command in the Python environment.

pip install Flask
pip install SQLAlchemy

2. Database configuration

Configure the MySQL database as the persistent storage of the project, before creating Flask-SQLAlchemy object, just pass the following parameters:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

First parameter: flask Application example

Second parameter: Database connection URI

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:password@localhost:3306/test'

Turn off the SQLALCHEMY_TRACK_MODIFICATIONS option to improve program running efficiency

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

Initialize the db object

db = SQLAlchemy(app)

Call app.config to set the configuration parameters of the Flask application instance. The SQLALCHEMY_DATABASE_URI parameter is used to specify the connected database type, user name, password, IP address, port number, database name and other information.

3. ORM implementation

Define data model

First, we need to define the data model, which is the mapping object of ORM. Here we take student information as an example , define a Student class:

from datetime import datetime
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

SQLAlchemy ORM design model

class Student(db.Model):

# 定义表名
__tablename__ = 'student'
# 定义表结构，其中id为主键，自增长
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), nullable=False)
gender = db.Column(db.String(2), nullable=False)
birthday = db.Column(db.Date, default=datetime.now())
address = db.Column(db.String(200), nullable=False)

# 类对象序列化成字典
def to_dict(self):
    return {c.name: getattr(self, c.name, None) for c in self.__table__.columns}

In the Student class, we define the table structures of __tablename__, id, name, gender, birthday, and address. Among them, __tablename__ is used to specify the table name, id is used to specify the primary key and grow automatically, and the fields name, gender, birthday, and address are used to store information about the student's name, gender, birthday, and address.

Add, delete, modify and query operations

Next, we implement the add, delete, modify and query operations:

(1) Add student information

@app.route(' /add', methods=['POST'])
def add_student():

student = Student()
student.name = request.form.get('name')
student.gender = request.form.get('gender')
student.birthday = datetime.strptime(request.form.get('birthday'), '%Y-%m-%d').date()
student.address = request.form.get('address')
db.session.add(student)
db.session.commit()
return jsonify({'code': 200, 'msg': 'add student success.'})

First get the submitted form data through request.form.get(), then create the Student object and set the attribute value , finally add the object to the database through db.session.add(), and commit the transaction through db.session.commit().

(2) Delete student information

@app.route('/delete/', methods=['DELETE'])
def delete_student(id ):

student = Student.query.get(id)
if student:
    db.session.delete(student)
    db.session.commit()
    return jsonify({'code': 200, 'msg': 'delete student success.'})
else:
    return jsonify({'code': 404, 'msg': 'student not found.'})

Pass the student id parameter, obtain the student instance through the query.get() method, and use the db.session.delete() method to delete it from the database and delete it from the database through db.session .commit() commits the transaction.

(3) Modify student information

@app.route('/update/', methods=['PUT'])
def update_student(id ):

student = Student.query.get(id)
if student:
    student.name = request.form.get('name')
    student.gender = request.form.get('gender')
    student.birthday = datetime.strptime(request.form.get('birthday'), '%Y-%m-%d').date()
    student.address = request.form.get('address')
    db.session.commit()
    return jsonify({'code': 200, 'msg': 'update student success.'})
else:
    return jsonify({'code': 404, 'msg': 'student not found.'})

Similarly obtain the student instance based on the student id parameter. After modifying the student information, use db.session.commit() to submit the transaction.

(4) Query student information

@app.route('/search')
def search_student():

students = Student.query.all()
if students:
    return jsonify({'code': 200, 'msg': 'search student success.', 'data': [student.to_dict() for student in students]})
else:
    return jsonify({'code': 404, 'msg': 'student not found.'})

Use query.all() method Query all student information in the Student table, and use list comprehension to convert the student object list into a dictionary list and return it.

4. Summary

Flask-SQLAlchemy is a very powerful ORM framework that can make Python code for database operations simpler and more readable. This article provides an in-depth introduction to the use of Flask-SQLAlchemy through an example.

In actual development, we can define the data model and implement addition, deletion, modification and query operations in a manner similar to this article. The complexity of these operations is very low. Using the Flask-SQLAlchemy framework allows us to improve development efficiency and reduce program maintenance costs.

The above is the detailed content of ORM framework Flask-SQLAlchemy in Python in practice. For more information, please follow other related articles on the PHP Chinese website!