Flask-Datenbankoperationen

In Flask sind Datenbankoperationen ein wichtiger Aspekt beim Erstellen von Webanwendungen.

Flask bietet mehrere Möglichkeiten, mit Datenbanken zu interagieren, einschließlich der direkten Verwendung von SQL und der Nutzung von ORM-Werkzeugen (Object-Relational Mapping) wie SQLAlchemy.

Das Folgende ist eine detaillierte Erklärung der Flask-Datenbankoperationen, einschließlich grundlegender Operationen mit SQLAlchemy und der direkten Ausführung von SQL-Anweisungen.

  1. SQLAlchemy verwenden: Modelle definieren, die Datenbank konfigurieren und grundlegende CRUD-Operationen ausführen.
  2. Datenbanken erstellen und verwalten: Verwendendb.create_all()Eine Tabelle erstellen.
  3. CRUD-Operationen: Datensätze hinzufügen, lesen, aktualisieren und löschen.
  4. Abfrageoperationen: Grundlegende und komplexe Abfragen ausführen, einschließlich Sortierung und Paginierung.
  5. Flask-Migrate: Flask-Migrate verwenden, um Datenbankmigrationen zu verwalten.
  6. Raw SQL ausführen: Raw-SQL-Anweisungen für Datenbankoperationen verwenden.

1. SQLAlchemy verwenden

SQLAlchemy ist eine leistungsstarke ORM-Bibliothek, die Datenbankoperationen vereinfacht, indem sie über Python-Objekte mit Datenbanktabellen interagiert.

Flask-SQLAlchemy ist eine Flask-Erweiterung zur Integration von SQLAlchemy.

Flask-SQLAlchemy installieren

pip install flask-sqlalchemy

SQLAlchemy konfigurieren

Code der Datei app.py:

Beispiel

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'  # SQLite-Datenbank verwenden
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

2. Modell definieren

Ein Modell ist eine Python-Klasse für eine Datenbanktabelle; jede Modellklasse repräsentiert eine Tabelle in der Datenbank.

Beispiel

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)

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

db.Model: Alle Modellklassen müssen von db.Model erben.

db.Column: Definieren Sie die Felder des Modells und geben Sie Attribute wie Feldtyp, ob es ein Primärschlüssel ist, ob es eindeutig ist, ob es null sein kann usw. an.

3. Datenbanken erstellen und verwalten

Die Datenbank und Tabellen erstellen

Nachdem du die Modelle definiert hast, kannst du die von SQLAlchemy bereitgestellten Methoden verwenden, um die Datenbank und die Tabellen zu erstellen.

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

db.create_all(): Tabellen erstellen, die allen im aktuellen Kontext definierten Modellen entsprechen.

4. Grundlegende CRUD-Operationen

Datensatz erstellen

Beispiel

@app.route('/add_user')
def add_user():
    new_user = User(username='john_doe', email='[email protected]')
    db.session.add(new_user)
    db.session.commit()
    return 'Benutzer hinzugefügt!'

db.session.add(new_user): Fügt das neue Benutzerobjekt zur Sitzung hinzu.

db.session.commit(): Führt einen Commit für die Transaktion aus, um Änderungen in der Datenbank zu speichern.

Datensatz lesen

Beispiel

@app.route('/get_users')
def get_users():
    users = User.query.all()  # Alle Benutzer abrufen
    return '<br>'.join([f'{user.username} ({user.email})' for user in users])

User.query.all(): Alle Benutzerdatensätze abfragen.

Datensatz aktualisieren

Beispiel

@app.route('/update_user/<int:user_id>')
def update_user(user_id):
    user = User.query.get(user_id)
    if user:
        user.username = 'new_username'
        db.session.commit()
        return 'Benutzer aktualisiert!'
    return 'Benutzer nicht gefunden!'

User.query.get(user_id): Einen einzelnen Benutzerdatensatz anhand des Primärschlüssels abfragen.

Feldwerte aktualisieren und die Transaktion festschreiben.

Datensatz löschen

Beispiel

@app.route('/delete_user/<int:user_id>')
def delete_user(user_id):
    user = User.query.get(user_id)
    if user:
        db.session.delete(user)
        db.session.commit()
        return 'Benutzer gelöscht!'
    return 'Benutzer nicht gefunden!'

db.session.delete(user): Den Benutzerdatensatz löschen und die Transaktion festschreiben.

5. Abfrageoperationen

SQLAlchemy bietet umfangreiche Abfragefunktionalität, mit der Sie verschiedene Abfrageoperationen über Abfrageobjekte durchführen können.

Einfache Abfrage

users = User.query.filter_by(username='john_doe').all()

filter_by(): Filtert Datensätze nach Feldwert.

Komplexe Abfrage

from sqlalchemy import or_

users = User.query.filter(or_(User.username == 'john_doe', User.email == '[email protected]')).all()

or_(): Wird zum Ausführen komplexer Abfragebedingungen verwendet.

Sortierung und Paginierung

users = User.query.order_by(User.username).paginate(page=1, per_page=10)

order_by(): Sortiert nach dem angegebenen Feld.

paginate(): Paginierte Abfrage.

6. Verwenden Sie Flask-Migrate für Migrationen.

