Une introduction aux index SQL

Dans les systèmes de bases de données relationnelles, un index de base de données est un outil extrêmement puissant pour la récupération de données. Dans ce guide, vous en apprendrez plus sur les index uniques, les clés primaires et les clés primaires composites.

Qu'est-ce qu'un index de base de données ?

Un index de base de données est un objet de structure de données associé à une table de base de données. Il permet d'augmenter la vitesse des requêtes en base de données (via le SQL SELECT commande). En général, il existe des méthodes bien définies pour décider des types d'index à créer. Ceci est largement régi par la manière dont les tables d'une base de données sont liées les unes aux autres et par la manière dont les données sont récupérées.

Pourquoi utiliser les index ?

En général, les requêtes (ou recherches) dans une table via le SQL SELECT commande sont séquentielles. La recherche séquentielle nécessite de commencer en haut de la table et de lire chaque ligne de données jusqu'à ce que les données souhaitées soient récupérées. Ceci est extrêmement inefficace et peut être une opération coûteuse en termes de vitesse.

Les index, d'autre part, utilisent une fonction de hachage pour calculer une valeur d'index. Il fournit un accès direct à la ligne concernée (clé) dans l'index. Une fois que cette ligne (clé) est localisée dans l'index, l'enregistrement d'index a un pointeur directement vers la ligne de table requise dans la requête. Ces pointeurs sont établis lors de la création et de la maintenance de l'index. La vitesse de récupération des données lors de l'utilisation d'index est augmentée de plusieurs ordres de grandeur.

L'anatomie d'un index de base de données unique

Une table de base de données peut avoir un ou plusieurs index associés. Les index eux-mêmes contiennent des valeurs de ligne (clé) d'une ou plusieurs colonnes d'une table. Il a également un pointeur qui pointe vers les lignes de table réelles contenant ces valeurs clés. Le nombre de lignes pointées par une clé donnée dans un index dépend du fait que l'index est un index unique ou un index non unique .

Comme son nom l'indique, un index unique contient des clés qui pointent vers une seule ligne de données dans une table donnée. Les index uniques garantissent que chaque ligne de la table contient des valeurs uniques dans les colonnes de table indexées définies. En effet, deux lignes ne peuvent pas avoir des valeurs identiques dans les colonnes indexées. De plus, des index uniques sont créés sur des colonnes désignées comme clé primaire pour le tableau. Les clés primaires sont définies comme une ou plusieurs colonnes qui définissent de manière unique une ligne dans une table de base de données.

Les exemples ci-dessous montrent comment les clés primaires et les index uniques sont utilisés dans SQL. Tous les exemples utilisent une table nommée Student , dans un exemple de base de données nommé exampledb . Pour ajouter les exemples de données, utilisez la commande suivante :

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

Visualiser les données stockées dans le Student tableau :

SELECT * FROM Student;

Vous devriez voir le résultat suivant :

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

Remarque Sauf mention contraire, toutes les commandes de ce guide fonctionnent bien sur MySQL et PostgreSQL bases de données.

Clé primaire et index à colonne unique

Par exemple, supposons qu'une école garde une trace de ses élèves dans une table nommée Student . Cette table a des colonnes associées nommées Student , SSNumber , LastName , et FirstName . À partir de ces colonnes, Student est la colonne de clé primaire car elle identifie de manière unique chaque ligne de données dans le Student table. Créer un index unique (SSIndex ) sur le SSNumber colonne, pour faciliter la récupération rapide des données de la table. La commande SQL DDL suivante est utilisée pour effectuer cette requête :

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

Remarque Les deux commandes SQL ci-dessus sont délimitées par un point-virgule (;), ce qui est compatible avec la plupart des systèmes de bases de données relationnelles. SSNumber est spécifiquement désignée comme clé primaire de la table.

SSIndex contient uniquement des informations qui identifient de manière unique les données dans chaque ligne du Student table. Chaque ligne de SSIndex a un pointeur vers sa ligne correspondante dans le Student table. Ce SSIndex index permet d'éviter une recherche séquentielle des données dans la table ce qui améliore les performances en minimisant le temps nécessaire à la requête.

