Daten filtern - WHERE¶

Im vorherigen Kapitel haben wir gesehen, wie man Daten aus der Datenbank SELECTt.

Wir haben das mit reinem SQL und mit SQLModel gemacht.

Aber wir haben immer alle Zeilen, die ganze Tabelle bekommen.

id	name	secret_name	age
1	Deadpond	Dive Wilson	null
2	Spider-Boy	Pedro Parqueador	null
3	Rusty-Man	Tommy Sharp	48

In den meisten Fällen möchten wir nur eine Zeile oder nur eine Gruppe von Zeilen erhalten.

Wir werden jetzt sehen, wie das geht, Daten zu filtern und nur die Zeilen zu erhalten, für die eine Bedingung where (wo) zutrifft.

Weiter mit vorherigem Code¶

Wir werden mit denselben Beispielen fortfahren, die wir in den vorherigen Kapiteln zum Erstellen und Auswählen von Daten verwendet haben.

Und jetzt werden wir select_heroes() aktualisieren, um die Daten zu filtern.

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

Wenn Sie die vorherigen Beispiele bereits ausgeführt haben und eine Datenbank mit Daten haben, entfernen Sie die Datenbankdatei, bevor Sie jedes Beispiel ausführen. So vermeiden Sie doppelte Daten und erzielen dieselben Ergebnisse.

Daten mit SQL filtern¶

Schauen wir uns zuerst an, wie man Daten mit SQL unter Verwendung des Schlüsselworts WHERE filtert.

SELECT id, name, secret_name, age
FROM hero
WHERE name = "Deadpond"

Der erste Teil bedeutet dasselbe wie zuvor

Hallo SQL-Datenbank 👋, bitte gehen Sie und wählen Sie einige Daten für mich aus SELECT.

Ich sage Ihnen zuerst, welche Spalten ich möchte

id

name

secret_name

age

Und ich möchte, dass Sie sie FROM der Tabelle namens "hero" holen.

Dann fügt das Schlüsselwort WHERE Folgendes hinzu:

Also, SQL-Datenbank, ich habe Ihnen bereits gesagt, welche Spalten ich SELECTen soll und wo ich sie FROM holen soll. Aber ich möchte nicht, dass Sie alle Zeilen bringen, ich möchte nur die Zeilen WHERE die Spalte name den Wert "Deadpond" hat.

Dann bringt die Datenbank eine Tabelle wie diese:

id	name	secret_name	age
1	Deadpond	Dive Wilson	null

Tipp

Selbst wenn das Ergebnis nur eine Zeile ist, gibt die Datenbank immer eine Tabelle zurück.

In diesem Fall eine Tabelle mit nur einer Zeile.

Sie können das in DB Browser for SQLite ausprobieren.

`WHERE` und `FROM` sind "Klauseln"¶

Diese zusätzlichen Schlüsselwörter mit einigen Abschnitten wie WHERE und FROM, die nach SELECT (oder anderen) kommen, haben einen technischen Namen: Sie werden Klauseln genannt.

Es gibt auch andere Klauseln mit eigenen SQL-Schlüsselwörtern.

Ich werde den Begriff Klausel hier nicht zu oft verwenden, aber es ist gut für Sie zu wissen, da er wahrscheinlich in anderen Tutorials auftauchen wird, die Sie später studieren könnten. 🤓

`SELECT` und `WHERE`¶

Hier ist ein kleiner Tipp, der mir hilft, es zu verstehen.

SELECT wird verwendet, um der SQL-Datenbank mitzuteilen, welche Spalten zurückgegeben werden sollen.
WHERE wird verwendet, um der SQL-Datenbank mitzuteilen, welche Zeilen zurückgegeben werden sollen.

Die Größe der Tabelle in den beiden Dimensionen hängt hauptsächlich von diesen beiden Schlüsselwörtern ab.

`SELECT` Land¶

Wenn die Tabelle zu viele oder zu wenige Spalten hat, wird dies im SELECT-Teil geändert.

Ausgehend von einer Tabelle

