Hubungan Satu-ke-Banyak dan Banyak-ke-Banyak dalam Python dengan SQLite

Apabila bekerja dengan pangkalan data dalam Python, memahami hubungan antara jadual adalah penting. Dua daripada perhubungan paling biasa yang anda akan temui ialah satu-ke-banyak dan banyak-ke-banyak. Mari gunakan contoh WNBA untuk meneroka apakah hubungan ini, cara ia berfungsi dalam SQLite dan cara melaksanakannya menggunakan Python.

Apakah Hubungan Satu-ke-Ramai dan Banyak-ke-Ramai?

Satu-ke-Banyak

Perhubungan satu dengan banyak bermakna satu rekod dalam jadual dikaitkan dengan berbilang rekod dalam jadual lain. Contohnya, dalam pangkalan data pasukan dan atlet:

• Satu pasukan boleh mempunyai ramai atlet.
• Setiap atlet tergolong dalam satu pasukan sahaja.

Banyak-ke-Ramai

Perhubungan banyak-ke-banyak berlaku apabila berbilang rekod dalam satu jadual dikaitkan dengan berbilang rekod dalam jadual lain. Contohnya, dalam pangkalan data atlet dan tawaran penajaan:

• Seorang atlet boleh mengadakan tawaran dengan banyak jenama.
• Sesuatu jenama boleh mengadakan tawaran dengan ramai atlet.

Untuk melaksanakan perhubungan banyak-ke-banyak dalam SQLite, anda memerlukan jadual persimpangan (juga dikenali sebagai jadual jambatan atau perkaitan) untuk memautkan dua jadual utama.

Melaksanakan Perhubungan dalam Python dengan SQLite

Menyediakan Pangkalan Data

Pertama, mari buat pangkalan data untuk menunjukkan perhubungan ini.

import sqlite3

Sambung ke pangkalan data SQLite (atau buat satu jika ia tidak wujud)

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

Buat jadual

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: Pasukan dan Atlet

Mari tambah data untuk menunjukkan hubungan satu-dengan-banyak antara pasukan dan atlet.

Masukkan pasukan dan atlet

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

Untuk menyoal semua atlet dalam satu pasukan:

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

Many-to-Many: Atlet dan Jenama

Sekarang, mari tambah data untuk menunjukkan hubungan banyak-ke-banyak antara atlet dan jenama menggunakan jadual Tawaran.

Masukkan jenama

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

Sisipkan tawaran

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

Untuk menanyakan semua jenama yang dikaitkan dengan seorang atlet:

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)

Kesimpulan

Dengan mentakrifkan perhubungan dengan kunci asing dalam SQLite dan menggunakan Python untuk mengurus data, anda boleh mencipta pangkalan data yang teguh dengan sambungan yang jelas antara jadual. Memahami perhubungan satu-ke-banyak dan banyak-ke-banyak adalah penting untuk menstruktur data dengan berkesan.

Contoh mudah ini mencalarkan permukaan, tetapi anda boleh mengembangkannya untuk mengendalikan perhubungan yang lebih kompleks.

Atas ialah kandungan terperinci Hubungan Satu-ke-Banyak dan Banyak-ke-Banyak dalam Python dengan SQLite. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!