Relations un-à-plusieurs et plusieurs-à-plusieurs en Python avec SQLite

Lorsque vous travaillez avec des bases de données en Python, il est crucial de comprendre les relations entre les tables. Deux des relations les plus courantes que vous rencontrerez sont les relations un-à-plusieurs et plusieurs-à-plusieurs. Utilisons un exemple WNBA pour explorer quelles sont ces relations, comment elles fonctionnent dans SQLite et comment les implémenter à l'aide de Python.

Que sont les relations un-à-plusieurs et plusieurs-à-plusieurs ?

Un à plusieurs

Une relation un-à-plusieurs signifie qu'un enregistrement d'une table est associé à plusieurs enregistrements d'une autre table. Par exemple, dans une base de données d'équipes et d'athlètes :

• Une équipe peut avoir plusieurs athlètes.
• Chaque athlète appartient à une seule équipe.

Plusieurs à plusieurs

Une relation plusieurs-à-plusieurs se produit lorsque plusieurs enregistrements d'une table sont associés à plusieurs enregistrements d'une autre table. Par exemple, dans une base de données d'athlètes et d'offres de sponsoring :

• Un athlète peut conclure des accords avec de nombreuses marques.
• Une marque peut avoir des accords avec de nombreux athlètes.

Pour implémenter des relations plusieurs-à-plusieurs dans SQLite, vous avez besoin d'une table de jonction (également appelée table de pont ou table d'association) pour relier les deux tables principales.

Implémentation de relations en Python avec SQLite

Configuration de la base de données

Tout d’abord, créons une base de données pour démontrer ces relations.

import sqlite3

Connectez-vous à la base de données SQLite (ou créez-en une si elle n'existe pas)

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

Créer des tableaux

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()

Un à plusieurs : équipes et athlètes

Ajoutons des données pour démontrer la relation un-à-plusieurs entre les équipes et les athlètes.

Insérer une équipe et des athlètes

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()

Pour interroger tous les athlètes d’une équipe :

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

Plusieurs à plusieurs : athlètes et marques

Maintenant, ajoutons des données pour démontrer la relation plusieurs-à-plusieurs entre les athlètes et les marques à l'aide de la table Deal.

Insérer des marques

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

Insérer des offres

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()

Pour interroger toutes les marques associées à un athlète :

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)

Conclusion

En définissant des relations avec des clés étrangères dans SQLite et en utilisant Python pour gérer les données, vous pouvez créer des bases de données robustes avec des connexions claires entre les tables. Comprendre les relations un-à-plusieurs et plusieurs-à-plusieurs est essentiel pour structurer efficacement les données.

Cet exemple simple ne fait qu'effleurer la surface, mais vous pouvez l'étendre pour gérer des relations plus complexes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!