id	name	secret_name	age
1	Deadpond	Dive Wilson	null
2	Spider-Boy	Pedro Parqueador	null
3	Rusty-Man	Tommy Sharp	48

...und Ändern der Anzahl der Spalten

name
Deadpond
Spider-Boy
Rusty-Man

...ist alles SELECT Land.

`WHERE` Land¶

Wenn die Tabelle zu viele oder zu wenige Zeilen hat, wird dies im WHERE-Teil geändert.

Ausgehend von einer Tabelle

id	name	secret_name	age
1	Deadpond	Dive Wilson	null
2	Spider-Boy	Pedro Parqueador	null
3	Rusty-Man	Tommy Sharp	48

...und Ändern der Anzahl der Zeilen

id	name	secret_name	age
2	Spider-Boy	Pedro Parqueador	null

...ist alles WHERE Land.

`SELECT` mit SQLModel überprüfen¶

Lassen Sie uns einen Teil des Codes überprüfen, den wir zum Lesen von Daten mit SQLModel verwendet haben.

Wir konzentrieren uns besonders auf die select-Anweisung.

Python 3.10+

# Code above omitted 👆

def select_heroes():
    with Session(engine) as session:
        statement = select(Hero)
        results = session.exec(statement)
        for hero in results:
            print(hero)

# Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

Zeilen mit `WHERE` und SQLModel filtern¶

So wie wir WHERE zu einer SQL-Anweisung hinzufügen, um Zeilen zu filtern, können wir einer SQLModel select()-Anweisung ein .where() hinzufügen, um Zeilen zu filtern, was die zurückgegebenen Objekte filtert.

Python 3.10+

# Code above omitted 👆

def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name == "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)

# Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name == "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name == "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

Es ist eine sehr kleine Änderung, aber sie steckt voller Details. Lassen Sie uns diese erkunden.

`select()` Objekte¶

Das von select(Hero) zurückgegebene Objekt ist ein spezieller Objekttyp mit einigen Methoden.

Eine dieser Methoden ist .where(), die (wenig überraschend) verwendet wird, um der SQL-Anweisung in diesem select-Objekt ein WHERE hinzuzufügen.

Es gibt noch andere Methoden, die wir später erkunden werden. 💡

Die meisten dieser Methoden geben das Objekt nach der Modifizierung wieder zurück.

So könnten wir eine nach der anderen aufrufen:

statement = select(Hero).where(Hero.name == "Deadpond").where(Hero.age == 48)

Aufruf von `.where()`¶

Nun, diese .where()-Methode ist besonders und sehr leistungsfähig. Sie ist eng mit SQLModel (eigentlich SQLAlchemy) integriert, damit Sie eine sehr vertraute Python-Syntax und Code verwenden können.

Beachten Sie, dass wir sie nicht mit einem einzelnen Gleichheitszeichen (=) aufgerufen haben, und mit etwas wie

# Not supported 🚨
select(Hero).where(name="Deadpond")

Das wäre natürlich kürzer gewesen, aber es wäre viel fehleranfälliger und eingeschränkter gewesen. Ich zeige Ihnen gleich, warum.

Stattdessen haben wir zwei == verwendet:

select(Hero).where(Hero.name == "Deadpond")

Also, was passiert da?

`.where()` und Ausdrücke¶

Im obigen Beispiel verwenden wir zwei Gleichheitszeichen (==). Das nennt man den "Gleichheitsoperator".

Tipp

Ein Operator ist nur ein Symbol, das neben einem Wert oder zwischen zwei Werten platziert wird, um etwas mit ihnen zu tun.

== wird der Gleichheits-Operator genannt, weil er prüft, ob zwei Dinge gleich sind.

Wenn Sie in Python etwas mit diesem Gleichheitsoperator (==) schreiben, wie z. B.:

some_name == "Deadpond"

...das nennt man eine Gleichheits-"Vergleich", und es ergibt normalerweise einen Wert von:

True

...oder

False

Tipp

<, >, ==, >=, <= und != sind alles Operatoren für Vergleiche.

Aber SQLAlchemy fügt den Spalten/Feldern einer Model-Klasse Magie hinzu, damit diese Python-Vergleiche Superkräfte erhalten.

