Zusammenfassung der MySQL-Fremdschlüsseleinschränkungen und Tabellenbeziehungen

Fremdschlüssel

Wie oben erwähnt, wird durch das Speichern von Mitarbeiterinformationen in einer Tabelle viel Ressourcen verschwendet und es entstehen zu viele doppelte Daten. Dieses Problem ist ähnlich wie das Schreiben aller Codes in eine PY-Datei. Daher können wir eine Tabelle in verschiedene Tabellen aufteilen und Verknüpfungen zwischen diesen verschiedenen Tabellen herstellen. Um Verknüpfungen herzustellen, müssen wir Fremdschlüssel verwenden. Auch Fremdschlüssel sind eine Art Einschränkung.

So ermitteln Sie Tabellenbeziehungen

Es gibt drei Arten von Beziehungen zwischen Tabellen: Eins-zu-viele, Viele-zu-viele und Eins-zu-eins. Wie bestimmen Sie also die Beziehung zwischen Tabellen?

Es empfiehlt sich, sich bei der Bestimmung der Beziehungen zwischen Tabellen in die Perspektive des anderen zu versetzen. Was bedeutet das? Das heißt, betrachten Sie es aus der Perspektive zweier Tabellen, beispielsweise der Beziehung zwischen der Mitarbeitertabelle und der Abteilungstabelle:

Betrachten wir es zunächst aus der Perspektive der Mitarbeitertabelle: Kann ein Mitarbeiter in der Mitarbeitertabelle mehreren Abteilungen angehören? Die Antwort ist nein

Aus Sicht der Abteilungstabelle: Kann eine Abteilung in der Abteilungstabelle mehrere Mitarbeiter haben? Die Antwort ist ja

Daher bestehen zwischen der Mitarbeitertabelle und der Abteilungstabelle unidirektionale Eins-zu-viele-Beziehungen, und zwischen der Mitarbeitertabelle und der Abteilungstabelle bestehen Eins-zu-viele-Beziehungen.

So erstellen Sie Tabellenbeziehungen

Beim Herstellen von Tabellenbeziehungen wird für die Verknüpfung zwischen Tabellen normalerweise die Primärschlüssel-ID als Verknüpfungsfeld verwendet.

Eins-zu-viele-Beziehung - Mitarbeitertabelle und Abteilungstabelle

In MySQL-Beziehungen gibt es kein Konzept von Viele-zu-Eins. Eins-zu-Viele und Viele-zu-Eins sind beide Eins-zu-Viele. Beim Erstellen einer Eins-zu-viele-Tabellenbeziehung müssen Sie die folgenden Punkte beachten:

Zunächst wird das Fremdschlüsselfeld auf der Multiple-Seite, also der Mitarbeitertabelle, eingerichtet

Zweitens müssen Sie beim Erstellen einer Tabelle zuerst die zugehörige Partei erstellen, d. h. die Abteilungstabelle

Drittens müssen Sie bei der Dateneingabe zuerst die Daten der zugehörigen Tabelle eingeben, also die Daten der Abteilungstabelle.

Viertens: Wenn verschiedene Tabellen Beziehungen herstellen, sind kaskadierende Aktualisierungen und Löschungen erforderlich, die auch als synchrone Aktualisierungen und Löschungen bezeichnet werden können. Wenn keine kaskadierenden Aktualisierungen und Löschungen hergestellt werden, können die zugehörigen Daten in der zugehörigen Tabelle nicht gelöscht oder die ID nicht geändert werden, da die beiden Tabellen miteinander verbunden sind.

-- Erstellen Sie die zugehörige Tabelle, Abteilungstabellemysql> create table bm(
    ID int Primärschlüssel auto_increment, 
    bm_name varchar(10), 
    bm_desc char(64)
);
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)

mysql> Beschreibung bm;
+---------+----------+------+-----+---------+----------------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+---------+----------+------+-----+---------+----------------+
| id | int(11) | NEIN | PRI | NULL | auto_increment |
| bm_name | varchar(10) | JA | | NULL | |
| bm_desc | char(64) | JA | | NULL | |
+---------+----------+------+-----+---------+----------------+
3 Zeilen im Satz (0,01 Sek.)

