--Ang index ay isang istraktura sa disk na nauugnay sa isang talahanayan o view at nagpapabilis sa pagkuha ng mga hilera mula sa talahanayan o view. Ang isang index ay naglalaman ng mga key na binuo mula sa isa o higit pang mga column sa isang table o view. Ang mga key na ito ay naka-imbak sa isang balanseng istraktura ng puno na sumusuporta sa mabilis na paghahanap ng mga hilera sa pamamagitan ng kanilang mga pangunahing halaga sa SQL Server.

--Ang mga naka-cluster na index ay nag-uuri at nag-iimbak ng mga hilera ng data sa mga talahanayan o view batay sa kanilang mga pangunahing halaga. Ang mga halagang ito ay ang mga column na kasama sa index definition. Mayroon lamang isang clustered index bawat talahanayan dahil ang mga row ng data ay maaari lamang pagbukud-bukurin sa isang solong pagkakasunud-sunod.
--Ang mga hilera ng data sa isang talahanayan ay iniimbak sa pagkakasunud-sunod lamang kung ang talahanayan ay naglalaman ng isang clustered index. Kung ang isang talahanayan ay may clustered index, kung gayon ang talahanayan ay tinatawag na clustered. Kung ang isang talahanayan ay walang clustered index, ang mga hilera ng data ay iniimbak sa isang hindi ayos na istraktura na tinatawag na isang heap.

--Ang isang nonclustered index ay may eksaktong parehong istraktura bilang isang clustered index, ngunit may dalawang mahahalagang pagkakaiba:
--hindi binabago ng nonclustered index ang pisikal na pagkakasunud-sunod ng mga row sa table, at ang mga leaf page sa isang nonclustered index ay binubuo ng mga index key at bookmark.

--Ang mga clustered index ay nagbibigay ng mas mabilis na data retrieval kaysa sa nonclustered indexes. Karaniwang nagiging mas mabilis ang mga ito kapag nag-a-update din, ngunit hindi kapag maraming update ang nangyayari sa parehong lugar sa gitna ng relasyon.

--Para sa ilang kadahilanan, ang isang clustered index ay may posibilidad na tumakbo nang mas mabilis kaysa sa isang nonclustered index. Kapag ang system ay nag-scan ng isang clustered index, hindi na kailangang umalis sa B-tree na istraktura upang i-scan ang mga pahina ng data dahil ang mga naturang pahina ay naroroon na sa antas ng dahon ng puno.

--Ang isang nonclustered index ay nangangailangan din ng mas maraming I/O operations kaysa sa kaukulang clustered index.

--Kailangang basahin ng nonclustered index ang mga page ng data pagkatapos i-scan ang B-tree o, kung mayroong clustered index sa isa pang column (s) ng table, kailangang basahin ng nonclustered index ang B-tree structure ng clustered index .

--Kaya ang isang clustered index ay magiging mas mabilis kaysa sa isang table scan, kahit na ang selectivity nito ay medyo mahina (ang query ay nagbabalik ng maraming mga row)

GUMAWA NG TALAAN tsql.dbo.NI
ID int NOT NULL,
T char(8) NULL
);

GUMAWA NG TALAAN tsql.dbo.NCI
ID int NOT NULL,
T char(8) NULL
);

--Gumawa ng clustered index

GUMAWA NG CLUSTERED INDEX IX_1
SA tsql.dbo.NCI(ID);

--Gumawa ng nonclustered index sa isang table

GUMAWA NG NONCLUSTERED INDEX IX_2
SA tsql.dbo.NCI(T);

--Magdagdag ng data ng pagsubok
IDEKLARA @i INT = 100000;
IDEKLARA ang @t CHAR(1) = "T";

HABANG @i > 0
MAGSIMULA
ipasok sa mga halaga ng tsql.dbo.NI(@i, @t + CAST(@i AS char(6)));
ipasok sa mga halaga ng tsql.dbo.NCI(@i, @t + CAST(@i AS char(6)));
SET @i -= 1;
WAKAS

--Mga query sa isang table na may mga index
PUMILI NG ID, T MULA SA tsql.dbo.NCI
ORDER BY ID, T

PUMILI NG ID, BILANG(*) BILANG C MULA SA tsql.dbo.NCI
GROUP BY ID, T

PUMILI NG ID, T MULA SA tsql.dbo.NCI
SAAN ID > 4000 AT ID< 55000 AND T LIKE "T%"

--Query gamit ang parehong mga index
GAMITIN ang tsql;
PUMILI NG CAST(dbo.NCI.ID BILANG VARCHAR)
MULA sa dbo.NCI
GROUP NG dbo.NCI.ID
UNION LAHAT
PUMILI ng dbo.NCI.T
MULA sa dbo.NCI
GROUP NI dbo.NCI.T

--Informasyon ng mga indeks
PUMILI ng index_type_desc, index_depth, index_level,
page_count, record_count
MULA sa sys.dm_db_index_physical_stats
(DB_ID(N"tsql"), OBJECT_ID(N"dbo.NCI"), NULL, NULL , "DETAILED");

--Pagtanggal ng mga index
KUNG MAY MAY (PUMILI NG pangalan MULA sa sys.indexes
WHERE pangalan = N"IX_1")
DROP INDEX IX_1 SA tsql.dbo.NCI;

KUNG MAY MAY (PUMILI NG pangalan MULA sa sys.indexes
WHERE pangalan = N"IX_2")
DROP INDEX IX_2 SA tsql.dbo.NCI;

Sa nakaraang artikulo, ipinakilala namin ang mga paraan upang i-optimize ang mga relational na database at tinalakay kung paano gumagana ang clustered at nonclustered index sa konteksto ng pag-optimize ng oras ng pagpapatupad ng query sa database. Ngayon ay oras na upang isagawa ang kaalamang ito sa pamamagitan ng pag-aaral kung paano lumikha ng mga index ng pag-optimize para sa isang database ng MS SQL.

Hayaan akong ipaalala sa iyo ang kahulugan ng schema ng talahanayan ng Staffs na gagawin namin:

Mesa ng mga tauhan

Sabihin nating kailangan nating lumikha ng hindi naka-cluster na index para sa talahanayan ng Staffs, na mag-o-optimize sa sumusunod na query:

PUMILI NG Id, Pangalan, Trabaho MULA SA Stuffs KUNG SAAN ANG SWELDO > 1000 AT Larawan AY HINDI NULL

Ang index key ay ang SALARY at Photo column, dahil ang pagpili ay sinasala ng mga field na ito. At ang mga column ng Id, Pangalan at Trabaho ang magiging mga column na kasama sa index.

Ang pangkalahatang command syntax ay ang mga sumusunod:

GAMITIN GO

GUMAWA NG NONCLUSTERED INDEX NAKA-ON (ASC -- index key column)

KASAMA ( -- kasama ang mga column) GO

Sa aming kaso, ang kahilingan ay magiging ganito:

(Suweldo, Larawan) INCLUDE (Id, Name, Job) GO

Nakagawa kami ng hindi naka-cluster na index. O sa halip, isang non-clustered covering index. Nangangahulugan ito na ang index ay naglalaman ng lahat ng mga patlang na kinakailangan upang maisagawa ang query at hindi maa-access ng SQL Server ang base table kapag isinasagawa ang query.

Kung ang aming code ay ganito:

GUMAWA NG NONCLUSTERED INDEX IDX_StaffsSearch ON Stuffs

(Suweldo, Larawan) INCLUDE (Id) GO

Sa kasong ito, ang index ay hindi na magiging isang sumasaklaw na index, dahil hindi nito kasama ang lahat ng mga column na ginamit sa query. Gagamitin pa rin ng optimizer ang index na ito kapag isinasagawa ang query, ngunit ang kahusayan nito ay mababawasan ng isang order ng magnitude dahil mangangailangan ito ng access sa base table.

Ang clustered index ay nilikha gamit ang sumusunod na command:

GUMAWA NG CLUSTERED INDEX IDX_Stsffsid ON Stuffs (Id)

Dito nilikha ang isang natatanging clustered index batay sa pangunahing key ng talahanayan (column ng Id).

Tunay na halimbawa

Bumuo tayo ngayon ng isang senaryo kung saan maaari nating makatotohanang suriin ang antas ng pakinabang ng pagganap sa kaso ng paggamit ng mga index.

Gumawa tayo ng bagong database:

GUMAWA NG DATABASE TestDB;

At isang talahanayan ng Mga Customer, na bubuo ng apat na column:

GUMAWA NG TALAAN .(

HINDI NULL, NULL, NULL, NULL) GO

Ngayon punan natin ang aming talahanayan ng random na data. Ang column ng Id ay tataas sa isang loop, at ang natitirang tatlong column ng talahanayan ay mapupuno ng mga random na numero gamit ang isang kakaibang bersyon ng random na function:

IDEKLARA ang @i int = 0;

HABANG (@i< 500000) BEGIN INSERT INTO Customers(Id, Num1, Num2, Num3) VALUES(

@i, abs(checksum(newid())), abs(checksum(newid())), abs(checksum(newid())) SET @i = @i + 1; WAKAS

Ang script na ito ay nagdaragdag ng kalahating milyong tala sa talahanayan, kaya maging matiyaga, ang script ay tatakbo nang hindi bababa sa 3 minuto.

Handa na ang lahat para sa pagsubok. Susuriin namin ang mga katangian ng pagganap ng query. Dahil ang oras ng pagpapatupad ng query ay maaaring depende sa partikular na makina, susuriin namin ang isang mas independiyenteng tagapagpahiwatig - ang bilang ng mga lohikal na pagbabasa.

Upang paganahin ang mode ng pagkolekta ng mga istatistika, dapat mong patakbuhin ang sumusunod na command:

Ngayon, pagkatapos isagawa ang bawat kahilingan, sa tab na Mga Mensahe magkakaroon kami ng access sa mga istatistika sa pagsasagawa ng kahilingang ito, tulad ng ipinapakita sa ibaba:

Interesado lang kami sa halaga ng parameter ng logical reads.

Kaya, wala pang mga index sa aming talahanayan. Patakbuhin natin ang sumusunod na tatlong query at itala ang bilang ng mga lohikal na pagbabasa para sa bawat query sa talahanayan ng mga resulta sa ibaba:

1) SELECT Id, Num1, Num2 FROM Customers WHERE Id = 2000