Wenn Sie also etwas schreiben wie:

Hero.name == "Deadpond"

...ergibt das nicht den Wert True oder False. 🤯

Stattdessen ergibt es einen speziellen Objekttyp. Wenn Sie das in einer interaktiven Python-Sitzung versuchen würden, würden Sie etwas wie das hier sehen:

>>> Hero.name == "Deadpond"
<sqlalchemy.sql.elements.BinaryExpression object at 0x7f4aec0d6c90>

Dieser Ergebniswert ist also ein Ausdrucksobjekt. 💡

Und .where() nimmt einen (oder mehrere) dieser Ausdrucksobjekte, um die SQL-Anweisung zu aktualisieren.

Model-Klassenattribute, Ausdrücke und Instanzen¶

Lassen Sie uns nun eine Sekunde innehalten, um eine wichtige und leicht zu übersehende Unterscheidung zu treffen.

Model-Klassenattribute für jede der Spalten/Felder sind besonders und können für Ausdrücke verwendet werden.

Aber das gilt nur für die Model-Klassenattribute. 🚨

Instanzattribute verhalten sich wie normale Python-Werte. ✅

Wenn Sie also die Klasse (Hero, mit großem H) in einem Python-Vergleich verwenden:

Hero.name == "Deadpond"

...ergibt das eines dieser Ausdrucksobjekte, das mit .where() verwendet wird.

<sqlalchemy.sql.elements.BinaryExpression object at 0x7f4aec0d6c90>

Aber wenn Sie eine Instanz nehmen:

some_hero = Hero(name="Deadpond", secret_name="Dive Wilson")

...und sie in einem Vergleich verwenden:

some_hero.name == "Deadpond"

...ergibt das einen Python-Wert von:

True

...oder wenn es ein anderes Objekt mit einem anderen Namen wäre, könnte es gewesen sein:

False

Der Unterschied ist, dass das eine die Model-Klasse verwendet, das andere eine Instanz.

Klasse oder Instanz¶

Es ist sehr wahrscheinlich, dass Sie eine Variable hero (mit kleinem h) haben werden, wie zum Beispiel:

hero = Hero(name="Deadpond", secret_name="Dive Wilson")

Und jetzt ist die Klasse Hero (mit großem H) und die Instanz ist hero (mit einem kleinen h).

Sie haben also jetzt Hero.name und hero.name, die sehr ähnlich aussehen, aber zwei verschiedene Dinge sind.

>>> Hero.name == "Deadpond"
<sqlalchemy.sql.elements.BinaryExpression object at 0x7f4aec0d6c90>

>>> hero.name == "Deadpond"
True

Das ist einfach etwas, worauf man achten muss. 🤓

Aber nachdem Sie diesen Unterschied zwischen Klassen und Instanzen verstanden haben, kann er sich natürlich anfühlen und Sie können sehr leistungsfähige Dinge tun. 🚀

Zum Beispiel, da hero.name wie ein str funktioniert und Hero.name wie ein spezielles Objekt für Vergleiche funktioniert, könnten Sie Code schreiben wie:

select(Hero).where(Hero.name == hero.name)

Das würde bedeuten:

Hallo SQL-Datenbank 👋, bitte SELECT alle Spalten.

FROM die Tabelle für die Model-Klasse Hero (die Tabelle "hero").

WHERE die Spalte "name" gleich dem Namen dieser Helden-Instanz ist, die ich hier habe: hero.name (im obigen Beispiel der Wert "Deadpond").

`.where()` und Ausdrücke anstelle von Schlüsselwortargumenten¶

Nun, lassen Sie mich Ihnen sagen, warum ich denke, dass es für diesen Anwendungsfall der Interaktion mit SQL-Datenbanken besser ist, diese Ausdrücke zu haben.

# Expression ✨
select(Hero).where(Hero.name == "Deadpond")

...anstelle von Schlüsselwortargumenten wie diesem:

# Not supported, keyword argument 🚨
select(Hero).where(name="Deadpond")

Natürlich wären die Schlüsselwortargumente etwas kürzer gewesen.

