Wie man viele-zu-viele Datenbankbeziehungen mit Flask-SQLAlchemy verwendet

Der Autor hat den Free and Open Source Fund ausgewählt, um eine Spende im Rahmen des Write for Donations-Programms zu erhalten.

Einführung

Flask ist ein leichtgewichtiges Python-Webframework, das nützliche Tools und Funktionen für die Erstellung von Webanwendungen in der Python-Sprache bietet. SQLAlchemy ist ein SQL-Toolkit, das effizienten und leistungsstarken Datenbankzugriff für relationale Datenbanken ermöglicht. Es bietet Möglichkeiten zur Interaktion mit verschiedenen Datenbank-Engines wie SQLite, MySQL und PostgreSQL. Es bietet Ihnen Zugriff auf die SQL-Funktionalitäten der Datenbank. Es bietet auch einen Object Relational Mapper (ORM), der es Ihnen ermöglicht, Abfragen zu erstellen und Daten mit Python-Objekten und -Methoden zu verarbeiten. Flask-SQLAlchemy ist eine Flask-Erweiterung, die die Verwendung von SQLAlchemy mit Flask erleichtert, indem sie Ihnen Tools und Methoden zur Verfügung stellt, um mit Ihrer Datenbank in Ihren Flask-Anwendungen über SQLAlchemy zu interagieren.

A many-to-many database relationship is a relationship between two database tables where a record in each table can reference several records in the other table. For example, in a blog, a table for posts can have a many-to-many relationship with a table for storing authors. Each post can have many authors, and each author can write many posts. Therefore, there is a many-to-many relationship between posts and authors. For another example, in a social media application, each post may have many hashtags, and each hashtag may have many posts.

In diesem Tutorial werden Sie eine Anwendung, die mit Flask und Flask-SQLAlchemy erstellt wurde, durch Hinzufügen einer Many-to-Many-Beziehung modifizieren. Sie werden eine Beziehung zwischen Beiträgen und Tags haben, wobei jeder Blogbeitrag mehrere Tags haben kann und jeder Tag mit mehreren markierten Beiträgen versehen werden kann.

Obwohl Sie dieses Tutorial eigenständig durchführen können, ist es auch eine Fortsetzung des Tutorials Wie man One-to-Many-Datenbankbeziehungen mit Flask-SQLAlchemy verwendet, in dem Sie eine Mehrtabellen-Datenbank mit einer One-to-Many-Beziehung zwischen Beiträgen und Kommentaren in einer Blogging-Anwendung erstellen.

Am Ende des Tutorials wird Ihre Anwendung über eine neue Funktion zum Hinzufügen von Tags zu Beiträgen verfügen. Beiträge können mit mehreren Tags versehen werden, und auf jeder Tag-Seite werden alle mit ihm versehenen Beiträge angezeigt.

Voraussetzungen

• Eine lokale Python 3-Programmierumgebung. Befolgen Sie das Tutorial für Ihre Distribution in der Serie So installieren und konfigurieren Sie eine lokale Programmierumgebung für Python 3. In diesem Tutorial nennen wir unser Projektverzeichnis flask_app.

• Ein Verständnis grundlegender Flask-Konzepte wie Routen, Ansichtsfunktionen und Vorlagen. Wenn Sie mit Flask nicht vertraut sind, schauen Sie sich Wie man Ihre erste Webanwendung mit Flask und Python erstellt und Wie man Vorlagen in einer Flask-Anwendung verwendet an.

• Ein Verständnis grundlegender HTML-Konzepte. Sie können unsere Tutorialreihe Wie man eine Website mit HTML erstellt für Hintergrundwissen durchgehen.

• (Optional) Im Schritt 1 klonen Sie die Blogging-Anwendung, an der Sie in diesem Tutorial arbeiten werden. Sie können jedoch optional das Tutorial „So verwenden Sie One-to-Many-Datenbankbeziehungen mit Flask-SQLAlchemy“ durchgehen. Sie können den endgültigen Code auf dieser Seite abrufen.

Schritt 1 — Einrichten der Webanwendung

In diesem Schritt richten Sie die Blogging-Anwendung so ein, dass sie für Modifikationen bereit ist. Sie werden auch die Flask-SQLAlchemy-Datenbankmodelle und die Flask-Routen überprüfen, um die Struktur der Anwendung zu verstehen. Wenn Sie das Tutorial im Abschnitt „Voraussetzungen“ befolgt haben und den Code sowie die virtuelle Umgebung noch auf Ihrem lokalen Rechner haben, können Sie diesen Schritt überspringen.

Um eine viele-zu-viele Beziehung zu einer Flask-Webanwendung mit Flask-SQLAlchemy hinzuzufügen, verwenden Sie den Anwendungscode des vorherigen Tutorials, der ein Blogsystem mit der Möglichkeit zum Hinzufügen und Anzeigen von Beiträgen, Kommentieren von Beiträgen sowie Lesen und Löschen von vorhandenen Kommentaren ist.

Klonen Sie das Repository und benennen Sie es von flask-slqa-bloggy in flask_app mit folgendem Befehl um:

git clone https://github.com/do-community/flask-slqa-bloggy flask_app

Wechseln Sie zu flask_app:

cd flask_app

Dann erstellen Sie eine neue virtuelle Umgebung:

python -m venv env

Aktivieren Sie die Umgebung:

source env/bin/activate

Installieren Sie Flask und Flask-SQLAlchemy:

pip install Flask Flask-SQLAlchemy

Legen Sie als nächstes die folgenden Umgebungsvariablen fest:

export FLASK_APP=app
export FLASK_ENV=development

FLASK_APP gibt die Anwendung an, an der Sie gerade arbeiten, in diesem Fall app.py. FLASK_ENV gibt den Modus an. Sie setzen ihn auf development für den Entwicklungsmodus; dies ermöglicht es Ihnen, die Anwendung zu debuggen. Denken Sie daran, diesen Modus nicht in einer Produktionsumgebung zu verwenden.

Öffnen Sie dann die Flask-Shell, um die Datenbanktabellen zu erstellen:

flask shell

Importieren Sie dann das db-Flask-SQLAlchemy-Datenbankobjekt, das Post-Modell und das Comment-Modell und erstellen Sie die Datenbanktabellen mit der Funktion db.create_all():

from app import db, Post, Comment
db.create_all()
exit()

Füllen Sie dann die Datenbank mit dem Programm init_db.py:

python init_db.py

Dies fügt der Datenbank drei Beiträge und vier Kommentare hinzu.

Starten Sie den Entwicklungsserver:

flask run

Wenn Sie Ihren Browser öffnen, läuft die Anwendung unter der folgenden URL:

http://127.0.0.1:5000/

Sie sehen eine Seite ähnlich der folgenden:

Wenn Sie einen Fehler erhalten, stellen Sie sicher, dass Sie die oben genannten Schritte korrekt befolgt haben.

Um den Entwicklungsserver zu stoppen, verwenden Sie STRG + C.

Als nächstes werden Sie die Flask-SQLAlchemy-Datenbankmodelle durchgehen, um die aktuellen Beziehungen zwischen den Tabellen zu verstehen. Wenn Sie mit dem Inhalt der Datei app.py vertraut sind, können Sie zum nächsten Schritt übergehen.

Öffnen Sie die Datei app.py:

nano app.py

Der Dateiinhalt lautet wie folgt:

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

basedir = os.path.abspath(os.path.dirname(__file__))

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] =\
           'sqlite:///' + os.path.join(basedir, 'database.db')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False


db = SQLAlchemy(app)


class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100))
    content = db.Column(db.Text)
    comments = db.relationship('Comment', backref='post')

    def __repr__(self):
        return f'<Post "{self.title}">'


class Comment(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text)
    post_id = db.Column(db.Integer, db.ForeignKey('post.id'))

    def __repr__(self):
        return f'<Comment "{self.content[:20]}...">'


@app.route('/')
def index():
    posts = Post.query.all()
    return render_template('index.html', posts=posts)


@app.route('/<int:post_id>/', methods=('GET', 'POST'))
def post(post_id):
    post = Post.query.get_or_404(post_id)
    if request.method == 'POST':
        comment = Comment(content=request.form['content'], post=post)
        db.session.add(comment)
        db.session.commit()
        return redirect(url_for('post', post_id=post.id))

    return render_template('post.html', post=post)


@app.route('/comments/')
def comments():
    comments = Comment.query.order_by(Comment.id.desc()).all()
    return render_template('comments.html', comments=comments)


@app.post('/comments/<int:comment_id>/delete')
def delete_comment(comment_id):
    comment = Comment.query.get_or_404(comment_id)
    post_id = comment.post.id
    db.session.delete(comment)
    db.session.commit()
    return redirect(url_for('post', post_id=post_id))

Hier haben Sie zwei Datenbankmodelle, die zwei Tabellen repräsentieren:

• Post: Das eine ID-Spalte, einen Titel, Inhalt und eine Eins-zu-Viele-Beziehung mit der Kommentartabelle hat.

• Comment: Das eine ID-Spalte, eine Spalte für Inhalt und eine post_id-Spalte hat, um auf den Beitrag zu verweisen, zu dem der Kommentar gehört.

Unter den Modellen haben Sie die folgenden Routen:

• /: Die Indexseite, die alle Beiträge in der Datenbank anzeigt.
• /<int:post_id>/: Die einzelne Beitragseite. Zum Beispiel zeigt der Link http://127.0.0.1:5000/2/ die Details des zweiten Beitrags in der Datenbank und seine Kommentare an.
• /comments/: Eine Seite, die alle Kommentare in der Datenbank anzeigt und Links zum Beitrag enthält, auf dem jeder Kommentar veröffentlicht wurde.
• /comments/<int:comment_id>/delete: Eine Route, die einen Kommentar über eine Kommentar löschen Schaltfläche löscht.

Schließen Sie die Datei app.py.

Im nächsten Schritt werden Sie eine viele-zu-viele-Beziehung verwenden, um eine Verknüpfung zwischen zwei Tabellen zu erstellen.

