Nutzung von Primary Keys in SQL verwendet

Einführung

Eines der wertvollen Merkmale relationaler Datenbanken besteht darin, die Daten in eine gut definierte Struktur zu bringen. Diese Struktur wird durch die Verwendung von Tabellen mit festen Spalten erreicht, in denen strikt definierte Datentypen eingehalten werden und jede Zeile die gleiche Form hat. Wenn Sie Daten als Zeilen in Tabellen speichern, ist es ebenso wichtig, diese ohne Mehrdeutigkeit finden und darauf verweisen zu können. In der Structured Query Language (SQL) kann dies mit Primary Keys erreicht werden, die als Kennungen für einzelne Zeilen in den Tabellen der relationalen Datenbank dienen.

In diesem Tutorial lernen Sie die Primary Keys kennen und erfahren, wie Sie mit verschiedenen Arten von Primary Keys eindeutige Zeilen in Datenbanktabellen identifizieren. Mithilfe einiger Beispieldatensätze werden Sie Primary Keys für einzelne und mehrere Spalten sowie auto-incrementierende sequenzielle Schlüssel erstellen.

Voraussetzungen zur Nutzung von Primary Keys in SQL

Um diesem Leitfaden folgen zu können, benötigen Sie einen Computer mit einem SQL-basierten relationalen Datenbankverwaltungssystem (RDBMS). Die Anweisungen und Beispiele in diesem Leitfaden wurden in der folgenden Umgebung validiert:

• Ein Server mit Ubuntu 20.04, mit einem nicht-root Benutzer mit administrativen Rechten und einer Firewall, konfiguriert mit UFW, wie in unserem Setup-Leitfaden für Ubuntu 20.04 beschrieben.
• MySQL installiert und auf dem Server gesichert, wie in „How To Install MySQL on Ubuntu 20.04“ beschrieben. Dieser Leitfaden wurde mit einem nicht-root MySQL-Benutzer überprüft, der gemäß Schritt 3 erstellt wurde.
• Grundkenntnisse in der Ausführung von SELECT-Abfragen, um Daten aus der Datenbank abzurufen, wie in unserem Leitfaden „How To SELECT Rows FROM Tables in SQL“ beschrieben.

Hinweis: Beachten Sie, dass viele RDBMS ihre eigenen spezifischen Implementierungen von SQL verwenden. Obwohl die in diesem Tutorial beschriebenen Befehle in den meisten RDBMS funktionieren und Primary Keys Teil des SQL-Standards sind, sind einige Funktionen datenbankspezifisch und daher kann die genaue Syntax oder Ausgabe variieren, wenn Sie sie auf einem anderen System als MySQL testen.

Sie benötigen außerdem eine leere Datenbank, in der Sie Tabellen erstellen können, um die Verwendung von Primary Keys zu demonstrieren. Wir empfehlen, den folgenden Abschnitt „Verbindung zu MySQL und Einrichten einer Beispieldatenbank“ durchzugehen, um Details zum Herstellen einer Verbindung zu einem MySQL-Server und zum Erstellen der in den Beispielen dieses Leitfadens verwendeten Testdatenbank zu erhalten.

Verbindung zu MySQL und Einrichten einer Beispieldatenbank

In diesem Abschnitt stellen Sie eine Verbindung zu einem MySQL-Server her und erstellen eine Beispieldatenbank, sodass Sie die Beispiele in diesem Leitfaden nachverfolgen können.

Wenn Ihr SQL-Datenbanksystem auf einem Remote-Server läuft, verbinden Sie sich per SSH von Ihrem lokalen Rechner mit Ihrem Server:

ssh sammy@your_server_ip

Öffnen Sie dann die MySQL-Server-Eingabeaufforderung, wobei Sie „sammy“ durch den Namen Ihres MySQL-Benutzerkontos ersetzen:

mysql -u sammy -p

Erstellen Sie eine Datenbank mit dem Namen „primary_keys“:

CREATE DATABASE primary_keys;

Wenn die Datenbank erfolgreich erstellt wurde, erhalten Sie eine Ausgabe wie diese:

Output
Query OK, 1 row affected (0.01 sec)

Um die primary_keys-Datenbank auszuwählen, führen Sie die folgende USE-Anweisung aus:

USE primary_keys;

Sie erhalten die folgende Ausgabe:

Output
Database changed

Nachdem Sie die Datenbank ausgewählt haben, können Sie darin Beispieltabellen erstellen. Sie sind nun bereit, den Rest des Leitfadens zu befolgen und mit Primary Keys in MySQL zu arbeiten.

