MySQL-Indizes und Leistungsoberfläche

MySQLMySQLBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie etwas über MySQL-Indizes und Techniken zur Leistungsoptimierung von Datenbanken kennen. Das Lab konzentriert sich auf die Erstellung und Verwaltung von Indizes, um die Leistung von Datenbankabfragen zu verbessern.

Sie beginnen damit, eine Tabelle users zu erstellen und Beispielsdaten einzufügen. Anschließend erstellen Sie einen einspaltigen Index für die Spalte username und lernen, wie Sie die erfolgreiche Erstellung überprüfen können. Das Lab behandelt auch die Analyse von Abfrageplänen mit EXPLAIN, das Hinzufügen von zusammengesetzten Indizes für Mehrfachspaltenabfragen und das Entfernen ungenutzter Indizes, um die Effizienz der Datenbank aufrechtzuerhalten.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL mysql(("MySQL")) -.-> mysql/BasicKeywordsandStatementsGroup(["Basic Keywords and Statements"]) mysql(("MySQL")) -.-> mysql/AdvancedQueryingandOptimizationGroup(["Advanced Querying and Optimization"]) mysql(("MySQL")) -.-> mysql/SystemManagementToolsGroup(["System Management Tools"]) mysql/BasicKeywordsandStatementsGroup -.-> mysql/create_table("Table Creation") mysql/BasicKeywordsandStatementsGroup -.-> mysql/drop_table("Table Removal") mysql/BasicKeywordsandStatementsGroup -.-> mysql/alter_table("Table Modification") mysql/BasicKeywordsandStatementsGroup -.-> mysql/select("Data Retrieval") mysql/BasicKeywordsandStatementsGroup -.-> mysql/insert("Data Insertion") mysql/AdvancedQueryingandOptimizationGroup -.-> mysql/index("Index Management") mysql/SystemManagementToolsGroup -.-> mysql/show_status("Status Overview") subgraph Lab Skills mysql/create_table -.-> lab-550910{{"MySQL-Indizes und Leistungsoberfläche"}} mysql/drop_table -.-> lab-550910{{"MySQL-Indizes und Leistungsoberfläche"}} mysql/alter_table -.-> lab-550910{{"MySQL-Indizes und Leistungsoberfläche"}} mysql/select -.-> lab-550910{{"MySQL-Indizes und Leistungsoberfläche"}} mysql/insert -.-> lab-550910{{"MySQL-Indizes und Leistungsoberfläche"}} mysql/index -.-> lab-550910{{"MySQL-Indizes und Leistungsoberfläche"}} mysql/show_status -.-> lab-550910{{"MySQL-Indizes und Leistungsoberfläche"}} end

Erstellen eines einspaltigen Indexes für eine Tabelle

In diesem Schritt lernen Sie, wie Sie in MySQL einen einspaltigen Index erstellen. Indizes sind von entscheidender Bedeutung für die Verbesserung der Leistung von Datenbankabfragen, insbesondere wenn es um große Tabellen geht. Ein Index für eine Spalte ermöglicht es der Datenbank, Zeilen, die einem bestimmten Wert in dieser Spalte entsprechen, schnell zu finden, ohne die gesamte Tabelle scannen zu müssen.

Grundlagen zu Indizes

Stellen Sie sich einen Index wie das Inhaltsverzeichnis in einem Buch vor. Anstatt das gesamte Buch zu lesen, um ein bestimmtes Thema zu finden, können Sie das Inhaltsverzeichnis nutzen, um schnell die relevanten Seiten zu lokalisieren. Ähnlich hilft ein Datenbankindex dem Datenbankmotor, bestimmte Zeilen schnell zu finden.

Erstellen einer Tabelle

Zunächst erstellen wir eine einfache Tabelle namens users, um die Erstellung eines Indexes zu demonstrieren. Öffnen Sie ein Terminal in der LabEx VM. Sie können das Xfce Terminal-Kürzel auf dem Desktop verwenden.

