Eine Einführung in SQL-Indizes

In relationalen Datenbanksystemen ein Datenbankindex ist ein äußerst leistungsfähiges Werkzeug zum Abrufen von Daten. In diesem Leitfaden erfahren Sie mehr über eindeutige Indizes, Primärschlüssel und zusammengesetzte Primärschlüssel.

Was ist ein Datenbankindex?

Ein Datenbankindex ist ein Datenstrukturobjekt, das einer Datenbanktabelle zugeordnet ist. Es wird verwendet, um die Geschwindigkeit von Datenbankabfragen zu erhöhen (über die SQL SELECT Befehl). Im Allgemeinen gibt es gut definierte Methoden, um zu entscheiden, welche Arten von Indizes erstellt werden sollen. Dies wird weitgehend davon bestimmt, wie Tabellen in einer Datenbank miteinander in Beziehung stehen und wie Daten abgerufen werden.

Warum Indizes verwenden?

Abfragen (oder Lookups) in einer Tabelle erfolgen im Allgemeinen über den SQL SELECT Befehle sind sequentiell. Bei der sequenziellen Suche muss oben in der Tabelle begonnen und jede Datenzeile gelesen werden, bis die gewünschten Daten abgerufen sind. Dies ist äußerst ineffizient und kann in Bezug auf die Geschwindigkeit ein teurer Vorgang sein.

Indizes hingegen verwenden eine Hash-Funktion, um einen Indexwert zu berechnen. Es bietet direkten Zugriff auf die betroffene Zeile (Schlüssel) im Index. Sobald sich diese Zeile (Schlüssel) im Index befindet, hat der Indexdatensatz einen Zeiger direkt auf die Tabellenzeile, die in der Abfrage benötigt wird. Diese Zeiger werden während der Indexerstellung und Indexwartung eingerichtet. Die Geschwindigkeit des Datenabrufs bei Verwendung von Indizes wird um Größenordnungen erhöht.

Die Anatomie eines einzigartigen Datenbankindex

Eine Datenbanktabelle kann einen oder mehrere zugeordnete Indizes haben. Indizes selbst enthalten Zeilenwerte (Schlüsselwerte) aus einer oder mehreren Spalten in einer Tabelle. Es hat auch einen Zeiger, der auf tatsächliche Tabellenzeilen zeigt, die diese Schlüsselwerte enthalten. Die Anzahl der Zeilen, auf die ein bestimmter Schlüssel in einem Index zeigt, hängt davon ab, ob der Index ein eindeutiger Index ist oder ein nicht eindeutiger Index .

Wie der Name schon sagt, enthält ein eindeutiger Index Schlüssel, die nur auf eine Datenzeile in einer bestimmten Tabelle zeigen. Eindeutige Indizes stellen sicher, dass jede Zeile in der Tabelle eindeutige Werte in den definierten indizierten Tabellenspalten enthält. Tatsächlich können keine zwei Zeilen identische Werte in den indizierten Spalten haben. Darüber hinaus werden eindeutige Indizes für Spalten erstellt, die als Primärschlüssel gekennzeichnet sind für den Tisch. Primärschlüssel sind als eine oder mehrere Spalten definiert, die eine Zeile in einer Datenbanktabelle eindeutig definieren.

Die folgenden Beispiele zeigen, wie Primärschlüssel und eindeutige Indizes in SQL verwendet werden. Alle Beispiele verwenden eine Tabelle namens Student , in einer Beispieldatenbank namens exampledb . Um die Beispieldaten hinzuzufügen, verwenden Sie den folgenden Befehl:

INSERT INTO Student(SSNumber, LastName, FirstName)
  VALUES
(111111111, Smith, John),
(222222222, Jones, Mary),
(333333333, Hansen, Robert);

Zeigen Sie die im Student gespeicherten Daten an Tabelle:

SELECT * FROM Student;

Sie sollten die folgende Ausgabe sehen:

+-----------+----------+-----------+
| SSNumber  | LastName | FirstName |
+-----------+----------+-----------+
| 111111111 | Smith    | John      |
| 222222222 | Jones    | Mary      |
| 333333333 | Hansen   | Robert    |
+-----------+----------+-----------+

Hinweis Sofern nicht anders erwähnt, funktionieren alle Befehle in diesem Handbuch sowohl auf MySQL als auch gut und PostgreSQL Datenbanken.