2) PUMILI Id, Num1, Num2 MULA SA Mga Customer WHERE Id >= 0 AND Id< 1000

3) PUMILI Id, Num1, Num2 MULA SA Mga Customer WHERE Id >= 0 AND Id< 5000

Ang mga query na ito ay magbabalik ng 1 row, 1000 row at 5000 row, ayon sa pagkakabanggit. Kung walang mga index, ang tagapagpahiwatig ng pagganap (bilang ng mga lohikal na pagbabasa) para sa lahat ng mga query ay pareho at katumbas ng 1621. Ipasok natin ang data sa talahanayan ng mga resulta:

Nakikita namin na para sa pangalawa at pangatlong mga query, kapag ang isang medyo malaking bilang ng mga hilera ay ibinalik, ang index na aming ginawa ay hindi nagpabuti ng pagganap. Gayunpaman, para sa isang query na nagbabalik ng isang row, napakalaki ng speedup. Kaya, maaari nating tapusin na makatuwirang gumawa ng mga hindi sumasaklaw na index kapag nag-o-optimize ng mga query na nagbabalik ng iisang resulta.

Ngayon, lumikha tayo ng isang sumasaklaw na index, sa gayon ay makakamit ang pinakamataas na pagganap.

Una, tanggalin natin ang nakaraang index:

GAMITIN ang TestDB GO DROP INDEX Customers.TestIndex1

At gumawa tayo ng bagong index:

GUMAWA NG NONCLUSTERED INDEX TestIndex2 SA dbo.Customers(Id) INCLUDE (Num1, Num2);

Ngayon, patakbuhin natin ang ating mga query sa pangatlong beses at isulat ang mga resulta sa isang talahanayan:

Walang mga index
Hindi sumasaklaw na index
Covering index

Madaling makita na ang pagtaas ng pagganap ay napakalaki. Kaya, pinataas namin ang bilis ng pagsasagawa ng query nang sampu-sampung beses. Kapag nagpapatakbo ng isang database na nag-iimbak ng milyun-milyong mga hilera, ang pakinabang ng pagganap na ito ay magiging kapansin-pansin.

Sa artikulong ito, tiningnan namin ang isang halimbawa ng pag-optimize ng database sa pamamagitan ng paglikha ng mga index. Kapansin-pansin na ang paglikha ng mga index ay isang indibidwal na proseso para sa bawat kahilingan. Upang bumuo ng isang index na tunay na mag-o-optimize sa pagganap ng query, dapat mong maingat na suriin ang query mismo at ang plano ng pagpapatupad nito.

Ang mahusay na pagbuo ng index ay isa sa mga pinakamahusay na paraan upang mapabuti ang pagganap ng isang database application. Nang walang paggamit ng mga index, ang SQL Server ay parang isang mambabasa na sinusubukang maghanap ng salita sa isang libro sa pamamagitan ng pagtingin sa bawat pahina. Kung ang aklat ay may index ng paksa (index), ang mambabasa ay maaaring maghanap para sa kinakailangang impormasyon nang mas mabilis.

Sa kawalan ng isang index, ang SQL server, kapag kumukuha ng data mula sa isang talahanayan, ay i-scan ang buong talahanayan at suriin ang bawat hilera upang makita kung ang mga pamantayan sa query ay natutugunan. Ang ganitong buong pag-scan ay maaaring nakapipinsala para sa pagganap ng buong system, lalo na kung maraming data sa mga talahanayan.

Ang isa sa pinakamahalagang gawain kapag nagtatrabaho sa isang database ay ang pagbuo ng pinakamainam na index upang mapabuti ang pagganap ng system. Karamihan sa mga pangunahing database ay nagbibigay ng mga tool upang tingnan ang plano ng pagpapatupad ng query at tulungan kang ibagay at i-optimize ang mga index. Ang artikulong ito ay nagha-highlight ng ilang mahusay na panuntunan ng thumb na nalalapat kapag gumagawa o nagbabago ng mga index sa isang database. Una, tingnan natin ang mga sitwasyon kung saan pinapabuti ng pag-index ang pagganap at kung saan maaaring makasakit ang pag-index.

Mga kapaki-pakinabang na index

Kaya, ang pag-index ng talahanayan ay magiging kapaki-pakinabang kapag naghahanap ng isang partikular na tala sa isang talahanayan gamit ang Saan na pahayag. Kasama sa mga naturang query, halimbawa, ang mga query na naghahanap ng hanay ng mga value, mga query na tumutugma sa eksaktong value sa isang partikular na value, at mga query na nagsasama ng dalawang table.

Halimbawa, ang mga sumusunod na query laban sa database ng Northwind ay tatakbo nang mas mahusay kapag bumubuo ng index sa column na UnitPrice.

Tanggalin mula sa Mga Produkto Kung saan ang UnitPrice=1
Piliin ang * mula sa mga produkto Kung saan UnitPrice sa pagitan ng 14 AT 16

Dahil ang mga item sa index ay nakaimbak na pinagsunod-sunod, ang pag-index ay kapaki-pakinabang din kapag bumubuo ng isang query gamit ang Order ayon sa sugnay. Kung walang index, nilo-load at pinagbubukod-bukod ang mga tala habang tumatakbo ang query. Ang isang index na batay sa UnitPrice ay magbibigay-daan sa iyo na i-scan lamang ang index at kunin ang mga hilera sa pamamagitan ng sanggunian kapag pinoproseso ang susunod na kahilingan. Kung gusto mong pag-uri-uriin ang mga hilera sa pababang pagkakasunud-sunod, maaari mo lamang i-scan ang index sa reverse order.

Piliin ang * Mula sa pagkakasunud-sunod ng Mga Produkto ayon sa UnitPrice ASC

Ang pagpapangkat ng isang talaan gamit ang Pangkat ayon sa pahayag ay madalas ding nangangailangan ng pag-uuri, kaya ang pagbuo ng index sa column na UnitPrice ay magiging kapaki-pakinabang din para sa susunod na query na nagbibilang ng bilang ng mga unit ng isang produkto sa bawat partikular na presyo

Piliin ang bilang(*), UnitPrice Mula sa Pangkat ng Mga Produkto ayon sa UnitPrice

Ang mga index ay kapaki-pakinabang para sa pagpapanatili ng isang natatanging halaga para sa isang column, dahil ang DBMS ay madaling tumingin sa index upang makita kung ang halaga ay mayroon na. Dahil dito, palaging naka-index ang mga pangunahing key.

Mga Disadvantages ng Indexing

Ang mga index ay nagpapababa sa pagganap ng system sa panahon ng mga pagbabago sa talaan. Anumang oras na ang isang query ay isinasagawa upang baguhin ang data sa isang talahanayan, ang index ay dapat ding magbago. Upang piliin ang pinakamainam na bilang ng mga index, kailangan mong subukan ang database at subaybayan ang pagganap nito. Ang mga static na system, kung saan pangunahing ginagamit ang mga database para sa pagkuha ng data, gaya ng pag-uulat, ay maaaring maglaman ng higit pang mga index upang suportahan ang mga read-only na query. Ang mga database na may malaking bilang ng mga transaksyon upang baguhin ang data ay mangangailangan ng maliit na bilang ng mga index upang makapagbigay ng mas mataas na throughput.

Ang mga index ay tumatagal ng karagdagang espasyo sa disk at sa RAM. Ang eksaktong sukat ay depende sa bilang ng mga tala sa talahanayan, pati na rin sa bilang at laki ng mga hanay sa index. Sa karamihan ng mga kaso, hindi ito isang pangunahing isyu dahil ang puwang sa disk ay madaling isakripisyo para sa mas mahusay na pagganap.

Pagbuo ng Optimal Index

Simpleng index

Ang isang simpleng index ay isang index na gumagamit ng mga halaga ng isang solong field sa isang talahanayan. Ang paggamit ng isang simpleng index ay kapaki-pakinabang para sa dalawang kadahilanan. Una, ang pagpapatakbo ng isang database ay naglalagay ng maraming stress sa iyong hard drive. Pipilitin ng malalaking index key ang database na magsagawa ng higit pang mga operasyon ng I/O, na naglilimita sa pagganap.

Pangalawa, dahil ang mga elemento ng index ay madalas na kasangkot sa mga paghahambing, ang mas maliit na mga index ay mas madaling ihambing. Para sa dalawang kadahilanang ito, ang isang solong column na integer ay isang mas mahusay na index dahil ito ay maliit at madaling ihambing. Ang mga string ng character, sa kabilang banda, ay nangangailangan ng mga paghahambing ng character-by-character at pansin sa paghawak ng parameter.

Selective index

Ang pinakamabisang mga index ay ang mga may mababang porsyento ng mga duplicate na halaga. Halimbawa, ang isang direktoryo ng telepono para sa isang lungsod kung saan halos lahat ay may apelyido na Smith ay hindi magiging kapaki-pakinabang kung ang mga entry dito ay pinagbukud-bukod ayon sa apelyido.

Ang isang index na may mataas na porsyento ng mga natatanging halaga ay tinatawag ding selective index. Malinaw, ang isang natatanging index ay may pinakamalaking pagpili, dahil hindi ito naglalaman ng mga duplicate na halaga. Maaaring subaybayan ng maraming DBMS ang mga istatistika tungkol sa bawat index at maaaring makilala kung gaano karaming mga hindi dobleng halaga ang nilalaman ng bawat index. Ang mga istatistikang ito ay ginagamit kapag bumubuo ng isang query execution plan.

