En introduktion till SQL-index

I relationsdatabassystem, ett databasindex är ett extremt kraftfullt verktyg för datahämtning. I den här guiden lär du dig om unika index, primärnycklar och sammansatta primärnycklar.

Vad är ett databasindex?

Ett Databasindex är ett datastrukturobjekt associerat med en databastabell. Den används för att öka hastigheten på databasfrågor (via SQL SELECT). kommando). I allmänhet finns det väldefinierade metoder för att bestämma vilka typer av index som ska skapas. Detta styrs till stor del av hur tabeller i en databas relaterar till varandra och hur data hämtas.

Varför använda index?

I allmänhet, frågor (eller uppslagningar) i en tabell via SQL SELECT kommandon är sekventiella. Sekventiell sökning kräver att man börjar överst i tabellen och läser varje rad med data tills önskad data hämtas. Detta är extremt ineffektivt och kan vara en dyr operation när det gäller hastighet.

Index, å andra sidan, använder en hashfunktion för att beräkna ett indexvärde. Det ger direkt åtkomst till den berörda raden (nyckeln) i indexet. När den raden (nyckeln) finns i indexet har indexposten en pekare direkt till tabellraden som krävs i frågan. Dessa pekare upprättas under indexskapande och indexunderhåll. Hastigheten för datahämtning vid användning av index ökas i storleksordningar.

The Anatomy of a Unique Database Index

En databastabell kan ha ett eller flera associerade index. Index innehåller själva radvärden (nyckel) från en eller flera kolumner i en tabell. Den har också en pekare som pekar på faktiska tabellrader som innehåller dessa nyckelvärden. Antalet rader som en given nyckel pekar på i ett index beror på om indexet är ett unikt index eller ett icke-unikt index .

Som namnet antyder innehåller ett unikt index nycklar som pekar på endast en datarad i en given tabell. Unika index säkerställer att varje rad i tabellen innehåller unika värden i de definierade indexerade tabellkolumnerna. I praktiken kan inga två rader ha identiska värden i de indexerade kolumnerna. Dessutom skapas unika index på kolumner som är designade som en primärnyckel för bordet. Primära nycklar definieras som en eller flera kolumner som unikt definierar en rad i en databastabell.

Exemplen nedan visar hur primärnycklar och unika index används i SQL. Alla exempel använder en tabell som heter Student , i en exempeldatabas med namnet exampledb . För att lägga till exempeldata använd följande kommando:

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

Visa data som lagras i Student tabell:

SELECT * FROM Student;

Du bör se följande utdata:

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

Obs Om inget annat nämns fungerar alla kommandon i den här guiden bra på båda MySQL och PostgreSQL databaser.

Enkelkolumns primärnyckel och index

Som ett exempel, anta att en skola håller reda på sina elever i en tabell som heter Student . Den här tabellen har associerade kolumner med namnet Student , SSNumber , LastName och FirstName . Från dessa kolumner, Student är den primära nyckelkolumnen eftersom den unikt identifierar varje rad med data i Student tabell. Skapa ett unikt index (SSIndex ) på SSNumber kolumn, för att underlätta snabb hämtning av data från tabellen. Följande SQL DDL-kommando används för att utföra denna fråga:

CREATE TABLE Student (SSNumber CHAR(9) NOT NULL,Efternamn VARCHAR(30) NOT NULL,FirstName VARCHAR(20) NOT NULL,PRIMÄRKEY (SSNumber));

CREATE UNIQUE INDEX SSIndex ON Student (SSNumber);

Obs Båda SQL-kommandona ovan är avgränsade med semikolon (;), vilket är kompatibelt med de flesta relationsdatabassystem. SSNumber är specifikt betecknad som tabellens primärnyckel.

SSIndex innehåller endast information som unikt identifierar data i varje rad av Student tabell. Varje rad i SSIndex har en pekare till motsvarande rad i Student tabell. Detta SSIndex index låter dig undvika en sekventiell sökning av data i tabellen som förbättrar prestandan genom att minimera tiden som krävs för frågan.