Einführung in Primary Keys in SQL

Daten in einer relationalen Datenbank werden in Tabellen mit einer bestimmten, einheitlichen Struktur einzelner Zeilen gespeichert. Die Tabellendefinition beschreibt, welche Spalten es gibt und welche Datentypen in den einzelnen Spalten gespeichert werden können. Das allein reicht aus, um die Informationen in der Datenbank zu speichern und sie später mit unterschiedlichen Filterkriterien zu finden, indem man die WHERE-Klausel verwendet. Diese Struktur garantiert jedoch nicht, dass eine einzelne Zeile eindeutig gefunden werden kann.

Stellen Sie sich eine Datenbank aller registrierten Fahrzeuge vor, die auf öffentlichen Straßen fahren dürfen. Die Datenbank würde Informationen wie Automarke, Modell, Baujahr und Lackfarbe enthalten. Wenn Sie jedoch nach einem roten Chevrolet Camaro aus dem Jahr 2007 suchen würden, könnten Sie mehr als einen finden. Schließlich verkaufen Autohersteller ähnliche Autos an mehrere Kunden. Deshalb haben registrierte Autos Kennzeichen, die jedes Fahrzeug eindeutig identifizieren. Wenn Sie ein Auto mit dem Kennzeichen OFP857 suchen, könnten Sie sicher sein, dass dieses Kriterium nur ein Auto finden wird. Das liegt daran, dass Kennzeichen per Gesetz registrierte Fahrzeuge eindeutig identifizieren. In einer relationalen Datenbank wird ein solcher Datensatz als Primary Key bezeichnet.

Primary Keys sind eindeutige Bezeichner, die in einer einzelnen Spalte oder einer Reihe von Spalten zu finden sind und jede Zeile in einer Datenbanktabelle eindeutig identifizieren können. Einige Regeln spiegeln die technischen Eigenschaften von Primary Keys wider:

• Ein Primary Key muss eindeutige Werte verwenden. Wenn der Primary Key aus mehr als einer Spalte besteht, muss die Kombination der Werte in diesen Spalten in der gesamten Tabelle eindeutig sein. Da der Schlüssel jede Zeile eindeutig identifizieren soll, darf er nicht mehr als einmal vorkommen.
• Ein Primary Key darf keine NULL-Werte enthalten.
• Jede Datenbanktabelle kann nur einen Primary Key verwenden.

Die Datenbank-Engine erzwingt diese Regeln, sodass Sie sich darauf verlassen können, dass diese Eigenschaften zutreffen, wenn der Primary Key in einer Tabelle definiert ist.

Zusätzlich zu diesen technischen Eigenschaften müssen Sie auch den Inhalt der Daten berücksichtigen, um zu entscheiden, welche Art von Daten eine gute Wahl für den Primary Key ist. Natürliche Schlüssel sind Bezeichner, die bereits im Datensatz vorhanden sind, während Surrogatschlüssel künstliche Bezeichner sind.

Einige Datenstrukturen haben Primary Keys, die natürlicherweise im Datensatz vorkommen, wie z.B. Kennzeichen in einer Autodatenbank oder Sozialversicherungsnummern im Verzeichnis der US-Bürger. Manchmal sind solche Bezeichner kein einzelner Wert, sondern ein Paar oder eine Kombination aus mehreren Werten. Beispielsweise kann in einem lokalen Stadtverzeichnis von Häusern nur ein Straßenname oder eine Hausnummer ein Haus nicht eindeutig identifizieren. Es kann mehrere Häuser in einer Straße geben, und dieselbe Nummer kann in mehreren Straßen vorkommen. Ein Paar aus Straßennamen und Hausnummern kann jedoch als eindeutiger Hausbezeichner angenommen werden. Solche natürlich vorkommenden Bezeichner werden als natürliche Schlüssel bezeichnet.

Oft können Daten jedoch nicht eindeutig durch die Werte einer einzelnen Spalte oder einer kleinen Untermenge von Spalten gekennzeichnet werden. Dann werden künstliche Primary Keys erstellt, zum Beispiel durch die Verwendung einer Zahlenfolge oder zufällig generierter Bezeichner wie UUIDs. Solche Schlüssel werden als Surrogatschlüssel bezeichnet.

In den folgenden Abschnitten erstellen Sie natürliche Schlüssel, die auf einer einzelnen Spalte oder mehreren Spalten basieren, und generieren Surrogatschlüssel für Tabellen, bei denen ein natürlicher Schlüssel keine Option ist.