Sumasaklaw sa mga Index

Ang mga index ay binubuo ng isang column ng data kung saan ang index mismo ay binuo at isang pointer sa kaukulang row. Ito ay tulad ng index ng isang libro: naglalaman lamang ito ng mga keyword at isang link sa isang pahina na maaari mong puntahan para sa higit pang impormasyon. Karaniwang susundan ng DBMS ang mga pointer sa isang hilera mula sa index upang kolektahin ang lahat ng impormasyong kailangan para sa query. Gayunpaman, kung ang index ay naglalaman ng lahat ng mga column na kailangan sa query, ang impormasyon ay maaaring makuha nang hindi ina-access ang talahanayan mismo.

Isaalang-alang natin ang isang index sa column na UnitPrice, na nabanggit na sa itaas. Magagamit lamang ng DBMS ang mga index na item upang isagawa ang susunod na query.

Piliin ang Bilang(*), UnitPrice Mula sa Pangkat ng Mga Produkto ayon sa UnitPrice

Ang ganitong uri ng query ay tinatawag na sumasaklaw na query dahil ang lahat ng mga column na itinatanong ay maaaring makuha mula sa isang index. Para sa pinakamahahalagang query, maaaring gusto mong isaalang-alang ang paglikha ng covering index para sa pinakamahusay na posibleng pagganap. Ang mga nasabing index ay malamang na composite (gamit ang higit sa isang column), na kabaligtaran ng unang prinsipyo: lumikha ng mga simpleng index. Malinaw, ang pagpili ng pinakamainam na bilang ng mga column sa isang index ay maaari lamang masuri sa pamamagitan ng pagsubok at pagsubaybay sa pagganap ng database sa iba't ibang sitwasyon.

Cluster index

Maraming mga database ang may isang espesyal na index sa isang talahanayan, kung saan ang lahat ng data mula sa isang hilera ay nakapaloob sa index. Sa SQL Server, ang naturang index ay tinatawag na clustered index. Ang isang clustered index ay maaaring ihambing sa isang direktoryo ng telepono dahil ang bawat elemento ng index ay naglalaman ng lahat ng impormasyong kailangan mo at hindi naglalaman ng mga link upang makakuha ng karagdagang data.

Mayroong pangkalahatang tuntunin - ang bawat di-trivial na talahanayan ay dapat na may clustered index. Kung posibleng gumawa lang ng isang index sa isang table, gawin itong clustered. Sa SQL Server, kapag ang isang pangunahing key ay ginawa, ang isang clustered index ay awtomatikong gagawin (kung ito ay hindi pa naglalaman ng isa), gamit ang pangunahing key na haligi bilang ang indexing key. Ang clustered index ay ang pinaka-epektibong index (kung ginamit, saklaw nito ang buong query) at sa maraming DBMS tulad ng index ay nakakatulong upang epektibong pamahalaan ang espasyo na hinihiling para sa pag-iimbak ng mga talahanayan, dahil kung hindi man (nang walang pagbuo ng clustered index) mga hilera ng talahanayan ay naka-imbak sa isang hindi maayos na istraktura, na tinatawag na isang bunton.

Mag-ingat kapag pumipili ng mga column para sa isang clustered index. Kung babaguhin mo ang isang tala at babaguhin ang halaga ng isang column sa isang clustered index, mapipilitan ang database na buuin muli ang mga item sa index (upang panatilihin ang mga ito sa pagkakasunod-sunod). Tandaan, ang mga item sa index para sa isang clustered index ay naglalaman ng lahat ng mga value ng column, kaya ang pagpapalit ng value ng isang column ay maihahambing sa pagsasagawa ng Delete statement na sinusundan ng isang Insert statement, na malinaw na magdudulot ng mga problema sa performance kung madalas gawin. Para sa kadahilanang ito, ang mga clustered index ay kadalasang binubuo ng pangunahing key at isang foreign key na column. Kung nagbabago ang mga pangunahing halaga, napakabihirang nagbabago.

Konklusyon

Ang pagtukoy sa mga tamang index na gagamitin sa isang database ay nangangailangan ng maingat na pagsusuri at pagsubok ng system. Ang mga kasanayang ipinakita sa artikulong ito ay mahusay na mga panuntunan para sa pagbuo ng mga index. Pagkatapos ilapat ang mga pamamaraang ito, kakailanganin mong muling subukan ang iyong partikular na application sa ilalim ng iyong partikular na hardware, memorya, at mga kundisyon ng pagpapatakbo.

Isa sa pinakamahalagang paraan upang makamit ang mataas na produktibidad SQL Server ay ang paggamit ng mga index. Pinapabilis ng isang index ang proseso ng query sa pamamagitan ng pagbibigay ng mabilis na access sa mga row ng data sa isang table, katulad ng isang index sa isang libro na tumutulong sa iyong mabilis na mahanap ang impormasyong kailangan mo. Sa artikulong ito ay magbibigay ako ng maikling pangkalahatang-ideya ng mga index sa SQL Server at ipaliwanag kung paano sila nakaayos sa database at kung paano sila nakakatulong na mapabilis ang mga query sa database.

Ginagawa ang mga index sa mga column ng talahanayan at view. Nagbibigay ang mga index ng paraan upang mabilis na maghanap ng data batay sa mga halaga sa mga column na iyon. Halimbawa, kung gagawa ka ng index sa isang pangunahing key at pagkatapos ay maghanap ng isang hilera ng data gamit ang mga halaga ng pangunahing key, pagkatapos SQL Server hahanapin muna ang halaga ng index at pagkatapos ay gagamitin ang index upang mabilis na mahanap ang buong row ng data. Kung walang index, isasagawa ang buong pag-scan ng lahat ng row sa talahanayan, na maaaring magkaroon ng malaking epekto sa performance.
Maaari kang gumawa ng index sa karamihan ng mga column sa isang table o view. Ang pagbubukod ay pangunahing mga haligi na may mga uri ng data para sa pag-iimbak ng malalaking bagay ( LOB), tulad ng larawan, text o varchar(max). Maaari ka ring gumawa ng mga index sa mga column na idinisenyo upang mag-imbak ng data sa format XML, ngunit ang mga index na ito ay bahagyang naiiba kaysa sa mga karaniwang at ang kanilang pagsasaalang-alang ay lampas sa saklaw ng artikulong ito. Gayundin, hindi tinatalakay ng artikulo columnstore mga index. Sa halip, nakatuon ako sa mga index na iyon na pinakakaraniwang ginagamit sa mga database SQL Server.
Ang isang index ay binubuo ng isang hanay ng mga pahina, mga index node, na nakaayos sa isang istraktura ng puno - balanseng puno. Ang istrukturang ito ay likas na hierarchical at nagsisimula sa isang root node sa tuktok ng hierarchy at mga node ng dahon, ang mga dahon, sa ibaba, tulad ng ipinapakita sa figure:


Kapag nag-query ka ng naka-index na column, magsisimula ang query engine sa tuktok ng root node at gagawa pababa sa mga intermediate node, na ang bawat intermediate na layer ay naglalaman ng mas detalyadong impormasyon tungkol sa data. Ang query engine ay patuloy na gumagalaw sa mga index node hanggang sa umabot ito sa ibabang antas na may mga index na umalis. Halimbawa, kung hinahanap mo ang value na 123 sa isang naka-index na column, tutukuyin muna ng query engine ang page sa unang intermediate level sa root level. Sa kasong ito, ang unang pahina ay tumuturo sa isang halaga mula 1 hanggang 100, at ang pangalawa mula 101 hanggang 200, kaya maa-access ng query engine ang pangalawang pahina ng intermediate na antas na ito. Susunod na makikita mo na dapat mong buksan ang ikatlong pahina ng susunod na intermediate na antas. Mula dito, babasahin ng subsystem ng query ang halaga ng index mismo sa mas mababang antas. Ang mga dahon ng index ay maaaring maglaman ng alinman sa data ng talahanayan mismo o isang pointer lamang sa mga row na may data sa talahanayan, depende sa uri ng index: clustered index o nonclustered index.

Clustered index

Iniimbak ng clustered index ang aktwal na mga row ng data sa mga dahon ng index. Pagbabalik sa nakaraang halimbawa, nangangahulugan ito na ang hilera ng data na nauugnay sa pangunahing halaga ng 123 ay maiimbak sa index mismo. Ang isang mahalagang katangian ng isang clustered index ay ang lahat ng mga halaga ay pinagsunod-sunod sa isang tiyak na pagkakasunud-sunod, alinman sa pataas o pababang. Samakatuwid, ang isang talahanayan o view ay maaari lamang magkaroon ng isang clustered index. Bilang karagdagan, dapat tandaan na ang data sa isang talahanayan ay iniimbak sa pinagsunod-sunod na anyo lamang kung ang isang clustered index ay ginawa sa talahanayang ito.
Ang isang talahanayan na walang clustered index ay tinatawag na isang heap.

Non-clustered index