Schritt 2 – Einrichten von Datenbankmodellen für eine viele-zu-viele-Beziehung

In diesem Schritt fügen Sie ein Datenbankmodell hinzu, das die Tabelle der Tags repräsentiert. Sie werden es mit der vorhandenen Beiträge-Tabelle mithilfe einer Verbindungstabelle verknüpfen, die eine Tabelle ist, die Ihre beiden Tabellen in einer viele-zu-viele-Beziehung verbindet. Eine viele-zu-viele-Beziehung verknüpft zwei Tabellen, bei der jedes Element in einer Tabelle viele zugehörige Elemente in der anderen Tabelle hat. In der Verbindungstabelle verweist jeder Beitrag auf seine Tags und jeder Tag verweist auf die mit ihm markierten Beiträge. Sie fügen auch ein paar Beiträge und Tags in Ihre Datenbank ein, drucken Beiträge mit ihren Tags aus und drucken Tags und ihre zugehörigen Beiträge aus.

Angenommen, Sie haben eine einfache Tabelle für Blog-Beiträge wie folgt:

Posts
+----+-----------------------------------+
| id | content                           |
+----+-----------------------------------+
| 1  | A post on life and death          |
| 2  | A post on joy                     |
+----+-----------------------------------+

Und eine Tabelle für Tags wie folgt:

Tags
+----+-------+
| id | name  |
+----+-------+
| 1  | life  |
| 2  | death |
| 3  | joy   |
+----+-------+

Angenommen, Sie möchten einen Beitrag über Leben und Tod mit den Tags Leben und Tod versehen. Sie könnten dies tun, indem Sie eine neue Zeile in der Posts-Tabelle wie folgt hinzufügen:

Posts
+----+-----------------------------------+------+
| id | content                           | tags |
+----+-----------------------------------+------+
| 1  | A post on life and death          | 1, 2 |
| 2  | A post on joy                     |      |
+----+------------------------------------------+

Dieser Ansatz funktioniert nicht, da jede Spalte nur einen Wert haben sollte. Wenn Sie mehrere Werte haben, werden grundlegende Operationen wie das Hinzufügen und Aktualisieren von Daten umständlich und langsam. Stattdessen sollte es eine dritte Tabelle geben, die Primärschlüssel von verwandten Tabellen referenziert – diese Tabelle wird oft als Verbindungstabelle oder Join-Tabelle bezeichnet und speichert IDs jedes Elements aus jeder Tabelle.

Hier ist ein Beispiel für eine Verbindungstabelle, die zwischen Beiträgen und Tags verlinkt:

post_tag
+----+---------+-------------+
| id | post_id | tag_id      |
+----+---------+-------------+
| 1  | 1       | 1           |
| 2  | 1       | 2           |
+----+---------+-------------+

In der ersten Zeile bezieht sich der Beitrag mit der ID 1 (das heißt, Ein Beitrag über Leben und Tod) auf den Tag mit der ID 1 (Leben). In der zweiten Zeile bezieht sich derselbe Beitrag auch auf den Tag mit der ID 2 (Tod). Das bedeutet, dass der Beitrag mit den Tags Leben und Tod versehen ist. Ebenso können Sie jeden Beitrag mit mehreren Tags versehen.

Jetzt werden Sie die Datei app.py ändern, um ein neues Datenbankmodell hinzuzufügen, das die Tabelle repräsentiert, die Sie zum Speichern von Tags verwenden werden. Sie werden auch eine Verbindungstabelle namens post_tag hinzufügen, die Beiträge mit Tags verknüpft.

Öffnen Sie zunächst app.py, um eine Beziehung zwischen Beiträgen und Tags herzustellen:

nano app.py

Fügen Sie eine post_tag-Tabelle und ein Tag-Modell unterhalb des db-Objekts und über dem Post-Modell hinzu, und fügen Sie dann eine tags-Beziehungsspalte zum Post-Modell hinzu, damit Sie auf die Tags eines Beitrags über post.tags zugreifen und auf Beiträge eines Tags über tag.posts zugreifen können:

# ...

db = SQLAlchemy(app)


post_tag = db.Table('post_tag',
                    db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
                    db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
                    )


class Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))

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



class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100))
    content = db.Column(db.Text)
    comments = db.relationship('Comment', backref='post')
    tags = db.relationship('Tag', secondary=post_tag, backref='posts')

    def __repr__(self):
        return f'<Post "{self.title}">'

Speichern und schließen Sie die Datei.

Hier verwenden Sie die db.Table()-Funktion, um eine Tabelle mit zwei Spalten zu erstellen. Für Verbindungstabellen ist es bewährte Praxis, eine Tabelle anstelle eines Datenbankmodells zu verwenden.

Die post_tag-Tabelle hat zwei Spalten, die zwei Fremdschlüssel repräsentieren, die Schlüssel, die verwendet werden, um Primärschlüsselspalten in einer anderen Tabelle zu referenzieren:

• post_id: Ein ganzzahliger Fremdschlüssel, der die Post-ID repräsentiert und auf die ID-Spalte in der post-Tabelle verweist.
• tag_id: Ein ganzzahliger Fremdschlüssel, der die Tag-ID repräsentiert und auf die ID-Spalte in der tag-Tabelle verweist.