Erstellen eines Primary Keys in SQL auf einer einzelnen Spalte

In vielen Fällen enthält ein Datensatz natürlicherweise eine einzelne Spalte, die verwendet werden kann, um Zeilen in der Tabelle eindeutig zu identifizieren. In diesen Fällen können Sie einen natürlichen Schlüssel erstellen, um die Daten zu beschreiben. Nehmen wir erneut das Beispiel der Datenbank mit registrierten Autos und stellen uns vor, dass die Tabelle wie folgt aussieht:

+---------------+-----------+------------+-------+------+
| 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 ersten beiden Zeilen beschreiben beide einen roten Ford Mustang aus dem Jahr 2018. Wenn nur die Automarke und das Modell verwendet würden, könnten Sie das Auto nicht eindeutig identifizieren. Das Kennzeichen unterscheidet sich jedoch in beiden Fällen und stellt eine gute, eindeutige Kennung für jede Zeile in der Tabelle dar. Da das Kennzeichen bereits Teil der Daten ist, würde die Verwendung als Primary Key einen natürlichen Schlüssel erstellen. Wenn Sie die Tabelle ohne die Verwendung eines Primary Keys in der Spalte „license_plate“ erstellen würden, könnten möglicherweise irgendwann ein doppeltes oder leeres Kennzeichen im Datensatz erscheinen.

Als Nächstes erstellen Sie eine Tabelle, die der oben gezeigten ähnelt, wobei die Spalte „license_plate“ als Primary Key und die folgenden Spalten verwendet werden:

• license_plate: Diese Spalte enthält das Kennzeichen, das durch den Datentyp „varchar“ dargestellt wird.
• brand: Diese Spalte enthält die Marke des Autos, ausgedrückt durch den Datentyp „varchar“ mit maximal 50 Zeichen.
• model: Diese Spalte enthält das Modell des Autos, ausgedrückt durch den Datentyp „varchar“ mit maximal 50 Zeichen.
• color: Diese Spalte enthält die Farbe, ausgedrückt durch den Datentyp „varchar“ mit maximal 20 Zeichen.
• year: Diese Spalte enthält das Jahr, in dem das Auto hergestellt wurde, ausgedrückt durch den Datentyp „int“ zur Speicherung von numerischen Daten.

Um die Tabelle „cars“ 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-Klausel folgt der Definition des Datentyps für „license_plate“. Bei der Verwendung von Primary Keys, die auf einzelnen Spalten basieren, können Sie die vereinfachte Syntax verwenden, indem Sie „PRIMARY KEY“ in der Spaltendefinition schreiben.

Wenn die folgende Ausgabe erscheint, wurde die Tabelle erstellt:

Output
Query OK, 0 rows affected (0.00 sec)

Laden Sie anschließend die Tabelle mit den im obigen Beispiel gezeigten Beispieldatensätzen, indem Sie den folgenden INSERT INTO-Befehl 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 der Erfolgsmeldung antworten:

Output
Query OK, 4 rows affected (0.010 sec)
Records: 4  Duplicates: 0  Warnings: 0

Sie können nun mithilfe 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 der 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 |
+---------------+-----------+------------+-------+------+

Nun können Sie überprüfen, ob die Regeln für den Primary Key von der Datenbank-Engine garantiert werden. Versuchen Sie, ein Auto mit einem doppelten Kennzeichen einzufügen, indem Sie folgenden Befehl ausführen:

INSERT INTO cars VALUES ('DEF456', 'Jeep', 'Wrangler', 'Yellow', 2019);

MySQL wird mit einer Fehlermeldung antworten, dass das Kennzeichen „DEF456“ zu einem doppelten Eintrag für den Primary Key führen würde:

Output
ERROR 1062 (23000): Duplicate entry 'DEF456' for key 'cars.PRIMARY'

Hinweis: Unter der Haube werden Primary Keys mit eindeutigen Indizes implementiert und teilen viele Eigenschaften mit Indizes, die Sie möglicherweise manuell für andere Spalten in der Tabelle erstellen. Insbesondere verbessern Primary Key-Indizes auch die Leistung der Abfrage der Tabelle gegen die Spalte, auf die der Index definiert ist. Weitere Informationen zur Verwendung von Indizes finden Sie im Leitfaden „How to Use Indexes“ in dieser Tutorialreihe.