Verbinden Sie sich als Root-Benutzer mit dem MySQL-Server:

mysql -u root -proot

Nun erstellen wir die Tabelle users:

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Diese SQL-Anweisung erstellt eine Tabelle namens users mit Spalten für id, username, email und created_at. Die Spalte id wird als Primärschlüssel festgelegt und erhöht sich automatisch.

Fügen wir einige Beispielsdaten in die Tabelle users ein:

INSERT INTO users (username, email) VALUES
('john_doe', '[email protected]'),
('jane_smith', '[email protected]'),
('peter_jones', '[email protected]');

Erstellen eines einspaltigen Indexes

Nun erstellen wir einen Index für die Spalte username. Dies wird die Geschwindigkeit von Abfragen verbessern, die Benutzer anhand ihres Benutzernamens suchen.

CREATE INDEX idx_username ON users (username);

Diese Anweisung erstellt einen Index namens idx_username für die Spalte username der Tabelle users.

Überprüfen des Indexes

Sie können überprüfen, ob der Index erstellt wurde, indem Sie den Befehl SHOW INDEXES verwenden:

SHOW INDEXES FROM users;

Die Ausgabe zeigt die Details der Indizes für die Tabelle users, einschließlich des von Ihnen gerade erstellten Indexes idx_username. Sie sollten eine Zeile sehen, in der Key_name idx_username und Column_name username ist.

+-------+------------+--------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| Table | Non_unique | Key_name     | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment | Visible | Expression |
+-------+------------+--------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| users |          0 | PRIMARY      |            1 | id          | A         |           3 |     NULL | NULL   |      | BTREE      |         |               | YES     | NULL       |
| users |          1 | idx_username |            1 | username    | A         |           3 |     NULL | NULL   |      | BTREE      |         |               | YES     | NULL       |
+-------+------------+--------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+

Verwenden des Indexes

Um den Nutzen des Indexes zu sehen, können Sie den Befehl EXPLAIN verwenden, um eine Abfrage zu analysieren, die die Spalte username nutzt. Wir werden EXPLAIN im nächsten Schritt ausführlicher behandeln, aber für jetzt sehen wir uns ein kurzes Beispiel an.

EXPLAIN SELECT * FROM users WHERE username = 'john_doe';

Die Ausgabe von EXPLAIN zeigt, dass die Abfrage den Index idx_username verwendet. Das bedeutet, dass die Datenbank die passende Zeile schnell finden kann, ohne die gesamte Tabelle zu scannen. Suchen Sie in der Ausgabe nach den Spalten possible_keys und key. Wenn der Index verwendet wird, sehen Sie idx_username in diesen Spalten.

Sie haben nun erfolgreich einen einspaltigen Index für eine Tabelle erstellt. Dies verbessert die Leistung von Abfragen, die Daten anhand der indizierten Spalte filtern.

exit;

Analysieren eines Abfrageplans mit EXPLAIN

In diesem Schritt lernen Sie, wie Sie die EXPLAIN-Anweisung in MySQL verwenden, um den Ausführungsplan einer Abfrage zu analysieren. Das Verständnis des Abfrageplans ist unerlässlich, um Leistungsschwachstellen zu identifizieren und Ihre Abfragen zu optimieren.

Was ist ein Abfrageplan?

Ein Abfrageplan ist eine Wegbeschreibung, die der Datenbankmotor verwendet, um eine Abfrage auszuführen. Er beschreibt die Reihenfolge, in der Tabellen abgerufen werden, die Indizes, die verwendet werden, und die Algorithmen, die zur Datengewinnung angewendet werden. Durch die Analyse des Abfrageplans können Sie verstehen, wie die Datenbank Ihre Abfrage ausführt, und Bereiche für Verbesserungen identifizieren.

Verwenden der EXPLAIN-Anweisung