Einzelspaltiger Primärschlüssel und Index

Nehmen Sie als Beispiel an, dass eine Schule ihre Schüler in einer Tabelle mit dem Namen Student verwaltet . Diese Tabelle hat zugeordnete Spalten namens Student , SSNumber , LastName , und FirstName . Aus diesen Spalten Student ist die Primärschlüsselspalte, da sie jede Datenzeile im Student eindeutig identifiziert Tisch. Erstellen Sie einen eindeutigen Index (SSIndex ) auf der SSNumber Spalte, um das schnelle Abrufen von Daten aus der Tabelle zu erleichtern. Der folgende SQL DDL-Befehl wird verwendet, um diese Abfrage auszuführen:

CREATE TABLE Student (SSNumber CHAR(9) NOT NULL,LastName VARCHAR(30) NOT NULL,FirstName VARCHAR(20) NOT NULL,PRIMARY KEY (SSNumber));

CREATE UNIQUE INDEX SSIndex ON Student (SSNumber);

Hinweis Beide obigen SQL-Befehle werden durch ein Semikolon (;) getrennt, was mit den meisten relationalen Datenbanksystemen kompatibel ist. SSNumber wird ausdrücklich als Primärschlüssel der Tabelle bezeichnet.

SSIndex enthält nur Informationen, die Daten in jeder Zeile des Student eindeutig identifizieren Tisch. Jede Zeile von SSIndex hat einen Zeiger auf die entsprechende Zeile im Student Tisch. Dieser SSIndex index ermöglicht es Ihnen, eine sequentielle Suche nach Daten in der Tabelle zu vermeiden, was die Leistung verbessert, indem die für die Abfrage benötigte Zeit minimiert wird.

So finden Sie die zugehörigen Informationen für Robert Hansen über ihre SSNumber , verwenden Sie den unten aufgeführten SQL-Befehl. Der Befehl eliminiert nicht nur die sequentielle Suche nach Student Tabelle, sondern verwendet auch den SSIndex direkten Zugriff auf die erforderliche Datenzeile bereitzustellen. Dies geschieht aufgrund der Verwendung einer Hash-Funktion und eines zugehörigen Indexzeigers.

SELECT * FROM Student WHERE SSNumber = 333333333;

Die zurückgegebenen Daten sollten die folgenden sein:

+-----------+----------+-----------+
| SSNumber  | LastName | FirstName |
+-----------+----------+-----------+
| 333333333 | Hansen   | Robert    |
+-----------+----------+-----------+

Mehrspaltiger zusammengesetzter Primärschlüssel und Index

In den Beispielen dieses Abschnitts werden drei Tabellen verwendet, die Daten zu einer Tennisliga speichern. Die drei Tabellen heißen Player , League , und Membership . Ein Spieler kann in mehreren Ligen spielen, und die Mitgliedertabelle stellt diese Zuordnung bereit. Den drei Tabellen sind die folgenden Spalten zugeordnet:

Die Spalten des Player Tabelle werden unten mit PlayedID angezeigt als Primärschlüssel.

+----------+-----------+-----------+
| PlayedID | LastName  | FirstName |
+----------+-----------+-----------+

Die Spalten der League Tabelle werden unten mit LeagueId angezeigt als Primärschlüssel.

+----------+------------+------------+
| LeagueId | LeagueName | SkillLevel |
+----------+------------+------------+

Die Spalten der Membership Tabelle werden unten angezeigt

+----------+-----------+
| PlayedID | LeagueId  |
+----------+-----------+

Die folgenden Schritte zeigen Ihnen, wie Sie den Player erstellen , League , und Membership Tabellen.

1. Aus dem Player Tabelle, die PlayedID Spalte identifiziert jede Datenzeile eindeutig. Erstellen Sie den Player Tabelle gefolgt von einem eindeutigen Index für die PlayerId Spalte.

    CREATE TABLE Player (
      PlayedID INT NOT NULL,
      LastName VARCHAR(30) NOT NULL,
      FirstName VARCHAR(20) NOT NULL,
      PRIMARY KEY (PlayedID)
    );
   
    CREATE UNIQUE INDEX PlayerIndex ON Player (PlayedID);
   