Aber mit den Ausdrücken kann Ihnen Ihr Editor viel mit Autovervollständigung und Inline-Fehlerprüfungen helfen. ✨

Lassen Sie mich Ihnen ein Beispiel geben. Stellen wir uns vor, Schlüsselwortargumente wären in SQLModel unterstützt und Sie möchten nach der geheimen Identität von Spider-Boy filtern.

Sie könnten schreiben:

# Don't copy this 🚨
select(Hero).where(secret_identity="Pedro Parqueador")

Der Editor würde den Code sehen, und da er keine Informationen darüber hat, welche Schlüsselwortargumente erlaubt sind und welche nicht, hätte er keine Möglichkeit, Ihnen bei der Fehlererkennung zu helfen.

Vielleicht würde Ihr Code sogar laufen und so aussehen, als wäre alles in Ordnung, und dann würden Sie sich Monate später fragen, warum Ihre App niemals Zeilen findet, obwohl Sie sicher waren, dass es einen "Pedro Parqueador" gab. 😱

Und vielleicht würden Sie schließlich feststellen, dass wir den Code mit secret_identity geschrieben haben, was keine Spalte in der Tabelle ist. Wir hätten stattdessen secret_name schreiben sollen.

Nun, mit den Ausdrücken würde Ihnen Ihr Editor sofort einen Fehler anzeigen, wenn Sie dies versuchen würden:

# Expression ✨
select(Hero).where(Hero.secret_identity == "Pedro Parqueador")

Noch besser, er würde Ihnen die richtige Autovervollständigung anbieten, um zu erhalten:

select(Hero).where(Hero.secret_name == "Pedro Parqueador")

Ich denke, allein die Tatsache, dass bessere Editor-Unterstützung, Autovervollständigung und Inline-Fehler vorhanden sind, reicht aus, um Ausdrücke anstelle von Schlüsselwortargumenten zu rechtfertigen. ✨

Tipp

Ausdrücke bieten auch mehr Funktionen für andere Arten von Vergleichen, die unten gezeigt werden. 👇

Anweisung ausführen¶

Nachdem wir nun wissen, wie .where() funktioniert, lassen Sie uns den Code fertigstellen.

Es ist eigentlich dasselbe wie in früheren Kapiteln zum Auswählen von Daten.

Python 3.10+

# Code above omitted 👆

def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name == "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)

# Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name == "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name == "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

Wir nehmen diese Anweisung, die jetzt ein WHERE enthält, und führen sie mit exec() aus, um die Ergebnisse zu erhalten.

Und in diesem Fall werden die Ergebnisse nur eins sein.

$ python app.py

// Some boilerplate output omitted 😉

// Now the important part, the SELECT with WHERE 💡

INFO Engine SELECT hero.id, hero.name, hero.secret_name, hero.age
FROM hero
WHERE hero.name = ?
INFO Engine [no key 0.00014s] ('Deadpond',)

// Here's the only printed hero
secret_name='Dive Wilson' age=None id=1 name='Deadpond'

Tipp

Das results-Objekt ist ein iterierbares Objekt, das in einer for-Schleife verwendet werden kann.

Auch wenn wir nur eine Zeile erhalten haben, iterieren wir über dieses results-Objekt. Genau so, als wäre es eine Liste mit einem Element.

Wir werden später noch andere Möglichkeiten sehen, die Daten abzurufen.

Andere Vergleiche¶

Hier ist ein weiterer großer Vorteil dieser speziellen Ausdrücke, die an .where() übergeben werden.

Oben haben wir einen "Gleichheits"-Vergleich (mit ==) verwendet, der nur prüft, ob zwei Dinge denselben Wert haben.

Aber wir können andere Standard-Python-Vergleiche verwenden. ✨

Ungleich¶

Wir könnten die Zeilen erhalten, bei denen eine Spalte ungleich einem Wert ist, unter Verwendung von !=.

Python 3.10+

# Code above omitted 👆

def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name != "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)

# Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name != "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.name != "Deadpond")
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

Das würde folgendes ausgeben:

secret_name='Pedro Parqueador' age=None id=2 name='Spider-Boy'
secret_name='Tommy Sharp' age=48 id=3 name='Rusty-Man'

Pause zum Hinzufügen von Daten¶

Lassen Sie uns die Funktion create_heroes() aktualisieren und einige weitere Zeilen hinzufügen, damit die nächsten Vergleichsbeispiele klarer werden.

Python 3.10+

# Code above omitted 👆

def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)
    hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32)
    hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35)
    hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36)
    hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)
        session.add(hero_4)
        session.add(hero_5)
        session.add(hero_6)
        session.add(hero_7)

        session.commit()

# Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)
    hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32)
    hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35)
    hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36)
    hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)
        session.add(hero_4)
        session.add(hero_5)
        session.add(hero_6)
        session.add(hero_7)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.age > 35)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)
    hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32)
    hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35)
    hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36)
    hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)
        session.add(hero_4)
        session.add(hero_5)
        session.add(hero_6)
        session.add(hero_7)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.age > 35)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

Nachdem wir nun mehrere Helden mit unterschiedlichen Altersangaben haben, wird deutlicher, was die nächsten Vergleiche bewirken.

Größer als¶

Verwenden wir nun >, um die Zeilen zu erhalten, bei denen eine Spalte größer als ein Wert ist.

Python 3.10+

# Code above omitted 👆

def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.age > 35)
        results = session.exec(statement)
        for hero in results:
            print(hero)

# Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)
    hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32)
    hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35)
    hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36)
    hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)
        session.add(hero_4)
        session.add(hero_5)
        session.add(hero_6)
        session.add(hero_7)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.age > 35)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
    hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
    hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)
    hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32)
    hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35)
    hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36)
    hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93)

    with Session(engine) as session:
        session.add(hero_1)
        session.add(hero_2)
        session.add(hero_3)
        session.add(hero_4)
        session.add(hero_5)
        session.add(hero_6)
        session.add(hero_7)

        session.commit()


def select_heroes():
    with Session(engine) as session:
        statement = select(Hero).where(Hero.age > 35)
        results = session.exec(statement)
        for hero in results:
            print(hero)


def main():
    create_db_and_tables()
    create_heroes()
    select_heroes()


if __name__ == "__main__":
    main()

Das würde folgendes ausgeben:

age=48 id=3 name='Rusty-Man' secret_name='Tommy Sharp'
age=36 id=6 name='Dr. Weird' secret_name='Steve Weird'
age=93 id=7 name='Captain North America' secret_name='Esteban Rogelios'

Tipp

Beachten Sie, dass Black Lion nicht ausgewählt wurde, da das Alter nicht strikt* größer als 35 ist.

Größer als oder gleich¶

Machen wir das noch einmal, aber mit >=, um die Zeilen zu erhalten, bei denen eine Spalte größer als oder gleich einem Wert ist.

Python 3.10+

# Code above omitted 👆 def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35) results = session.exec(statement) for hero in results: print(hero) # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Da wir >= verwenden, wird das Alter 35 in die Ausgabe aufgenommen.

age=48 id=3 name='Rusty-Man' secret_name='Tommy Sharp' age=35 id=5 name='Black Lion' secret_name='Trevor Challa' age=36 id=6 name='Dr. Weird' secret_name='Steve Weird' age=93 id=7 name='Captain North America' secret_name='Esteban Rogelios'

Tipp

Diesmal haben wir auch Black Lion erhalten, weil das Alter zwar nicht strikt* größer als 35 ist, aber gleich 35 ist.

Kleiner als¶

Ähnlich können wir < verwenden, um die Zeilen zu erhalten, bei denen eine Spalte kleiner als ein Wert ist.

Python 3.10+

# Code above omitted 👆 def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age < 35) results = session.exec(statement) for hero in results: print(hero) # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age < 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age < 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Und wir erhalten den jüngeren mit einem Alter in der Datenbank.

age=32 id=4 name='Tarantula' secret_name='Natalia Roman-on'

Tipp

Wir könnten uns vorstellen, dass Spider-Boy sogar jünger ist. Aber da wir das Alter nicht kennen, ist es in der Datenbank NULL (None in Python) und passt nicht zu diesen Altersvergleichen mit Zahlen.