Hindi tulad ng clustered index, ang mga dahon ng nonclustered index ay naglalaman lamang ng mga column na iyon ( susi) kung saan tinutukoy ang index na ito, at naglalaman din ng pointer sa mga row na may totoong data sa talahanayan. Nangangahulugan ito na ang subquery system ay nangangailangan ng karagdagang operasyon upang mahanap at makuha ang kinakailangang data. Nakadepende ang content ng data pointer sa kung paano iniimbak ang data: clustered table o heap. Kung ang isang pointer ay tumuturo sa isang clustered table, ito ay tumuturo sa isang clustered index na maaaring magamit upang mahanap ang aktwal na data. Kung ang isang pointer ay tumutukoy sa isang heap, pagkatapos ay tumuturo ito sa isang partikular na data row identifier. Ang mga nonclustered index ay hindi maaaring pagbukud-bukurin tulad ng mga clustered index, ngunit maaari kang lumikha ng higit sa isang nonclustered index sa isang table o view, hanggang 999. Hindi ito nangangahulugan na dapat kang lumikha ng maraming index hangga't maaari. Maaaring mapabuti o pababain ng mga index ang pagganap ng system. Bilang karagdagan sa kakayahang lumikha ng maramihang hindi naka-cluster na index, maaari ka ring magsama ng mga karagdagang column ( kasama ang column) sa index nito: ang mga dahon ng index ay mag-iimbak hindi lamang ng halaga ng mga na-index na haligi mismo, kundi pati na rin ang mga halaga ng mga hindi na-index na karagdagang mga haligi. Ang diskarte na ito ay magbibigay-daan sa iyo na lampasan ang ilan sa mga paghihigpit na inilagay sa index. Halimbawa, maaari kang magsama ng hindi na-index na column o i-bypass ang limitasyon sa haba ng index (900 bytes sa karamihan ng mga kaso).

Mga Uri ng Index

Bilang karagdagan sa pagiging isang clustered o nonclustered index, maaari itong higit pang i-configure bilang isang composite index, isang natatanging index, o isang sumasaklaw na index.

Composite index

Ang nasabing index ay maaaring maglaman ng higit sa isang column. Maaari kang magsama ng hanggang 16 na column sa isang index, ngunit ang kabuuang haba ng mga ito ay limitado sa 900 byte. Ang parehong clustered at nonclustered index ay maaaring composite.

Natatanging index

Tinitiyak ng index na ito na ang bawat value sa naka-index na column ay natatangi. Kung composite ang index, nalalapat ang uniqueness sa lahat ng column sa index, ngunit hindi sa bawat indibidwal na column. Halimbawa, kung gagawa ka ng natatanging index sa mga column PANGALAN At SURNAME, kung gayon ang buong pangalan ay dapat na natatangi, ngunit ang mga duplicate sa una o apelyido ay posible.
Awtomatikong nagagawa ang isang natatanging index kapag tumukoy ka ng isang hadlang sa hanay: pangunahing susi o natatanging hadlang sa halaga:

• Pangunahing susi
  Kapag tinukoy mo ang isang pangunahing hadlang sa key sa isa o higit pang mga column noon SQL Server Awtomatikong gumagawa ng isang natatanging clustered index kung ang isang clustered index ay hindi pa nagagawa dati (sa kasong ito, isang natatanging non-clustered index ay nilikha sa pangunahing key)
• Kakaiba ng mga halaga
  Kapag tinukoy mo ang isang hadlang sa pagiging natatangi ng mga halaga noon SQL Server awtomatikong lumilikha ng isang natatanging hindi naka-cluster na index. Maaari mong tukuyin na ang isang natatanging clustered index ay gagawin kung wala pang clustered index na nagawa sa talahanayan

Covering index

Ang nasabing index ay nagbibigay-daan sa isang partikular na query na agad na makuha ang lahat ng kinakailangang data mula sa mga dahon ng index nang walang karagdagang access sa mga talaan mismo ng talahanayan.

Pagdidisenyo ng mga Index

Kahit gaano kapaki-pakinabang ang mga index, dapat itong idisenyo nang mabuti. Dahil ang mga index ay maaaring tumagal ng malaking espasyo sa disk, hindi mo nais na lumikha ng higit pang mga index kaysa sa kinakailangan. Bilang karagdagan, ang mga index ay awtomatikong ina-update kapag ang mismong row ng data ay na-update, na maaaring humantong sa karagdagang overhead ng mapagkukunan at pagkasira ng pagganap. Kapag nagdidisenyo ng mga index, maraming mga pagsasaalang-alang tungkol sa database at mga query laban dito ay dapat isaalang-alang.

Database

Tulad ng nabanggit kanina, ang mga index ay maaaring mapabuti ang pagganap ng system dahil binibigyan nila ang query engine ng mabilis na paraan para maghanap ng data. Gayunpaman, dapat mo ring isaalang-alang kung gaano kadalas mo balak magsingit, mag-update, o magtanggal ng data. Kapag binago mo ang data, dapat ding baguhin ang mga index upang ipakita ang mga kaukulang aksyon sa data, na maaaring makabuluhang bawasan ang performance ng system. Isaalang-alang ang sumusunod na mga alituntunin kapag nagpaplano ng iyong diskarte sa pag-index:

• Para sa mga talahanayan na madalas na ina-update, gumamit ng kaunting mga index hangga't maaari.
• Kung ang talahanayan ay naglalaman ng isang malaking halaga ng data ngunit ang mga pagbabago ay maliit, pagkatapos ay gumamit ng maraming mga index kung kinakailangan upang mapabuti ang pagganap ng iyong mga query. Gayunpaman, mag-isip nang mabuti bago gumamit ng mga index sa maliliit na talahanayan, dahil... Posible na ang paggamit ng isang paghahanap sa index ay maaaring mas matagal kaysa sa simpleng pag-scan sa lahat ng mga hilera.
• Para sa mga clustered index, subukang panatilihing maikli ang mga field hangga't maaari. Ang pinakamahusay na diskarte ay ang paggamit ng isang clustered index sa mga haligi na may natatanging mga halaga at hindi pinapayagan ang NULL. Ito ang dahilan kung bakit kadalasang ginagamit ang pangunahing key bilang clustered index.
• Ang pagiging natatangi ng mga halaga sa isang haligi ay nakakaapekto sa pagganap ng index. Sa pangkalahatan, mas maraming duplicate ang mayroon ka sa isang column, mas malala ang performance ng index. Sa kabilang banda, mas maraming natatanging mga halaga ang mayroon, mas mahusay ang pagganap ng index. Gumamit ng natatanging index hangga't maaari.
• Para sa isang composite index, isaalang-alang ang pagkakasunud-sunod ng mga column sa index. Mga hanay na ginagamit sa mga expression SAAN(Halimbawa, WHERE FirstName = "Charlie") dapat mauna sa index. Ang mga kasunod na column ay dapat na nakalista batay sa pagiging natatangi ng kanilang mga halaga (mga column na may pinakamataas na bilang ng mga natatanging halaga ang mauna).
• Maaari ka ring tumukoy ng index sa mga nakalkulang column kung natutugunan ng mga ito ang ilang partikular na kinakailangan. Halimbawa, ang mga expression na ginamit upang makuha ang halaga ng isang column ay dapat na deterministiko (palaging ibalik ang parehong resulta para sa isang ibinigay na hanay ng mga parameter ng input).

Mga query sa database

Ang isa pang pagsasaalang-alang kapag nagdidisenyo ng mga index ay kung anong mga query ang pinapatakbo laban sa database. Gaya ng nasabi kanina, dapat mong isaalang-alang kung gaano kadalas nagbabago ang data. Bilang karagdagan, ang mga sumusunod na prinsipyo ay dapat gamitin:

• Subukang magpasok o magbago ng maraming row hangga't maaari sa isang query, sa halip na gawin ito sa ilang solong query.
• Gumawa ng hindi naka-cluster na index sa mga column na kadalasang ginagamit bilang mga termino para sa paghahanap sa iyong mga query. SAAN at mga koneksyon sa SUMALI.
• Isaalang-alang ang pag-index ng mga column na ginagamit sa row lookup query para sa eksaktong mga tugma ng halaga.

At ngayon, sa totoo lang:

14 na tanong tungkol sa mga index sa SQL Server na nahihiya kang itanong

Bakit hindi maaaring magkaroon ng dalawang clustered index ang isang table?

Gusto mo ng maikling sagot? Ang isang clustered index ay isang talahanayan. Kapag gumawa ka ng clustered index sa isang table, pinag-uuri-uriin ng storage engine ang lahat ng row sa table sa pataas o pababang pagkakasunud-sunod, ayon sa index definition. Ang clustered index ay hindi isang hiwalay na entity tulad ng iba pang mga index, ngunit isang mekanismo para sa pag-uuri ng data sa isang talahanayan at pagpapadali ng mabilis na pag-access sa mga hilera ng data.
Isipin natin na mayroon kang isang talahanayan na naglalaman ng kasaysayan ng mga transaksyon sa pagbebenta. Kasama sa talahanayan ng Pagbebenta ang impormasyon gaya ng order ID, posisyon ng produkto sa order, numero ng produkto, dami ng produkto, numero ng order at petsa, atbp. Gumawa ka ng clustered index sa mga column OrderID At LineID, pinagsunod-sunod sa pataas na pagkakasunud-sunod tulad ng ipinapakita sa sumusunod T-SQL code:
GUMAWA NG NATATANGING CLUSTERED INDEX ix_oriderid_lineid SA dbo.Sales(OrderID, LineID);
Kapag pinatakbo mo ang script na ito, ang lahat ng mga row sa talahanayan ay pisikal na pag-uuri-uriin muna ayon sa column ng OrderID at pagkatapos ay sa pamamagitan ng LineID, ngunit ang data mismo ay mananatili sa isang solong lohikal na bloke, ang talahanayan. Para sa kadahilanang ito, hindi ka makakagawa ng dalawang clustered index. Maaari lamang magkaroon ng isang talahanayan na may isang data at ang talahanayang iyon ay maaari lamang ayusin nang isang beses sa isang partikular na pagkakasunud-sunod.

Kung ang isang clustered table ay nagbibigay ng maraming benepisyo, bakit gagamit ng heap?

