सूचकांक विशिष्टता ओवरहेड


14

मैं एक सूचकांक की लागत पर अपने कार्यालय में विभिन्न डेवलपर्स के साथ चल रही बहस कर रहा हूं, और क्या अद्वितीयता फायदेमंद है या नहीं (शायद दोनों)। इस मुद्दे की जड़ हमारे प्रतिस्पर्धी संसाधन हैं।

पृष्ठभूमि

मैंने पहले एक चर्चा पढ़ी है जिसमें कहा गया है कि एक Uniqueअनुक्रमणिका को बनाए रखने के लिए कोई अतिरिक्त लागत नहीं है, क्योंकि एक Insertऑपरेशन जहां यह बी-ट्री में फिट बैठता है, और अगर कोई डुप्लिकेट गैर-अनूठे इंडेक्स में पाया जाता है, के लिए जाँच करता है, तो एक यूनिकफायर को भेजता है। कुंजी का अंत, लेकिन अन्यथा सीधे सम्मिलित करता है। घटनाओं के इस क्रम में, एक Uniqueसूचकांक की कोई अतिरिक्त लागत नहीं है।

मेरे सहकर्मी ने यह कहकर इस कथन का मुकाबला किया Unique के बाद बी-वृक्ष में नए स्थान की तलाश है, और इस प्रकार अधिक एक गैर-अद्वितीय सूचकांक की तुलना में बनाए रखने के लिए महंगा है एक दूसरे ऑपरेशन के रूप में लागू की जाती है।

सबसे खराब रूप से, मैंने एक पहचान स्तंभ (अंतर्निहित अद्वितीय) के साथ तालिकाओं को देखा है जो तालिका की क्लस्टरिंग कुंजी है, लेकिन स्पष्ट रूप से गैर-अद्वितीय के रूप में कहा गया है। सबसे बुरे पक्ष में विशिष्टता के साथ मेरा जुनून है, और सभी सूचकांक अद्वितीय के रूप में बनाए जाते हैं, और जब किसी सूचकांक के लिए स्पष्ट रूप से अद्वितीय संबंध को परिभाषित करना संभव नहीं होता है, तो मैं तालिका के पीके को सूचकांक के अंत तक सुनिश्चित करने के लिए अपील करता हूं। विशिष्टता की गारंटी है।

मैं अक्सर देव टीम के लिए कोड समीक्षाओं में शामिल होता हूं, और मुझे उनके पालन के लिए सामान्य दिशानिर्देश देने में सक्षम होना चाहिए। हां, प्रत्येक सूचकांक का मूल्यांकन किया जाना चाहिए, लेकिन जब आपके पास प्रत्येक में हजारों तालिकाओं के साथ पांच सर्वर होते हैं और एक मेज पर बीस सूचकांक होते हैं, तो आपको गुणवत्ता के एक निश्चित स्तर को सुनिश्चित करने के लिए कुछ सरल नियमों को लागू करने में सक्षम होना चाहिए।

सवाल

क्या Insertगैर-अद्वितीय सूचकांक को बनाए रखने की लागत की तुलना में विशिष्टता के पीछे-छोर पर एक अतिरिक्त लागत है ? दूसरे, अद्वितीयता सुनिश्चित करने के लिए एक सूचकांक के अंत में एक तालिका के प्राथमिक कुंजी को जोड़ने में क्या गलत है?

उदाहरण तालिका परिभाषा

create table #test_index
    (
    id int not null identity(1, 1),
    dt datetime not null default(current_timestamp),
    val varchar(100) not null,
    is_deleted bit not null default(0),
    primary key nonclustered(id desc),
    unique clustered(dt desc, id desc)
    );

create index
    [nonunique_nonclustered_example]
on #test_index
    (is_deleted)
include
    (val);

create unique index
    [unique_nonclustered_example]
on #test_index
    (is_deleted, dt desc, id desc)
include
    (val);

उदाहरण