Kleiner als oder gleich¶

Schließlich können wir <= verwenden, um die Zeilen zu erhalten, bei denen eine Spalte kleiner als oder gleich einem Wert ist.

Python 3.10+

# Code above omitted 👆 def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: print(hero) # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Und wir erhalten die jüngeren, 35 und darunter.

age=32 id=4 name='Tarantula' secret_name='Natalia Roman-on' age=35 id=5 name='Black Lion' secret_name='Trevor Challa'

Tipp

Wir erhalten hier auch Black Lion, weil das Alter zwar nicht strikt* kleiner als 35 ist, aber gleich 35 ist.

Vorteile von Ausdrücken¶

Dies ist ein guter Zeitpunkt, um zu sehen, dass die Verwendung dieser reinen Python-Ausdrücke anstelle von Schlüsselwortargumenten sehr hilfreich sein kann. ✨

Wir können dieselben Standard-Python-Vergleichsoperatoren wie <, <=, >, >=, == usw. verwenden.

Mehrere .where()¶

Da .where() dasselbe spezielle select-Objekt zurückgibt, können wir weitere .where()-Aufrufe hinzufügen.

Python 3.10+

# Code above omitted 👆 def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35).where(Hero.age < 40) results = session.exec(statement) for hero in results: print(hero) # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35).where(Hero.age < 40) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35).where(Hero.age < 40) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Dies wählt die Zeilen aus, WHERE das age größer oder gleich 35 ist, AND auch das age kleiner als 40 ist.

Die äquivalente SQL wäre:

SELECT id, name, secret_name, age FROM hero WHERE age >= 35 AND age < 40

Dies verwendet AND, um beide Vergleiche zu kombinieren.

Wir können es dann ausführen, um die Ausgabe des Programms zu sehen.

$ python app.py // Some boilerplate output omitted 😉 // The SELECT statement with WHERE, also using AND INFO Engine SELECT hero.id, hero.name, hero.secret_name, hero.age FROM hero WHERE hero.age >= ? AND hero.age < ? INFO Engine [no key 0.00014s] (35, 40) // The two heroes printed age=35 id=5 name='Black Lion' secret_name='Trevor Challa' age=36 id=6 name='Dr. Weird' secret_name='Steve Weird'

.where() mit mehreren Ausdrücken¶

Als Alternative zur Verwendung mehrerer .where() können wir auch mehrere Ausdrücke an ein einziges .where() übergeben.

Python 3.10+

# Code above omitted 👆 def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35, Hero.age < 40) results = session.exec(statement) for hero in results: print(hero) # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35, Hero.age < 40) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(Hero.age >= 35, Hero.age < 40) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Dies ist dasselbe wie oben und führt zur selben Ausgabe mit den beiden Helden.

age=35 id=5 name='Black Lion' secret_name='Trevor Challa' age=36 id=6 name='Dr. Weird' secret_name='Steve Weird'

.where() mit mehreren Ausdrücken unter Verwendung von OR¶

Diese letzten Beispiele verwenden where() mit mehreren Ausdrücken. Und diese werden dann in der endgültigen SQL mit AND kombiniert, was bedeutet, dass alle* Ausdrücke in einer Zeile wahr sein müssen, damit sie in die Ergebnisse aufgenommen wird.

Aber wir können Ausdrücke auch mit OR kombinieren. Das bedeutet, dass irgendeiner (aber nicht unbedingt alle) der Ausdrücke in einer Zeile wahr sein muss, damit sie aufgenommen wird.

Dazu können Sie or_ importieren.

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, or_, select # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, or_, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(or_(Hero.age <= 35, Hero.age > 90)) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, create_engine, or_, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(or_(Hero.age <= 35, Hero.age > 90)) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Und dann beide Ausdrücke an or_() übergeben und sie in .where() einfügen.

Hier wählen wir zum Beispiel die Helden aus, die die jüngsten ODER die ältesten sind.

Python 3.10+