Die EXPLAIN-Anweisung liefert Informationen darüber, wie MySQL eine Abfrage ausführt. Sie zeigt die beteiligten Tabellen, die verwendeten Indizes, die Join-Reihenfolge und andere Details, die Ihnen helfen können, die Leistung der Abfrage zu verstehen.

Wir verwenden weiterhin die Tabelle users, die wir im vorherigen Schritt erstellt haben. Öffnen Sie ein Terminal in der LabEx VM (verwenden Sie das Xfce Terminal-Kürzel auf dem Desktop) und verbinden Sie sich als Root-Benutzer mit dem MySQL-Server:

mysql -u root -proot

Nun analysieren wir eine einfache Abfrage mit EXPLAIN.

EXPLAIN SELECT * FROM users WHERE username = 'john_doe';

Die Ausgabe der EXPLAIN-Anweisung ist eine Tabelle mit mehreren Spalten. Hier ist eine Zusammenfassung einiger der wichtigsten Spalten:

  • id: Die ID der SELECT-Anweisung.
  • select_type: Der Typ der SELECT-Abfrage (z. B. SIMPLE, PRIMARY, SUBQUERY).
  • table: Die Tabelle, auf die zugegriffen wird.
  • type: Der Join-Typ. Dies ist eine der wichtigsten Spalten. Häufige Werte sind:
    • system: Die Tabelle hat nur eine Zeile.
    • const: Die Tabelle hat höchstens eine übereinstimmende Zeile, die zu Beginn der Abfrage gelesen wird.
    • eq_ref: Für jede Kombination von Zeilen aus den vorherigen Tabellen wird eine Zeile aus dieser Tabelle gelesen. Dies wird verwendet, wenn auf einer indizierten Spalte verbunden wird.
    • ref: Alle übereinstimmenden Zeilen werden für jede Kombination von Zeilen aus den vorherigen Tabellen aus dieser Tabelle gelesen. Dies wird verwendet, wenn auf einer indizierten Spalte verbunden wird.
    • range: Nur Zeilen innerhalb eines bestimmten Bereichs werden unter Verwendung eines Index abgerufen.
    • index: Es wird ein vollständiger Indexscan durchgeführt.
    • ALL: Es wird ein vollständiger Tabellenscan durchgeführt. Dies ist der am wenigsten effiziente Typ.
  • possible_keys: Die Indizes, die MySQL verwenden könnte, um die Zeilen in der Tabelle zu finden.
  • key: Der Index, den MySQL tatsächlich verwendet.
  • key_len: Die Länge des Schlüssels, den MySQL verwendet.
  • ref: Die Spalten oder Konstanten, die mit dem Index verglichen werden.
  • rows: Die Anzahl der Zeilen, die MySQL schätzt, dass es zur Ausführung der Abfrage untersuchen muss.
  • Extra: Zusätzliche Informationen darüber, wie MySQL die Abfrage ausführt. Häufige Werte sind:
    • Using index: Die Abfrage kann nur mit dem Index erfüllt werden.
    • Using where: MySQL muss die Zeilen nach dem Zugriff auf die Tabelle filtern.
    • Using temporary: MySQL muss eine temporäre Tabelle erstellen, um die Abfrage auszuführen.
    • Using filesort: MySQL muss die Zeilen nach dem Zugriff auf die Tabelle sortieren.

Interpretieren der EXPLAIN-Ausgabe

Für die Abfrage SELECT * FROM users WHERE username = 'john_doe' sollte die EXPLAIN-Ausgabe in etwa so aussehen:

+----+-------------+-------+------------+------+---------------+--------------+---------+-------+------+-------+-------+
| id | select_type | table | partitions | type | possible_keys | key          | key_len | ref   | rows | filtered | Extra |
+----+-------------+-------+------------+------+---------------+--------------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | users | NULL       | ref  | idx_username  | idx_username | 767     | const |    1 |   100.00 | NULL  |
+----+-------------+-------+------------+------+---------------+--------------+---------+-------+------+----------+-------+

