Uma introdução aos índices SQL

Em sistemas de banco de dados relacionais, um índice de banco de dados é uma ferramenta extremamente poderosa para recuperação de dados. Neste guia, você aprenderá sobre índices exclusivos, chaves primárias e chaves primárias compostas.

O que é um índice de banco de dados?

Um Índice de banco de dados é um objeto de estrutura de dados associado a uma tabela de banco de dados. Ele é usado para aumentar a velocidade das consultas de banco de dados (através do SQL SELECT comando). Em geral, existem métodos bem definidos para decidir os tipos de índices a serem criados. Isso é amplamente governado por como as tabelas em um banco de dados se relacionam umas com as outras e como os dados são recuperados.

Por que usar índices?

Em geral, as consultas (ou pesquisas) em uma tabela via SQL SELECT comando são sequenciais. A pesquisa sequencial requer iniciar na parte superior da tabela e ler todas as linhas de dados até que os dados desejados sejam recuperados. Isso é extremamente ineficiente e pode ser uma operação cara em termos de velocidade.

Os índices, por outro lado, utilizam uma função hash para calcular um valor de índice. Ele fornece acesso direto à linha afetada (chave) no índice. Quando essa linha (chave) estiver localizada no índice, o registro do índice terá um ponteiro diretamente para a linha da tabela que é necessária na consulta. Esses ponteiros são estabelecidos durante a criação e manutenção do índice. A velocidade de recuperação de dados ao usar índices é aumentada em ordens de magnitude.

A anatomia de um índice de banco de dados exclusivo

Uma tabela de banco de dados pode ter um ou mais índices associados. Os próprios índices contêm valores de linha (chave) de uma ou mais colunas em uma tabela. Ele também tem um ponteiro que aponta para as linhas reais da tabela que contêm esses valores de chave. O número de linhas apontadas por uma determinada chave em um índice depende se o índice é um índice único ou um índice não exclusivo .

Como o nome indica, um índice exclusivo contém chaves que apontam para apenas uma linha de dados em uma determinada tabela. Os índices exclusivos garantem que cada linha na tabela contenha valores exclusivos nas colunas da tabela indexada definida. Efetivamente, duas linhas não podem ter valores idênticos nas colunas indexadas. Além disso, índices exclusivos são criados em colunas designadas como chave primária para a mesa. As chaves primárias são definidas como uma ou mais colunas que definem exclusivamente uma linha em uma tabela de banco de dados.

Os exemplos abaixo demonstram como as chaves primárias e os índices exclusivos são usados no SQL. Todos os exemplos usam uma tabela chamada Student , em um banco de dados de exemplo chamado exampledb . Para adicionar os dados de exemplo, use o seguinte comando:

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

Visualize os dados armazenados no Student tabela:

SELECT * FROM Student;

Você deve ver a seguinte saída:

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

Observação Salvo menção em contrário, todos os comandos neste guia funcionam bem em MySQL e PostgreSQL bancos de dados.

Chave primária e índice de coluna única

Como exemplo, suponha que uma escola acompanhe seus alunos em uma tabela chamada Student . Esta tabela tem colunas associadas denominadas Student , SSNumber , LastName e FirstName . Nessas colunas, Student é a coluna de chave primária, pois identifica exclusivamente cada linha de dados no Student tabela. Crie um índice exclusivo (SSIndex ) no SSNumber coluna, para facilitar a recuperação rápida de dados da tabela. O seguinte comando SQL DDL é usado para realizar esta consulta:

CREATE TABLE Aluno (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);

Observação Ambos os comandos SQL acima são delimitados por um ponto e vírgula (;), que é compatível com a maioria dos sistemas de banco de dados relacionais. SSNumber é especificamente designado como a chave primária da tabela.

SSIndex contém apenas informações que identificam exclusivamente os dados em cada linha do Student tabela. Cada linha de SSIndex tem um ponteiro para sua linha correspondente no Student tabela. Este SSIndex index permite evitar uma pesquisa sequencial de dados na tabela que melhora o desempenho minimizando o tempo necessário para a consulta.