# Code above omitted 👆 def select_heroes(): with Session(engine) as session: statement = select(Hero).where(or_(Hero.age <= 35, Hero.age > 90)) results = session.exec(statement) for hero in results: print(hero) # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, create_engine, or_, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(or_(Hero.age <= 35, Hero.age > 90)) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, create_engine, or_, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(or_(Hero.age <= 35, Hero.age > 90)) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Wenn wir es ausführen, erzeugt dies die Ausgabe:

$ python app.py // Some boilerplate output omitted 😉 // The SELECT statement with WHERE, also using OR 🔍 INFO Engine SELECT hero.id, hero.name, hero.secret_name, hero.age FROM hero WHERE hero.age <= ? OR hero.age > ? INFO Engine [no key 0.00021s] (35, 90) // The results include the youngest and oldest ✨ secret_name='Natalia Roman-on' age=32 id=4 name='Tarantula' secret_name='Trevor Challa' age=35 id=5 name='Black Lion' secret_name='Esteban Rogelios' age=93 id=7 name='Captain North America'

Typ-Annotationen und Fehler¶

Es besteht die Möglichkeit, dass Ihr Editor einen Fehler anzeigt, wenn Sie diese Vergleiche verwenden, wie zum Beispiel:

Hero.age > 35

Es wäre ein Fehler, der Ihnen mitteilt, dass:

Hero.age ist potenziell None, und Sie können None nicht mit > vergleichen.

Das liegt daran, dass wir reine und einfache Python-Annotationen für die Felder verwenden, age ist tatsächlich als int | None annotiert.

Durch die Verwendung dieser einfachen und Standard-Python-Typannotationen erhalten wir den Vorteil der zusätzlichen Einfachheit und der Inline-Fehlerprüfungen beim Erstellen oder Verwenden von Instanzen. ✨

Und wenn wir diese speziellen Klassenattribute in einem .where() verwenden, weiß das spezielle Klassenattribut während der Programmausführung, dass der Vergleich nur für Werte gilt, die in der Datenbank nicht NULL sind, und es funktioniert korrekt.

Aber der Editor weiß nicht, dass es sich um ein spezielles Klassenattribut handelt, daher versucht er, uns bei der Verhinderung eines Fehlers zu helfen (der in diesem Fall ein Fehlalarm ist).

Dennoch können wir das leicht beheben. 🎉

Wir können dem Editor mitteilen, dass dieses Klassenattribut tatsächlich eine spezielle SQLModel-Spalte ist (anstelle eines Instanzattributs mit einem normalen Wert).

Dazu können wir col() (als Kurzform für "column") importieren.

Python 3.10+

from sqlmodel import Field, Session, SQLModel, col, create_engine, select # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, col, create_engine, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(col(Hero.age) >= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, col, create_engine, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(col(Hero.age) >= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Und dann das Klassenattribut in col() einschließen, wenn wir es in einem .where() verwenden.

Python 3.10+

# Code above omitted 👆 def select_heroes(): with Session(engine) as session: statement = select(Hero).where(col(Hero.age) >= 35) results = session.exec(statement) for hero in results: print(hero) # Code below omitted 👇

👀 Vorschau der vollständigen Datei

Python 3.10+

from sqlmodel import Field, Session, SQLModel, col, create_engine, select class Hero(SQLModel, table=True): id: int | None = Field(default=None, primary_key=True) name: str secret_name: str age: int | None = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(col(Hero.age) >= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

🤓 Andere Versionen und Varianten

Python 3.8+

from typing import Optional from sqlmodel import Field, Session, SQLModel, col, create_engine, select class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine = create_engine(sqlite_url, echo=True) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def create_heroes(): hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson") hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador") hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48) hero_4 = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32) hero_5 = Hero(name="Black Lion", secret_name="Trevor Challa", age=35) hero_6 = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36) hero_7 = Hero(name="Captain North America", secret_name="Esteban Rogelios", age=93) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.add(hero_4) session.add(hero_5) session.add(hero_6) session.add(hero_7) session.commit() def select_heroes(): with Session(engine) as session: statement = select(Hero).where(col(Hero.age) >= 35) results = session.exec(statement) for hero in results: print(hero) def main(): create_db_and_tables() create_heroes() select_heroes() if __name__ == "__main__": main()