एक Uniqueसूचकांक के अंत की कुंजी मैं क्यों जोड़ूंगा इसका एक उदाहरण हमारे एक तथ्य तालिका में है। वहाँ एक है Primary Keyएक है कि Identityस्तंभ। हालाँकि, Clustered Indexइसके बजाए विभाजन स्कीम कॉलम है, जिसके बाद तीन विदेशी कुंजी आयाम हैं जिनमें कोई विशिष्टता नहीं है। इस तालिका पर प्रदर्शन का चयन संक्षिप्त है, और मैं अक्सर Primary Keyलीवरेज करने के बजाय एक महत्वपूर्ण लुकअप के साथ बेहतर समय का उपयोग करता हूं Clustered Index। अन्य तालिकाएँ जो एक समान डिज़ाइन का पालन करती हैं, लेकिन Primary Keyअंत तक संलग्न होती हैं, उनमें बेहतर प्रदर्शन होता है।

-- date_int is equivalent to convert(int, convert(varchar, current_timestamp, 112))
if not exists(select * from sys.partition_functions where [name] = N'pf_date_int')
    create partition function 
        pf_date_int (int) 
    as range right for values 
        (19000101, 20180101, 20180401, 20180701, 20181001, 20190101, 20190401, 20190701);
go

if not exists(select * from sys.partition_schemes where [name] = N'ps_date_int')
    create partition scheme 
        ps_date_int
    as partition 
        pf_date_int all 
    to 
        ([PRIMARY]);
go

if not exists(select * from sys.objects where [object_id] = OBJECT_ID(N'dbo.bad_fact_table'))
    create table dbo.bad_fact_table
        (
        id int not null, -- Identity implemented elsewhere, and CDC populates
        date_int int not null,
        dt date not null,
        group_id int not null,
        group_entity_id int not null, -- member of group
        fk_id int not null,
        -- tons of other columns
        primary key nonclustered(id, date_int),
        index [ci_bad_fact_table] clustered (date_int, group_id, group_entity_id, fk_id)
        )
    on ps_date_int(date_int);
go

if not exists(select * from sys.objects where [object_id] = OBJECT_ID(N'dbo.better_fact_table'))
    create table dbo.better_fact_table
        (
        id int not null, -- Identity implemented elsewhere, and CDC populates
        date_int int not null,
        dt date not null,
        group_id int not null,
        group_entity_id int not null, -- member of group
        -- tons of other columns
        primary key nonclustered(id, date_int),
        index [ci_better_fact_table] clustered(date_int, group_id, group_entity_id, id)
        )
    on ps_date_int(date_int);
go

जवाबों:


16

मैं अक्सर देव टीम के लिए कोड समीक्षाओं में शामिल होता हूं, और मुझे उनके पालन के लिए सामान्य दिशानिर्देश देने में सक्षम होना चाहिए।

वर्तमान में मैं जिस वातावरण में शामिल हूं, उसमें 2500 डेटाबेस के साथ 250 सर्वर हैं। मैंने 30,000 डेटाबेस के साथ सिस्टम पर काम किया है । अनुक्रमण के लिए दिशानिर्देशों को नामकरण सम्मेलन के चारों ओर घूमना चाहिए, आदि, जो किसी सूचकांक में शामिल करने के लिए "नियम" नहीं हैं - प्रत्येक व्यक्ति सूचकांक को उस विशिष्ट व्यवसाय नियम या तालिका को छूने वाले कोड के लिए सही सूचकांक होने के लिए इंजीनियर होना चाहिए।

क्या Insertगैर-अद्वितीय सूचकांक को बनाए रखने की लागत की तुलना में विशिष्टता के पीछे-छोर पर एक अतिरिक्त लागत है ? दूसरे, अद्वितीयता सुनिश्चित करने के लिए एक सूचकांक के अंत में एक तालिका के प्राथमिक कुंजी को जोड़ने में क्या गलत है?