-- Erstellen Sie die Tabelle, in der sich der Fremdschlüssel befindet, die Mitarbeitertabellemysql> create table yg(
    ID int Primärschlüssel auto_increment, 
    yg_name varchar(6), 
    bm_id int, 
    Fremdschlüssel (bm_id) verweist auf bm(id) – gibt an, dass bm_id ein Fremdschlüsselfeld ist, das mit dem ID-Feld in der bm-Tabelle verknüpft ist (bei Update-Kaskade # Kaskaden-Update, bei Löschen-Kaskade # Kaskaden-Löschen);
Abfrage OK, 0 Zeilen betroffen (0,10 Sek.)

mysql> Beschreibung yg;
+---------+------------+------+-----+---------+----------------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+---------+------------+------+-----+---------+----------------+
| id | int(11) | NEIN | PRI | NULL | auto_increment |
| yg_name | varchar(6) | JA | | NULL | |
| bm_id | int(11) | JA | MUL | NULL | |
+---------+------------+------+-----+---------+----------------+
3 Zeilen im Satz (0,01 Sek.)


-- Daten einfügenmysql> in bm einfügen (bm_name, bm_desc) Werte ('Python', 'Das Leben ist kurz'), ('go', 'lass uns gehen');
Abfrage OK, 2 Zeilen betroffen (0,00 Sek.)
Datensätze: 2 Duplikate: 0 Warnungen: 0

mysql> wähle * von bm;
+----+---------+--------------+
| Ich würde | bm_name | bm_desc |
+----+---------+--------------+
| 1 | Python | das Leben ist kurz |
| 2 | geh | lass uns gehen |
+----+---------+--------------+
2 Zeilen im Satz (0,00 Sek.)


mysql> in yg einfügen (yg_name, bm_id) Werte ('xu', 1), ('zhuang', 2), ('lili', 1);
Abfrage OK, 3 Zeilen betroffen (0,09 Sek.)
Datensätze: 3 Duplikate: 0 Warnungen: 0

mysql> wähle * von yg;
+----+---------+-------+
| Ich würde | yg_name | bm_id |
+----+---------+-------+
| 2 | xu | 1 |
| 3 | zhuang | 2 |
| 4 | Lilie | 1 |
+----+---------+-------+
3 Zeilen im Satz (0,00 Sek.)

-- Die mit dem Fremdschlüssel verknüpften Daten müssen in der verknüpften Tabelle vorhanden sein, sonst wird ein Fehler gemeldet~
mysql> in yg einfügen (yg_name, bm_id) Werte ('xu', 3);
FEHLER 1452 (23000): Eine untergeordnete Zeile kann nicht hinzugefügt oder aktualisiert werden: Eine Fremdschlüsseleinschränkung schlägt fehl (`book_manage`.`yg`, EINSCHRÄNKUNG `yg_ibfk_1` FREMDER SCHLÜSSEL (`bm_id`) REFERENZEN `bm` (`id`))

-- Wenn keine kaskadierenden Aktualisierungen und Löschungen verwendet werden, treten die folgenden Fehler auf. Die folgenden SQL-Anweisungen werden in den folgenden Artikeln vorgestellt. . .
mysql> update bm set id=5 where id=2; -- Ändert den Datensatz mit der ID=2 in der bm-Tabelle in die ID=5.
FEHLER 1451 (23000): Eine übergeordnete Zeile kann nicht gelöscht oder aktualisiert werden: Eine Fremdschlüsseleinschränkung schlägt fehl (`book_manage`.`yg`, EINSCHRÄNKUNG `yg_ibfk_1` FREMDER SCHLÜSSEL (`bm_id`) REFERENZEN `bm` (`id`))

mysql> delete from bm where id = 2; -- Löscht den Datensatz mit der ID 2 in der bm-Tabelle. FEHLER 1451 (23000): Eine übergeordnete Zeile kann nicht gelöscht oder aktualisiert werden: Eine Fremdschlüsseleinschränkung schlägt fehl (`book_manage`.`yg`, EINSCHRÄNKUNG `yg_ibfk_1` FREMDER SCHLÜSSEL (`bm_id`) REFERENZEN `bm` (`id`)) 

Viele-zu-viele

Die Viele-zu-viele-Beziehung wird am Beispiel von Büchern und Autoren ausführlich vorgestellt. Warum besteht zwischen Büchern und Autoren eine Viele-zu-viele-Beziehung?

Beginnen wir mit der Perspektive des Büchertisches: Kann ein Buch mehrere Autoren haben? Die Antwort ist ja

Aus Sicht der Autorentabelle: Kann ein Autor mehrere Bücher schreiben? Die Antwort ist ja

Die Buchtabelle und die Autorentabelle sind bidirektional Eins-zu-viele, die Beziehung zwischen den beiden Tabellen ist also Viele-zu-viele.

Lassen Sie uns zwei Tabellen erstellen:

-- Erstellen Sie eine Buchtabelle create table book(
    ID int Primärschlüssel auto_increment,
    Titel varchar(32),
    Preis int,
    Autor_ID int,
    Der Fremdschlüssel (Autor-ID) verweist auf den Autor (ID).
    bei Updatekaskade
    bei Löschkaskade
);

-- Erstellen Sie die Autorentabelle create table author(
    ID int Primärschlüssel auto_increment,
    Name varchar(32),
    Alter int,
    Buch-ID int,
    Fremdschlüssel (Buch-ID) verweist auf Buch (ID)
    bei Updatekaskade
    bei Löschkaskade
);

Wenn Sie eine Tabelle auf die oben beschriebene Weise erstellen, wird dies definitiv nicht erfolgreich sein. Beim Erstellen einer Eins-zu-viele-Tabellenbeziehung haben wir gesagt, dass wir zuerst die zugehörige Tabelle erstellen sollten, d. h. die Tabelle ohne Fremdschlüssel. Eine Viele-zu-viele-Beziehung ist jedoch eine bidirektionale Eins-zu-viele-Beziehung, und in jeder Tabelle gibt es Fremdschlüssel. Was soll ich tun? Die Lösung besteht darin, eine dritte Tabelle zu erstellen, in der die Verknüpfung zwischen den beiden Tabellen der Viele-zu-viele-Beziehung gespeichert wird.

-- Erstellen Sie eine Buchtabellemysql> create table book(
    ID int Primärschlüssel auto_increment, 
    Name varchar(10), 
    Preis int
);
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)

-- Erstellen Sie die Autorentabellemysql> create table author(
    ID int Primärschlüssel auto_increment, 
    Name varchar(6), 
    Alter int
);
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)