Tama ka. Ang mga naka-cluster na talahanayan ay mahusay at karamihan sa iyong mga query ay gaganap nang mas mahusay sa mga talahanayan na may clustered index. Ngunit sa ilang mga kaso maaaring gusto mong iwanan ang mga talahanayan sa kanilang natural, malinis na estado, i.e. sa anyo ng isang heap, at lumikha lamang ng mga hindi naka-cluster na index upang panatilihing tumatakbo ang iyong mga query.
Ang heap, gaya ng naaalala mo, ay nag-iimbak ng data sa random na pagkakasunud-sunod. Karaniwan, ang storage subsystem ay nagdaragdag ng data sa isang talahanayan sa pagkakasunud-sunod kung saan ito ipinasok, ngunit ang storage subsystem ay gusto ding magpalipat-lipat ng mga row para sa mas mahusay na storage. Bilang resulta, wala kang pagkakataong mahulaan kung anong pagkakasunud-sunod ang maiimbak ang data.
Kung kailangang maghanap ng data ang query engine nang walang pakinabang ng isang nonclustered index, gagawa ito ng buong pag-scan ng talahanayan upang mahanap ang mga row na kailangan nito. Sa napakaliit na mga talahanayan, kadalasang hindi ito problema, ngunit habang lumalaki ang tambak, mabilis na bumababa ang pagganap. Siyempre, makakatulong ang isang hindi naka-cluster na index sa pamamagitan ng paggamit ng isang pointer sa file, page at row kung saan naka-imbak ang kinakailangang data - kadalasan ito ay isang mas mahusay na alternatibo sa isang table scan. Gayunpaman, mahirap ihambing ang mga benepisyo ng isang clustered index kapag isinasaalang-alang ang pagganap ng query.
Gayunpaman, makakatulong ang heap na mapabuti ang performance sa ilang partikular na sitwasyon. Isaalang-alang ang isang talahanayan na may maraming mga pagsingit ngunit kakaunti ang mga pag-update o pagtanggal. Halimbawa, ang isang talahanayan na nag-iimbak ng isang log ay pangunahing ginagamit upang magpasok ng mga halaga hanggang sa ito ay ma-archive. Sa heap, hindi mo makikita ang paging at fragmentation ng data tulad ng makikita mo sa isang clustered index dahil idinaragdag lang ang mga row sa dulo ng heap. Ang labis na paghahati ng mga pahina ay maaaring magkaroon ng malaking epekto sa pagganap, at hindi sa isang mahusay na paraan. Sa pangkalahatan, pinapayagan ka ng heap na magpasok ng data nang medyo walang sakit at hindi mo na kailangang harapin ang mga overhead ng storage at maintenance na gagawin mo gamit ang clustered index.
Ngunit ang kakulangan sa pag-update at pagtanggal ng data ay hindi dapat isaalang-alang ang tanging dahilan. Ang paraan ng pag-sample ng data ay isa ring mahalagang salik. Halimbawa, hindi ka dapat gumamit ng heap kung madalas kang mag-query ng mga hanay ng data o ang data na madalas mong i-query ay kailangang pagbukud-bukurin o pagpangkatin.
Ang ibig sabihin nito ay dapat mo lang isaalang-alang ang paggamit ng heap kapag nagtatrabaho ka sa napakaliit na mga talahanayan o ang lahat ng iyong pakikipag-ugnayan sa talahanayan ay limitado sa pagpasok ng data at ang iyong mga query ay napakasimple (at gumagamit ka ng mga hindi naka-cluster na index gayon pa man). Kung hindi, manatili sa isang mahusay na idinisenyong clustered index, tulad ng tinukoy sa isang simpleng ascending key field, tulad ng isang malawak na ginagamit na column na may IDENTIDAD.

Paano ko babaguhin ang default na index fill factor?

Ang pagbabago sa default na index fill factor ay isang bagay. Ang pag-unawa sa kung paano gumagana ang default na ratio ay isa pang usapin. Ngunit una, bumalik ng ilang hakbang. Tinutukoy ng index fill factor ang dami ng espasyo sa page para iimbak ang index sa ibabang antas (leaf level) bago magsimulang punan ang isang bagong page. Halimbawa, kung ang coefficient ay nakatakda sa 90, pagkatapos ay kapag lumaki ang index, sasakupin nito ang 90% ng pahina at pagkatapos ay lilipat sa susunod na pahina.
Bilang default, nasa ang halaga ng index fill factor SQL Server ay 0, na kapareho ng 100. Bilang resulta, awtomatikong mamanahin ng lahat ng bagong index ang setting na ito maliban kung partikular kang tumukoy ng value sa iyong code na iba sa standard value ng system o binago ang default na gawi. Pwede mong gamitin SQL Server Management Studio upang ayusin ang default na halaga o magpatakbo ng system stored procedure sp_configure. Halimbawa, ang sumusunod na hanay T-SQL itinatakda ng mga command ang coefficient value sa 90 (kailangan mo munang lumipat sa advanced na mode ng mga setting):
EXEC sp_configure "ipakita ang mga advanced na pagpipilian", 1; GO RECONFIGURE; GO EXEC sp_configure "fill factor", 90; GO RECONFIGURE; GO
Pagkatapos baguhin ang halaga ng index fill factor, kailangan mong i-restart ang serbisyo SQL Server. Maaari mo na ngayong suriin ang itinakdang halaga sa pamamagitan ng pagpapatakbo ng sp_configure nang walang tinukoy na pangalawang argumento:
EXEC sp_configure "fill factor" GO
Ang command na ito ay dapat magbalik ng value na 90. Bilang resulta, lahat ng bagong likhang index ay gagamit ng value na ito. Maaari mong subukan ito sa pamamagitan ng paglikha ng isang index at pagtatanong para sa halaga ng fill factor:
GAMITIN ang AdventureWorks2012; -- ang iyong database GUMAWA NG NONCLUSTERED INDEX ix_people_lastname SA Person.Person(LastName); PUMILI NG fill_factor MULA sa sys.indexes WHERE object_id = object_id("Person.Person") AT name="ix_people_apelyido";
Sa halimbawang ito, gumawa kami ng hindi naka-cluster na index sa isang table Tao sa database AdventureWorks2012. Pagkatapos gawin ang index, makukuha natin ang halaga ng fill factor mula sa mga talahanayan ng system ng sys.indexes. Ang query ay dapat bumalik sa 90.
Gayunpaman, isipin natin na tinanggal namin ang index at ginawa itong muli, ngunit ngayon ay tinukoy namin ang isang partikular na halaga ng fill factor:
GUMAWA NG NONCLUSTERED INDEX ix_people_lastname SA Person.Person(LastName) WITH (fillfactor=80); PUMILI NG fill_factor MULA sa sys.indexes WHERE object_id = object_id("Person.Person") AT name="ix_people_apelyido";
Sa pagkakataong ito ay nagdagdag kami ng mga tagubilin SA at opsyon fillfactor para sa aming operasyon sa paglikha ng index GUMAWA NG INDEX at tinukoy ang halaga 80. Operator PUMILI ngayon ay nagbabalik ng kaukulang halaga.
Sa ngayon, ang lahat ay medyo prangka. Kung saan ka talaga masusunog sa buong prosesong ito ay kapag gumawa ka ng index na gumagamit ng default na coefficient value, sa pag-aakalang alam mo ang halagang iyon. Halimbawa, may nag-iisip sa mga setting ng server at napakatigas ng ulo na itinakda nila ang index fill factor sa 20. Samantala, patuloy kang gumagawa ng mga index, kung ipagpalagay na ang default na halaga ay 0. Sa kasamaang palad, wala kang paraan upang malaman ang fill factor hanggang sa hangga't hindi ka lumikha ng isang index at pagkatapos ay suriin ang halaga tulad ng ginawa namin sa aming mga halimbawa. Kung hindi, kailangan mong maghintay para sa sandali kapag ang pagganap ng query ay bumaba nang husto na nagsimula kang maghinala ng isang bagay.
Ang isa pang isyu na dapat mong malaman ay ang muling pagtatayo ng mga index. Tulad ng paggawa ng index, maaari mong tukuyin ang halaga ng index fill factor kapag itinayo mo itong muli. Gayunpaman, hindi katulad ng create index command, hindi ginagamit ng rebuild ang mga default na setting ng server, sa kabila ng kung ano ang hitsura nito. Higit pa, kung hindi mo partikular na tinukoy ang halaga ng index fill factor, kung gayon SQL Server gagamitin ang halaga ng koepisyent kung saan umiral ang index na ito bago ang muling pagsasaayos nito. Halimbawa, ang sumusunod na operasyon ALTER INDEX muling itinatayo ang index na nilikha namin:
ALTER INDEX ix_people_apelyido SA Person.Person REBUILD; PUMILI NG fill_factor MULA sa sys.indexes WHERE object_id = object_id("Person.Person") AT name="ix_people_apelyido";
Kapag sinuri namin ang halaga ng fill factor, makakakuha kami ng halaga na 80, dahil iyon ang tinukoy namin noong huli naming ginawa ang index. Binabalewala ang default na halaga.
Tulad ng nakikita mo, ang pagbabago ng halaga ng index fill factor ay hindi ganoon kahirap. Mas mahirap malaman ang kasalukuyang halaga at maunawaan kapag ito ay inilapat. Kung palagi mong partikular na tinukoy ang koepisyent kapag lumilikha at muling nagtatayo ng mga index, kung gayon palagi mong alam ang partikular na resulta. Maliban na lang kung kailangan mong mag-alala tungkol sa pagtiyak na ang ibang tao ay hindi sisirain muli ang mga setting ng server, na nagiging sanhi ng lahat ng mga index na mabuo muli na may katawa-tawa na mababang index fill factor.

Posible bang gumawa ng clustered index sa isang column na naglalaman ng mga duplicate?