गैर-अद्वितीय अनुक्रमणिका के अंत में प्राथमिक कुंजी कॉलम जोड़ना यह मुझे एक अद्वितीय प्रतिरूप बनाता है। यदि व्यावसायिक नियम निर्धारित करते हैं तो डेटा अद्वितीय होना चाहिए, फिर कॉलम में एक अद्वितीय बाधा जोड़ें; जो स्वचालित रूप से एक अद्वितीय सूचकांक बनाएगा। यदि आप प्रदर्शन के लिए एक कॉलम अनुक्रमण कर रहे हैं , तो आप सूचकांक में एक स्तंभ क्यों जोड़ेंगे?

यहां तक ​​कि अगर आपका तर्क जो अद्वितीयता को लागू करता है, तो कोई अतिरिक्त उपरि नहीं जोड़ता है, जो सही है (जो यह नहीं है कुछ मामलों के लिए ), आप अनावश्यक रूप से सूचकांक को जटिल करके क्या हल कर रहे हैं?

प्राथमिक कुंजी को अपनी अनुक्रमणिका कुंजी के अंत में जोड़ने के विशिष्ट उदाहरण में ताकि आप अनुक्रमणिका परिभाषा को शामिल कर सकें UNIQUE संशोधक , यह वास्तव में डिस्क पर भौतिक सूचकांक संरचना में शून्य अंतर करता है। यह बी-ट्री इंडेक्स कीज़ की संरचना की प्रकृति के कारण है, इसमें उन्हें हमेशा अद्वितीय होने की आवश्यकता होती है।

जैसा कि डेविड ब्राउन ने एक टिप्पणी में उल्लेख किया है:

चूंकि प्रत्येक गैर-अनुक्रमित सूचकांक को अद्वितीय सूचकांक के रूप में संग्रहीत किया जाता है, इसलिए एक अद्वितीय सूचकांक डालने में कोई अतिरिक्त लागत नहीं है । वास्तव में केवल अतिरिक्त लागत एक उम्मीदवार कुंजी को एक अद्वितीय सूचकांक के रूप में घोषित करने में विफल हो सकती है, जिससे क्लस्टर कुंजी को सूचकांक कुंजी में जोड़ा जाएगा।

निम्न को पूर्ण रूप से पूर्ण और सत्यापित करने योग्य उदाहरण लें :

USE tempdb;

DROP TABLE IF EXISTS dbo.IndexTest;
CREATE TABLE dbo.IndexTest
(
    id int NOT NULL
        CONSTRAINT IndexTest_pk
        PRIMARY KEY
        CLUSTERED
        IDENTITY(1,1)
    , rowDate datetime NOT NULL
);

मैं दूसरी अनुक्रमणिका कुंजी परिभाषा के अंतिम छोर पर प्राथमिक कुंजी को शामिल करने के अलावा दो सूचकांक जोड़ूंगा:

CREATE INDEX IndexTest_rowDate_ix01
ON dbo.IndexTest(rowDate);

CREATE UNIQUE INDEX IndexTest_rowDate_ix02
ON dbo.IndexTest(rowDate, id);

अगला, हम तालिका में कई पंक्तियाँ देंगे:

INSERT INTO dbo.IndexTest (rowDate)
VALUES (DATEADD(SECOND, 0, GETDATE()))
     , (DATEADD(SECOND, 0, GETDATE()))
     , (DATEADD(SECOND, 0, GETDATE()))
     , (DATEADD(SECOND, 1, GETDATE()))
     , (DATEADD(SECOND, 2, GETDATE()));

जैसा कि आप ऊपर देख सकते हैं, तीन पंक्तियों में rowDateकॉलम के लिए समान मूल्य होता है, और दो पंक्तियों में अद्वितीय मान होते हैं।

इसके बाद, हम अनिर्दिष्ट DBCC PAGEकमांड का उपयोग करते हुए, प्रत्येक सूचकांक के लिए भौतिक पृष्ठ संरचनाओं को देखेंगे :

DECLARE @dbid int = DB_ID();
DECLARE @fileid int;
DECLARE @pageid int;
DECLARE @indexid int;

SELECT @fileid = ddpa.allocated_page_file_id
    , @pageid = ddpa.allocated_page_page_id