Para encontrar as informações associadas para Robert Hansen através de seu SSNumber , use o comando SQL incluído abaixo. O comando não apenas elimina a busca sequencial de Student tabela, mas também usa o SSIndex para fornecer acesso direto à linha de dados necessária. Isso ocorre em virtude de usar uma função de hash e um ponteiro de índice associado.

SELECT * FROM Student WHERE SSNumber = 333333333;

Os dados retornados devem ser os seguintes:

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

Chave primária composta de várias colunas e índice

Os exemplos desta seção usam três tabelas que armazenam dados relacionados a uma liga de tênis. As três tabelas são denominadas Player , League e Membership . Um jogador pode jogar em várias ligas e a tabela de membros fornece essa associação. As três tabelas têm as seguintes colunas associadas a elas:

As colunas do Player tabela são exibidas abaixo com PlayedID como chave primária.

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

As colunas da League tabela são exibidas abaixo com LeagueId como chave primária.

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

As colunas da Membership tabela são exibidas abaixo

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

As etapas abaixo mostram como criar o Player , League e Membership mesas.

Do Player tabela, o PlayedID coluna identifica exclusivamente cada linha de dados. Crie o Player tabela seguida por um índice exclusivo no PlayerId coluna.

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

Da League tabela, o LeagueId coluna identifica exclusivamente cada linha de dados. Crie a League tabela seguida por um índice exclusivo no LeagueId coluna. Segue o comando SQL para realizar esta operação:

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

Do Membership tabela, tanto o PlayedID e LeagueId as colunas identificam exclusivamente cada linha de dados; que é a chave primária composta. Crie a Membership tabela seguida por um índice composto exclusivo no PlayedID e LeagueId colunas.
```
 CREATE TABLE Membership (
   PlayerId INT NOT NULL,
   LeagueId INT NOT NULL,
   PRIMARY KEY(PlayerId, LeagueId)
 );

 CREATE UNIQUE INDEX MembershipIndex ON Membership (PlayerId, LeagueId);
```

O MembershipIndex é um índice gerado por hash que consiste na Chave Composta(PlayedId e LeagueId ). Ele tem ponteiros para as linhas de dados que ele representa. O uso de tal índice facilita a recuperação de dados rápida e de acesso direto, em oposição à recuperação de dados sequencial linear. Por exemplo, para determinar todos os jogadores associados a “Duplas Masculinas” de vários registros em cada uma das tabelas acima, você pode emitir o seguinte comando SQL:

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

Os seguintes dados são retornados:

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

Sem o uso do MembershipIndex e PlayerIndex , a consulta acima seria executada de forma significativamente mais lenta.

Índices não exclusivos

Um índice não exclusivo contém entradas que podem apontar para uma ou mais linhas para qualquer valor de chave fornecido. Por exemplo, para pesquisar pelo nome de uma pessoa, é necessário criar um índice composto não exclusivo em uma tabela para FirstName e LastName . Como a combinação de FirstName e LastName não pode ser garantido como exclusivo, o índice resultante criado nessas duas colunas gera efetivamente um índice não exclusivo.

Problema de degradação do desempenho do banco de dados usando índices

Embora os índices ajudem na velocidade de execução da consulta, eles precisam ser atualizados sempre que as colunas indexadas forem alteradas ou quando as linhas da tabela forem adicionadas ou excluídas do banco de dados. Isso pode prejudicar o desempenho do banco de dados. É importante ter em mente a quantidade de inserção, exclusão e modificação necessária de seus índices durante o uso do banco de dados transacional. Considere o que é importante para você no aplicativo de banco de dados; a velocidade de execução da consulta ou a velocidade de manipulação de dados. A resposta a essa pergunta está em como o aplicativo de banco de dados é usado, com que frequência ele afeta o design do banco de dados e o número de índices criados.

Conclusão

Criar e usar índices de banco de dados gera respostas de recuperação de consulta rápidas e elimina pesquisas de linha sequenciais das tabelas. No entanto, a manutenção do índice por meio da manipulação de dados pode ter impactos prejudiciais no desempenho de um banco de dados. Os designers de banco de dados precisam estar cientes das compensações envolvidas ao usar índices de banco de dados e ter em mente a otimização para o desempenho geral do banco de dados.