In diesem Beispiel:

  • type ist ref, was bedeutet, dass MySQL einen Index verwendet, um die übereinstimmende Zeile zu finden.
  • possible_keys und key zeigen beide idx_username, was bedeutet, dass MySQL den idx_username-Index verwendet, den wir im vorherigen Schritt erstellt haben.
  • rows ist 1, was bedeutet, dass MySQL schätzt, dass es nur eine Zeile untersuchen muss, um die Abfrage auszuführen.

Analysieren einer Abfrage ohne Index

Nun analysieren wir eine Abfrage, die keinen Index verwendet. Zunächst fügen wir der Tabelle users eine neue Spalte namens city hinzu:

ALTER TABLE users ADD COLUMN city VARCHAR(255);

Nun führen wir eine EXPLAIN-Analyse für eine Abfrage durch, die nach city sucht:

EXPLAIN SELECT * FROM users WHERE city = 'New York';

Da wir noch keine Daten in die Spalte city eingefügt haben, aktualisieren wir eine der Zeilen:

UPDATE users SET city = 'New York' WHERE username = 'john_doe';

Nun führen wir die EXPLAIN-Anweisung erneut aus:

EXPLAIN SELECT * FROM users WHERE city = 'New York';

Die Ausgabe könnte in etwa so aussehen:

+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra       |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | users | NULL       | ALL  | NULL          | NULL | NULL    | NULL |    3 |    33.33 | Using where |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+

In diesem Beispiel:

  • type ist ALL, was bedeutet, dass MySQL einen vollständigen Tabellenscan durchführt.
  • possible_keys und key sind beide NULL, was bedeutet, dass MySQL keine Indizes verwendet.
  • rows ist 3, was bedeutet, dass MySQL schätzt, dass es alle 3 Zeilen in der Tabelle untersuchen muss, um die Abfrage auszuführen.
  • Extra zeigt Using where, was bedeutet, dass MySQL die Zeilen nach dem Zugriff auf die Tabelle filtern muss.

Dies zeigt, dass die Abfrage nicht optimiert ist und von einem Index auf der Spalte city profitieren könnte.

exit;

Hinzufügen eines zusammengesetzten Indexes für Mehrspaltenabfragen

In diesem Schritt lernen Sie, wie Sie in MySQL einen zusammengesetzten Index (composite index) erstellen. Ein zusammengesetzter Index ist ein Index, der sich auf zwei oder mehr Spalten in einer Tabelle bezieht. Er kann die Leistung von Abfragen, die Daten anhand mehrerer Spalten filtern, erheblich verbessern.

Was ist ein zusammengesetzter Index?

Ein zusammengesetzter Index ist ein Index, der mehrere Spalten abdeckt. Er ist nützlich, wenn Abfragen häufig mehrere Spalten in der WHERE-Klausel verwenden. Die Reihenfolge der Spalten im zusammengesetzten Index ist wichtig. Der Index ist am effektivsten, wenn die Spalten in der gleichen Reihenfolge in der WHERE-Klausel der Abfrage angegeben werden.

Wir verwenden weiterhin die Tabelle users, die wir in den vorherigen Schritten erstellt haben. Öffnen Sie ein Terminal in der LabEx VM (verwenden Sie das Xfce Terminal-Kürzel auf dem Desktop) und verbinden Sie sich als Root-Benutzer mit dem MySQL-Server:

mysql -u root -proot

Fügen wir einige weitere Daten in die Tabelle users ein, einschließlich verschiedener Städte:

INSERT INTO users (username, email, city) VALUES
('alice_brown', '[email protected]', 'Los Angeles'),
('bob_davis', '[email protected]', 'Chicago'),
('charlie_wilson', '[email protected]', 'New York'),
('david_garcia', '[email protected]', 'Los Angeles');

Erstellen eines zusammengesetzten Indexes

Angenommen, Sie führen häufig Abfragen aus, die Benutzer sowohl nach city als auch nach username filtern. In diesem Fall können Sie einen zusammengesetzten Index auf den Spalten city und username erstellen.