FROM sys.indexes i 
CROSS APPLY sys.dm_db_database_page_allocations(DB_ID(), i.object_id, i.index_id, NULL, 'LIMITED') ddpa
WHERE i.name = N'IndexTest_rowDate_ix01'
    AND ddpa.is_allocated = 1
    AND ddpa.is_iam_page = 0;

PRINT N'*************************************** IndexTest_rowDate_ix01 *****************************************';
DBCC TRACEON(3604);
DBCC PAGE (@dbid, @fileid, @pageid, 1);
DBCC TRACEON(3604);
PRINT N'*************************************** IndexTest_rowDate_ix01 *****************************************';

SELECT @fileid = ddpa.allocated_page_file_id
    , @pageid = ddpa.allocated_page_page_id
FROM sys.indexes i 
CROSS APPLY sys.dm_db_database_page_allocations(DB_ID(), i.object_id, i.index_id, NULL, 'LIMITED') ddpa
WHERE i.name = N'IndexTest_rowDate_ix02'
    AND ddpa.is_allocated = 1
    AND ddpa.is_iam_page = 0;

PRINT N'*************************************** IndexTest_rowDate_ix02 *****************************************';
DBCC TRACEON(3604);
DBCC PAGE (@dbid, @fileid, @pageid, 1);
DBCC TRACEON(3604);
PRINT N'*************************************** IndexTest_rowDate_ix02 *****************************************';

मैंने आउटपुट से परे तुलना का उपयोग करके देखा है, और आवंटन पृष्ठ आईडी आदि के आसपास स्पष्ट अंतरों को छोड़कर, दो सूचकांक संरचनाएं समान हैं।

यहाँ छवि विवरण दर्ज करें

आप ऊपर ले जा सकते हैं, जिसका अर्थ है कि प्रत्येक सूचकांक में प्राथमिक कुंजी शामिल है, और अद्वितीय के रूप में परिभाषित करना एक अच्छा बात है ™ क्योंकि यह वैसे भी अंडर-कवर शामिल है। मैं उस धारणा को नहीं बनाऊंगा, और केवल एक सूचकांक को अद्वितीय के रूप में परिभाषित करने का सुझाव दूंगा यदि वास्तव में सूचकांक में प्राकृतिक डेटा पहले से ही अद्वितीय है।

इस विषय के बारे में इंटरवेब में कई उत्कृष्ट संसाधन हैं, जिनमें शामिल हैं:

FYI करें, एक identityकॉलम की मात्र उपस्थिति विशिष्टता की गारंटी नहीं देती है। आपको स्तंभ को एक प्राथमिक कुंजी के रूप में या एक अद्वितीय बाधा के साथ परिभाषित करना होगा ताकि यह सुनिश्चित हो सके कि उस स्तंभ में संग्रहीत मान वास्तव में अद्वितीय हैं। SET IDENTITY_INSERT schema.table ON;बयान आप एक स्तंभ के रूप में परिभाषित में गैर अनन्य मान सम्मिलित करने की अनुमति देगा identity


5

मैक्स के उत्कृष्ट उत्तर के लिए बस एक ऐड-ऑन ।

जब एक गैर अद्वितीय क्लस्टर इंडेक्स बनाने की बात आती है, तो SQL सर्वर Uniquifierपृष्ठभूमि में वैसे भी कुछ बनाता है ।

यह Uniquifierभविष्य में संभावित समस्याओं का कारण बन सकता है यदि आपके प्लेटफ़ॉर्म में बहुत सारे CRUD ऑपरेशन हैं, क्योंकि यह Uniquifierकेवल 4 बाइट्स बड़ा (एक मूल 32 बिट पूर्णांक) है। इसलिए, यदि आपके सिस्टम में बहुत सारे CRUD ऑपरेशन हैं, तो संभव है कि आप सभी उपलब्ध अद्वितीय नंबरों का उपयोग करेंगे और अचानक आपको एक त्रुटि प्राप्त होगी और यह आपको अपने टेबल में डेटा डालने की अनुमति नहीं देगा (क्योंकि यह है) अब आपके नए सम्मिलित पंक्तियों को निर्दिष्ट करने के लिए कोई अद्वितीय मान नहीं है)।

