Was sind CRUD-Operationen?

CRUD-Operationen sind das Herzstück fast jeder Anwendung, mit der Sie interagieren. Als Entwickler möchten Sie normalerweise Daten erstellen, Daten lesen oder abrufen, Daten aktualisieren und Daten löschen. Unabhängig davon, ob Sie auf eine Datenbank zugreifen oder mit einer REST-API interagieren, können Sie nur dann einen vollständigen Daten-Roundtrip in Ihrer App durchführen, wenn alle vier Vorgänge vorhanden sind.

Erstellen, Lesen, Aktualisieren und Löschen sind in der Softwareentwicklung so wichtig, dass diese Methoden allgemein als CRUD bezeichnet werden. Wenn Sie CRUD verstehen, erhalten Sie beim Erstellen von Anwendungen einen umsetzbaren Entwurf und können besser verstehen, wie die von Ihnen verwendeten Anwendungen hinter den Kulissen funktionieren. Was genau bedeutet CRUD?

Kurz gesagt: CRUD steht für Erstellen, Lesen, Aktualisieren und Löschen

CRUD-Vorgänge sind der Eckpfeiler der Anwendungsfunktionalität und berühren jeden Aspekt der Art und Weise, wie Apps Daten speichern, abrufen und verwalten. Hier ist ein kurzer Überblick über die vier CRUD-Operationen:

• Erstellen: Hier geht es darum, Ihrer Datenbank neue Einträge hinzuzufügen. Es ist aber auch auf andere Arten von persistentem Speicher anwendbar, beispielsweise auf Dateien oder Netzwerkdienste. Wenn Sie einen Erstellungsvorgang ausführen, initiieren Sie eine Reise für ein neues Datenelement in Ihrem System.
• Lesen: Durch Lesen rufen Sie vorhandene Datenbankeinträge ab oder zeigen sie an. Dieser Vorgang ist so einfach wie das Abrufen Ihrer E-Mails oder das Neuladen einer Website. Dank des Lesevorgangs wurden alle Informationen, die Sie erhalten, aus einer Datenbank empfangen.
• Aktualisieren: Durch das Aktualisieren können Sie die Details bereits in der Datenbank vorhandener Daten ändern. Zum Beispiel, wenn Sie ein Profilbild aktualisieren oder eine Chat-Nachricht bearbeiten. Jedes Mal findet ein Aktualisierungsvorgang statt, der sicherstellt, dass Ihre neuen Daten in der Datenbank gespeichert werden.
• Löschen: Durch das Löschen werden vorhandene Einträge aus der Datenbank entfernt. Unabhängig davon, ob Sie ein Konto schließen oder einen Beitrag entfernen, stellen Löschvorgänge sicher, dass unerwünschte oder unnötige Daten ordnungsgemäß gelöscht werden können.

CRUD-Operationen beschreiben die Schritte, die Daten von der Erstellung bis zum Löschen durchlaufen, unabhängig davon, welche Programmiersprache Sie verwenden. Jedes Mal, wenn Sie mit einer Anwendung interagieren, führen Sie wahrscheinlich eine der vier CRUD-Operationen durch.

Warum sind CRUD-Operationen unerlässlich?

Unabhängig davon, ob Sie an einer einfachen Aufgabenlisten-App oder einer komplexen E-Commerce-Plattform arbeiten, CRUD-Operationen bieten eine universelle Sprache zum Entwerfen und Bearbeiten von Datenmodellen. Wenn Sie als Benutzer CRUD kennen, können Sie besser verstehen, was hinter den Kulissen passiert. Wenn Sie als Entwickler CRUD verstehen, erhalten Sie ein strukturiertes Framework zum Speichern von Daten in Ihrer Anwendung mit Persistenz:

In der Informatik bezieht sich Persistenz auf die Zustandseigenschaft eines Systems, die den Prozess, der es geschaffen hat, überdauert (mehr fortbesteht). Dies wird in der Praxis dadurch erreicht, dass der Zustand als Daten in einem Computerdatenspeicher gespeichert wird. (Quelle)

Selbst wenn ein Programm abstürzt oder ein Benutzer die Verbindung trennt, sind die Daten sicher und können später wiederhergestellt werden. Das bedeutet auch, dass die Reihenfolge der Operationen wichtig ist. Sie können nur Elemente lesen, aktualisieren oder löschen, die zuvor erstellt wurden.

Es empfiehlt sich, jede CRUD-Operation separat in Ihren Anwendungen zu implementieren. Wenn Sie beispielsweise Elemente abrufen, sollten Sie diese nicht gleichzeitig aktualisieren.