Oo at hindi. Oo maaari kang lumikha ng isang clustered index sa isang pangunahing column na naglalaman ng mga duplicate na halaga. Hindi, ang halaga ng isang pangunahing column ay hindi maaaring manatili sa isang hindi natatanging estado. Hayaan mo akong magpaliwanag. Kung gagawa ka ng hindi kakaibang clustered index sa isang column, magdaragdag ang storage engine ng uniquifier sa duplicate na value para matiyak ang uniqueness at samakatuwid ay matukoy ang bawat row sa clustered table.
Halimbawa, maaari kang magpasya na gumawa ng clustered index sa isang column na naglalaman ng data ng customer Huling pangalan pinapanatili ang apelyido. Ang column ay naglalaman ng mga value na Franklin, Hancock, Washington, at Smith. Pagkatapos ay ipasok mo muli ang mga halagang Adams, Hancock, Smith at Smith. Ngunit ang halaga ng pangunahing column ay dapat na natatangi, kaya babaguhin ng storage engine ang halaga ng mga duplicate upang magmukhang ganito ang mga ito: Adams, Franklin, Hancock, Hancock1234, Washington, Smith, Smith4567 at Smith5678.
Sa unang sulyap, ang diskarte na ito ay mukhang maayos, ngunit ang isang integer na halaga ay nagpapataas ng laki ng susi, na maaaring maging isang problema kung mayroong isang malaking bilang ng mga duplicate, at ang mga halagang ito ay magiging batayan ng isang hindi naka-cluster na index o isang dayuhan. pangunahing sanggunian. Para sa mga kadahilanang ito, dapat mong palaging subukang lumikha ng mga natatanging clustered index hangga't maaari. Kung hindi ito posible, subukang gumamit ng mga column na may napakataas na natatanging halaga ng nilalaman.

Paano naiimbak ang talahanayan kung ang isang clustered index ay hindi pa nagagawa?

SQL Server sumusuporta sa dalawang uri ng mga talahanayan: mga clustered na talahanayan na mayroong clustered index at mga heap table o mga tambak lang. Hindi tulad ng mga clustered table, ang data sa heap ay hindi pinagsunod-sunod sa anumang paraan. Sa esensya, ito ay isang pile (heap) ng data. Kung magdaragdag ka ng row sa naturang talahanayan, idaragdag lang ito ng storage engine sa dulo ng page. Kapag ang pahina ay napuno ng data, ito ay idaragdag sa isang bagong pahina. Sa karamihan ng mga kaso, gugustuhin mong lumikha ng isang clustered index sa isang talahanayan upang samantalahin ang pagkakasunud-sunod at bilis ng query (subukang isipin ang paghahanap ng isang numero ng telepono sa isang hindi naayos na address book). Gayunpaman, kung pipiliin mong huwag gumawa ng clustered index, maaari ka pa ring gumawa ng nonclustered index sa heap. Sa kasong ito, ang bawat index row ay magkakaroon ng pointer sa isang heap row. Kasama sa index ang file ID, page number, at data line number.

Ano ang kaugnayan sa pagitan ng mga limitasyon sa pagiging natatangi ng halaga at isang pangunahing susi na may mga index ng talahanayan?

Tinitiyak ng isang pangunahing susi at isang natatanging hadlang na ang mga halaga sa isang hanay ay natatangi. Maaari ka lamang lumikha ng isang pangunahing key para sa isang talahanayan at hindi ito maaaring maglaman ng mga halaga WALA. Maaari kang lumikha ng ilang mga paghihigpit sa pagiging natatangi ng isang halaga para sa isang talahanayan, at bawat isa sa kanila ay maaaring magkaroon ng isang tala na may WALA.
Kapag gumawa ka ng pangunahing key, gagawa din ang storage engine ng natatanging clustered index kung hindi pa nagagawa ang clustered index. Gayunpaman, maaari mong i-override ang default na gawi at gagawa ng hindi naka-cluster na index. Kung mayroong clustered index kapag ginawa mo ang primary key, isang natatanging nonclustered index ang gagawa.
Kapag gumawa ka ng kakaibang hadlang, ang storage engine ay gagawa ng natatangi, hindi naka-cluster na index. Gayunpaman, maaari mong tukuyin ang paglikha ng isang natatanging clustered index kung ang isa ay hindi pa nagawa dati.
Sa pangkalahatan, ang isang natatanging hadlang sa halaga at isang natatanging index ay pareho.

Bakit ang mga clustered at non-clustered index ay tinatawag na B-tree sa SQL Server?

Ang mga pangunahing index sa SQL Server, clustered o nonclustered, ay ipinamamahagi sa mga hanay ng mga page na tinatawag na index node. Ang mga pahinang ito ay nakaayos sa isang partikular na hierarchy na may istraktura ng puno na tinatawag na balanseng puno. Sa itaas na antas ay mayroong root node, sa ibaba ay may mga leaf node, na may mga intermediate node sa pagitan ng itaas at ibabang antas, tulad ng ipinapakita sa figure:


Ang root node ay nagbibigay ng pangunahing entry point para sa mga query na sumusubok na kunin ang data sa pamamagitan ng index. Simula sa node na ito, ang query engine ay magsisimula ng isang nabigasyon pababa sa hierarchical na istraktura patungo sa naaangkop na leaf node na naglalaman ng data.
Halimbawa, isipin na ang isang kahilingan ay natanggap upang pumili ng mga hilera na naglalaman ng isang pangunahing halaga ng 82. Ang query subsystem ay nagsisimulang gumana mula sa root node, na tumutukoy sa isang angkop na intermediate node, sa aming kaso 1-100. Mula sa intermediate node 1-100 mayroong isang paglipat sa node 51-100, at mula doon hanggang sa huling node 76-100. Kung ito ay isang clustered index, ang node leaf ay naglalaman ng data ng row na nauugnay sa key na katumbas ng 82. Kung ito ay isang non-clustered index, ang index leaf ay naglalaman ng pointer sa clustered table o isang partikular na row sa ang bunton.

Paano mapapabuti ng isang index ang pagganap ng query kung kailangan mong lampasan ang lahat ng mga index node na ito?

Una, ang mga index ay hindi palaging nagpapabuti sa pagganap. Masyadong maraming maling ginawang mga index ang nagiging quagmire at nagpapababa sa performance ng query. Mas tumpak na sabihin na kung maingat na inilapat ang mga index, makakapagbigay ang mga ito ng makabuluhang mga tagumpay sa pagganap.
Mag-isip ng isang malaking aklat na nakatuon sa pag-tune ng pagganap SQL Server(papel na bersyon, hindi elektronikong bersyon). Isipin na gusto mong maghanap ng impormasyon tungkol sa pag-configure ng Resource Governor. Maaari mong i-drag ang iyong daliri sa bawat pahina sa buong aklat, o buksan ang talaan ng mga nilalaman at alamin ang eksaktong numero ng pahina na may impormasyong hinahanap mo (sa kondisyon na ang aklat ay na-index nang tama at ang mga nilalaman ay may mga tamang index). Ito ay tiyak na makakatipid sa iyo ng makabuluhang oras, kahit na kailangan mo munang ma-access ang isang ganap na naiibang istraktura (ang index) upang makuha ang impormasyong kailangan mo mula sa pangunahing istraktura (ang aklat).
Tulad ng isang book index, isang index sa SQL Server nagbibigay-daan sa iyo na magpatakbo ng mga tumpak na query sa data na kailangan mo sa halip na ganap na i-scan ang lahat ng data na nilalaman sa isang talahanayan. Para sa maliliit na talahanayan, ang isang buong pag-scan ay karaniwang hindi isang problema, ngunit ang malalaking talahanayan ay kumukuha ng maraming mga pahina ng data, na maaaring magresulta sa makabuluhang oras ng pagpapatupad ng query maliban kung mayroong isang index upang payagan ang query engine na agad na makuha ang tamang lokasyon ng data. Isipin na maligaw sa isang multi-level na daanan sa harap ng isang pangunahing metropolis na walang mapa at makakakuha ka ng ideya.

Kung napakahusay ng mga index, bakit hindi na lang gumawa ng isa sa bawat column?

Walang mabuting gawa ang hindi dapat parusahan. Hindi bababa sa iyon ang kaso sa mga index. Siyempre, mahusay ang mga index hangga't nagpapatakbo ka ng mga query sa pagkuha ng operator PUMILI, ngunit sa sandaling magsimula ang mga madalas na tawag sa mga operator INSERT, I-UPDATE At I-DELETE, kaya mabilis na nagbabago ang landscape.
Kapag nagpasimula ka ng kahilingan sa data ng operator PUMILI, hinahanap ng query engine ang index, gumagalaw sa istraktura ng puno nito, at natuklasan ang data na hinahanap nito. Ano ang maaaring maging mas simple? Ngunit magbabago ang mga bagay kung magsisimula ka ng isang pahayag ng pagbabago tulad ng I-UPDATE. Oo, para sa unang bahagi ng pahayag, magagamit muli ng query engine ang index upang mahanap ang row na binago - magandang balita iyon. At kung mayroong isang simpleng pagbabago sa data sa isang hilera na hindi nakakaapekto sa mga pagbabago sa mga pangunahing column, kung gayon ang proseso ng pagbabago ay magiging ganap na walang sakit. Ngunit paano kung ang pagbabago ay nagiging sanhi ng paghahati ng mga pahina na naglalaman ng data, o ang halaga ng isang pangunahing column ay nabago na nagiging sanhi ng paglipat nito sa ibang index node - magreresulta ito sa index na posibleng nangangailangan ng muling pagsasaayos na makakaapekto sa lahat ng nauugnay na index at operasyon , na nagreresulta sa malawakang pagbaba ng produktibidad.
Ang mga katulad na proseso ay nangyayari kapag tumatawag sa isang operator I-DELETE. Makakatulong ang isang index na mahanap ang data na tinatanggal, ngunit ang pagtanggal sa mismong data ay maaaring magresulta sa pag-reshuff ng page. Tungkol sa operator INSERT, ang pangunahing kaaway ng lahat ng mga index: magsisimula kang magdagdag ng isang malaking halaga ng data, na humahantong sa mga pagbabago sa mga index at kanilang muling pagsasaayos at lahat ay nagdurusa.
Kaya isaalang-alang ang mga uri ng mga query sa iyong database kapag iniisip kung anong uri ng mga index at ilan ang lilikhain. Ang mas marami ay hindi nangangahulugang mas mabuti. Bago magdagdag ng bagong index sa isang talahanayan, isaalang-alang ang halaga ng hindi lamang ang pinagbabatayan na mga query, kundi pati na rin ang dami ng disk space na natupok, ang halaga ng pagpapanatili ng functionality at mga index, na maaaring humantong sa isang domino effect sa iba pang mga operasyon. Ang iyong diskarte sa disenyo ng index ay isa sa pinakamahalagang aspeto ng iyong pagpapatupad at dapat magsama ng maraming pagsasaalang-alang, mula sa laki ng index, ang bilang ng mga natatanging value, hanggang sa uri ng mga query na susuportahan ng index.