जब ऐसा होता है, तो आपको यह त्रुटि मिलेगी:

The maximum system-generated unique value for a duplicate group 
was exceeded for index with partition ID (someID). 

Dropping and re-creating the index may resolve this;
otherwise, use another clustering key.

त्रुटि 666 (उपरोक्त त्रुटि) तब होती है जब uniquifierगैर-विशिष्ट कुंजी के एक सेट के लिए 2,147,483,647 पंक्तियों से अधिक खपत होती है।

तो, आपको एकल कुंजी मान के लिए या तो ~ 2 बिलियन पंक्तियों की आवश्यकता होगी, या आपको इस त्रुटि को देखने के लिए एकल कुंजी मान ~ 2 बिलियन बार संशोधित करने की आवश्यकता होगी। जैसे, यह बहुत संभव नहीं है कि आप इस सीमा में भाग लेंगे।


मुझे इस बात का अंदाजा नहीं था कि छिपा हुआ अनोखा प्रमुख स्थान छोड़ सकता है, लेकिन मुझे लगता है कि सभी चीजें किसी न किसी मामले में सीमित हैं। बहुत कुछ कैसे Caseऔर Ifसंरचनाएं 10 स्तरों तक सीमित हैं, यह समझ में आता है कि गैर-अद्वितीय संस्थाओं को हल करने की एक सीमा भी है। आपके कथन से, ऐसा लगता है कि यह केवल उन मामलों पर लागू होता है जब क्लस्टरिंग कुंजी गैर-अद्वितीय होती है। क्या यह एक समस्या है Nonclustered Indexया यदि क्लस्टरिंग कुंजी है Uniqueतो Nonclusteredअनुक्रमणिका के लिए कोई समस्या नहीं है ?
सोलोनोटिक्स

एक अद्वितीय सूचकांक है (जहां तक ​​मुझे पता है) स्तंभ प्रकार के आकार तक सीमित है (इसलिए यदि यह एक बड़ी प्रकार है, तो आपके पास काम करने के लिए 8bytes है)। इसके अलावा, माइक्रोसॉफ़्ट के आधिकारिक दस्तावेज के अनुसार, अधिकतम संकुल के लिए अधिकतम 900bytes अनुक्रमणिका और गैर-संकुल के लिए 1700bytes की अनुमति है (क्योंकि आपके पास एक से अधिक गैर-संकुल अनुक्रमणिका हो सकती है और केवल 1 सारणीबद्ध अनुक्रमणिका है)। docs.microsoft.com/en-us/sql/sql-server/…
Chessbrain

1
@ सॉलोनॉटिक्स - क्लस्टर किए गए इंडेक्स से यूनीकिफायर का उपयोग नॉन-क्लस्टर्ड इंडेक्स में किया जाता है। यदि आप प्राथमिक कुंजी के बिना मेरे उदाहरण में कोड चलाते हैं (इसके बजाय एक क्लस्टर इंडेक्स बनाएं), तो आप देख सकते हैं कि आउटपुट गैर-अद्वितीय और अद्वितीय इंडेक्स दोनों के लिए समान है।
मैक्स वेरनॉन

-2

मैं इस सवाल पर तौलना नहीं जा रहा हूं कि क्या एक सूचकांक अद्वितीय होना चाहिए या नहीं, और इस दृष्टिकोण में अधिक ओवरहेड है या नहीं। लेकिन कुछ चीजों ने मुझे आपके सामान्य डिजाइन में परेशान कर दिया

  1. dt डेटाटाइम डिफ़ॉल्ट नहीं है (current_timestamp)। डेटाइम एक पुराना रूप है या यह है, और आप डेटटाइम 2 () और सिसडटाइम () का उपयोग करके कम से कम कुछ अंतरिक्ष बचत प्राप्त करने में सक्षम हो सकते हैं।
  2. #test_index (is_deleted) में सूचकांक (nonunique_nonclustered_example] शामिल करें (घाटी) बनाएं। यह मुझे परेशान करता है। डेटा को कैसे एक्सेस किया जाना है, इस पर एक नज़र डालें (मैं शर्त लगा रहा हूं कि यह अधिक है WHERE is_deleted = 0) और फ़िल्टर किए गए इंडेक्स का उपयोग करके देखें। मैं 2 फ़िल्टर किए गए इंडेक्स का उपयोग करने पर भी विचार करूंगा, एक के लिए where is_deleted = 0और दूसरे के लिएwhere is_deleted = 1

