Einführung
Eine der wertvollen Eigenschaften relationaler Datenbanken ist die Formatierung von Daten in einer klar definierten Struktur. Diese Struktur wird durch die Verwendung von Tabellen mit festen Spalten, die Einhaltung klar definierter Datentypen und die Gewährleistung eines einheitlichen Formats für jede Zeile erreicht. Beim Speichern von Daten als Zeilen in Tabellen ist es ebenso wichtig, diese eindeutig finden und referenzieren zu können. In der strukturierten Abfragesprache (SQL) wird dies durch Primärschlüssel realisiert, die als Identifikatoren für einzelne Zeilen in Tabellen einer relationalen Datenbank dienen.
In diesem Tutorial lernen Sie Primärschlüssel kennen und verwenden verschiedene Typen, um eindeutige Zeilen in Datenbanktabellen zu identifizieren. Anhand von Beispieldatensätzen erstellen Sie Primärschlüssel für einzelne Spalten, für mehrere Spalten und automatisch inkrementierende, fortlaufende Schlüssel.
Voraussetzungen
Um dieser Anleitung folgen zu können, benötigen Sie einen Computer mit einem SQL-basierten relationalen Datenbankmanagementsystem (RDBMS). Die Anweisungen und Beispiele in dieser Anleitung wurden in der folgenden Umgebung validiert:
- Ein Server mit Ubuntu 20.04, einem Benutzer ohne Root-Rechte, aber mit Administratorrechten, und einer mit UFW konfigurierten Firewall.
- MySQL ist auf dem Server installiert und gesichert.
- Grundlegende Einführung in die Ausführung von SELECT-Abfragen zum Abrufen von Daten aus der Datenbank
Hinweis: Bitte beachten Sie, dass viele relationale Datenbankmanagementsysteme (RDBMS) ihre eigene SQL-Implementierung verwenden. Obwohl die in diesem Tutorial genannten Befehle auf den meisten RDBMS funktionieren und Primärschlüssel Teil des SQL-Standards sind, sind einige Funktionen datenbankspezifisch. Daher können Syntax und Ausgabe auf anderen Systemen als MySQL abweichen.
Sie benötigen außerdem eine leere Datenbank, in der Sie die Tabellen mithilfe von Primärschlüsseln erstellen. Wir empfehlen Ihnen, die folgenden Abschnitte zu lesen, um detaillierte Informationen zum Verbinden mit dem MySQL-Server und zum Erstellen der in den Beispielen dieses Leitfadens verwendeten Testdatenbank zu erhalten.
Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten
In diesem Abschnitt stellen Sie eine Verbindung zum MySQL-Server her und erstellen eine Datenbankinstanz, damit Sie die Beispiele in diesem Leitfaden verwenden können.
Wenn Ihr SQL-Datenbanksystem auf einem Remote-Server läuft, stellen Sie eine SSH-Verbindung von Ihrem lokalen Rechner zu Ihrem Server her:
ssh sammy@your_server_ipÖffnen Sie anschließend die MySQL-Server-Eingabeaufforderung und ersetzen Sie „Sami“ durch Ihren MySQL-Benutzernamen:
mysql -u sammy -p
Erstelle eine Datenbank namens primary_keys:
CREATE DATABASE primary_keys;
Wenn die Datenbank erfolgreich erstellt wurde, erhalten Sie folgende Ausgabe:
Output
Query OK, 1 row affected (0.01 sec)Um die Datenbank primary_keys auszuwählen, führen Sie die folgende USE-Anweisung aus:
USE primary_keys;
Sie erhalten folgende Ausgabe:
Output
Database changedNachdem Sie eine Datenbank ausgewählt haben, können Sie darin Beispieltabelle erstellen. Nun können Sie dem Rest der Anleitung folgen und mit Primärschlüsseln in MySQL arbeiten.
Einführung in die Dur-Tonarten
Daten in einer relationalen Datenbank werden in Tabellen mit einer spezifischen, einheitlichen Struktur einzelner Zeilen gespeichert. Die Tabellendefinition beschreibt die Spalten und die Datentypen, die in den einzelnen Spalten gespeichert werden können. Dies allein genügt, um Informationen in der Datenbank zu speichern und sie mithilfe verschiedener Filterkriterien über die WHERE-Klausel zu finden. Diese Struktur garantiert jedoch nicht, dass jede Zeile eindeutig gefunden werden kann.
Stellen Sie sich eine Datenbank aller zugelassenen Fahrzeuge vor, die auf öffentlichen Straßen fahren dürfen. Die Datenbank enthält Informationen wie Marke, Modell, Baujahr und Lackfarbe. Wenn Sie jedoch nach einem roten Chevrolet Camaro aus dem Jahr 2007 suchen, finden Sie möglicherweise mehrere Exemplare. Schließlich verkaufen Autohersteller dieselben Fahrzeuge an mehrere Kunden. Deshalb haben zugelassene Autos Kennzeichen, die jedes Fahrzeug eindeutig identifizieren. Wenn Sie nach einem Auto mit dem Kennzeichen OFP857 suchen, finden Sie mit Sicherheit nur ein einziges Fahrzeug. Denn laut Gesetz identifizieren Kennzeichen zugelassene Fahrzeuge eindeutig. In einer relationalen Datenbank wird ein solches Datenelement als Primärschlüssel bezeichnet.
Primärschlüssel sind eindeutige Kennungen in einer Spalte oder einer Gruppe von Spalten, die jede Zeile einer Datenbanktabelle eindeutig identifizieren können. Mehrere Regeln spiegeln die technischen Eigenschaften von Primärschlüsseln wider:
- Ein Primärschlüssel muss eindeutige Werte verwenden. Besteht der Primärschlüssel aus mehreren Spalten, muss die Kombination der Werte in diesen Spalten innerhalb der gesamten Tabelle eindeutig sein. Da der Schlüssel jede Zeile eindeutig identifiziert, darf er nicht mehrfach vorkommen.
- Ein Primärschlüssel sollte keine NULL-Werte enthalten.
- Jede Datenbanktabelle kann nur einen Primärschlüssel verwenden.
Die Datenbank-Engine setzt diese Regeln durch. Wenn also ein Primärschlüssel für eine Tabelle definiert ist, können Sie darauf vertrauen, dass diese Attribute korrekt sind.
Neben diesen technischen Merkmalen sollten Sie auch den Inhalt der Daten berücksichtigen, um zu entscheiden, welche Art von Daten sich als Primärschlüssel eignet. Natürliche Schlüssel sind Kennungen, die bereits im Datensatz vorhanden sind, während künstliche Schlüssel künstliche Kennungen sind.
Manche Datenstrukturen besitzen Primärschlüssel, die auf natürliche Weise im Datensatz vorkommen, wie beispielsweise Kfz-Kennzeichen in einer Fahrzeugdatenbank oder Sozialversicherungsnummern in einem US-amerikanischen Bürgerregister. Manchmal bestehen solche Identifikatoren nicht aus einem einzelnen Wert, sondern aus einem Paar oder einer Kombination mehrerer Werte. So kann beispielsweise in einem lokalen Hausverzeichnis ein Straßenname oder eine Hausnummer allein ein Haus nicht eindeutig identifizieren. Es können sich mehrere Häuser in einer Straße befinden, und dieselbe Hausnummer kann in mehreren Straßen vorkommen. Ein Paar aus Straßenname und Hausnummer kann jedoch als eindeutiger Hausidentifikator betrachtet werden. Solche natürlich vorkommenden Identifikatoren werden als natürliche Schlüssel bezeichnet.
Häufig lassen sich Daten jedoch nicht eindeutig anhand der Werte einer einzelnen Spalte oder einer kleinen Teilmenge von Spalten identifizieren. In solchen Fällen werden künstliche Primärschlüssel erstellt, beispielsweise mithilfe einer Zahlenfolge oder zufällig generierter Kennungen wie UUIDs. Diese Schlüssel werden als Ersatzschlüssel bezeichnet.
In den folgenden Abschnitten erstellen Sie natürliche Schlüssel auf Basis einer oder mehrerer Spalten und erstellen alternative Schlüssel in Tabellen, in denen ein natürlicher Schlüssel nicht möglich ist.
Erstellen Sie einen Primärschlüssel für eine Spalte
In vielen Fällen enthält ein Datensatz von Natur aus eine Spalte, die zur eindeutigen Identifizierung von Zeilen in einer Tabelle verwendet werden kann. In diesen Fällen kann ein natürlicher Schlüssel zur Beschreibung der Daten erstellt werden. Stellen Sie sich, ausgehend vom vorherigen Beispiel der Datenbank für zugelassene Fahrzeuge, eine Tabelle mit folgender Struktur vor:
Sample table
+---------------+-----------+------------+-------+------+
| license_plate | brand | model | color | year |
+---------------+-----------+------------+-------+------+
| ABC123 | Ford | Mustang | Red | 2018 |
| CES214 | Ford | Mustang | Red | 2018 |
| DEF456 | Chevrolet | Camaro | Blue | 2016 |
| GHI789 | Dodge | Challenger | Black | 2014 |
+---------------+-----------+------------+-------+------+Die erste und zweite Zeile beschreiben jeweils einen roten Ford Mustang Baujahr 2018. Das Fahrzeug lässt sich anhand von Marke und Modell nicht eindeutig identifizieren. Das Kennzeichen ist in beiden Fällen unterschiedlich und dient als eindeutiger Identifikator für jede Zeile in der Tabelle. Da die Kennzeichennummer bereits Teil der Daten ist, erzeugt ihre Verwendung als Primärschlüssel einen natürlichen Schlüssel. Würde man die Tabelle ohne Primärschlüssel für die Spalte „Kennzeichen“ erstellen, bestünde die Gefahr, dass an einer Stelle im Datensatz doppelte oder leere Einträge auftreten.
Als Nächstes erstellen Sie eine Tabelle ähnlich der obigen, wobei die Spalte „License_plate“ als Primärschlüssel dient und die folgenden Spalten enthalten sind:
- License_plate: Diese Spalte enthält die Kfz-Kennzeichennummer, dargestellt durch den Datentyp varchar.
- Marke: Diese Spalte repräsentiert die Marke des Autos und wird mit Hilfe des Datentyps varchar mit maximal 50 Zeichen angegeben.
- Modell: Diese Spalte enthält das Automodell, ausgedrückt als varchar-Datentyp mit maximal 50 Zeichen.
- Farbe: Diese Spalte enthält die Farbe, die mit dem Datentyp varchar und maximal 20 Zeichen angegeben wird.
- Jahr: Diese Spalte zeigt das Herstellungsjahr des Fahrzeugs an, ausgedrückt durch den Datentyp int zur Speicherung numerischer Daten.
Um die Tabelle „Maschinen“ zu erstellen, führen Sie die folgende SQL-Anweisung aus:
CREATE TABLE cars (
license_plate varchar(8) PRIMARY KEY,
brand varchar(50),
model varchar(50),
color varchar(20),
year int
);... */Die PRIMARY KEY-Anweisung folgt der Definition des Datentyps License_plate. Bei Primärschlüsseln, die auf einzelnen Spalten basieren, kann die vereinfachte Syntax zum Erstellen des Schlüssels verwendet und der Primärschlüssel in der Spaltendefinition angegeben werden.
Wenn die folgende Ausgabe gedruckt wird, wurde die Tabelle erstellt:
Output
Query OK, 0 rows affected (0.00 sec)Laden Sie anschließend die Tabelle mit den oben genannten Beispielzeilen, indem Sie die folgende INSERT INTO-Operation ausführen:
INSERT INTO cars VALUES
('ABC123', 'Ford', 'Mustang', 'Red', 2018),
('CES214', 'Ford', 'Mustang', 'Red', 2018),
('DEF456', 'Chevrolet', 'Camaro', 'Blue', 2016),
('GHI789', 'Dodge', 'Challenger', 'Black', 2014);Die Datenbank wird mit einer Erfolgsmeldung antworten:
Output
Query OK, 4 rows affected (0.010 sec)
Records: 4 Duplicates: 0 Warnings: 0Sie können nun mit der SELECT-Anweisung überprüfen, ob die neu erstellte Tabelle die erwarteten Daten und das erwartete Format enthält:
SELECT * FROM cars;
Die Ausgabe zeigt eine Tabelle, die derjenigen am Anfang des Abschnitts ähnelt:
Output
+---------------+-----------+------------+-------+------+
| license_plate | brand | model | color | year |
+---------------+-----------+------------+-------+------+
| ABC123 | Ford | Mustang | Red | 2018 |
| CES214 | Ford | Mustang | Red | 2018 |
| DEF456 | Chevrolet | Camaro | Blue | 2016 |
| GHI789 | Dodge | Challenger | Black | 2014 |
+---------------+-----------+------------+-------+------+Als Nächstes können Sie überprüfen, ob die Regeln für den Primärschlüssel von der Datenbank-Engine gewährleistet werden. Versuchen Sie, ein Auto mit einem doppelten Kennzeichen einzufügen, indem Sie Folgendes ausführen:
INSERT INTO cars VALUES ('DEF456', 'Jeep', 'Wrangler', 'Yellow', 2019);
MySQL antwortet mit einer Fehlermeldung, die besagt, dass das DEF456-Tag zu einem doppelten Eintrag für den Primärschlüssel führt:
Output ERROR 1062 (23000): Duplicate entry 'DEF456' for key 'cars.PRIMARY'
Hinweis: Primärschlüssel werden im Hintergrund mithilfe eindeutiger Indizes implementiert und weisen viele ähnliche Eigenschaften wie manuell erstellte Indizes für andere Spalten einer Tabelle auf. Vor allem verbessern Primärschlüsselindizes die Abfrageleistung der Spalte, für die der Index definiert ist. Weitere Informationen zur Verwendung von Indizes für diesen Zweck finden Sie im Abschnitt „Verwendung von Indizes“ in diesem Tutorial.
Sie können nun sicher sein, dass doppelte Kennzeichen nicht zulässig sind. Prüfen Sie als Nächstes, ob ein Auto mit einem leeren Kennzeichen importiert werden kann:
INSERT INTO cars VALUES (NULL, 'Jeep', 'Wrangler', 'Yellow', 2019);
Diesmal antwortet die Datenbank mit einer anderen Fehlermeldung:
Output
ERROR 1048 (23000): Column 'license_plate' cannot be nullDank dieser beiden von der Datenbank durchgesetzten Regeln können Sie sicher sein, dass License_plate jede Zeile in der Tabelle eindeutig identifiziert. Wenn Sie die Tabelle anhand jedes Kennzeichens abfragen, erhalten Sie jedes Mal genau eine Zeile zurück.
Im nächsten Abschnitt erfahren Sie, wie Sie Primärschlüssel mit mehreren Spalten verwenden.
Erstellen eines Primärschlüssels über mehrere Spalten
Wenn eine Spalte nicht ausreicht, um eine Zeile in einer Tabelle eindeutig zu identifizieren, können Sie Primärschlüssel erstellen, die mehr als eine Spalte verwenden.
Stellen Sie sich beispielsweise ein Hausregister vor, in dem weder der Straßenname noch die Hausnummer allein ausreichen, um jedes Haus zu identifizieren:
Sample table
+-------------------+---------------+-------------------+------+
| street_name | street_number | house_owner | year |
+-------------------+---------------+-------------------+------+
| 5th Avenue | 100 | Bob Johnson | 2018 |
| Broadway | 1500 | Jane Smith | 2016 |
| Central Park West | 100 | John Doe | 2014 |
| Central Park West | 200 | Tom Thompson | 2015 |
| Lexington Avenue | 5001 | Samantha Davis | 2010 |
| Park Avenue | 7000 | Michael Rodriguez | 2012 |
+-------------------+---------------+-------------------+------+Der Straßenname Central Park West und die Hausnummer 100 kommen mehrfach in der Tabelle vor. Es gibt jedoch keine doppelten Paare aus Straßenname und Hausnummer. Obwohl in diesem Fall keine der beiden Spalten als Primärschlüssel dienen kann, lassen sich die beiden Wertepaare verwenden, um jede Zeile in der Tabelle eindeutig zu identifizieren.
Als Nächstes erstellen Sie eine Tabelle ähnlich der oben gezeigten mit den folgenden Spalten:
- street_name: Diese Spalte repräsentiert den Namen der Straße, in der sich das Haus befindet. Der Datentyp ist varchar und auf 50 Zeichen begrenzt.
- Hausnummer: Diese Spalte enthält die Hausnummer, dargestellt als VARCHAR. Sie kann bis zu 5 Zeichen speichern. Der numerische Datentyp INT wird nicht verwendet, da manche Hausnummern Buchstaben enthalten (z. B. 200B).
- house_owner: Diese Spalte enthält den Namen des Hausbesitzers, dargestellt durch den Datentyp varchar mit einer maximalen Länge von 50 Zeichen.
- Jahr: Diese Spalte gibt das Baujahr des Hauses an, dargestellt durch den Datentyp int zur Speicherung numerischer Werte.
Diesmal verwendet der Primärschlüssel sowohl die Spalte „street_name“ als auch die Spalte „street_number“ anstatt nur einer von beiden. Führen Sie dazu die folgende SQL-Anweisung aus:
CREATE TABLE houses (
street_name varchar(50),
street_number varchar(5),
house_owner varchar(50),
year int,
PRIMARY KEY(street_name, street_number)
);Diesmal, anders als im vorherigen Beispiel, steht die PRIMARY KEY-Anweisung unterhalb der Spaltendefinitionen. Sie ist in Klammern gesetzt und enthält die beiden Spaltennamen „street_name“ und „street_number“. Diese Syntax erzeugt einen Primärschlüssel in der Tabelle „houses“, der sich auf zwei Spalten bezieht.
Wenn die folgende Ausgabe gedruckt wird, wurde die Tabelle erstellt:
Output
Query OK, 0 rows affected (0.00 sec)Laden Sie anschließend die Tabelle mit den im vorherigen Beispiel bereitgestellten Beispielzeilen, indem Sie die folgende INSERT INTO-Operation ausführen:
INSERT INTO houses VALUES
('Central Park West', '100', 'John Doe', 2014),
('Broadway', '1500', 'Jane Smith', 2016),
('5th Avenue', '100', 'Bob Johnson', 2018),
('Lexington Avenue', '5001', 'Samantha Davis', 2010),
('Park Avenue', '7000', 'Michael Rodriguez', 2012),
('Central Park West', '200', 'Tom Thompson', 2015);
Die Datenbank wird mit einer Erfolgsmeldung antworten:
Output
Query OK, 6 rows affected (0.000 sec)
Records: 6 Duplicates: 0 Warnings: 0Sie können nun mit der SELECT-Anweisung überprüfen, ob die neu erstellte Tabelle die erwarteten Daten und das erwartete Format enthält:
SELECT * FROM houses;
Die Ausgabe zeigt eine Tabelle, die derjenigen am Anfang des Abschnitts ähnelt:
Output
+-------------------+---------------+-------------------+------+
| street_name | street_number | house_owner | year |
+-------------------+---------------+-------------------+------+
| 5th Avenue | 100 | Bob Johnson | 2018 |
| Broadway | 1500 | Jane Smith | 2016 |
| Central Park West | 100 | John Doe | 2014 |
| Central Park West | 200 | Tom Thompson | 2015 |
| Lexington Avenue | 5001 | Samantha Davis | 2010 |
| Park Avenue | 7000 | Michael Rodriguez | 2012 |
+-------------------+---------------+-------------------+------+
6 rows in set (0.000 sec)Prüfen wir nun, ob die Datenbank Zeilen mit wiederholten Straßennamen und Hausnummern zulässt, aber doppelte vollständige Adressen in der Tabelle verhindert. Beginnen wir mit dem Hinzufügen eines weiteren Hauses in der Parkstraße:
INSERT INTO houses VALUES ('Park Avenue', '8000', 'Emily Brown', 2011);
MySQL antwortet mit einer Erfolgsmeldung, da die Adresse 8000 Park Avenue zuvor nicht in der Tabelle vorhanden war:
Output
Query OK, 1 row affected (0.010 sec)Ein ähnliches Ergebnis ergibt sich, wenn man ein Haus in der Hauptstraße 8000 hinzufügt und die Hausnummer wiederholt:
INSERT INTO houses VALUES ('Main Street', '8000', 'David Jones', 2009);
Auch hier wird die neue Zeile korrekt eingefügt, da die gesamte Adresse nicht wiederholt wird:
Output
Query OK, 1 row affected (0.010 sec)Fügen Sie jedoch ein weiteres Haus in der 100 5th Avenue mithilfe der folgenden INSERT-Anweisung hinzu:
INSERT INTO houses VALUES ('5th Avenue', '100', 'Josh Gordon', 2008);
Die Datenbank antwortet mit einer Fehlermeldung, die Sie darüber informiert, dass ein doppelter Eintrag für den Primärschlüssel für das Wertepaar 5th Avenue und 100 existiert:
Output
ERROR 1062 (23000): Duplicate entry '5th Avenue-100' for key 'houses.PRIMARY'Die Datenbank setzt die Regeln für Primärschlüssel korrekt um, wobei der Schlüssel über ein Spaltenpaar definiert ist. Sie können sicher sein, dass die vollständige Adresse, einschließlich Straßenname und Hausnummer, nicht doppelt in der Tabelle vorhanden ist.
In diesem Abschnitt haben Sie einen natürlichen Schlüssel mit zwei Spalten erstellt, um jede Zeile in der Basistabelle eindeutig zu identifizieren. Primärschlüssel lassen sich jedoch nicht immer direkt aus den Daten extrahieren. Im nächsten Abschnitt verwenden Sie daher künstliche Primärschlüssel, die nicht direkt aus den Daten stammen.
Erstellen eines sequenziellen Primärschlüssels
Bisher haben Sie eindeutige Primärschlüssel mithilfe von Spalten aus dem Beispieldatensatz erstellt. In manchen Fällen sind Daten jedoch unvermeidlich dupliziert, sodass die Spalten keine eindeutigen Identifikatoren mehr darstellen können. In diesen Fällen können Sie mithilfe der generierten Identifikatoren sequentielle Primärschlüssel erstellen. Wenn Ihre Daten die Erstellung neuer Identifikatoren zur Identifizierung von Zeilen erfordern, werden die auf diesen künstlichen Identifikatoren basierenden Primärschlüssel als Ersatzschlüssel bezeichnet.
Stellen Sie sich eine Liste von Buchclubmitgliedern vor – ein informelles Treffen, dem jeder ohne Ausweis beitreten kann. Es ist wahrscheinlich, dass Personen mit ähnlichen Namen dem Club irgendwann beitreten werden:
Sample table
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| John | Doe |
| Jane | Smith |
| Bob | Johnson |
| Samantha | Davis |
| Michael | Rodriguez |
| Tom | Thompson |
| Sara | Johnson |
| David | Jones |
| Jane | Smith |
| Bob | Johnson |
+------------+-----------+Die Namen Bob Johnson und Jane Smith kommen in der Tabelle doppelt vor. Um die einzelnen Personen eindeutig zu identifizieren, wäre ein zusätzliches Identifikationsmerkmal erforderlich, und es gibt keine Möglichkeit, die Zeilen in dieser Tabelle eindeutig zu kennzeichnen. Würde man eine Liste der Buchclubmitglieder auf Papier führen, könnte man Hilfsidentifikatoren verwenden, um Personen mit ähnlichen Namen innerhalb der Gruppe zu unterscheiden.
In einer relationalen Datenbank lässt sich etwas Ähnliches realisieren, indem man eine zusätzliche Spalte verwendet, die generierte, nicht-reale IDs enthält, deren einziger Zweck darin besteht, alle Zeilen in der Tabelle eindeutig zu identifizieren. Nennen wir sie Member_id.
Es ist jedoch mühsam, jedes Mal eine solche Kennung zu erstellen, wenn man ein weiteres Buchclubmitglied zur Datenbank hinzufügen möchte. Um dieses Problem zu lösen, bietet MySQL eine Funktion zur automatischen Inkrementierung numerischer Spalten. Dabei erhöht die Datenbank den Spaltenwert automatisch um eine Folge von ganzen Zahlen.
Erstellen wir eine Tabelle ähnlich der obigen. Sie fügen eine zusätzliche Spalte mit automatischer Inkrementierung (member_id) hinzu, die jedem Clubmitglied automatisch zugewiesene Nummern enthält. Diese automatisch zugewiesene Nummer dient als Primärschlüssel der Tabelle.
Member_id: Diese Spalte verfügt über eine automatisch inkrementierende numerische ID, die vom Datentyp int dargestellt wird.
first_name: Diese Spalte enthält den Vornamen der Clubmitglieder, dargestellt durch den Datentyp varchar mit einer maximalen Länge von 50 Zeichen.
Nachname: Diese Spalte enthält den Nachnamen der Clubmitglieder, der mit einem varchar-Datentyp angezeigt wird, der auf 50 Zeichen begrenzt ist.
Um die Tabelle zu erstellen, führen Sie die folgende SQL-Anweisung aus:
CREATE TABLE club_members (
member_id int AUTO_INCREMENT PRIMARY KEY,
first_name varchar(50),
last_name varchar(50)
);Die PRIMARY KEY-Anweisung folgt zwar nach der Spaltentypdefinition, genau wie bei einem einspaltigen Primärschlüssel, jedoch steht davor ein zusätzliches Attribut: AUTO_INCREMENT. Dieses weist MySQL an, Werte für diese Spalte automatisch zu generieren, sofern keine expliziten Werte angegeben werden. Dabei werden fortlaufend aufsteigende Zahlen verwendet.
Hinweis: Die AUTO_INCREMENT-Eigenschaft für Spaltendefinitionen ist spezifisch für MySQL. Andere Datenbanken bieten oft ähnliche Methoden zur Generierung sequenzieller Schlüssel, die Syntax variiert jedoch je nach Datenbanksystem. Im Zweifelsfall empfehlen wir, die offizielle Dokumentation Ihres RDBMS zu konsultieren.
Wenn die folgende Ausgabe gedruckt wird, wurde die Tabelle erstellt:
Output
Query OK, 0 rows affected (0.00 sec)Laden Sie anschließend die Tabelle mit den oben genannten Beispielzeilen, indem Sie die folgende INSERT INTO-Operation ausführen:
INSERT INTO club_members (first_name, last_name) VALUES
('John', 'Doe'),
('Jane', 'Smith'),
('Bob', 'Johnson'),
('Samantha', 'Davis'),
('Michael', 'Rodriguez'),
('Tom', 'Thompson'),
('Sara', 'Johnson'),
('David', 'Jones'),
('Jane', 'Smith'),
('Bob', 'Johnson');Die INSERT-Anweisung enthält nun eine Liste der Spaltennamen (first_name und last_name), wodurch sichergestellt wird, dass die Datenbank weiß, dass die Spalte Member_id im Datensatz nicht vorhanden ist, sodass stattdessen der Standardwert verwendet werden soll.
Die Datenbank wird mit einer Erfolgsmeldung antworten:
Output
Query OK, 10 rows affected (0.002 sec)
Records: 10 Duplicates: 0 Warnings: 0Verwenden Sie die SELECT-Anweisung, um die Daten in der neu erstellten Tabelle zu überprüfen:
SELECT * FROM club_members;
Die Ausgabe zeigt eine Tabelle, die derjenigen am Anfang des Abschnitts ähnelt:
Output
+-----------+------------+-----------+
| member_id | first_name | last_name |
+-----------+------------+-----------+
| 1 | John | Doe |
| 2 | Jane | Smith |
| 3 | Bob | Johnson |
| 4 | Samantha | Davis |
| 5 | Michael | Rodriguez |
| 6 | Tom | Thompson |
| 7 | Sara | Johnson |
| 8 | David | Jones |
| 9 | Jane | Smith |
| 10 | Bob | Johnson |
+-----------+------------+-----------+
10 rows in set (0.000 sec)Diesmal erscheint jedoch die Spalte Member_id im Ergebnis und enthält eine Zahlenfolge von 1 bis 10. Dank dieser Spalte sind die doppelten Zeilen für Jane Smith und Bob Johnson nicht mehr erkennbar, da jedem Namen eine eindeutige Kennung (Member_id) zugeordnet ist.
Nun prüfen wir, ob die Datenbank es uns erlaubt, einen weiteren Tom Thompson zur Mitgliederliste des Clubs hinzuzufügen:
INSERT INTO club_members (first_name, last_name) VALUES ('Tom', 'Thompson');
MySQL antwortet mit einer Erfolgsmeldung:
Output
Query OK, 1 row affected (0.009 sec)
Um zu überprüfen, welche numerische ID die Datenbank dem neuen Eintrag zugewiesen hat, führen Sie die SELECT-Abfrage erneut aus:
SELECT * FROM club_members;
Die Ausgabe enthält noch eine weitere Zeile:
Output
+-----------+------------+-----------+
| member_id | first_name | last_name |
+-----------+------------+-----------+
| 1 | John | Doe |
| 2 | Jane | Smith |
| 3 | Bob | Johnson |
| 4 | Samantha | Davis |
| 5 | Michael | Rodriguez |
| 6 | Tom | Thompson |
| 7 | Sara | Johnson |
| 8 | David | Jones |
| 9 | Jane | Smith |
| 10 | Bob | Johnson |
| 11 | Tom | Thompson |
+-----------+------------+-----------+
11 rows in set (0.000 sec)Über das AUTO_INCREMENT-Attribut der Datenbank wurde automatisch eine neue Zeile mit der Nummer 11 in der Spalte Member_id erstellt.
Wenn die Daten, mit denen Sie arbeiten, keine natürlichen Kandidaten für Primärschlüssel aufweisen und Sie nicht jedes Mal neue Kennungen erfinden möchten, wenn Sie neue Daten zur Datenbank hinzufügen, können Sie getrost auf sequenziell generierte Kennungen als Primärschlüssel zurückgreifen.
Ergebnis
Durch Befolgen dieser Anleitung haben Sie gelernt, was Primärschlüssel sind und wie Sie in MySQL gängige Datentypen erstellen, um eindeutige Zeilen in Datenbanktabellen zu identifizieren. Sie haben natürliche Primärschlüssel erstellt, Primärschlüssel, die sich über mehrere Spalten erstrecken, und automatisch inkrementierende sequentielle Schlüssel verwendet, wenn keine natürlichen Schlüssel vorhanden sind.