2. Aus der League Tabelle, die LeagueId Spalte identifiziert jede Datenzeile eindeutig. Erstellen Sie die League Tabelle gefolgt von einem eindeutigen Index für dieLeagueId Säule. Im Folgenden finden Sie den SQL-Befehl zum Ausführen dieser Operation:

    CREATE TABLE League (
      LeagueId INT NOT NULL,
      LeagueName VARCHAR(50) NOT NULL,
      SkilLevel VARCHAR(20) NOT NULL,
      PRIMARY KEY (LeagueId)
    );
   
    CREATE UNIQUE INDEX LeagueIndex ON League (LeagueId);
   

3. Aus der Membership Tabelle, sowohl die PlayedID und LeagueId Spalten identifizieren jede Datenzeile eindeutig; das ist der zusammengesetzte Primärschlüssel. Erstellen Sie die Membership Tabelle gefolgt von einem eindeutigen zusammengesetzten Index auf der PlayedID und LeagueId Spalten.

    CREATE TABLE Membership (
      PlayerId INT NOT NULL,
      LeagueId INT NOT NULL,
      PRIMARY KEY(PlayerId, LeagueId)
    );
   
    CREATE UNIQUE INDEX MembershipIndex ON Membership (PlayerId, LeagueId);
   

Der MembershipIndex ist ein Hash-generierter Index, der aus dem zusammengesetzten Schlüssel (PlayedId und LeagueId ). Es hat Zeiger auf die Datenzeilen, die es darstellt. Die Verwendung eines solchen Index erleichtert den schnellen Datenabruf mit direktem Zugriff im Gegensatz zum linearen sequentiellen Datenabruf. Um beispielsweise alle Spieler zu ermitteln, die mit „Herrendoppel“ aus mehreren Datensätzen in jeder der obigen Tabellen verbunden sind, können Sie den folgenden SQL-Befehl eingeben:

SELECT Player.LastName, Player.Firstname
FROM Player, Membership
WHERE Membership.LeagueId = 2
AND Membership.PlayerId = Player.PlayerId

Die folgenden Daten werden zurückgegeben:

+----------+-----------+
| LastName | FirstName |
+----------+-----------+
| Smith    | John      |
| Hansen   | Robert    |
+-----------+----------+

Ohne Verwendung des MembershipIndex und PlayerIndex , würde die obige Abfrage erheblich langsamer ausgeführt.

Nicht eindeutige Indizes

Ein nicht eindeutiger Index enthält Einträge, die auf eine oder mehrere Zeilen für beliebige Schlüsselwerte verweisen können. Um beispielsweise nach dem Namen einer Person zu suchen, ist es erforderlich, einen nicht eindeutigen zusammengesetzten Index für eine Tabelle für FirstName zu erstellen und LastName . Da die Kombination aus FirstName und LastName nicht garantiert werden kann, dass sie eindeutig sind, generiert der resultierende Index, der auf diesen beiden Spalten erstellt wird, effektiv einen nicht eindeutigen Index.

Problem mit der Verschlechterung der Datenbankleistung bei Verwendung von Indizes

Obwohl Indizes die Geschwindigkeit der Abfrageausführung unterstützen, müssen sie aktualisiert werden, wenn sich indizierte Spalten ändern oder wenn Tabellenzeilen zur Datenbank hinzugefügt oder aus ihr gelöscht werden. Dies kann die Leistung der Datenbank beeinträchtigen. Es ist wichtig, den Umfang des Einfügens, Löschens und Änderns zu berücksichtigen, der für Ihre Indizes während der Verwendung von Transaktionsdatenbanken erforderlich ist. Überlegen Sie, was Ihnen bei der Datenbankanwendung wichtig ist; die Geschwindigkeit der Abfrageausführung oder die Geschwindigkeit der Datenmanipulation. Die Antwort auf diese Frage liegt darin, wie die Datenbankanwendung verwendet wird, wie oft sie das Design der Datenbank beeinflusst und wie viele Indizes erstellt werden.

Schlussfolgerung

Das Erstellen und Verwenden von Datenbankindizes generiert schnelle Abfrageantworten und eliminiert sequentielle Zeilensuchen aus Tabellen. Die Indexwartung durch Datenmanipulation kann sich jedoch nachteilig auf die Leistung einer Datenbank auswirken. Datenbankdesigner müssen sich der Kompromisse bewusst sein, die bei der Verwendung von Datenbankindizes auftreten, und die Optimierung für die Gesamtleistung der Datenbank berücksichtigen.