मौलिक रूप से यह एक वास्तविक समस्या / समाधान के बजाय एक परिकल्पना का परीक्षण करने के लिए डिज़ाइन की गई एक कोडिंग अभ्यास की तरह दिखता है, लेकिन उन दो पैटर्न निश्चित रूप से कुछ हैं जो मैं कोड समीक्षाओं में देखता हूं।


सबसे अधिक आप डेटाइम 2 के बजाय डेटाटाइम 2 का उपयोग करके बचाएंगे 1 बाइट, और अगर आपकी परिशुद्धता 3 से कम है, तो इसका मतलब होगा कि आंशिक सेकंड पर सटीक खोना, जो हमेशा एक व्यवहार्य समाधान नहीं है। उदाहरण के लिए प्रदान किए गए इंडेक्स के लिए, मेरे प्रश्न पर ध्यान केंद्रित करने के लिए डिज़ाइन को सरल रखा गया था। एक Nonclusteredअनुक्रमणिका में मुख्य रूप से आंतरिक लुकअप के लिए डेटा पंक्ति के अंत में संलग्न क्लस्टरिंग कुंजी होगी। जैसे, दो सूचकांक शारीरिक रूप से एक जैसे हैं, जो मेरे प्रश्न का बिंदु था।
सोलोनोटिक्स

पैमाने पर हम एक बाइट या दो को बचाने के लिए जल्दी से कहते हैं। और मैंने यह मान लिया था कि चूंकि आप अभेद्य डेटाइम का उपयोग कर रहे थे, हम सटीकता को कम कर सकते हैं। अनुक्रमितों के लिए, मैं फिर से बताऊंगा कि सूचकांक पर प्रमुख स्तंभों के रूप में बिट कॉलम एक पैटर्न है जिसे मैं एक खराब विकल्प मानता हूं। सभी चीजों के साथ, आपका माइलेज अलग हो सकता है। एक अनुमानित मॉडल के नुकसान का सामना करना पड़ता है।
टोबी

-4

यह आपके लिए बस एक वैकल्पिक, छोटे सूचकांक बनाने के लिए पीके का उपयोग करने जैसा दिखता है। इसलिए, इस पर प्रदर्शन तेज है।

आप इसे उन कंपनियों पर देखते हैं जिनमें बड़े पैमाने पर डेटा टेबल हैं (जैसे: मास्टर डेटा टेबल)। कोई व्यक्ति इस पर एक बड़े पैमाने पर क्लस्टर इंडेक्स लगाने का फैसला करता है जिससे उसे विभिन्न रिपोर्टिंग समूहों की जरूरतों को पूरा करने की उम्मीद होती है।

लेकिन, एक समूह को उस सूचकांक के केवल कुछ हिस्सों की आवश्यकता हो सकती है, जबकि दूसरे समूह को अन्य भागों की आवश्यकता होती है .. इसलिए सूचकांक को "प्रदर्शन का अनुकूलन" करने के लिए सूर्य के नीचे प्रत्येक कॉलम में केवल थप्पड़ मारने से वास्तव में मदद नहीं मिलती है।

इस बीच, कई, छोटे, लक्षित सूचकांकों को बनाने के लिए इसे तोड़ना, अक्सर समस्या को हल करता है।

और, ऐसा लगता है कि आप क्या कर रहे हैं। आपके पास भयानक प्रदर्शन के साथ यह बड़े पैमाने पर संकुलित सूचकांक है, तो आप पीके का उपयोग कम स्तंभों (कोई आश्चर्य नहीं) के साथ एक और सूचकांक बनाने के लिए बेहतर प्रदर्शन करते हैं।