Sie können nun sicher sein, dass doppelte Kennzeichen nicht zugelassen werden. Überprüfen Sie als Nächstes, ob es möglich ist, ein Auto mit einem leeren Kennzeichen hinzuzufügen:

INSERT INTO cars VALUES (NULL, 'Jeep', 'Wrangler', 'Yellow', 2019);

Diesmal wird die Datenbank mit einer weiteren Fehlermeldung antworten:

Output
ERROR 1048 (23000): Column 'license_plate' cannot be null

Mit diesen beiden von der Datenbank erzwungenen Regeln können Sie sicher sein, dass die Spalte „license_plate“ jede Zeile in der Tabelle eindeutig identifiziert. Wenn Sie die Tabelle anhand eines beliebigen Kennzeichens abfragen, können Sie jedes Mal eine einzelne Zeile erwarten.

Im nächsten Abschnitt lernen Sie, wie Sie Primary Keys mit mehreren Spalten verwenden können.

Erstellen eines Primary Keys in SQL auf mehreren Spalten

Wenn eine einzelne Spalte nicht ausreicht, um eine Zeile in der Tabelle eindeutig zu identifizieren, können Sie Primary Keys erstellen, die mehr als eine Spalte verwenden.

Stellen Sie sich beispielsweise ein Register von Häusern vor, in dem weder der Straßenname noch die Hausnummer allein ausreichen, um ein Haus eindeutig zu identifizieren:

+-------------------+---------------+-------------------+------+
| 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“ erscheint mehr als einmal in der Tabelle, ebenso die Hausnummer „100“. Es gibt jedoch keine doppelten Paare aus Straßennamen und Hausnummern. In diesem Fall kann das Paar dieser beiden Werte verwendet werden, um jede Zeile in der Tabelle eindeutig zu identifizieren, während keine einzelne Spalte als Primary Key dienen könnte.

Als Nächstes erstellen Sie eine Tabelle, die der oben gezeigten ähnelt, mit den folgenden Spalten:

• street_name: Diese Spalte enthält den Namen der Straße, auf der das Haus liegt, dargestellt durch den Datentyp „varchar“, beschränkt auf 50 Zeichen.
• street_number: Diese Spalte enthält die Hausnummer, dargestellt durch den Datentyp „varchar“, der bis zu 5 Zeichen speichern kann. Es wird nicht der numerische Datentyp „int“ verwendet, da einige Hausnummern Buchstaben enthalten können (z.B. „200B“).
• house_owner: Diese Spalte enthält den Namen des Hauseigentümers, dargestellt durch den Datentyp „varchar“, beschränkt auf 50 Zeichen.
• year: Diese Spalte enthält das Baujahr des Hauses, dargestellt durch den Datentyp „int“, um numerische Werte zu speichern.

Dieses Mal wird der Primary Key die Spalten „street_name“ und „street_number“ anstelle einer einzelnen Spalte verwenden. 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 erscheint die PRIMARY KEY-Klausel unterhalb der Spaltendefinitionen, anders als im vorherigen Beispiel. Die PRIMARY KEY-Anweisung wird von Klammern gefolgt, die zwei Spaltennamen enthalten: „street_name“ und „street_number“. Diese Syntax erstellt den Primary Key in der Tabelle „houses“, der sich über zwei Spalten erstreckt.

Wenn die folgende Ausgabe erscheint, wurde die Tabelle erstellt:

Output
Query OK, 0 rows affected (0.00 sec)

Laden Sie anschließend die Tabelle mit den im vorherigen Beispiel gezeigten Beispieldatensätzen, indem Sie den folgenden INSERT INTO-Befehl 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 der Erfolgsmeldung antworten:

Output
Query OK, 6 rows affected (0.000 sec)
Records: 6  Duplicates: 0  Warnings: 0

Sie können nun mithilfe 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 der 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 |
+-------------------+---------------+-------------------+------+

Nun überprüfen wir, ob die Datenbank das Einfügen von Zeilen erlaubt, die Straßennamen und Hausnummern duplizieren, jedoch keine doppelten vollständigen Adressen in der Tabelle zulässt. Fügen wir zunächst ein weiteres Haus in der Park Avenue hinzu:

INSERT INTO houses VALUES ('Park Avenue', '8000', 'Emily Brown', 2011);

MySQL wird eine Erfolgsmeldung ausgeben, da die Adresse 8000 Park Avenue bisher nicht in der Tabelle enthalten ist:

Output
Query OK, 1 row affected (0.010 sec)