Flask-Migrate ist eine Erweiterung für Datenbankmigrationen, basierend auf Alembic, die Ihnen hilft, die Versionierung der Datenbank zu verwalten.

Flask-Migrate installieren

pip install flask-migrate

Flask-Migrate konfigurieren

Code der Datei app.py:

from flask_migrate import Migrate

migrate = Migrate(app, db)

Migration initialisieren

flask db init

Migrationsskripte erstellen

flask db migrate -m "Initial migration."

Migration anwenden

flask db upgrade
  • flask db init: Migrationsumgebung initialisieren.
  • flask db migrate -m "message": Migrationsskript erstellen.
  • flask db upgrade: Migrationen auf die Datenbank anwenden.

7. Ausführen von Raw SQL

Obwohl SQLAlchemy ORM-Funktionalität bietet, können Sie auch Raw-SQL-Anweisungen ausführen.

Beispiel

@app.route('/raw_sql')
def raw_sql():
    result = db.session.execute('SELECT * FROM user')
    return '<br>'.join([str(row) for row in result])

db.session.execute(): Führt eine rohe SQL-Abfrage aus.

Verbinden mit und Betreiben einer MySQL-Datenbank in Flask

Das Verbinden mit und Betreiben einer MySQL-Datenbank in Flask umfasst typischerweise die Verwendung von SQLAlchemy oder die direkte Verwendung von Python-Treibern für MySQL. Im Folgenden finden Sie detaillierte Schritte, einschließlich der Verwendung von Flask-SQLAlchemy und der direkten Verwendung von Python-Treibern für MySQL.

1. Flask-SQLAlchemy verwenden, um eine Verbindung zu MySQL herzustellen

Flask-SQLAlchemy ist eine Flask-Erweiterung, die die Konfiguration und Nutzung von SQLAlchemy vereinfacht. Um eine Verbindung zu MySQL herzustellen, müssen Sie Flask-SQLAlchemy und einen MySQL-Treiber installieren.

Installieren Sie die erforderlichen Bibliotheken:

pip install flask-sqlalchemy mysqlclient
  • flask-sqlalchemy: Flask-Erweiterung für SQLAlchemy.
  • mysqlclient: Python-Treiber für die MySQL-Datenbank.

Flask-SQLAlchemy konfigurieren

Code der Datei app.py:

Beispiel

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://username:password@localhost/dbname'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

code>SQLALCHEMY_DATABASE_URI: Legt die Datenbankverbindungs-URI fest, das Format istmysql://username:password@localhost/dbname。

  • username: MySQL-Benutzername.
  • password: MySQL-Passwort.
  • localhost: MySQL-Hostadresse (normalerweise local istlocalhost）。
  • dbname: Datenbankname.

Modelle definieren und grundlegende Operationen ausführen

Code der Datei app.py:

Beispiel

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)

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

@app.route('/')
def index():
    users = User.query.all()
    return '<br>'.join([f'{user.username} ({user.email})' for user in users])

if __name__ == '__main__':
    with app.app_context():
        db.create_all()  # Datenbanktabelle erstellen
    app.run(debug=True)

MySQL-Python-Treiber direkt verwenden.

Wenn Sie nicht SQLAlchemy verwenden möchten, sondern direkt den Python-Treiber von MySQL, können Sie die Bibliothek mysql-connector-python oder PyMySQL verwenden.

mysql-connector-python installieren:

pip install mysql-connector-python

PyMySQL installieren (wenn Sie PyMySQL verwenden möchten):

pip install PyMySQL

mysql-connector-python zum Herstellen einer Verbindung mit MySQL verwenden

Code der Datei app.py:

Beispiel

from flask import Flask, request, jsonify
import mysql.connector

app = Flask(__name__)

def get_db_connection():
    connection = mysql.connector.connect(
        host='localhost',
        user='username',
        password='password',
        database='dbname'
    )
    return connection

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

    connection = get_db_connection()
    cursor = connection.cursor()
    cursor.execute('INSERT INTO user (username, email) VALUES (%s, %s)', (name, email))
    connection.commit()
    cursor.close()
    connection.close()

    return 'Benutzer hinzugefügt!'

@app.route('/get_users')
def get_users():
    connection = get_db_connection()
    cursor = connection.cursor(dictionary=True)
    cursor.execute('SELECT * FROM user')
    users = cursor.fetchall()
    cursor.close()
    connection.close()

    return jsonify(users)

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

Verwenden Sie PyMySQL, um eine Verbindung zu MySQL herzustellen, Code der Datei app.py:

Beispiel

from flask import Flask, request, jsonify
import pymysql

app = Flask(__name__)

def get_db_connection():
    connection = pymysql.connect(
        host='localhost',
        user='username',
        password='password',
        database='dbname',
        cursorclass=pymysql.cursors.DictCursor
    )
    return connection

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

    connection = get_db_connection()
    with connection.cursor() as cursor:
        cursor.execute('INSERT INTO user (username, email) VALUES (%s, %s)', (name, email))
        connection.commit()

    connection.close()
    return 'Benutzer hinzugefügt!'

@app.route('/get_users')
def get_users():
    connection = get_db_connection()
    with connection.cursor() as cursor:
        cursor.execute('SELECT * FROM user')
        users = cursor.fetchall()

    connection.close()
    return jsonify(users)

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