Diese Schlüssel etablieren die Beziehungen zwischen den Tabellen.

Unterhalb der post_tag-Tabelle erstellen Sie ein Tag-Modell, das die Tabelle darstellt, in der Sie Ihre Tags speichern werden. Diese Tags-Tabelle hat zwei Spalten:

• id: Die ID des Tags.
• name: Der Name des Tags.

Sie verwenden den Namen des Tags in der speziellen __repr__()-Methode, um jedem Tag-Objekt eine klare Zeichenfolgenrepräsentation für Debugging-Zwecke zu geben.

Du fügst eine tags-Klassenvariable zum Post-Modell hinzu. Du verwendest die db.relationship()-Methode und übergibst ihr den Namen des Tag-Modells (Tag in diesem Fall).

Du übergibst die post_tag-Assoziationstabelle dem secondary-Parameter, um eine viele-zu-viele-Beziehung zwischen Beiträgen und Tags herzustellen.

Du verwendest den backref-Parameter, um einen Rückverweis hinzuzufügen, der sich wie eine Spalte im Tag-Modell verhält. Auf diese Weise kannst du auf die Beiträge des Tags über tag.posts und die Tags eines Beitrags über post.tags zugreifen. Ein Beispiel dazu wird später gezeigt.

Anschließend bearbeite die Python-Datei init_db.py, um die Datenbank zu ändern, indem du die post_tag-Assoziationstabelle und die Tags-Tabelle hinzufügst, die auf dem Tag-Modell basieren:

nano init_db.py

Bearbeite die Datei, damit sie wie folgt aussieht:

from app import db, Post, Comment, Tag

db.drop_all()
db.create_all()

post1 = Post(title='Post The First', content='Content for the first post')
post2 = Post(title='Post The Second', content='Content for the Second post')
post3 = Post(title='Post The Third', content='Content for the third post')

comment1 = Comment(content='Comment for the first post', post=post1)
comment2 = Comment(content='Comment for the second post', post=post2)
comment3 = Comment(content='Another comment for the second post', post_id=2)
comment4 = Comment(content='Another comment for the first post', post_id=1)

tag1 = Tag(name='animals')
tag2 = Tag(name='tech')
tag3 = Tag(name='cooking')
tag4 = Tag(name='writing')

post1.tags.append(tag1)  # Tagge den ersten Beitrag mit 'Tiere'
post1.tags.append(tag4)  # Tagge den ersten Beitrag mit 'Schreiben'
post3.tags.append(tag3)  # Tagge den dritten Beitrag mit 'Kochen'
post3.tags.append(tag2)  # Tagge den dritten Beitrag mit 'Technik'
post3.tags.append(tag4)  # Tagge den dritten Beitrag mit 'Schreiben'


db.session.add_all([post1, post2, post3])
db.session.add_all([comment1, comment2, comment3, comment4])
db.session.add_all([tag1, tag2, tag3, tag4])

db.session.commit()

Speichere und schließe die Datei.

Hier importieren Sie das Tag-Modell. Sie löschen alles in der Datenbank mit der db.drop_all()-Funktion, um die Tags und post_tag-Tabellen sicher hinzuzufügen und etwaige häufige Probleme im Zusammenhang mit dem Hinzufügen neuer Tabellen zu einer Datenbank zu vermeiden. Anschließend erstellen Sie alle Tabellen neu mit der db.create_all()-Funktion.

Nach dem Code aus dem vorherigen Tutorial, der die Beiträge und Kommentare deklariert, verwenden Sie das Tag-Modell, um vier Tags zu erstellen.

Sie fügen dann Tags zu Beiträgen hinzu, indem Sie das tags-Attribut verwenden, das über die Zeile tags = db.relationship('Tag', secondary=post_tag, backref='posts') in der app.py-Datei hinzugefügt wurde. Sie weisen Beiträgen Tags zu, indem Sie eine append()-Methode ähnlich wie bei Python-Listen verwenden.

Als nächstes fügen Sie die erstellten Tags der Datenbanksitzung mit der db.session.add_all()-Funktion hinzu.

Führen Sie das Programm init_db.py aus, um die Änderungen an der Datenbank anzuwenden:

python init_db.py

Das Programm sollte erfolgreich ohne Ausgabe ausgeführt werden. Wenn Sie einen Fehler sehen, stellen Sie sicher, dass Sie die init_db.py-Datei ordnungsgemäß geändert haben.

Um sich die Beiträge und Tags anzusehen, die sich derzeit in der Datenbank befinden, öffnen Sie die Flask-Shell:

flask shell

Führen Sie den folgenden Python-Code aus, der durch Beiträge und Tags iteriert:

from app import Post

posts = Post.query.all()

for post in posts:
    print(post.title)
    print(post.tags)
    print('---')

Hier importieren Sie das Post-Modell aus app.py. Sie fragen die Beiträge-Tabelle ab und holen alle Beiträge in der Datenbank. Sie durchlaufen die Beiträge und geben den Beitragstitel sowie die Liste der mit jedem Beitrag verknüpften Tags aus.