Ein ähnliches Ergebnis tritt auf, wenn Sie ein Haus in der 8000 Main Street hinzufügen, wobei die Hausnummer erneut verwendet wird:

INSERT INTO houses VALUES ('Main Street', '8000', 'David Jones', 2009);

Auch hier wird eine neue Zeile korrekt eingefügt, da die vollständige Adresse nicht dupliziert ist:

Output
Query OK, 1 row affected (0.010 sec)

Versuchen Sie jedoch, ein weiteres Haus in der 100 5th Avenue hinzuzufügen, indem Sie die folgende INSERT-Anweisung verwenden:

INSERT INTO houses VALUES ('5th Avenue', '100', 'Josh Gordon', 2008);

Die Datenbank wird mit einer Fehlermeldung antworten, dass es für das Paar der Werte „5th Avenue“ und „100“ einen doppelten Eintrag für den Primary Key gibt:

Output
ERROR 1062 (23000): Duplicate entry '5th Avenue-100' for key 'houses.PRIMARY'

Die Datenbank erzwingt korrekt die Regeln für den Primary Key, wobei der Schlüssel auf einem Paar von Spalten definiert ist. Sie können sicher sein, dass die vollständige Adresse, bestehend aus Straßenname und Hausnummer, nicht in der Tabelle dupliziert wird.

In diesem Abschnitt haben Sie einen natürlichen Schlüssel mit einem Spaltenpaar erstellt, um jede Zeile in der Tabelle „houses“ eindeutig zu identifizieren. Es ist jedoch nicht immer möglich, Primary Keys aus dem Datensatz abzuleiten. Im nächsten Abschnitt verwenden Sie künstliche Primary Keys, die nicht direkt aus den Daten stammen.

Erstellen eines sequenziellen Primary Keys in SQL

Bis jetzt haben Sie eindeutige Primary Keys mithilfe bestehender Spalten in den Beispieldatensätzen erstellt. In manchen Fällen werden die Daten jedoch zwangsläufig dupliziert, wodurch keine Spalten als gute eindeutige Bezeichner dienen. In diesen Fällen können Sie sequenzielle Primary Keys mithilfe generierter Bezeichner erstellen. Wenn die Ihnen zur Verfügung stehenden Daten Sie dazu zwingen, neue Bezeichner zu erfinden, um Zeilen eindeutig zu identifizieren, werden die Primary Keys, die auf diesen künstlichen Bezeichnern basieren, Surrogatschlüssel genannt.

Stellen Sie sich eine Liste von Buchclubmitgliedern vor – ein informelles Treffen, bei dem jeder ohne amtlichen Ausweis beitreten kann. Es besteht die Möglichkeit, dass irgendwann Personen mit demselben Namen dem Club beitreten:

+------------+-----------+
| 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“ sind in der Tabelle doppelt vorhanden. Sie müssen einen zusätzlichen Bezeichner verwenden, um sicher zu sein, wer wer ist, und es ist nicht möglich, die Zeilen in dieser Tabelle auf eine andere Weise eindeutig zu identifizieren. Wenn Sie die Liste der Buchclubmitglieder auf Papier führen würden, könnten Sie zusätzliche Kennungen verwenden, um Personen mit demselben Namen in der Gruppe zu unterscheiden.

In einer relationalen Datenbank können Sie Ähnliches tun, indem Sie eine zusätzliche Spalte hinzufügen, die generierte, bedeutungslose Bezeichner enthält, die einzig und allein dazu dienen, alle Zeilen in der Tabelle eindeutig zu trennen. Wir nennen diese Spalte „member_id“.

Es wäre jedoch mühsam, sich bei jedem Hinzufügen eines neuen Buchclubmitglieds zur Datenbank eine solche Kennung auszudenken. MySQL bietet dazu eine Funktion für automatisch inkrementierte numerische Spalten, bei denen die Datenbank den Spaltenwert automatisch in einer aufsteigenden Zahlenfolge bereitstellt.

Erstellen Sie eine Tabelle, die der oben gezeigten ähnelt. Sie fügen eine zusätzliche auto-incrementierende Spalte („member_id“) hinzu, die automatisch die Nummer für jedes Clubmitglied zuweist. Diese automatisch zugewiesene Nummer fungiert als Primary Key für die Tabelle:

• member_id: Diese Spalte enthält eine auto-incrementierende, numerische Kennung, dargestellt durch den Datentyp „int“.
• first_name: Diese Spalte enthält die Vornamen der Clubmitglieder, dargestellt durch den Datentyp „varchar“, begrenzt auf 50 Zeichen.
• last_name: Diese Spalte enthält die Nachnamen der Clubmitglieder, dargestellt durch den Datentyp „varchar“, begrenzt auf 50 Zeichen.

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

Während die PRIMARY KEY-Klausel wie bei einem Primary Key für eine einzelne Spalte nach der Spaltendefinition erscheint, gibt es zusätzlich das Attribut AUTO_INCREMENT davor. Es teilt MySQL mit, dass die Werte für diese Spalte automatisch generiert werden, wenn keine explizit angegebenen Werte vorhanden sind, und zwar in einer wachsenden Zahlenfolge.

Hinweis: Die AUTO_INCREMENT-Eigenschaft zur Definition einer Spalte ist spezifisch für MySQL. Andere Datenbanken bieten oft ähnliche Methoden zum Generieren sequenzieller Schlüssel, aber die Syntax unterscheidet sich je nach Datenbank. Im Zweifel empfehlen wir, die offizielle Dokumentation Ihres RDBMS zu Rate zu ziehen.

Wenn die folgende Ausgabe erscheint, wurde die Tabelle erstellt:

Output
Query OK, 0 rows affected (0.00 sec)

Laden Sie anschließend die Tabelle mit den Beispieldatensätzen aus dem obigen Beispiel, indem Sie den folgenden INSERT INTO-Befehl 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 Datenbank wird mit der Erfolgsmeldung antworten:

Output
Query OK, 10 rows affected (0.002 sec)
Records: 10  Duplicates: 0  Warnings: 0

Verwenden 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 dem Beispiel zu Beginn 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   |
+-----------+------------+-----------+

Allerdings erscheint diesmal die Spalte „member_id“ im Ergebnis und enthält eine Zahlenfolge von 1 bis 10. Mit dieser Spalte sind die doppelten Zeilen für „Jane Smith“ und „Bob Johnson“ nicht mehr identisch, da jeder Name einer eindeutigen Kennung („member_id“) zugeordnet ist.

Überprüfen wir, ob die Datenbank das Hinzufügen eines weiteren „Tom Thompson“ zur Liste der Clubmitglieder zulässt:

INSERT INTO club_members (first_name, last_name) VALUES ('Tom', 'Thompson');

MySQL gibt eine Erfolgsmeldung aus:

Output
Query OK, 1 row affected (0.009 sec)

Um zu überprüfen, welcher numerische Bezeichner der neuen Zeile von der Datenbank zugewiesen wurde, führen Sie die SELECT-Abfrage erneut aus:

SELECT * FROM club_members;

Es gibt eine weitere Zeile in der Ausgabe:

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  |
+-----------+------------+-----------+

Eine neue Zeile wurde automatisch mit der Nummer 11 in der Spalte „member_id“ über die AUTO_INCREMENT-Funktion der Datenbank zugewiesen.

Wenn die Daten, mit denen Sie arbeiten, keine natürlichen Kandidaten für Primary Keys enthalten und Sie keine erfundenen Kennungen für jede neue Datenzeile bereitstellen möchten, können Sie sich sicher auf sequentiell generierte Kennungen als Primary Keys verlassen.

Fazit

Indem Sie diesem Leitfaden gefolgt sind, haben Sie gelernt, was Primary Keys in SQL sind und wie Sie die gängigen Typen in MySQL erstellen können, um eindeutige Zeilen in Datenbanktabellen zu identifizieren. Sie haben natürliche Primary Keys erstellt, Primary Keys über mehrere Spalten erstellt und auto-incrementierende sequentielle Schlüssel verwendet, wenn natürliche Schlüssel nicht vorhanden sind.

Sie können Primary Keys verwenden, um die Struktur der Datenbank weiter zu gestalten und sicherzustellen, dass Datenzeilen eindeutig identifizierbar sind. Dieses Tutorial behandelte nur die Grundlagen der Verwendung von Primary Keys in SQL. Weitere Informationen hierzu finden Sie in der MySQL-Dokumentation zu Constraints. Sie können auch unsere Leitfäden zu „Understanding SQL Constraints“ und „How To Use Constraints in SQL“ durchsehen.

Wenn Sie mehr über verschiedene Konzepte rund um die SQL-Sprache und deren Anwendung erfahren möchten, empfehlen wir Ihnen, die anderen Leitfäden in der „How To Use SQL“-Reihe anzuschauen.