तो, बस एक विश्लेषण करें और पता करें कि क्या आप एकल क्लस्टर इंडेक्स को ले सकते हैं और इसे छोटे, लक्षित सूचकांकों में तोड़ सकते हैं जो कि आवश्यक नौकरी की आवश्यकता है।

आपको "सिंगल इंडेक्स बनाम मल्टीपल इंडेक्स" स्टैंड-पॉइंट से प्रदर्शन का विश्लेषण करना होगा, क्योंकि सूचकांकों को बनाने और अपडेट करने में ओवरहेड है। लेकिन, आपको इसका विश्लेषण समग्र दृष्टिकोण से करना होगा।

ईजी: यह एक बड़े पैमाने पर क्लस्टर इंडेक्स के लिए कम संसाधन-गहन हो सकता है, और कई छोटे लक्षित सूचकांकों के लिए अधिक संसाधन गहन हो सकता है। लेकिन, यदि आप तब बैक-एंड बहुत जल्दी लक्षित प्रश्नों को चलाने में सक्षम होते हैं, तो समय (और धन) की बचत होती है, यह इसके लायक हो सकता है।

इसलिए, आपको एंड-टू-एंड विश्लेषण करना होगा .. न केवल यह देखें कि यह आपकी अपनी दुनिया को कैसे प्रभावित करता है, बल्कि यह भी कि यह एंड-यूजर्स को कैसे प्रभावित करता है।

मुझे लगता है कि आप पीके पहचानकर्ता का गलत उपयोग कर रहे हैं। लेकिन, आप एक डेटाबेस सिस्टम का उपयोग कर सकते हैं जो केवल 1 इंडेक्स (?) की अनुमति देता है, लेकिन यदि आप पीके (b / c हर रिलेशनल डेटाबेस सिस्टम इन दिनों पीके को स्वचालित रूप से अनुक्रमित करने के लिए लगता है) में एक और चुपके कर सकते हैं। हालांकि, अधिकांश आधुनिक आरडीबीएमएस को कई सूचकांक बनाने की अनुमति देनी चाहिए; आपके द्वारा किए जाने वाले अनुक्रमणिकाओं की संख्या की कोई सीमा नहीं होनी चाहिए (1 PK की सीमा के विपरीत)।

इसलिए, पीके व्हिसिह बनाकर, केवल एक ऑल्ट इंडेक्स की तरह काम करता है .. आप अपने पीके का उपयोग कर रहे हैं, जिसकी आवश्यकता हो सकती है यदि तालिका बाद में इसमें भूमिका में विस्तारित हो।

यह कहने के लिए नहीं है कि आपकी तालिका को PK की आवश्यकता नहीं है .. SOP DB के 101 का कहना है कि "हर तालिका में PK होना चाहिए"। लेकिन, डेटा-वेयरहाउसिंग स्थिति में या ऐसे .. एक मेज पर पीके होने से बस अतिरिक्त ओवरहेड हो सकता है जिसकी आपको आवश्यकता नहीं है। या, यह सुनिश्चित करने के लिए एक ईश्वर-संदेश हो सकता है कि आप दोहरे प्रविष्टियों को जोड़ नहीं रहे हैं। यह वास्तव में एक बात है कि आप क्या कर रहे हैं और क्यों कर रहे हैं।

लेकिन, बड़े पैमाने पर तालिकाओं को अनुक्रमित होने से बड़े पैमाने पर लाभ होता है। लेकिन, एक बड़े पैमाने पर संकुलित सूचकांक को मानना ​​सबसे अच्छा होगा ... यह सबसे अच्छा हो सकता है .. लेकिन मैं एक परीक्षण पर परीक्षण करने की सिफारिश करूँगा कि सूचकांक को तोड़ने के अलावा कई छोटे सूचकांकों में विशिष्ट उपयोग के मामले परिदृश्यों को लक्षित किया जाता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.