Sie erhalten eine Ausgabe ähnlich wie folgt:

Output
Post The First
[<Tag "animals">, <Tag "writing">]
---
Post The Third
[<Tag "cooking">, <Tag "tech">, <Tag "writing">]
---
Post The Second
[]
---

Sie können auf Tag-Namen über tag.name zugreifen, wie im folgenden Beispiel demonstriert, das Sie über die Flask-Shell ausführen können:

from app import Post

posts = Post.query.all()

for post in posts:
    print('TITLE: ', post.title)
    print('-')
    print('TAGS:')
    for tag in post.tags:
        print('> ', tag.name)
    print('-'*30)

Hier durchlaufen Sie neben dem Ausdrucken des Beitragstitels auch die Tags jedes Beitrags und geben den Tag-Namen aus.

Sie erhalten eine Ausgabe ähnlich wie folgt:

Output
TITLE:  Post The First
-
TAGS:
>  animals
>  writing
------------------------------
TITLE:  Post The Third
-
TAGS:
>  cooking
>  tech
>  writing
------------------------------
TITLE:  Post The Second
-
TAGS:
------------------------------

Wie Sie sehen können, sind die Tags, die Sie den Beiträgen im init_db.py-Programm hinzugefügt haben, ordnungsgemäß mit den Beiträgen verknüpft.

Um eine Demonstration darüber zu sehen, wie Sie auf Beiträge zugreifen, die mit einem bestimmten Tag über tag.posts markiert sind, führen Sie den folgenden Code im Flask-Shell aus:

from app import Tag

writing_tag = Tag.query.filter_by(name='writing').first()

for post in writing_tag.posts:
    print(post.title)
    print('-'*6)
    print(post.content)
    print('-')
    print([tag.name for tag in post.tags])
    print('-'*20)

Sie importieren das Tag-Modell. Dann verwenden Sie die filter_by()-Methode auf dem query-Attribut und übergeben ihm einen name-Parameter, um den Tag writing nach seinem Namen zu erhalten, und Sie erhalten das erste Ergebnis mit der first()-Methode. Sie speichern das Tag-Objekt in einer Variablen namens writing_tag. Für weitere Informationen zur filter_by-Methode siehe Schritt 4 des Tutorials So verwenden Sie Flask-SQLAlchemy zum Interagieren mit Datenbanken in einer Flask-Anwendung.

Sie durchlaufen die mit dem Tag writing markierten Beiträge, auf die Sie über writing_tag.posts zugreifen. Sie drucken den Titel des Beitrags, den Inhalt und eine Liste der Tag-Namen, die Sie mithilfe einer List Comprehension basierend auf den Tags des Beitrags konstruieren, auf die Sie über post.tags zugreifen.

Sie erhalten eine Ausgabe ähnlich der folgenden:

Output
Post The Third
------
Content for the third post
-
['cooking', 'tech', 'writing']
--------------------
Post The First
------
Content for the first post
-
['animals', 'writing']
--------------------

Hier sehen Sie die beiden Beiträge, die mit dem Tag writing markiert wurden, und die Tag-Namen werden in einer Python-Liste angezeigt.

Sie können jetzt Beiträge und ihre Tags abrufen und Beiträge eines bestimmten Tags abrufen.

Sie haben ein Datenbankmodell hinzugefügt, das die Tag-Tabelle repräsentiert. Sie haben zwischen Beiträgen und Tags mithilfe einer Verbindungstabelle verknüpft und einige Tags in die Datenbank eingefügt und Beiträge damit versehen. Sie haben auf Beiträge und ihre Tags zugegriffen sowie auf die Beiträge eines einzelnen Tags. Als nächstes verwenden Sie die Flask-Shell, um neue Beiträge und neue Tags hinzuzufügen und eine Verbindung zwischen Tags und Beiträgen herzustellen. Außerdem lernen Sie, wie Sie Tags von einem Beitrag entfernen.

Schritt 3 – Verwalten von Daten in einer Many-to-Many-Beziehung

In diesem Schritt verwenden Sie die Flask-Shell, um neue Beiträge in die Datenbank einzufügen, Tags hinzuzufügen und eine Verbindung zwischen Beiträgen und Tags herzustellen. Sie greifen auf Beiträge mit ihren Tags zu und erfahren, wie Sie in Many-to-Many-Beziehungen eine Entität von einer anderen trennen.

Zuerst öffnen Sie mit Ihrer Programmierumgebung aktiviert die Flask-Shell, wenn Sie dies noch nicht getan haben:

flask shell

Dann fügen Sie einige Beiträge und Tags hinzu:

from app import db, Post, Tag

life_death_post = Post(title='A post on life and death', content='life and death')
joy_post = Post(title='A post on joy', content='joy')

life_tag = Tag(name='life')
death_tag = Tag(name='death')
joy_tag = Tag(name='joy')

life_death_post.tags.append(life_tag)
life_death_post.tags.append(death_tag)
joy_post.tags.append(joy_tag)

db.session.add_all([life_death_post, joy_post, life_tag, death_tag, joy_tag])