Pour trouver les informations associées pour Robert Hansen via leur SSNumber , utilisez la commande SQL incluse ci-dessous. La commande élimine non seulement la recherche séquentielle de Student table mais utilise aussi le SSIndex pour fournir un accès direct à la ligne de données requise. Ceci est dû à l'utilisation d'une fonction de hachage et d'un pointeur d'index associé.

SELECT * FROM Student WHERE SSNumber = 333333333;

Les données renvoyées doivent être les suivantes :

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

Clé primaire et index composites multi-colonnes

Les exemples de cette section utilisent trois tables qui stockent des données relatives à une ligue de tennis. Les trois tables sont nommées Player , League , et Membership . Un joueur peut jouer dans plusieurs ligues, et le tableau des membres fournit cette association. Les trois tables sont associées aux colonnes suivantes :

Les colonnes du Player le tableau sont affichés ci-dessous avec PlayedID comme clé primaire.

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

Les colonnes de la League le tableau sont affichés ci-dessous avec LeagueId comme clé primaire.

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

Les colonnes de l'Membership tableau sont affichés ci-dessous

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

Les étapes ci-dessous vous montrent comment créer le Player , League , et Membership tableaux.

1. Depuis le Player table, le PlayedID colonne identifie de manière unique chaque ligne de données. Créer le Player table suivie d'un index unique sur le PlayerId colonne.

    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. De la League table, le LeagueId colonne identifie de manière unique chaque ligne de données. Créer la League table suivie d'un index unique sur le LeagueId colonne. Voici la commande SQL pour effectuer cette opération :

    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. Depuis le Membership table, à la fois le PlayedID et LeagueId les colonnes identifient de manière unique chaque ligne de données ; qui est la clé primaire composée. Créer l'Membership table suivie d'un index composite unique sur le PlayedID et LeagueId colonnes.

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

L'MembershipIndex est un index généré par hachage composé de la clé composite (PlayedId et LeagueId ). Il a des pointeurs vers les lignes de données qu'il représente. L'utilisation d'un tel index facilite l'extraction rapide de données à accès direct, par opposition à l'extraction de données séquentielle linéaire. Par exemple, pour déterminer tous les joueurs associés à "Doubles Hommes" à partir de plusieurs enregistrements dans chacun des tableaux ci-dessus, vous pouvez émettre la commande SQL suivante :

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

Les données suivantes sont renvoyées :

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

Sans l'utilisation du MembershipIndex et PlayerIndex , la requête ci-dessus s'exécuterait beaucoup plus lentement.

Index non uniques

Un index non unique contient des entrées qui peuvent pointer vers une ou plusieurs lignes pour n'importe quelle valeur de clé donnée. Par exemple, pour rechercher par le nom d'une personne, il est nécessaire de créer un index composite non unique sur une table à la fois pour FirstName et LastName . Depuis la combinaison de FirstName et LastName ne peut pas être garanti comme étant unique, l'index résultant créé sur ces deux colonnes génère effectivement un index non unique.

Problème de dégradation des performances de la base de données à l'aide d'index

Bien que les index contribuent à la vitesse d'exécution des requêtes, ils doivent être mis à jour chaque fois que les colonnes indexées changent ou lorsque des lignes de table sont ajoutées ou supprimées de la base de données. Cela peut nuire aux performances de la base de données. Il est important de garder à l'esprit la quantité d'insertions, de suppressions et de modifications requises de vos index lors de l'utilisation de la base de données transactionnelle. Considérez ce qui est important pour vous dans l'application de base de données ; la vitesse d'exécution des requêtes ou la vitesse de manipulation des données. La réponse à cette question réside dans la manière dont l'application de base de données est utilisée, la fréquence à laquelle elle affecte la conception de la base de données et le nombre d'index créés.

Conclusion

La création et l'utilisation d'index de base de données génèrent des réponses d'extraction de requêtes rapides et éliminent les recherches de lignes séquentielles dans les tables. Cependant, la maintenance de l'index via la manipulation des données peut avoir un impact négatif sur les performances d'une base de données. Les concepteurs de bases de données doivent être conscients des compromis impliqués lors de l'utilisation des index de base de données et garder à l'esprit l'optimisation des performances globales de la base de données.