Die Vergleich ist also nicht mehr:

Hero.age > 35

...sondern:

col(Hero.age) > 35

Und damit weiß der Editor, dass dieser Code tatsächlich in Ordnung ist, da dies eine spezielle SQLModel-Spalte ist.

Tipp

Dieses col() wird später nützlich sein und Autovervollständigung für mehrere andere Dinge bieten, die wir mit diesen speziellen Klassenattributen für Spalten tun können.

Aber das kommt später.

Zusammenfassung¶

Sie können .where() mit leistungsstarken Ausdrücken unter Verwendung von SQLModel-Spalten (den speziellen Klassenattributen) verwenden, um die gewünschten Zeilen zu filtern. 🚀

Bis jetzt hat die Datenbank jeden einzelnen Datensatz (Zeile) durchsucht, um die passenden zu finden. Wenn Sie Tausende oder Millionen von Datensätzen haben, kann dies sehr langsam sein. 😱

Im nächsten Abschnitt erfahren Sie, wie Sie Indizes zur Datenbank hinzufügen können. Das macht die Abfragen sehr effizient. 😎

Daten filtern - WHERE¶

Weiter mit vorherigem Code¶

Daten mit SQL filtern¶

`WHERE` und `FROM` sind "Klauseln"¶

`SELECT` und `WHERE`¶

`SELECT` Land¶

`WHERE` Land¶

`SELECT` mit SQLModel überprüfen¶

Zeilen mit `WHERE` und SQLModel filtern¶

`select()` Objekte¶

Aufruf von `.where()`¶

`.where()` und Ausdrücke¶

Model-Klassenattribute, Ausdrücke und Instanzen¶

Klasse oder Instanz¶

`.where()` und Ausdrücke anstelle von Schlüsselwortargumenten¶

Anweisung ausführen¶

Andere Vergleiche¶

Ungleich¶

Pause zum Hinzufügen von Daten¶

Größer als¶

Größer als oder gleich¶

Kleiner als¶

Kleiner als oder gleich¶

Vorteile von Ausdrücken¶

Mehrere `.where()`¶

`.where()` mit mehreren Ausdrücken¶

`.where()` mit mehreren Ausdrücken unter Verwendung von `OR`¶

Typ-Annotationen und Fehler¶

Zusammenfassung¶

Daten filtern - WHERE¶

Weiter mit vorherigem Code¶

Daten mit SQL filtern¶

WHERE und FROM sind "Klauseln"¶

SELECT und WHERE¶

SELECT Land¶

WHERE Land¶

SELECT mit SQLModel überprüfen¶

Zeilen mit WHERE und SQLModel filtern¶

select() Objekte¶

Aufruf von .where()¶

.where() und Ausdrücke¶

Model-Klassenattribute, Ausdrücke und Instanzen¶

Klasse oder Instanz¶

.where() und Ausdrücke anstelle von Schlüsselwortargumenten¶

Anweisung ausführen¶

Andere Vergleiche¶

Ungleich¶

Pause zum Hinzufügen von Daten¶

Größer als¶

Größer als oder gleich¶

Kleiner als¶

Kleiner als oder gleich¶

Vorteile von Ausdrücken¶

Mehrere .where()¶

.where() mit mehreren Ausdrücken¶

.where() mit mehreren Ausdrücken unter Verwendung von OR¶

Typ-Annotationen und Fehler¶

Zusammenfassung¶

`WHERE` und `FROM` sind "Klauseln"¶

`SELECT` und `WHERE`¶

`SELECT` Land¶

`WHERE` Land¶

`SELECT` mit SQLModel überprüfen¶

Zeilen mit `WHERE` und SQLModel filtern¶

`select()` Objekte¶

Aufruf von `.where()`¶

`.where()` und Ausdrücke¶

`.where()` und Ausdrücke anstelle von Schlüsselwortargumenten¶

Mehrere `.where()`¶

`.where()` mit mehreren Ausdrücken¶

`.where()` mit mehreren Ausdrücken unter Verwendung von `OR`¶