db.session.commit()

Dies erstellt zwei Beiträge und drei Tags. Sie versehen Beiträge mit ihren zugehörigen Tags und verwenden die Methode add_all(), um die neu erstellten Elemente der Datenbanksitzung hinzuzufügen. Dann bestätigen Sie die Änderungen und wenden sie auf die Datenbank mit der Methode commit() an.

Als nächstes verwenden Sie die Flask-Shell, um alle Beiträge und ihre Tags abzurufen, wie Sie es im vorherigen Schritt getan haben:

posts = Post.query.all()

for post in posts:
    print(post.title)
    print(post.tags)
    print('---')

Sie erhalten eine Ausgabe ähnlich der folgenden:

Output
Post The First
[<Tag "animals">, <Tag "writing">]
---
Post The Third
[<Tag "cooking">, <Tag "tech">, <Tag "writing">]
---
Post The Second
[]
---
A post on life and death
[<Tag "life">, <Tag "death">]
---
A post on joy
[<Tag "joy">]
---

Sie können sehen, dass Beiträge zusammen mit ihren Tags hinzugefügt wurden.

Um eine Beziehung zwischen zwei Elementen in einer vielen-zu-vielen-Datenbankbeziehung zu trennen, nehmen wir an, dass der Beitrag Post The Third nicht mehr über Kochen handelt. Daher müssen Sie das Tag cooking daraus entfernen.

Zuerst erhalten Sie den Beitrag und das Tag, das Sie entfernen möchten:

from app import db, Post, Tag
post = Post.query.filter_by(title='Post The Third').first()
tag = Tag.query.filter_by(name='cooking').first()
print(post.title)
print(post.tags)
print(tag.posts)

Hier rufen Sie den Beitrag mit dem Titel Post The Third mithilfe der Methode filter_by() ab. Sie erhalten das Tag cooking. Sie geben den Titel des Beitrags, seine Tags und die Beiträge, die mit dem Tag cooking markiert sind, aus.

Die Methode filter_by() gibt ein Abfrageobjekt zurück, und Sie können die Methode all() verwenden, um eine Liste aller Ergebnisse zu erhalten. Da wir in diesem Fall nur ein Ergebnis erwarten, verwenden Sie jedoch die Methode first(), um das erste (und einzige) Ergebnis zu erhalten. Für weitere Informationen zu den Methoden first() und all() siehe Schritt 4: So verwenden Sie Flask-SQLAlchemy zur Interaktion mit Datenbanken in einer Flask-Anwendung.

Sie erhalten folgende Ausgabe:

Output
Post The Third


[<Tag "cooking">, <Tag "tech">, <Tag "writing">]


[<Post "Post The Third">]

Hier sehen Sie den Beitragstitel, die Beitragstags und eine Liste der Beiträge mit dem Tag cooking.

Um das Tag cooking aus dem Beitrag zu entfernen, verwenden Sie die Methode remove() wie folgt:

post.tags.remove(tag)
db.session.commit()
print(post.tags)
print(tag.posts)

Hier verwenden Sie die Methode remove(), um das Tag cooking vom Beitrag zu trennen. Dann wenden Sie die Methode db.session.commit() an, um die Änderungen in der Datenbank zu übernehmen.

Du erhältst eine Ausgabe, die bestätigt, dass das Tag aus dem Beitrag entfernt wurde:

Output
[<Tag "tech">, <Tag "writing">]

[]

Wie du sehen kannst, ist das cooking-Tag nicht mehr in der post.tags-Liste enthalten, und der Beitrag wurde aus der tag.posts-Liste entfernt.

Verlasse die Flask-Shell:

exit()

Du hast neue Beiträge und Tags hinzugefügt. Du hast Beiträge markiert und Tags von Beiträgen entfernt. Als nächstes wirst du die Tags jedes Beitrags auf der Indexseite deines Flask-Weblogs anzeigen.

Schritt 4 — Anzeige von Tags unter jedem Beitrag

In diesem Schritt wirst du die Indexvorlage bearbeiten, um Tags unter jedem Beitrag anzuzeigen.

Zuerst wirf einen Blick auf die aktuelle Startseite des Flask-Weblogs.

Mit deiner Programmierumgebung aktiviert, teile Flask über die Anwendung mit (app.py in diesem Fall) unter Verwendung der Umgebungsvariable FLASK_APP mit. Setze dann die Umgebungsvariable FLASK_ENV auf development, um die Anwendung im Entwicklungsmodus auszuführen:

export FLASK_APP=app
export FLASK_ENV=development

Anschließend starte die Anwendung:

flask run

Mit dem Entwicklungsserver aktiv, besuche die folgende URL in deinem Browser:

http://127.0.0.1:5000/

Du siehst eine Seite ähnlich wie die folgende:

Lasse den Entwicklungsserver laufen und öffne ein neues Terminalfenster.