-- Erstellen Sie die dritte Kapiteltabelle, um die Verknüpfung zwischen den Buch- und Autorentabellen zu speichernmysql> create table book2author(
    ID int Primärschlüssel auto_increment, 
    Autor_ID int, 
    Buch-ID int, 
    Der Fremdschlüssel (Autor-ID) verweist auf den Autor (ID). 
    bei Updatekaskade 
    beim Löschen der Kaskade, 	
    Fremdschlüssel (Buch-ID) verweist auf Buch (ID) 
    bei Updatekaskade 
    beim Löschen der Kaskade);
Abfrage OK, 0 Zeilen betroffen (0,02 Sek.)

Eins-zu-eins

Wenn eine Tabelle viele Felder hat und nicht alle bei jeder Datenabfrage verwendet werden können, können wir die Tabelle in zwei Teile aufteilen. In der Benutzerinformationstabelle umfassen die Benutzerinformationen beispielsweise Benutzername, Passwort, Alter, Geschlecht, Adresse, Telefonnummer usw., und nur Benutzername und Passwort des Benutzers werden möglicherweise häufig verwendet. In diesem Fall können wir eine Benutzerinformationstabelle in eine Tabelle mit grundlegenden Benutzerinformationen und eine Tabelle mit detaillierten Benutzerinformationen aufteilen. In ähnlicher Weise kann die Beziehung zwischen den beiden Tabellen durch Transpositionsdenken bestimmt werden:

Schauen Sie sich zunächst die Tabelle mit den grundlegenden Benutzerinformationen an: Kann ein Benutzer über mehrere detaillierte Informationen verfügen? Die Antwort ist nein.

Schauen wir uns die Tabelle mit den Benutzerdetails noch einmal an: Können Benutzerdetails mehreren Benutzern gehören? Die Antwort ist nein.

Wenn die unidirektionale Eins-zu-viele-Beziehung nicht gilt, dann ist die Tabellenbeziehung zwischen den beiden eine Eins-zu-eins-Beziehung oder es besteht keine Beziehung.

Wenn Sie SQL-Anweisungen verwenden, um eine 1:1-Fremdschlüsselbeziehung herzustellen, kann der Fremdschlüssel auf beiden Seiten erstellt werden. Es wird jedoch empfohlen, den Fremdschlüssel in einer Tabelle mit einer höheren Abfragefrequenz zu erstellen. Erstellen Sie beim Erstellen einer Tabelle ebenfalls zuerst die zugehörige Tabelle.

-- Erstellen Sie eine Tabelle mit Benutzerdetails.create table authordetail(
	ID int Primärschlüssel auto_increment,
	Telefon int,
	Adresse varchar(64)
);

--Benutzer-Basisinformationstabelle, erstellen, Tabelle, Autor(
	ID int Primärschlüssel auto_increment,
    Name varchar(32),
    Alter int,
    authordetali_id int,
    Der Fremdschlüssel (authordetali_id) verweist auf authordetali(id)
    bei Updatekaskade
    bei Löschkaskade
);

Zusammenfassung der Tabellenbeziehungen

Zum Herstellen von Tabellenbeziehungen müssen Sie Fremdschlüssel verwenden und die Beziehungen zwischen Tabellen ermitteln, indem Sie sich in die Lage eines anderen versetzen.

Eins-zu-viele-Tabellenbeziehung: Der Fremdschlüssel wird auf der Viele-Seite erstellt

Eins-zu-eins-Tabellenbeziehung: Der Fremdschlüssel kann auf beiden Seiten erstellt werden, es wird jedoch empfohlen, ihn auf der Seite mit der hohen Abfragefrequenz zu erstellen.

Viele-zu-viele-Tabellenbeziehung: Sie müssen eine dritte Tabelle erstellen, um die Beziehung zwischen den beiden Tabellen zu speichern

Oben finden Sie eine detaillierte Zusammenfassung der MySQL-Fremdschlüsseleinschränkungen und Tabellenbeziehungen. Weitere Informationen zu MySQL-Fremdschlüsseleinschränkungen und Tabellenbeziehungen finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!