CREATE INDEX idx_city_username ON users (city, username);

Diese Anweisung erstellt einen Index namens idx_city_username auf den Spalten city und username der Tabelle users.

Überprüfen des Indexes

Sie können überprüfen, ob der Index erstellt wurde, indem Sie den Befehl SHOW INDEXES verwenden:

SHOW INDEXES FROM users;

Die Ausgabe zeigt die Details der Indizes für die Tabelle users, einschließlich des von Ihnen gerade erstellten Indexes idx_city_username. Sie sollten zwei Zeilen für idx_city_username sehen, eine für die Spalte city und eine für die Spalte username.

+-------+------------+-------------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| Table | Non_unique | Key_name          | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment | Visible | Expression |
+-------+------------+-------------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| users |          0 | PRIMARY           |            1 | id          | A         |           7 |     NULL | NULL   |      | BTREE      |         |               | YES     | NULL       |
| users |          1 | idx_username      |            1 | username    | A         |           7 |     NULL | NULL   |      | BTREE      |         |               | YES     | NULL       |
| users |          1 | idx_city_username |            1 | city        | A         |           3 |     NULL | NULL   | YES  | BTREE      |         |               | YES     | NULL       |
| users |          1 | idx_city_username |            2 | username    | A         |           7 |     NULL | NULL   |      | BTREE      |         |               | YES     | NULL       |
+-------+------------+-------------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+

Verwenden des zusammengesetzten Indexes

Um den Nutzen des zusammengesetzten Indexes zu sehen, können Sie den Befehl EXPLAIN verwenden, um eine Abfrage zu analysieren, die sowohl die Spalte city als auch die Spalte username in der WHERE-Klausel verwendet.

EXPLAIN SELECT * FROM users WHERE city = 'New York' AND username = 'charlie_wilson';

Die Ausgabe von EXPLAIN zeigt, dass die Abfrage den Index idx_city_username verwendet. Das bedeutet, dass die Datenbank die passende Zeile schnell finden kann, ohne die gesamte Tabelle zu scannen. Suchen Sie in der Ausgabe nach den Spalten possible_keys und key. Wenn der Index verwendet wird, sehen Sie idx_city_username in diesen Spalten.

+----+-------------+-------+------------+------+-------------------+-------------------+---------+-------------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys     | key               | key_len | ref         | rows | filtered | Extra |
+----+-------------+-------+------------+------+-------------------+-------------------+---------+-------------+------+----------+-------+
|  1 | SIMPLE      | users | NULL       | ref  | idx_city_username | idx_city_username | 770     | const,const |    1 |   100.00 | NULL  |
+----+-------------+-------+------------+------+-------------------+-------------------+---------+-------------+------+----------+-------+

Reihenfolge der Spalten im Index

Die Reihenfolge der Spalten im zusammengesetzten Index ist von Bedeutung. Wenn Sie einen Index auf (username, city) anstelle von (city, username) erstellen, ist der Index für Abfragen, die zuerst nach city und dann nach username filtern, weniger effektiv.

Beispielsweise würde, wenn wir einen Index auf (username, city) hätten und die folgende Abfrage ausführen würden:

EXPLAIN SELECT * FROM users WHERE city = 'New York' AND username = 'charlie_wilson';

MySQL möglicherweise den Index nicht verwenden oder ihn nur teilweise nutzen, da die Spalte city nicht die führende Spalte im Index ist.

exit;

Entfernen eines nicht verwendeten Indexes

In diesem Schritt lernen Sie, wie Sie in MySQL einen nicht verwendeten Index entfernen. Während Indizes die Abfrageleistung erheblich verbessern können, erhöhen sie auch den Aufwand für Schreiboperationen (Einfügungen, Updates und Löschungen). Daher ist es wichtig, nicht mehr verwendete Indizes zu identifizieren und zu entfernen.

Warum sollten nicht verwendete Indizes entfernt werden?