Sie müssen die Tags jedes Beitrags auf zwei Seiten anzeigen: unter jedem Beitrag auf der Indexseite und unter dem Beitragstext auf der Beitragseite. Sie verwenden denselben Code, um Tags anzuzeigen. Um Code-Wiederholungen zu vermeiden, verwenden Sie ein Jinja-Makro, das sich wie eine Python-Funktion verhält. Ein Makro enthält dynamischen HTML-Code, der überall aufgerufen werden kann, wo Sie das Makro aufrufen, und Änderungen werden überall dort vorgenommen, wo das Makro aufgerufen wurde, was den Code wiederverwendbar macht.

Öffnen Sie zunächst eine neue Datei namens macros.html in Ihrem templates-Verzeichnis:

nano templates/macros.html

Fügen Sie den folgenden Code hinzu:

{% macro display_tags(post) %}
    <div class="tags">
        <p>
            <h4>Tags:</h4>
            {% for tag in post.tags %}
                <a href="#" style="text-decoration: none; color: #dd5b5b">
                    {{ tag.name }}
                </a>
                |
            {% endfor %}
        </p>
    </div>
{% endmacro %}

Speichern und schließen Sie die Datei.

Hier verwenden Sie das macro-Schlüsselwort, um ein Makro namens display_tags() mit einem Parameter namens post zu deklarieren. Sie verwenden ein <div>-Tag, in dem Sie eine <h4>-Überschrift anzeigen. Sie verwenden eine for-Schleife, um die Tags des Beitragobjekts durchzugehen, das als Argument an das Makro übergeben wird, wenn es aufgerufen wird, ähnlich wie bei einem Argument in einem Python-Funktionsaufruf. Sie erhalten Tags über post.tags. Sie zeigen den Tag-Namen innerhalb eines <a>-Tags an. Sie werden später den Wert des href-Attributs bearbeiten, um auf eine Tag-Seite zu verlinken, die Sie erstellen werden, auf der alle Beiträge mit einem bestimmten Tag angezeigt werden. Sie geben das Ende des Makros mit dem Schlüsselwort endmacro an.

Öffnen Sie als nächstes die index.html-Template-Datei, um Tags unter jedem Beitrag auf der Indexseite anzuzeigen:

nano templates/index.html

Zuerst müssen Sie das display_tags()-Makro aus der macros.html-Datei importieren. Fügen Sie den folgenden Import oben über der {% extends 'base.html' %}-Zeile hinzu:

{% from 'macros.html' import display_tags %}
{% extends 'base.html' %}

Dann bearbeiten Sie die for post in posts-Schleife, indem Sie das display_tags()-Makro wie folgt aufrufen:

{% for post in posts %}
    <div class="post">
        <p><b>#{{ post.id }}</b></p>
        <b>
            <p class="title">
                <a href="{{ url_for('post', post_id=post.id)}}">
                    {{ post.title }}
                </a>
            </p>
        </b>
        <div class="content">
            <p>{{ post.content }}</p>
        </div>

        {{ display_tags(post) }}

        <hr>
    </div>
{% endfor %}

Speichern und schließen Sie die Datei.

Sie rufen das display_tags()-Makro auf und übergeben ihm das post-Objekt. Dadurch werden Tag-Namen unter jedem Beitrag angezeigt.

Aktualisieren Sie die Indexseite in Ihrem Browser, und Sie sehen Tags unter jedem Beitrag, wie im folgenden Bild gezeigt:

Als nächstes fügen Sie Tags unter dem Beitragstext auf der Beitragseite hinzu. Öffnen Sie die post.html-Template-Datei:

nano templates/post.html

Importieren Sie zuerst das display_tags-Makro oben:

{% from 'macros.html' import display_tags %}
{% extends 'base.html' %}

Rufen Sie dann das display_tags()-Makro auf und übergeben Sie ihm das post-Objekt unterhalb des Beitragstextes und über dem <hr>-Tag:

<div class="post">
    <p><b>#{{ post.id }}</b></p>
    <b>
        <p class="title">{{ post.title }}</p>
    </b>
    <div class="content">
        <p>{{ post.content }}</p>
    </div>

    {{ display_tags(post) }}

    <hr>
    <h3>Comments</h3>

Speichern und schließen Sie die Datei.

Navigieren Sie jetzt zu einer Beitragseite:

http://127.0.0.1:5000/2

Sie sehen, dass Tags genauso angezeigt werden wie die Tags auf der Indexseite.

Sie haben die Tags, die Sie zu Beiträgen hinzugefügt haben, unter jedem Beitrag angezeigt. Als nächstes fügen Sie Ihrem Flask-Anwendungsroute eine neue Route hinzu, die alle Beiträge mit einem bestimmten Tag anzeigt. Dann machen Sie die Tag-Links, die Sie in diesem Schritt angezeigt haben, funktionsfähig.

Schritt 5 — Anzeige von Tags und ihren Beiträgen

In diesem Schritt fügen Sie Ihrem Webanwendungscode eine Route und ein Template hinzu, um die Tags anzuzeigen, die Sie in Ihrer Datenbank haben, und ihre Beiträge.

Zunächst fügen Sie eine Route hinzu, um die Beiträge jedes Tags anzuzeigen. Zum Beispiel wird die Route /tags/tag_name/ eine Seite anzeigen, die alle Beiträge anzeigt, die mit einem Tag namens tag_name versehen sind.