Während CRUD ein Konzept beschreibt, das unabhängig von bestimmten Programmiersprachen ist, könnte man argumentieren, dass CRUD-Operationen eng mit SQL-Befehlen und HTTP-Methoden verbunden sind.

Was sind CRUD-Operationen in SQL?

Die Idee von CRUD ist eng mit Datenbanken verbunden. Deshalb ist es nicht verwunderlich, dass CRUD-Operationen nahezu eins zu eins mit SQL-Befehlen übereinstimmen:

Create

INSERT

Read

AUSWÄHLEN

Update

UPDATE

Delete

LÖSCHEN

Wenn Sie Daten erstellen, verwenden Sie den Befehl INSERT, um einer Tabelle neue Datensätze hinzuzufügen. Nach der Erstellung können Sie die Daten mit SELECT lesen. Mit einer SELECT-Abfrage bitten Sie die Datenbank, die spezifischen Informationen abzurufen, die Sie benötigen, sei es ein einzelner Wert, eine Reihe von Datensätzen oder komplexe Beziehungen zwischen Datenpunkten.

Der Vorgang update entspricht dem Befehl UPDATE in SQL, mit dem Sie Daten ändern können. Damit können Sie ein vorhandenes Element bearbeiten oder ändern.

Schließlich bezieht sich die Operation delete auf den Befehl DELETE. Dies ist das digitale Äquivalent zur Vernichtung eines vertraulichen Dokuments. Mit DELETE entfernen Sie ein Element dauerhaft aus der Datenbank.

CRUD-Operationen in Raw SQL schreiben

CRUD-Operationen beschreiben Aktionen. Aus diesem Grund ist es eine gute Idee, die Ärmel hochzukrempeln und Code zu schreiben, um zu erkunden, wie CRUD-Operationen in unformatierte SQL-Befehle übersetzt werden.

In den folgenden Beispielen verwenden Sie das in Python integrierte sqlite3-Paket. SQLite ist eine praktische SQL-Bibliothek zum Ausprobieren, da Sie mit einer einzigen SQLite-Datenbankdatei arbeiten.

Sie nennen die Datenbank birds.db. Wie der Name schon sagt, verwenden Sie die Datenbank, um die Namen der Vögel zu speichern, die Ihnen gefallen. Um das Beispiel klein zu halten, verfolgen Sie nur die Vogelnamen und geben ihnen eine ID als eindeutige Kennung.

Starten Sie eine neue Python-Datei mit dem Namen crud_sql.py mit dem folgenden Code:

import sqlite3

def connect_to_db(db_path):
    return sqlite3.connect(db_path)

if __name__ == "__main__":
    with connect_to_db("birds.db") as connection:
        connection.execute("""
          CREATE TABLE IF NOT EXISTS bird (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL
          );
        """)

Nachdem Sie sqlite3 in Zeile 1 importiert haben, definieren Sie in Zeile 3 eine Funktion mit dem Namen connect_to_db(). Wie der Name schon sagt, verwenden Sie diese Funktion, um eine Verbindung zur Datenbank herzustellen , die Sie als Argument übergeben. Wenn sqlite3.connect() in Zeile 4 keine Datenbank im angegebenen Pfad finden kann, wird die Datenbank erstellt.

In Zeile 6 verwenden Sie das Name-Main-Idiom, um eine Verbindung zu birds.db herzustellen und eine bird-Tabelle in der Datenbank zu erstellen, wenn Sie crud_sql.py ausführen direkt. In Zeile 8 führen Sie den Roh-SQL-Befehl aus, den Sie in den Zeilen 9 bis 11 definiert haben. Da Sie einen Kontextmanager verwenden, müssen Sie sich keine Gedanken über das Schließen der Datenbank machen.

Der von Ihnen definierte SQL-Befehl führt unter bestimmten Bedingungen zwei Dinge aus. Wenn die Tabelle bird nicht in der Datenbank vorhanden ist, erstellen Sie sie mit zwei Spalten:

1. id zur eindeutigen Identifizierung von Datenbankeinträgen
2. name zum Speichern des Namens eines Vogels

Sie können sich die bird-Datenbanktabelle wie eine Tabellenkalkulation vorstellen. Die Spalten id und name sind die Tabellenüberschriften. Später fügen Sie der Tabelle Zeilen hinzu, bei denen es sich um Ihre Datenbankeinträge handelt.

Öffnen Sie ein Terminalfenster im selben Arbeitsverzeichnis wie crud_sql.py und führen Sie das Python-Skript aus:

$ python crud_sql.py

Wenn Sie crud_sql.py zum ersten Mal ausführen, wird birds.db mit einer bird-Tabelle erstellt. Starten Sie als Nächstes eine neue Python-REPL, um CRUD-Operationen mit unformatiertem SQL auszuführen:

>>> from crud_sql import connect_to_db
>>> connection = connect_to_db("birds.db")
>>> cursor = connection.cursor()
>>> CREATE_BIRDS_SQL = """
... INSERT INTO
...   bird (name)
... VALUES
...   ('Humming Bird'),
...   ('Sugar Glider');
... """
>>> cursor.execute(CREATE_BIRDS_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> connection.commit()

Zunächst stellen Sie die Verbindung zur Datenbank birds.db her und erstellen einen Cursor. Anschließend bereiten Sie Ihren SQL-Befehl vor, um zwei fliegende Tiere in die Tabelle bird einzufügen. Genau wie zuvor verwenden Sie .execute(), um den Vorgang auszuführen. Dieses Mal eröffnen Sie jedoch eine Datenbanktransaktion, weil Sie den Befehl INSERT verwenden.

In dieser Phase können Sie weitere Abfragen mit Ihrem Transaktionsstapel verknüpfen. Um den Vorgang auszuführen, müssen Sie .commit() verwenden. Im Moment verwenden Sie die geöffnete Verbindung, um die anderen CRUD-Vorgänge auszuführen. Sie schließen die Verbindung am Ende des Abschnitts.

Nachdem Sie die Datenbankeinträge erstellt haben, ist es an der Zeit zu überprüfen, ob sie in der Datenbank vorhanden sind. Hierzu verwenden Sie die Retrieval-CRUD-Operation:

>>> READ_BIRDS_SQL = "SELECT * from bird"
>>> cursor.execute(READ_BIRDS_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> cursor.fetchall()
[(1, 'Humming Bird'), (2, 'Sugar Glider')]

Mit SELECT gefolgt von einem Sternchen (*) richten Sie die READ_BIRDS_SQL-Abfrage ein, um alle Datenbankeinträge des bird abzurufen. Tabelle. Wenn Ihre Datenbank größer wäre, wäre dies eine große Transaktion. Für Ihre kleine Datenbank mit nur zwei kleinen Tieren ist dieser CRUD-Vorgang in Ordnung.

Die Methode .fetchall() gibt eine Liste von Tupeln zurück. Die Listenelemente sind die Datenbankelemente. Der Inhalt des Tupels sind die Zeilenwerte von id und name.

An dieser Stelle ist Ihnen möglicherweise die falsche Schreibweise des Eintrags „Kolibri“ aufgefallen. Die korrekte Schreibweise dieses kleinen Vogels ist „Kolibri“. Was für eine großartige Gelegenheit, eine weitere CRUD-Operation zu nutzen!

Fahren Sie fort und verwenden Sie den Update-CRUD-Vorgang für den Eintrag „Humming Bird“, indem Sie auf dessen id verweisen:

>>> UPDATE_HUMMINGBIRD_SQL = """
... UPDATE
...   bird
... SET
...   name = "Hummingbird"
... WHERE
...   id = 1
... """
>>> cursor.execute(UPDATE_HUMMINGBIRD_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> connection.commit()

Wenn Sie den Befehl UPDATE ausführen, müssen Sie den neuen Inhalt angeben, mit dem Sie den alten überschreiben möchten. Hier ändern Sie den Namen des kleinen Vogels in „Kolibri“.

Ein weiteres wichtiges Detail für den Update-CRUD-Vorgang besteht darin, dass Sie Informationen darüber bereitstellen müssen, welche Daten Sie aktualisieren möchten. Wenn Sie einen bestimmten Datenbankeintrag aktualisieren möchten, müssen Sie eine eindeutige Kennung wie die ID angeben.

Das Gleiche gilt, wenn Sie einen CRUD-Löschvorgang durchführen möchten. Auch hier müssen Sie der Datenbank den genauen Eintrag oder die genauen Einträge mitteilen, die Sie löschen möchten, um zu vermeiden, dass gewünschte Einträge gelöscht werden.

Wenn Sie den Löschvorgang in SQL ausprobieren, haben Sie die Möglichkeit, einen weiteren Fehler in einem Ihrer Datenbankeinträge zu beheben. Ein Zuckersegelflugzeug ist ein niedliches, fliegendes Tier. Dennoch ist der Zuckersegelflieger kein Vogel.

Sie können Ihre Datenbank irgendwann in der Zukunft diversifizieren, um einen Lebensraum für jedes niedliche Tier zu schaffen. Aber jetzt ist es an der Zeit, den Sugar Glider aus der birds.db zu entfernen:

>>> DELETE_SUGAR_GLIDER_SQL = "DELETE FROM bird WHERE id = 2"
>>> cursor.execute(DELETE_SUGAR_GLIDER_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> connection.commit()
>>> connection.close()

Mit DELETE schreiben Sie keine neuen Daten. Deshalb reicht die Angabe einer id aus, um der Datenbank mitzuteilen, welchen Eintrag Sie löschen möchten.

Achten Sie auch hier darauf, die WHERE-Klausel nicht zu verpassen. Andernfalls würden Sie alle Einträge der bird-Tabelle löschen. Wenn Sie mehr über die SQL-Befehle erfahren möchten, die Sie mit SQLite verwenden können, können Sie sich die Übersicht über SQL im Sinne von SQLite ansehen.

Nachdem Sie nun alle SQL CRUD-Vorgänge abgeschlossen haben, rufen Sie außerdem .close() auf, um die Datenbankverbindung zu schließen.

Durch die Übersetzung von CRUD-Konzepten in SQL können Sie Abfragen erstellen, um Daten in Ihrer Datenbank zu bearbeiten. Wie Sie in den obigen Beispielen gesehen haben, stehen die CRUD-Operationen in engem Zusammenhang mit SQL-Befehlen. Allerdings kann das Schreiben von reinem SQL umständlich sein. Hier kommt ein Paket wie SQLAlchemy ins Spiel, das Ihnen hilft, CRUD-Operationen bequemer durchzuführen.

Ausführen von CRUD-Operationen mit SQLAlchemy

SQLAlchemy ist ein beliebter objektrelationaler Mapper (ORM) für Python. Mit einem ORM können Sie mithilfe von Python-Objekten mit einer Datenbank interagieren, anstatt wie im vorherigen Abschnitt unformatierte SQL-Abfragen zu schreiben. Dadurch wird das Schreiben von Code für Sie als Python-Entwickler komfortabler.

Ein weiterer Vorteil der Verwendung von ORMs besteht darin, dass Sie sich nicht um die genaue SQL-Implementierung kümmern müssen:

Obwohl SQL seit 1986 standardisiert ist, gibt es leider viele verschiedene Implementierungen. Sie weichen mehr oder weniger voneinander ab, was die Entwicklung von Anwendungen, die mit einer Reihe verschiedener SQL-Server funktionieren, besonders schwierig macht. (Quelle)

Mit einem ORM wie SQLAlchemy können Sie die SQL-Bibliothek im Hintergrund wechseln und Ihre Datenbankabfragen unverändert lassen.

SQLAlchemy ist ein externes Python-Paket, das Sie im Python Package Index (PyPI) finden.

Wie bei anderen externen Paketen ist es eine gute Idee, SQLAlchemy in einer virtuellen Umgebung zu installieren. Auf diese Weise installieren Sie alle Projektabhängigkeiten nicht systemweit, sondern nur in der virtuellen Umgebung Ihres Projekts.

Wählen Sie unten Ihr Betriebssystem aus und verwenden Sie Ihren plattformspezifischen Befehl, um eine virtuelle Umgebung einzurichten:

Das erste Code-Snippet sollte unter Windows verwendet werden und das zweite Code-Snippet ist für Linux + macOS:

PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS>

$ python -m venv venv
$ source venv/bin/activate
(venv) $

Mit den oben gezeigten Befehlen erstellen und aktivieren Sie eine virtuelle Umgebung namens venv, indem Sie das in Python integrierte venv-Modul verwenden. Der in Klammern gesetzte (venv) vor der Eingabeaufforderung zeigt an, dass Sie die virtuelle Umgebung erfolgreich aktiviert haben.

Nachdem Sie Ihre virtuelle Umgebung erstellt und aktiviert haben, können Sie mit der Installation von SQLAlchemy fortfahren:

(venv) $ python -m pip install SQLAlchemy

Nachdem Sie SQLAlchemy installiert haben, können Sie CRUD-Operationen mit dem SQLAlchemy ORM erkunden.

Im vorherigen Abschnitt haben Sie CRUD-Operationen mit reinem SQL durchgeführt. Selbst wenn ein ORM wie SQLAlchemy verwendet wird, gilt das Konzept der Verwendung von CRUD-Operationen.

Beginnen Sie erneut mit der Erstellung einer Python-Datei, die Ihnen beim Herstellen einer Verbindung zur Datenbank birds.db hilft:

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import DeclarativeBase, sessionmaker

class Base(DeclarativeBase):
    pass

class Bird(Base):
    __tablename__ = "bird"
    id = Column(Integer, primary_key=True)
    name = Column(String)

    def __repr__(self):
        return f"Bird(id={self.id}, name={self.name!r})"

engine = create_engine("sqlite:///birds.db")
Session = sessionmaker(bind=engine)

def init_db():
    Base.metadata.create_all(engine)

Ein wichtiger Vorteil der Verwendung von SQLAlchemy besteht darin, dass Sie Modelle deklarieren können. In Zeile 7 erstellen Sie eine Bird-Klasse, die sowohl eine bird-Datenbanktabelle als auch das Python-Objektmodell beschreibt, das später mit Tabellenelementen interagieren wird.

Mit init_db() in Zeile 18 erstellen Sie entweder die Datenbank birds.db, wenn sie nicht existiert, oder stellen eine Verbindung zu ihr her, wenn sie vorhanden ist. Das bedeutet, dass Sie weiterhin mit der vorhandenen Datenbank birds.db aus dem vorherigen Abschnitt arbeiten können, um die CRUD-Operationen mit SQLAlchemy zu untersuchen.

Starten Sie eine weitere Python REPL-Sitzung in demselben Ordner, in dem Sie crud_sql_alchemy.py gespeichert haben. Führen Sie dann Ihre ersten CRUD-Vorgänge mit SQLAlchemy aus:

>>> from crud_sql_alchemy import Session, Bird, init_db
>>> init_db()
>>> session = Session()
>>> new_bird = Bird(name="Test Bird")
>>> session.add(new_bird)
>>> session.commit()

Mit SQLAlchemy können Sie neue Datenbankeinträge mithilfe der Methode .add() von Session erstellen. Im obigen Beispiel erstellen Sie einen neuen Eintrag mit dem Namen „Test Bird“.

Um zu überprüfen, ob „Test Bird“ in der Datenbank vorhanden ist, können Sie die Datenbank abfragen:

>>> from sqlalchemy import select
>>> query = select(Bird).where(Bird.name == "Test Bird")
>>> bird = session.execute(query).scalar_one()
>>> bird
<Bird(id=3, name='Test Bird')>

Um Datenbankeinträge mit SQLAlchemy abzurufen, verwenden Sie select() in Kombination mit der Methode .where(). Die Abfrage ähnelt der reinen SQL-Anweisung, aber der Python-Code sieht wohl viel vertrauter aus. Hier möchten Sie alle Bird-Objekte auswählen, deren Namen mit "Test Bird" übereinstimmen.

Im Gegenzug erhalten Sie ein Select-Objekt, das Sie in einer query-Variable speichern.

Wenn Sie query an .execute() übergeben, führen Sie die Abfrage aus. Obwohl es in Ihrer Datenbank nur einen „Test Bird“ gibt, der Ihrer Abfrage entspricht, müssen Sie .scalar_one() verwenden, um genau diesen Datenbankeintrag als bird zu speichern.

Nachdem Sie nun den „Test Bird“ erfasst und das Objekt in der Variablen bird gespeichert haben, können Sie fortfahren und seinen Namen aktualisieren:

>>> bird.name = "Example Bird"
>>> session.commit()
>>> session.execute(select(Bird)).scalars().all()
[<Bird(id=1, name='Hummingbird')>, <Bird(id=3, name='Example Bird')>]

In SQLAlchemy ist der Aktualisierungsvorgang so einfach wie das Ändern der Eigenschaft eines Objekts und das anschließende Festschreiben der Änderung. Um zu überprüfen, ob alles funktioniert hat, könnten Sie die Datenbank erneut abfragen und alle Datenbankeinträge überprüfen.

Nachdem Sie Ihre Datenbank mit SQLAlchemy erstellt, gelesen und aktualisiert haben, fehlt nur noch eine Operation Ihrer CRUD-Routine: das Löschen eines Eintrags.

Solange Sie in der Sitzung bleiben, können Sie mit bird weiterarbeiten:

>>> session.delete(bird)
>>> session.commit()
>>> session.close()

Sie können das Löschen eines Datenbankeintrags mit SQLAlchemy vorbereiten, indem Sie die Methode .delete() der Sitzung aufrufen. Auch hier müssen Sie .commit() aufrufen, um den CRUD-Löschvorgang auszuführen.

Abschließend empfiehlt es sich, die Sitzung zurückzusetzen. Sie können sich session.close() als Aufräumen nach Ihnen vorstellen.

Die Verwendung von SQLAlchemy kann die Komplexität des Schreibens von Roh-SQL verringern, indem eine Abstraktionsebene zur Durchführung von CRUD-Operationen hinzugefügt wird. Bei der Arbeit mit Webanwendungen kann es bei der Durchführung von CRUD-Operationen eine noch weitere Abstraktionsebene geben.

Als Nächstes erkunden Sie die Rolle von CRUD-Operationen im Web und erstellen dann Ihre eigene CRUD-basierte REST-API, die HTTP-Anforderungsmethoden und SQLAlchemy verwendet, um mit Ihrer Datenbank zu interagieren.

Was sind CRUD-Operationen in HTTP-Anforderungsmethoden?

Wenn Sie im Internet surfen, führen Sie ständig CRUD-Vorgänge in Form von HTTP-Anfragemethoden aus. Bevor Sie HTTP-Anfragen weiter untersuchen, werfen Sie einen Blick darauf, wie CRUD-Operationen HTTP-Anfragemethoden entsprechen:

Create

POST

Read

GET

Update

PUT oder PATCH

Delete

LÖSCHEN

Die mit Abstand gebräuchlichste HTTP-Anfragemethode ist die GET-Anfragemethode. Wenn Sie eine Website besuchen, rufen Sie Daten vom Server ab. Mit anderen Worten: Sie führen bei jeder Anfrage eine Lese-CRUD-Operation durch.

Um zu untersuchen, wie alle vier CRUD-Operationen im Kontext von HTTP-Anforderungsmethoden interagieren, stellen Sie sich eine Website vor, auf der Sie über ein Benutzerkonto verfügen.

Als Sie sich angemeldet haben, haben Sie ein neues Konto mit der HTTP-Anfragemethode POST erstellt. Wenn Sie Ihr Profil besuchen, senden Sie eine GET-Anfrage an den Server und bitten um den Empfang Ihrer Daten. Mit anderen Worten: Sie lesen Daten vom Server.

Wenn Sie Ihren Benutzernamen aktualisieren, verwenden Sie wahrscheinlich eine PATCH-HTTP-Anfragemethode. Wenn Sie Ihr Avatarbild ersetzen, verwenden Sie möglicherweise die HTTP-Methode PUT. Mit anderen Worten: PUT ersetzt einen gesamten Datenbankeintrag durch neuen Inhalt, während PATCH nur seine einzelnen Felder aktualisiert.

Um einen Beitrag, den Sie in Ihrem Feed erstellt haben, zu löschen, können Sie eine DELETE-HTTP-Methode auslösen. Wenn Sie mit DELETE arbeiten, ist es wichtig, die Zielressource tatsächlich zu löschen. Nach dem DELETE-Vorgang sollte ein GET für die gelöschte Ressource einen 404-Antwortcode zurückgeben.

Welche genaue HTTP-Anfragemethode Sie verwenden, hängt davon ab, wie die Weboberfläche aufgebaut ist. Wenn Sie mit einer REST-API interagieren, sind die HTTP-Methoden besser sichtbar. Und wie könnte man besser erkunden, wie HTTP-Methoden und CRUD-Operationen in einer REST-API funktionieren, als selbst eine REST-API zu erstellen?

Durchführen von CRUD-Operationen mit einer REST-API

REST ist eine Abkürzung für Representational State Transfer. Mit einer REST-API definieren Sie eine Reihe von Pfaden und Regeln für HTTP-Anforderungsmethoden zur Interaktion mit Ihrem Webdienst.

CRUD-Operationen in REST-APIs sind in erster Linie HTTP-Methoden. Ähnlich wie bei der Interaktion mit Websites in Ihrem Browser können REST-API-Aufrufe Datenbank-CRUD-Vorgänge im Backend auslösen.

Im nächsten Abschnitt erstellen Sie Ihre eigene REST-API mit FastAPI, um besser zu verstehen, wie eine REST-API, HTTP-Anforderungsmethoden und Datenbanken mithilfe von CRUD-Operationen zusammenarbeiten.

Ausführen von CRUD-Operationen mit FastAPI

FastAPI ist ein Webframework zum Erstellen von APIs mit Python. Fahren Sie fort und installieren Sie FastAPI in derselben virtuellen Umgebung, die Sie zuvor erstellt und SQLAlchemy installiert haben:

(venv) $ python -m pip install fastapi "uvicorn[standard]"

Neben FastAPI installieren Sie auch Uvicorn mit dem obigen Befehl. Uvicorn ist der Server, auf dem Sie FastAPI ausführen.

Außerdem installiert FastAPI Pydantic als Abhängigkeit. Pydantic unterstützt Sie bei der Modellierung Ihrer Daten. Wenn Sie mehr über Pydantic erfahren möchten, können Sie das Tutorial zur Vereinfachung der Datenvalidierung in Python lesen.

Sie verwenden FastAPI, um Endpunkte zu erstellen, an die Sie HTTP-Anfragen senden. Sobald ein Endpunkt eine Anfrage erhält, führen Sie einen CRUD-Vorgang für Ihre birds.db-Datenbank durch. Um den Prozess zu optimieren, nutzen Sie die Datei crud_sql_alchemy.py von zuvor.

Wenn Sie dem Tutorial bisher noch nicht gefolgt sind, können Sie die Python-Skripte herunterladen, indem Sie auf den folgenden Link klicken:

Erstellen Sie eine neue Datei mit dem Namen crud_fastapi.py neben crud_sql_alchemy.py und beginnen Sie mit dem folgenden Code:

from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy import select
from sqlalchemy.orm import Session
from pydantic import BaseModel, ConfigDict

from crud_sql_alchemy import Bird, init_db
from crud_sql_alchemy import Session as SessionLocal

app = FastAPI()
init_db()

class BirdCreate(BaseModel):
    name: str

class BirdUpdate(BaseModel):
    name: str

class BirdResponse(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    name: str

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

Zuerst importieren Sie FastAPI, um Ihre Webanwendung zu erstellen, und HTTPException, um potenzielle Fehler zu behandeln. Sie verwenden das BaseModel von Pydantic zur Datenvalidierung und Einstellungsverwaltung.

Bevor Sie Ihre API ausprobieren können, müssen Sie die Endpunkte für Ihre CRUD-Vorgänge definieren. Bearbeiten Sie crud_fastapi.py weiter und fügen Sie den folgenden Code hinzu, um Ihren ersten Endpunkt zu definieren:

# ...

@app.post("/birds/", response_model=BirdResponse)
def create_bird(bird: BirdCreate, db: Session = Depends(get_db)):
    new_bird = Bird(name=bird.name)
    db.add(new_bird)
    db.commit()
    db.refresh(new_bird)
    return new_bird

Sie verwenden die Funktion create_bird(), um einen neuen Vogel in der Tabelle bird zu erstellen. Diese Funktion antwortet auf POST-Anfragen am /birds/-Endpunkt. Da Sie mit SQLAlchemy arbeiten, sieht der Code dem Beispiel im vorherigen Abschnitt sehr ähnlich.

Der nächste Endpunkt, den Sie implementieren, ist der Endpunkt zum Lesen aller Vögel, die derzeit in der Datenbank gespeichert sind:

# ...

@app.get("/birds/", response_model=list[BirdResponse])
def read_birds(db: Session = Depends(get_db)):
    birds = db.execute(select(Bird)).scalars().all()
    return birds

Die Funktion read_birds() gibt alle Vögel zurück, die in der Tabelle bird Ihrer Datenbank gespeichert sind. Dieser Endpunkt antwortet auf GET-Anfragen, sodass Sie eine Liste aller Vögel abrufen können.

Wenn Sie nur einen bestimmten Vogel erhalten möchten, müssen Sie der API mitteilen, welchen Vogel Sie in der Antwort erhalten möchten. Fügen Sie dazu einen weiteren Endpunkt hinzu, der die id eines Vogels als Parameter akzeptiert:

# ...

@app.get("/birds/{bird_id}", response_model=BirdResponse)
def read_bird(bird_id: int, db: Session = Depends(get_db)):
    query = select(Bird).where(Bird.id == bird_id)
    found_bird = db.execute(query).scalar_one()
    if found_bird is None:
        raise HTTPException(status_code=404, detail="Bird not found")
    return found_bird

Wenn Sie bird_id als Teil der Endpunkt-URL Ihrer GET-Anfrage übergeben, versucht die Funktion read_bird(), den Vogel mit dem zurückzugeben Ausweis gegeben.

Der obige SQLAlchemy-Code ähnelt den Schritten, die Sie zuvor in der Python REPL ausgeführt haben. Ein kleiner Unterschied besteht darin, dass Sie hier den Fall abdecken, dass kein Vogel mit der angegebenen ID gefunden wird. In diesem Fall lösen Sie eine HTTPException aus, um den API-Benutzer darüber zu informieren, dass der Vogel nicht gefunden wurde.

Sie verwenden ein ähnliches Muster für den CRUD-Vorgang update. Sie können den Namen des Vogels nur dann ändern, wenn ein Vogel mit der angeforderten ID existiert:

# ...

@app.put("/birds/{bird_id}", response_model=BirdResponse)
def update_bird(bird_id: int, bird: BirdUpdate, db: Session = Depends(get_db)):
    query = select(Bird).where(Bird.id == bird_id)
    found_bird = db.execute(query).scalar_one()
    if found_bird is None:
        raise HTTPException(status_code=404, detail="Bird not found")
    found_bird.name = bird.name
    db.commit()
    db.refresh(found_bird)
    return found_bird

Die Funktion update_bird() ersetzt die Details eines vorhandenen Vogels durch den bereitgestellten neuen Namen. Nach wie vor ähnelt der CRUD-Vorgang delete stark dem Vorgang, den Sie zum Aktualisieren eines Datenbankeintrags verwenden. Anstatt einen Vogel umzubenennen, rufen Sie dieses Mal die Methode .delete() auf:

# ...

@app.delete("/birds/{bird_id}", response_model=dict)
def delete_bird(bird_id: int, db: Session = Depends(get_db)):
    query = select(Bird).where(Bird.id == bird_id)
    found_bird = db.execute(query).scalar_one()
    if found_bird is None:
        raise HTTPException(status_code=404, detail="Bird not found")
    db.delete(found_bird)
    db.commit()
    return {"message": "Bird deleted successfully"}

Da nun alle Ihre CRUD-API-Endpunkte vorhanden sind, ist es an der Zeit, Ihre API auszuprobieren! Starten Sie den Uvicorn-Server, indem Sie den Befehl uvicorn ausführen. Als Argument müssen Sie den Dateinamen ohne die Erweiterung .py angeben, gefolgt von einem Doppelpunkt (:) und dem Namen der FastAPI-App:

(venv) $ uvicorn crud_fastapi:app
INFO:     Will watch for changes in these directories: [...]
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [29889] using WatchFiles
INFO:     Started server process [29891]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Eine coole Sache an FastAPI ist, dass es standardmäßig eine interaktive API-Dokumentation enthält. Das heißt, Sie können die REST-API-Endpunkte direkt im Browser testen. Besuchen Sie http://127.0.0.1:8000/docs und führen Sie einige CRUD-Vorgänge auf Ihrer REST-API aus:

CRUD-Operationen in REST-APIs bieten ein standardisiertes Framework zum Erstellen von Webdiensten, die Ressourcen über das Web erstellen, lesen, aktualisieren und löschen können.

FastAPI ist ein großartiges Paket zum Verbinden von CRUD-Vorgängen mit HTTP-Anforderungsmethoden. Mit Ihren Endpunkten haben Sie die CRUD-Vorgänge Funktionen zugeordnet, die mit Ihrer Datenbank interagieren. Auch hier ist SQLAlchemy ein großartiger Helfer für die intuitive Durchführung von CRUD-Operationen in Ihrer Datenbank.

Abschluss

CRUD steht für Erstellen, Lesen, Aktualisieren und Löschen. Diese vier Vorgänge sind für die Funktionalität und Interaktivität moderner Anwendungen von grundlegender Bedeutung. Ob es um die Verwaltung von Benutzerdaten in einer Social-Media-App, die Aktualisierung des Inventars auf einer E-Commerce-Plattform oder einfach um die Pflege einer Datenbank mit Vögeln geht, die Prinzipien von CRUD sind universell anwendbar.

In diesem Tutorial haben Sie CRUD-Operationen in Datenbanken und REST-APIs untersucht. Nachdem Sie CRUD-Operationen in Roh-SQL geschrieben haben, haben Sie SQLAlchemy für eine intuitivere Art der Interaktion mit Ihrer Datenbank genutzt. Anschließend haben Sie mit FastAPI eine REST-API erstellt, um zu verstehen, wie CRUD-Vorgänge eine Verbindung zu HTTP-Anforderungsmethoden herstellen.

CRUD-Operationen sind das Herzstück fast jeder Anwendung, mit der Sie interagieren. Im digitalen Ökosystem sind CRUD-Operationen so wichtig wie die Flügel eines Vogels und ermöglichen es Anwendungen, mit Agilität und Anmut durch die Lüfte des Datenmanagements zu navigieren.