Kailangan bang gumawa ng clustered index sa isang column na may primary key?

Maaari kang gumawa ng clustered index sa anumang column na nakakatugon sa mga kinakailangang kundisyon. Totoo na ang isang clustered index at isang primary key constraint ay ginawa para sa isa't isa at ito ay isang tugma na ginawa sa langit, kaya unawain ang katotohanan na kapag lumikha ka ng isang pangunahing key, pagkatapos ay isang clustered index ay awtomatikong gagawin kung ang isa ay hindi pa nilikha noon. Gayunpaman, maaari kang magpasya na ang isang clustered index ay gaganap nang mas mahusay sa ibang lugar, at kadalasan ang iyong desisyon ay makatwiran.
Ang pangunahing layunin ng isang clustered index ay pag-uri-uriin ang lahat ng mga row sa iyong talahanayan batay sa key column na tinukoy kapag tinutukoy ang index. Nagbibigay ito ng mabilis na paghahanap at madaling pag-access sa data ng talahanayan.
Ang pangunahing key ng isang talahanayan ay maaaring maging isang mahusay na pagpipilian dahil ito ay natatanging kinikilala ang bawat hilera sa mga talahanayan nang hindi kinakailangang magdagdag ng karagdagang data. Sa ilang mga kaso, ang pinakamahusay na pagpipilian ay isang kahalili na pangunahing susi, na hindi lamang natatangi, ngunit maliit din ang laki at ang mga halaga ay tumataas nang sunud-sunod, na ginagawang mas mahusay ang mga hindi naka-cluster na index batay sa halagang ito. Gusto rin ng query optimizer ang kumbinasyong ito ng clustered index at primary key dahil mas mabilis ang pagsali sa mga table kaysa sa pagsali sa ibang paraan na hindi gumagamit ng primary key at ang nauugnay na clustered index nito. Gaya nga ng sabi ko match made in heaven.
Sa wakas, gayunpaman, ito ay nagkakahalaga ng pagpuna na kapag gumagawa ng isang clustered index mayroong ilang mga aspeto upang isaalang-alang: kung gaano karaming mga non-clustered index ang ibabatay dito, gaano kadalas magbabago ang halaga ng key index column, at gaano kalaki. Kapag ang mga halaga sa mga column ng isang clustered index ay nagbago o ang index ay hindi gumanap gaya ng inaasahan, ang lahat ng iba pang mga index sa talahanayan ay maaaring maapektuhan. Ang isang clustered index ay dapat na nakabatay sa pinaka-patuloy na column na ang mga halaga ay tumataas sa isang partikular na pagkakasunud-sunod ngunit hindi nagbabago sa random na paraan. Dapat na suportahan ng index ang mga query laban sa pinakamadalas na ma-access na data ng talahanayan, kaya ang mga query ay lubos na nakikinabang sa katotohanan na ang data ay pinagsunod-sunod at naa-access sa mga root node, ang mga dahon ng index. Kung ang pangunahing key ay umaangkop sa sitwasyong ito, pagkatapos ay gamitin ito. Kung hindi, pumili ng ibang hanay ng mga column.

Paano kung nag-index ka ng view, view pa rin ba ito?

Ang view ay isang virtual na talahanayan na bumubuo ng data mula sa isa o higit pang mga talahanayan. Sa pangkalahatan, ito ay isang pinangalanang query na kumukuha ng data mula sa mga pinagbabatayan na talahanayan kapag nag-query ka ng view na iyon. Mapapahusay mo ang pagganap ng query sa pamamagitan ng paggawa ng clustered index at nonclustered index sa view na ito, katulad ng kung paano ka gumagawa ng mga index sa isang table, ngunit ang pangunahing caveat ay gumawa ka muna ng clustered index, at pagkatapos ay maaari kang lumikha ng isang nonclustered.
Kapag ang isang naka-index na view (materialized na view) ay ginawa, ang mismong kahulugan ng view ay nananatiling isang hiwalay na entity. Ito ay, pagkatapos ng lahat, isang hardcoded operator lamang PUMILI, na nakaimbak sa database. Ngunit ang index ay isang ganap na naiibang kuwento. Kapag gumawa ka ng clustered o nonclustered index sa isang provider, pisikal na nase-save ang data sa disk, tulad ng isang regular na index. Bilang karagdagan, kapag nagbago ang data sa mga nakapailalim na talahanayan, awtomatikong nagbabago ang index ng view (nangangahulugan ito na maaaring gusto mong iwasan ang pag-index ng mga view sa mga talahanayan na madalas na nagbabago). Sa anumang kaso, ang view ay nananatiling isang view - isang view ng mga talahanayan, ngunit isa ay naisakatuparan sa sandaling ito, na may mga index na naaayon dito.
Bago ka makagawa ng index sa isang view, dapat itong matugunan ang ilang mga hadlang. Halimbawa, ang isang view ay maaari lamang sumangguni sa mga base table, ngunit hindi sa iba pang mga view, at ang mga talahanayan ay dapat na nasa parehong database. Marami talagang ibang mga paghihigpit, kaya siguraduhing suriin ang dokumentasyon para sa SQL Server para sa lahat ng maruming detalye.

Bakit gumamit ng covering index sa halip na isang composite index?

Una, siguraduhin nating naiintindihan natin ang pagkakaiba ng dalawa. Ang compound index ay simpleng regular na index na naglalaman ng higit sa isang column. Maaaring gamitin ang maramihang mga key na column upang matiyak na ang bawat row sa isang talahanayan ay natatangi, o maaaring mayroon kang maraming column upang matiyak na ang pangunahing key ay natatangi, o maaaring sinusubukan mong i-optimize ang pagpapatupad ng mga madalas na ginagamit na mga query sa maraming column. Sa pangkalahatan, gayunpaman, ang mas maraming mga pangunahing column na naglalaman ng isang index, mas magiging mas mahusay ang index, na nangangahulugan na ang mga pinagsama-samang index ay dapat gamitin nang matalino.
Gaya ng nakasaad, ang isang query ay maaaring makinabang nang malaki kung ang lahat ng kinakailangang data ay matatagpuan kaagad sa mga dahon ng index, tulad ng mismong index. Hindi ito problema para sa isang clustered index dahil nandoon na ang lahat ng data (kaya naman napakahalagang mag-isip nang mabuti kapag lumikha ka ng clustered index). Ngunit ang isang hindi naka-cluster na index sa mga dahon ay naglalaman lamang ng mga pangunahing column. Upang ma-access ang lahat ng iba pang data, ang query optimizer ay nangangailangan ng mga karagdagang hakbang, na maaaring magdagdag ng makabuluhang overhead sa pagsasagawa ng iyong mga query.
Ito ay kung saan ang covering index ay dumating sa pagsagip. Kapag tinukoy mo ang isang hindi naka-cluster na index, maaari mong tukuyin ang mga karagdagang column sa iyong mga pangunahing column. Halimbawa, sabihin nating ang iyong application ay madalas na nagtatanong ng data ng column OrderID At OrderDate sa mesa Benta:
PUMILI NG OrderID, OrderDate MULA SA Mga Benta KUNG SAAN OrderID = 12345;
Maaari kang lumikha ng isang compound na hindi naka-cluster na index sa parehong mga column, ngunit ang OrderDate column ay magdaragdag lamang ng index maintenance overhead nang hindi nagsisilbing isang partikular na kapaki-pakinabang na key column. Ang pinakamainam na solusyon ay ang gumawa ng covering index sa key column OrderID at karagdagang kasamang column OrderDate:
GUMAWA NG NONCLUSTERED INDEX ix_orderid SA dbo.Sales(OrderID) INCLUDE (OrderDate);
Iniiwasan nito ang mga disadvantage ng pag-index ng mga redundant na column habang pinapanatili pa rin ang mga benepisyo ng pag-iimbak ng data sa mga dahon kapag nagpapatakbo ng mga query. Ang kasamang column ay hindi bahagi ng key, ngunit ang data ay nakaimbak sa leaf node, ang index leaf. Mapapabuti nito ang pagganap ng query nang walang anumang karagdagang overhead. Bilang karagdagan, ang mga column na kasama sa covering index ay napapailalim sa mas kaunting mga paghihigpit kaysa sa mga pangunahing column ng index.

Mahalaga ba ang bilang ng mga duplicate sa isang pangunahing column?