Öffnen Sie zur Bearbeitung die Datei app.py:

nano app.py

Fügen Sie die folgende Route am Ende der Datei hinzu:

# ...

@app.route('/tags/<tag_name>/')
def tag(tag_name):
    tag = Tag.query.filter_by(name=tag_name).first_or_404()
    return render_template('tag.html', tag=tag)

Speichern und schließen Sie die Datei.

Hier verwenden Sie eine URL-Variable namens tag_name, die den Tag und die mit ihm versehenen Beiträge bestimmt, die auf der Tag-Seite angezeigt werden. Der Tagname wird über den Parameter tag_name an die Funktion tag() übergeben, den Sie auf der Methode filter_by() verwenden, um den Tag abzufragen. Sie verwenden first_or_404(), um das Tag-Objekt zu erhalten und es in einer Variablen namens tag zu speichern, oder um mit einer 404 Not Found-Fehlermeldung zu antworten, falls kein Tag mit dem angegebenen Namen in der Datenbank existiert.

Dann rendern Sie eine Template-Datei namens tag.html, indem Sie ihr das tag-Objekt übergeben.

Öffnen Sie die neue templates/tag.html zur Bearbeitung:

nano templates/tag.html

Fügen Sie den folgenden Code hinzu:

{% from 'macros.html' import display_tags %}
{% extends 'base.html' %}

{% block content %}
    <span class="title">
        <h1>{% block title %} Posts Tagged with "{{ tag.name }}" {% endblock %}</h1>
    </span>
    <div class="content">
        {% for post in tag.posts %}
        <div class="post">
            <p><b>#{{ post.id }}</b></p>
            <b>
                <p class="title">
                    <a href="{{ url_for('post', post_id=post.id)}}">
                        {{ post.title }}
                    </a>
                </p>
            </b>
            <div class="content">
                <p>{{ post.content }}</p>
            </div>

            {{ display_tags(post) }}

            <hr>
        </div>
        {% endfor %}
    </div>
{% endblock %}

Speichern und schließen Sie die Datei.

Sie importieren das display_tags() Makro aus macros.html und erweitern die Basisschablone.

Im Inhaltsblock setzen Sie eine Überschrift als Titel mit dem Tag-Namen ein. Anschließend durchlaufen Sie die Beiträge, die mit dem angegebenen Tag versehen sind, auf die Sie über tag.posts zugreifen. Sie zeigen die Beitrag-ID, den Beitragstitel und den Beitragstext an. Dann rufen Sie das display_tags() Makro auf, um alle Beitragstags anzuzeigen.

Mit Ihrem Entwicklungsserver aktiviert, navigieren Sie zur folgenden URL:

http://127.0.0.1:5000/tags/writing/

Dies ist die Seite für den writing Tag. Wie Sie sehen können, werden alle Beiträge, die mit writing markiert wurden, angezeigt:

Jetzt bearbeiten Sie das display_tags() Makro, um die Tag-Links funktionsfähig zu machen. Öffnen Sie macros.html:

nano templates/macros.html

Bearbeiten Sie den Wert des href Attributs wie folgt:

{% macro display_tags(post) %}
    <div class="tags">
        <p>
            <h4>Tags:</h4>
            {% for tag in post.tags %}
            <a href="{{ url_for('tag', tag_name=tag.name) }}"
               style="text-decoration: none; color: #dd5b5b">
                    {{ tag.name }}
                </a>
                |
            {% endfor %}
        </p>
    </div>
{% endmacro %}

Speichern und schließen Sie die Datei.

Aktualisieren Sie die Seiten, auf denen das display_tags() Makro verwendet wird, und Sie werden feststellen, dass die Tag-Links jetzt funktionsfähig sind:

http://127.0.0.1:5000/
http://127.0.0.1:5000/2/
http://127.0.0.1:5000/tags/writing/

Wie Sie sehen können, ermöglichen Ihnen die Verwendung von Jinja-Makros die Wiederverwendung von Code, und das Bearbeiten eines Makros wirkt sich auf mehrere Vorlagen aus.

Sie haben eine Seite für einzelne Tags hinzugefügt, auf der Benutzer alle Beiträge anzeigen können, die mit einem bestimmten Tag versehen wurden, und die Tags unter den Beiträgen verlinken nun auf diese neue Seite.

Fazit

Die Funktionen, die Sie Ihrem Blogsystem hinzugefügt haben, zeigen, wie man viele-zu-viele-Beziehungen mithilfe der Flask-SQLAlchemy-Erweiterung verwaltet. Sie haben gelernt, wie man zwischen zwei verwandten Tabellen mithilfe einer Assoziationstabelle (auch Verbindungstabelle genannt) verknüpft, einen Eintrag mit einem anderen verknüpft, den Eintrag zur Datenbank hinzufügt und auf Daten zugreift und sie von einem Eintrag trennt.

Wenn Sie mehr über Flask erfahren möchten, schauen Sie sich die anderen Tutorials in der Wie man Webanwendungen mit Flask erstellt-Serie an.