För att hitta tillhörande information om Robert Hansen via deras SSNumber , använd SQL-kommandot som ingår nedan. Kommandot eliminerar inte bara sekventiell sökning av Student tabellen men använder också SSIndex för att ge direkt åtkomst till den erforderliga dataraden. Detta är genom att använda en hashfunktion och tillhörande indexpekare.

SELECT * FROM Student WHERE SSNumber = 333333333;

Den data som returneras bör vara följande:

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

Multi-column Composite Primary Key and Index

I det här avsnittets exempel används tre tabeller som lagrar data relaterad till en tennisliga. De tre borden heter Player , League och Membership . En spelare kan spela i flera ligor, och medlemstabellen ger den föreningen. De tre tabellerna har följande kolumner kopplade till sig:

Kolumnerna i Player tabellen visas nedan med PlayedID som primärnyckel.

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

Kolumnerna i League tabellen visas nedan med LeagueId som primärnyckel.

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

Kolumnerna i Membership tabellen visas nedan

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

Stegen nedan visar hur du skapar Player , League och Membership tabeller.

1. Från Player tabellen, PlayedID kolumnen identifierar varje rad med data unikt. Skapa Player tabell följt av ett unikt index på PlayerId kolumn.

    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. Från League tabellen, LeagueId kolumnen identifierar varje rad med data unikt. Skapa League tabell följt av ett unikt index på LeagueId kolumn. Följande är SQL-kommandot för att utföra denna 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. Från Membership tabellen, både PlayedID och LeagueId kolumner identifierar varje rad med data unikt; som är den sammansatta primärnyckeln. Skapa Membership tabell följt av ett unikt sammansatt index på PlayedID och LeagueId kolumner.

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

MembershipIndex är ett hashgenererat index som består av den sammansatta nyckeln (PlayedId och LeagueId ). Den har pekare till dataraderna som den representerar. Användningen av ett sådant index underlättar snabb datahämtning med direkt åtkomst, i motsats till linjär sekventiell datahämtning. Till exempel, för att fastställa alla spelare som är associerade med "Dubbel herr" från flera poster i var och en av tabellerna ovan, kan du utfärda följande SQL-kommando:

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

Följande data returneras:

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

Utan användning av MembershipIndex och PlayerIndex , skulle frågan ovan köras betydligt långsammare.

Icke-unika index

Ett icke-unikt index innehåller poster som kan peka på en eller flera rader för ett givet nyckelvärde. Till exempel, för att söka på en persons namn, är det nödvändigt att skapa ett icke-unikt sammansatt index på en tabell för både FirstName och LastName . Eftersom kombinationen av FirstName och LastName kan inte garanteras att vara unikt, det resulterande indexet som skapas på dessa två kolumner genererar effektivt ett icke-unikt index.

Problem med försämring av databasprestanda med hjälp av index

Även om index underlättar exekveringshastigheten för frågor, måste de uppdateras när indexerade kolumner ändras eller när tabellrader läggs till eller tas bort från databasen. Detta kan vara skadligt för databasens prestanda. Det är viktigt att komma ihåg mängden infogning, radering och ändring som krävs av dina index under användning av transaktionsdatabas. Fundera på vad som är viktigt för dig i databasapplikationen; hastigheten för exekvering av frågor eller hastigheten för datamanipulering. Svaret på den frågan ligger i hur databasapplikationen används, hur ofta den påverkar databasens design och antalet skapade index.

Slutsats

Att skapa och använda databasindex genererar snabba frågehämtningssvar och eliminerar sekventiella raduppslagningar från tabeller. Indexunderhåll genom datamanipulation kan dock ha skadliga prestandaeffekter på en databas. Databasdesigners måste vara medvetna om de avvägningar som är inblandade när de använder databasindex och tänka på optimering för övergripande databasprestanda.