Kapag gumawa ka ng index, dapat mong subukang bawasan ang bilang ng mga duplicate sa iyong mga pangunahing column. O mas tiyak: subukang panatilihing mababa ang rate ng pag-uulit hangga't maaari.
Kung nagtatrabaho ka sa isang pinagsama-samang index, ang pagdoble ay nalalapat sa lahat ng mga pangunahing column sa kabuuan. Ang isang column ay maaaring maglaman ng maraming duplicate na value, ngunit dapat mayroong minimal na pag-uulit sa lahat ng index column. Halimbawa, lumikha ka ng isang tambalang nonclustered index sa mga column Pangalan At Huling pangalan, maaari kang magkaroon ng maraming mga halaga ng John Doe at maraming mga halaga ng Doe, ngunit nais mong magkaroon ng kaunting mga halaga ng John Doe hangga't maaari, o mas mabuti na isang halaga lamang ng John Doe.
Ang uniqueness ratio ng mga value ng key column ay tinatawag na index selectivity. Ang mas maraming natatanging mga halaga, mas mataas ang pagpili: ang isang natatanging index ay may pinakamalaking posibleng pagpili. Talagang gusto ng query engine ang mga column na may mataas na selectivity value, lalo na kung ang mga column na iyon ay kasama sa mga sugnay na WHERE ng iyong mga query na pinakamadalas isagawa. Kung mas pinipili ang index, mas mabilis na mababawasan ng query engine ang laki ng resultang set ng data. Ang downside, siyempre, ay ang mga column na may kaunting natatanging mga halaga ay bihirang maging mahusay na mga kandidato para sa pag-index.

Posible bang gumawa ng hindi naka-cluster na index sa isang partikular na subset lang ng data ng isang pangunahing column?

Bilang default, ang isang nonclustered index ay naglalaman ng isang row para sa bawat row sa table. Siyempre, maaari mong sabihin ang parehong bagay tungkol sa isang clustered index, sa pag-aakalang ang naturang index ay isang talahanayan. Ngunit pagdating sa isang hindi clustered index, ang one-to-one na relasyon ay isang mahalagang konsepto dahil, simula sa bersyon SQL Server 2008, mayroon kang opsyon na lumikha ng na-filter na index na naglilimita sa mga row na kasama dito. Ang isang na-filter na index ay maaaring mapabuti ang pagganap ng query dahil... ito ay mas maliit sa laki at naglalaman ng na-filter, mas tumpak na mga istatistika kaysa sa lahat ng mga tabular - humahantong ito sa paglikha ng mga pinahusay na plano sa pagpapatupad. Ang isang na-filter na index ay nangangailangan din ng mas kaunting espasyo sa imbakan at mas mababang gastos sa pagpapanatili. Ina-update lang ang index kapag nagbago ang data na tumutugma sa filter.
Bilang karagdagan, ang isang na-filter na index ay madaling gawin. Sa operator GUMAWA NG INDEX kailangan mo lang ipahiwatig SAAN kondisyon ng filter. Halimbawa, maaari mong i-filter ang lahat ng mga hilera na naglalaman ng NULL mula sa index, tulad ng ipinapakita sa code:
GUMAWA NG NONCLUSTERED INDEX ix_trackingnumber SA Sales.SalesOrderDetail(CarrierTrackingNumber) KUNG SAAN ANG CarrierTrackingNumber AY HINDI NULL;
Sa katunayan, maaari naming i-filter ang anumang data na hindi mahalaga sa mga kritikal na query. Ngunit mag-ingat, dahil... SQL Server nagpapataw ng ilang mga paghihigpit sa mga na-filter na index, tulad ng kawalan ng kakayahang lumikha ng isang na-filter na index sa isang view, kaya basahin nang mabuti ang dokumentasyon.
Maaari rin na makakamit mo ang mga katulad na resulta sa pamamagitan ng paglikha ng naka-index na view. Gayunpaman, ang isang na-filter na index ay may ilang mga pakinabang, tulad ng kakayahang bawasan ang mga gastos sa pagpapanatili at pagbutihin ang kalidad ng iyong mga plano sa pagpapatupad. Ang mga na-filter na index ay maaari ding muling itayo online. Subukan ito gamit ang isang naka-index na view.

At muli ng kaunti mula sa tagasalin

Ang layunin ng paglitaw ng pagsasaling ito sa mga pahina ng Habrahabr ay upang sabihin o ipaalala sa iyo ang tungkol sa SimpleTalk blog mula sa RedGate.
Naglalathala ito ng maraming nakakaaliw at kawili-wiling mga post.
Hindi ako kaakibat sa anumang produkto ng kumpanya RedGate, o sa kanilang pagbebenta.

Gaya ng ipinangako, mga libro para sa mga gustong malaman pa
Inirerekomenda ko ang tatlong napakagandang libro mula sa aking sarili (ang mga link ay humahantong sa papagsiklabin mga bersyon sa tindahan Amazon):

Sa prinsipyo, maaari mong buksan ang mga simpleng index

para sa mga nagsisimula pa lamang

index

Magdagdag ng mga tag

Microsoft SQL Server 2012 T-SQL Fundamentals (Developer Reference) May-akda Itzik Ben-Gan Petsa ng Paglalathala: Hulyo 15, 2012 Ang may-akda, isang master ng kanyang craft, ay nagbibigay ng pangunahing kaalaman tungkol sa pagtatrabaho sa mga database. Kung nakalimutan mo na ang lahat o hindi mo alam, tiyak na sulit itong basahin.

ROWID index ay mga bagay sa database na nagbibigay ng pagpapakita ng lahat ng mga halaga sa isang haligi ng talahanayan, pati na rin ang mga ROWID ng lahat ng mga hilera sa talahanayan na naglalaman ng mga halaga ng haligi.

ROWID ay isang pseudo-column na isang natatanging identifier para sa isang row sa isang table at aktwal na naglalarawan ng eksaktong pisikal na lokasyon ng partikular na row na iyon. Batay sa impormasyong ito Oracle mahahanap ang data na nauugnay sa row ng talahanayan. Sa bawat oras na ang isang row ay inilipat, na-export, na-import, o anumang iba pang operasyon na nagbabago sa lokasyon nito, ang ROWID linya dahil ito ay sumasakop sa ibang pisikal na posisyon. Para sa pag-iimbak ng data ROWID Kinakailangan ang 80 bits (10 bytes). Mga Identifier ROWID binubuo ng apat na bahagi: object number (32 bits), relative file number (10 bits), block number (22 bits) at line number (16 bits). Ang mga identifier na ito ay ipinapakita bilang 18-character sequence na nagsasaad ng lokasyon ng data sa database, na ang bawat character ay kinakatawan sa base-64 na format na binubuo ng mga character na A-Z, a-z, 0-9, + at /. Ang unang anim na character ay ang data object number, ang susunod na tatlo ay ang relative file number, ang susunod na anim ay ang block number, at ang huling tatlo ay ang line number.

Halimbawa:

PUMILI ng pamilya, ROWID MULA sa mag-aaral;

FAM ROWID

——————————————

IVANOV AAAA3kAAGAAAAGsAAA

PETROV AAAA3kAAGAAAAGsAAB

Sa database Oracle ang mga index ay ginagamit para sa iba't ibang layunin: upang matiyak ang pagiging natatangi ng mga halaga sa database, upang mapabuti ang pagganap ng paghahanap ng mga tala sa isang talahanayan, atbp. Ang pagganap ay pinabuting sa pamamagitan ng pagsasama ng isang sanggunian sa naka-index na column o mga column sa pamantayan sa paghahanap para sa data sa talahanayan. SA Oracle ang mga index ay maaaring gawin sa anumang column ng talahanayan maliban sa mga MAHABANG column. Naiiba ang mga index sa pagitan ng mga application na hindi sensitibo sa bilis at mga application na may mataas na pagganap, lalo na kapag nagtatrabaho sa malalaking talahanayan. Gayunpaman, bago magpasya na lumikha ng isang index, kailangan mong timbangin ang mga kalamangan at kahinaan tungkol sa pagganap ng system. Hindi gaganda ang performance kung maglalagay ka lang ng index at kalimutan ito.

Bagama't ang pinakamalaking pagpapabuti ng pagganap ay nagmumula sa paglikha ng isang index sa isang column kung saan ang lahat ng mga halaga ay natatangi, maaari kang makakuha ng mga katulad na resulta para sa mga column na naglalaman ng mga duplicate o NULL na mga halaga. Hindi kinakailangan para sa mga halaga ng hanay na maging natatangi upang lumikha ng isang index. Narito ang ilang rekomendasyon upang matulungan kang makamit ang ninanais na pagpapalakas ng pagganap kapag gumagamit ng karaniwang index, at titingnan din namin ang mga isyu na nauugnay sa balanse sa pagitan ng pagganap at pagkonsumo ng espasyo sa disk kapag gumagawa ng index.

Ang paggamit ng mga index upang maghanap ng impormasyon sa mga talahanayan ay maaaring magbigay ng makabuluhang mga pagpapabuti sa pagganap kaysa sa pag-scan ng mga talahanayan na ang mga column ay hindi na-index. Gayunpaman, ang pagpili ng tamang index ay hindi madali. Siyempre, ang isang hanay na ang mga halaga ay natatangi lahat ay mas mainam para sa pag-index gamit ang isang B-tree index, ngunit ang isang hanay na hindi nakakatugon sa mga kinakailangang ito ay isang mahusay na kandidato hangga't ang tungkol sa 10% ng mga hilera nito ay naglalaman ng magkaparehong mga halaga. at wala na. Ang mga column na "Switch" o "flag", halimbawa, ang mga nag-iimbak ng impormasyon tungkol sa kasarian ng isang tao, ay hindi angkop para sa mga B-tree index. Ang mga column na ginagamit upang mag-imbak ng kaunting bilang ng "maaasahang halaga", gayundin ang mga nag-iimbak ang ilang mga halaga, ay hindi rin angkop. pagkatapos ay ang mga palatandaan, halimbawa, "pagkakatiwalaan" o "hindi mapagkakatiwalaan", "aktibidad" o "hindi aktibo", "oo" o "hindi", atbp., atbp. Sa wakas, ang mga index na may mga reverse key ay ginagamit, bilang panuntunan, kung saan ito naka-install at nagpapatakbo Oracle Parallel Server at kailangan mong taasan ang antas ng parallelism sa database sa maximum.