Nicht verwendete Indizes belegen Plattenplatz und können Schreiboperationen verlangsamen. Wenn Daten in einer Tabelle geändert werden, muss der Datenbankmotor auch alle Indizes auf dieser Tabelle aktualisieren. Wenn ein Index von keiner Abfrage verwendet wird, erhöht er nur unnötig den Aufwand.

Wir verwenden weiterhin die Tabelle users, die wir in den vorherigen Schritten erstellt haben. Öffnen Sie ein Terminal in der LabEx VM (verwenden Sie das Xfce Terminal-Kürzel auf dem Desktop) und verbinden Sie sich als Root-Benutzer mit dem MySQL-Server:

mysql -u root -proot

In den vorherigen Schritten haben wir einen Index namens idx_username auf der Spalte username erstellt. Nehmen wir an, dass Sie nach der Analyse Ihrer Abfrage-Muster feststellen, dass dieser Index nicht mehr verwendet wird.

Entfernen des Indexes

Um den Index idx_username zu entfernen, können Sie die DROP INDEX-Anweisung verwenden:

DROP INDEX idx_username ON users;

Diese Anweisung entfernt den Index idx_username aus der Tabelle users.

Überprüfen der Indexentfernung

Sie können überprüfen, ob der Index entfernt wurde, indem Sie den Befehl SHOW INDEXES verwenden:

SHOW INDEXES FROM users;

Die Ausgabe zeigt die Details der Indizes auf der Tabelle users. Der Index idx_username sollte in der Ausgabe nicht mehr erscheinen.

+-------+------------+-------------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| Table | Non_unique | Key_name          | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment | Visible | Expression |
+-------+------------+-------------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| users |          0 | PRIMARY           |            1 | id          | A         |           7 |     NULL | NULL   |      | BTREE      |         |               | YES     | NULL       |
| users |          1 | idx_city_username |            1 | city        | A         |           3 |     NULL | NULL   | YES  | BTREE      |         |               | YES     | NULL       |
| users |          1 | idx_city_username |            2 | username    | A         |           7 |     NULL | NULL   |      | BTREE      |         |               | YES     | NULL       |
+-------+------------+-------------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+

Identifizieren von nicht verwendeten Indizes

In der Praxis kann es schwierig sein, nicht verwendete Indizes zu identifizieren. MySQL bietet mehrere Tools und Techniken, die Ihnen bei dieser Aufgabe helfen:

  • MySQL Enterprise Audit: Diese Funktion ermöglicht es Ihnen, alle auf Ihrem Server ausgeführten Abfragen zu protokollieren. Anschließend können Sie die Abfrageprotokolle analysieren, um festzustellen, welche Indizes verwendet werden.
  • Performance Schema: Die Performance Schema bietet detaillierte Informationen über die Serverleistung, einschließlich der Indexnutzung.
  • Drittanbieter-Tools: Mehrere Drittanbieter-Tools können Ihnen helfen, die Indexnutzung zu überwachen und nicht verwendete Indizes zu identifizieren.

Durch die regelmäßige Überwachung Ihrer Indexnutzung und das Entfernen nicht verwendeter Indizes können Sie die Gesamtleistung Ihrer Datenbank verbessern.

exit;

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in MySQL einen Einzelspaltenindex (single-column index) erstellen, um die Abfrageleistung, insbesondere für große Tabellen, zu verbessern. Der Prozess umfasste die Verbindung zum MySQL-Server, die Erstellung einer Tabelle users mit Spalten für id, username, email und created_at sowie das Einfügen von Beispieldaten.

Der Schlüsselschritt war die Erstellung eines Index namens idx_username auf der Spalte username mithilfe der CREATE INDEX-Anweisung. Dieser Index beschleunigt Abfragen, die Benutzer anhand ihres Benutzernamens suchen, indem die Datenbank Zeilen, die bestimmten Benutzernamenwerten entsprechen, schnell finden kann, ohne die gesamte Tabelle zu scannen.