Eins-zu-Viele- und Viele-zu-Viele-Beziehungen in Python mit SQLite

Bei der Arbeit mit Datenbanken in Python ist das Verständnis der Beziehungen zwischen Tabellen von entscheidender Bedeutung. Zwei der häufigsten Beziehungen, denen Sie begegnen werden, sind Eins-zu-Viele- und Viele-zu-Viele-Beziehungen. Lassen Sie uns anhand eines WNBA-Beispiels untersuchen, was diese Beziehungen sind, wie sie in SQLite funktionieren und wie man sie mit Python implementiert.

Was sind One-to-Many- und Many-to-Many-Beziehungen?

Eins-zu-Viele

Eine Eins-zu-viele-Beziehung bedeutet, dass ein Datensatz in einer Tabelle mit mehreren Datensätzen in einer anderen Tabelle verknüpft ist. Zum Beispiel in einer Datenbank mit Mannschaften und Sportlern:

• Ein Team kann viele Athleten haben.
• Jeder Athlet gehört nur einer Mannschaft an.

Viele-zu-viele

Eine Viele-zu-Viele-Beziehung liegt vor, wenn mehrere Datensätze in einer Tabelle mit mehreren Datensätzen in einer anderen Tabelle verknüpft sind. Zum Beispiel in einer Datenbank mit Sportlern und Sponsoring-Angeboten:

• Ein Sportler kann mit vielen Marken Geschäfte machen.
• Eine Marke kann mit vielen Sportlern Geschäfte machen.

Um Viele-zu-Viele-Beziehungen in SQLite zu implementieren, benötigen Sie eine Verbindungstabelle (auch als Bridge oder Assoziationstabelle bekannt), um die beiden Haupttabellen zu verknüpfen.

Beziehungen in Python mit SQLite implementieren

Einrichten der Datenbank

Erstellen wir zunächst eine Datenbank, um diese Beziehungen zu demonstrieren.

import sqlite3

Stellen Sie eine Verbindung zur SQLite-Datenbank her (oder erstellen Sie eine, falls diese nicht vorhanden ist).

conn = sqlite3.connect("sports.db")
cursor = conn.cursor()

Tabellen erstellen

cursor.execute("""
CREATE TABLE IF NOT EXISTS Team (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL
)
""")

cursor.execute("""
CREATE TABLE IF NOT EXISTS Athlete (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    team_id INTEGER,
    FOREIGN KEY (team_id) REFERENCES Team (id)
)
""")

cursor.execute("""
CREATE TABLE IF NOT EXISTS Brand (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL
)
""")

cursor.execute("""
CREATE TABLE IF NOT EXISTS Deal (
    id INTEGER PRIMARY KEY,
    athlete_id INTEGER,
    brand_id INTEGER,
    FOREIGN KEY (athlete_id) REFERENCES Athlete (id),
    FOREIGN KEY (brand_id) REFERENCES Brand (id)
)
""")

conn.commit()

One-to-Many: Teams und Athleten

Fügen wir Daten hinzu, um die Eins-zu-viele-Beziehung zwischen Teams und Athleten zu demonstrieren.

Fügen Sie ein Team und Athleten ein

cursor.execute("INSERT INTO Team (name) VALUES (?)", ("New York Liberty",))
team_id = cursor.lastrowid

cursor.execute("INSERT INTO Athlete (name, team_id) VALUES (?, ?)", ("Breanna Stewart", team_id))
cursor.execute("INSERT INTO Athlete (name, team_id) VALUES (?, ?)", ("Sabrina Ionescu", team_id))

conn.commit()

So fragen Sie alle Athleten eines Teams ab:

cursor.execute("SELECT name FROM Athlete WHERE team_id = ?", (team_id,))
athletes = cursor.fetchall()
print("Athletes on the team:", athletes)

Many-to-Many: Sportler und Marken

Fügen wir nun Daten hinzu, um die Viele-zu-Viele-Beziehung zwischen Sportlern und Marken mithilfe der Deal-Tabelle zu demonstrieren.

Marken einfügen

cursor.execute("INSERT INTO Brand (name) VALUES (?)", ("Nike",))
brand_id_nike = cursor.lastrowid

cursor.execute("INSERT INTO Brand (name) VALUES (?)", ("Adidas",))
brand_id_adidas = cursor.lastrowid

Angebote einfügen

cursor.execute("INSERT INTO Deal (athlete_id, brand_id) VALUES (?, ?)", (1, brand_id_nike))
cursor.execute("INSERT INTO Deal (athlete_id, brand_id) VALUES (?, ?)", (1, brand_id_adidas))
cursor.execute("INSERT INTO Deal (athlete_id, brand_id) VALUES (?, ?)", (2, brand_id_nike))

conn.commit()

So fragen Sie alle mit einem Sportler verbundenen Marken ab:

cursor.execute("""
SELECT Brand.name 
FROM Brand
JOIN Deal ON Brand.id = Deal.brand_id
WHERE Deal.athlete_id = ?
""", (1,))
brands = cursor.fetchall()
print("Brands for Athlete 1:", brands)

Abschluss

Durch die Definition von Beziehungen mit Fremdschlüsseln in SQLite und die Verwendung von Python zur Datenverwaltung können Sie robuste Datenbanken mit klaren Verbindungen zwischen Tabellen erstellen. Das Verständnis von Eins-zu-viele- und Viele-zu-viele-Beziehungen ist für die effektive Strukturierung von Daten von entscheidender Bedeutung.

Dieses einfache Beispiel kratzt an der Oberfläche, aber Sie können es erweitern, um komplexere Beziehungen zu verarbeiten.

Das obige ist der detaillierte Inhalt vonEins-zu-Viele- und Viele-zu-Viele-Beziehungen in Python mit SQLite. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!