SQL सर्वर में प्राथमिक कुंजी कैसे बनाएं (T-SQL उदाहरण)

यह आलेख दर्शाता है कि Transact-SQL का उपयोग करके तालिका बनाते समय SQL सर्वर में प्राथमिक कुंजी कैसे बनाई जाए।

प्राथमिक कुंजी एक या अधिक स्तंभ हैं जिन्हें किसी तालिका के लिए विशिष्ट पहचानकर्ता के रूप में कॉन्फ़िगर किया गया है। तालिका में डेटा अखंडता को लागू करने के लिए प्राथमिक कुंजियों का उपयोग किया जा सकता है।

एक तालिका में केवल एक प्राथमिक कुंजी हो सकती है, और प्राथमिक कुंजी केवल उन स्तंभों में जोड़ी जा सकती है जिन्हें NOT NULL के रूप में परिभाषित किया गया है .

यह आलेख दर्शाता है कि नई . में प्राथमिक कुंजी कैसे बनाई जाती है तालिका (यानी तालिका बनाते समय)। यदि आपको किसी मौजूदा . में प्राथमिक कुंजी बनाने की आवश्यकता है तालिका, SQL सर्वर में किसी मौजूदा तालिका में प्राथमिक कुंजी कैसे जोड़ें देखें।

उदाहरण 1 - प्राथमिक कुंजी के साथ तालिका बनाएं

पहले मैं एक परीक्षण डेटाबेस बनाऊँगा:

CREATE DATABASE PK_Test;

अब एक नई तालिका बनाएं जिसमें प्राथमिक कुंजी बाधा शामिल हो:

USE PK_Test;

CREATE TABLE Colors
(
    ColorId int IDENTITY (1,1) NOT NULL PRIMARY KEY,
    ColorName varchar(50)
);

इसने Colors . नामक एक नई तालिका बनाई जिसकी ColorId . पर प्राथमिक कुंजी बाधा है कॉलम।

उदाहरण 2 - प्राथमिक कुंजी बाधा की जांच करें

डेटाबेस में प्राथमिक कुंजी बाधाओं की सूची वापस करने के लिए हम निम्नलिखित कोड चला सकते हैं:

SELECT
  name,
  type,
  unique_index_id,
  is_system_named
FROM sys.key_constraints
WHERE type = 'PK';

परिणाम:

+------------------------------+--------+-------------------+-------------------+
| name                         | type   | unique_index_id   | is_system_named   |
|------------------------------+--------+-------------------+-------------------|
| PK__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
+------------------------------+--------+-------------------+-------------------+

मैंने इस उदाहरण के लिए कॉलम को छोटा कर दिया है। sys.key_constraints सिस्टम व्यू इससे अधिक कॉलम लौटाता है। आप हमेशा * . का उपयोग कर सकते हैं यदि आप चाहें तो सभी कॉलम वापस करने के लिए वाइल्डकार्ड।

हम क्वेरी परिणाम से देख सकते हैं कि इस डेटाबेस में केवल एक प्राथमिक कुंजी है (जिसे हमने अभी बनाया है)।

इस मामले में प्राथमिक कुंजी को सिस्टम द्वारा स्वचालित रूप से नामित किया गया था। आपके पास अपना नाम प्रदान करने का विकल्प भी है (उस पर और बाद में)।

उदाहरण 3 - इंडेक्स की जांच करें

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

यहां एक क्वेरी है जो उस इंडेक्स को लौटाती है जो मेरे द्वारा उपरोक्त प्राथमिक कुंजी बनाते समय स्वचालित रूप से बनाया गया था:

SELECT *
FROM sys.indexes
WHERE name = 'PK__Colors__8DA7674DD34F4585';

परिणाम (ऊर्ध्वाधर आउटपुट का उपयोग करके):

object_id                  | 885578193
name                       | PK__Colors__8DA7674DD34F4585
index_id                   | 1
type                       | 1
type_desc                  | CLUSTERED
is_unique                  | 1
data_space_id              | 1
ignore_dup_key             | 0
is_primary_key             | 1
is_unique_constraint       | 0
fill_factor                | 0
is_padded                  | 0
is_disabled                | 0
is_hypothetical            | 0
is_ignored_in_optimization | 0
allow_row_locks            | 1
allow_page_locks           | 1
has_filter                 | 0
filter_definition          | NULL
compression_delay          | NULL
suppress_dup_key_messages  | 0
auto_created               | 0

इस मामले में मैंने परिणामों को केवल उस पंक्ति तक सीमित कर दिया है जिसमें मेरे द्वारा अभी बनाई गई प्राथमिक कुंजी का समान नाम है। आप WHERE . को हमेशा हटा सकते हैं क्लॉज यदि आपको वापस करने के लिए और परिणाम चाहिए।

हम देख सकते हैं कि इस इंडेक्स में एक type_desc . है क्लस्टर किए गए . के .

उदाहरण 4 - प्राथमिक कुंजी का नामकरण

ऊपर हमने जो प्राथमिक कुंजी बनाई थी, उसे सिस्टम द्वारा स्वचालित रूप से नामित किया गया था। आप चाहें तो अपना नाम दे सकते हैं।

प्राथमिक कुंजी के लिए नाम निर्दिष्ट करने का एक उदाहरण यहां दिया गया है। इस मामले में मैं एक गैर-संकुल सूचकांक भी निर्दिष्ट करता हूं।

USE PK_Test;

CREATE TABLE Cats
(
    CatId int IDENTITY (1,1) NOT NULL, 
       CONSTRAINT PK_Cats_CatId PRIMARY KEY NONCLUSTERED (CatId),
    CatName varchar(50)
);

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

प्राथमिक कुंजी जांचें:

SELECT
  name,
  type,
  unique_index_id,
  is_system_named
FROM sys.key_constraints
WHERE type = 'PK';

परिणाम:

+------------------------------+--------+-------------------+-------------------+
| name                         | type   | unique_index_id   | is_system_named   |
|------------------------------+--------+-------------------+-------------------|
| PK__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
| PK_Cats_CatId                | PK     | 2                 | 0                 |
+------------------------------+--------+-------------------+-------------------+

सूचकांक की जाँच करें:

SELECT *
FROM sys.indexes
WHERE name = 'PK_Cats_CatId';

परिणाम (ऊर्ध्वाधर आउटपुट का उपयोग करके):

object_id                  | 917578307
name                       | PK_Cats_CatId
index_id                   | 2
type                       | 2
type_desc                  | NONCLUSTERED
is_unique                  | 1
data_space_id              | 1
ignore_dup_key             | 0
is_primary_key             | 1
is_unique_constraint       | 0
fill_factor                | 0
is_padded                  | 0
is_disabled                | 0
is_hypothetical            | 0
is_ignored_in_optimization | 0
allow_row_locks            | 1
allow_page_locks           | 1
has_filter                 | 0
filter_definition          | NULL
compression_delay          | NULL
suppress_dup_key_messages  | 0
auto_created               | 0

तो हम देख सकते हैं कि इस बार type_desc NONCLUSTERED . है ।

ध्यान दें कि तालिका बनाते समय, CLUSTERED केवल एक बाधा के लिए निर्दिष्ट किया जा सकता है। अगर यह UNIQUE . के लिए निर्दिष्ट है बाधा और एक PRIMARY KEY बाधा भी निर्दिष्ट है, PRIMARY KEY डिफ़ॉल्ट रूप से NONCLUSTERED .

उदाहरण 5 - अशक्त कॉलम पर प्राथमिक कुंजी बनाएं

प्राथमिक कुंजी केवल उन स्तंभों के लिए बनाई जा सकती है जिन्हें NOT NULL . के रूप में परिभाषित किया गया है . यदि आप NULL . पर सेट कॉलम पर प्राथमिक कुंजी बनाने का प्रयास करते हैं , आपको एक त्रुटि मिलेगी।

हालाँकि, यदि आप अशक्तता निर्दिष्ट नहीं करते हैं, तो कॉलम NOT NULL . पर सेट है डिफ़ॉल्ट रूप से।

इसे प्रदर्शित करने के लिए, आइए एक और तालिका बनाएं, लेकिन इस बार, हम इसे NULL पर सेट करेंगे। :

USE PK_Test;

CREATE TABLE Dogs
(
    DogId int IDENTITY (1,1) NULL PRIMARY KEY,
    DogName varchar(50)
);

परिणाम:

Msg 8147, Level 16, State 1, Line 3
Could not create IDENTITY attribute on nullable column 'DogId', table 'Dogs'.
Msg 8111, Level 16, State 1, Line 3
Cannot define PRIMARY KEY constraint on nullable column in table 'Dogs'.
Msg 1750, Level 16, State 0, Line 3
Could not create constraint or index. See previous errors.

जैसा कि अपेक्षित था, हमें एक त्रुटि मिलती है।

आइए NULL को हटा दें तालिका परिभाषा से और पुनः प्रयास करें:

USE PK_Test;

CREATE TABLE Dogs
(
    DogId int IDENTITY (1,1) PRIMARY KEY,
    DogName varchar(50)
);

परिणाम:

Commands completed successfully.
Total execution time: 00:00:00.015

इस बार तालिका सफलतापूर्वक बनाई गई थी।

आइए इसे देखें:

SELECT 
  t.name AS 'Table',
  c.name AS 'Column', 
  c.is_nullable,
  c.is_identity
FROM sys.columns c
INNER JOIN sys.tables T
ON c.object_id = t.object_id
WHERE c.name = 'DogId';

परिणाम:

+---------+----------+---------------+---------------+
| Table   | Column   | is_nullable   | is_identity   |
|---------+----------+---------------+---------------|
| Dogs    | DogId    | 0             | 1             |
+---------+----------+---------------+---------------+

इसलिए हम देख सकते हैं कि यह अशक्त नहीं है, क्योंकि is_nullable ध्वज 0 . पर सेट है ।

उदाहरण 6 - एकाधिक स्तंभों पर प्राथमिक कुंजी

आप एकाधिक स्तंभों पर प्राथमिक कुंजी भी बना सकते हैं। बहुस्तंभ प्राथमिक कुंजी को समग्र प्राथमिक कुंजी के रूप में भी जाना जाता है। एक समग्र प्राथमिक कुंजी बनाने के लिए, कुंजी को परिभाषित करते समय केवल स्तंभों को अल्पविराम से अलग करें।

इस तरह:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

यहां एक ऐसी स्थिति का उदाहरण दिया गया है जहां एक बहु-स्तंभ प्राथमिक कुंजी का उपयोग किया जा सकता है:

CREATE TABLE Musician (
MusicianId int NOT NULL,
FirstName varchar(60),
LastName varchar(60),
CONSTRAINT PK_Musician PRIMARY KEY (MusicianID)
);

CREATE TABLE Band (
BandId int NOT NULL,
BandName varchar(255),
CONSTRAINT PK_Band PRIMARY KEY (BandId)
);

CREATE TABLE BandMember (
MusicianId int NOT NULL,
BandId int NOT NULL,
CONSTRAINT PK_BandMember PRIMARY KEY (MusicianID, BandId),
CONSTRAINT FK_BandMember_Band FOREIGN KEY (BandId) REFERENCES Band(BandId),
CONSTRAINT FK_BandMember_Musician FOREIGN KEY (MusicianId) REFERENCES Musician(MusicianId)
);

इस उदाहरण में, BandMember तालिका में एक बहु-स्तंभ प्राथमिक कुंजी है। इस मामले में प्राथमिक कुंजी में प्रत्येक स्तंभ किसी अन्य तालिका की प्राथमिक कुंजी के लिए एक विदेशी कुंजी भी है, लेकिन यह कोई आवश्यकता नहीं है।

इस उदाहरण की अधिक विस्तृत व्याख्या के लिए SQL सर्वर में समग्र प्राथमिक कुंजी कैसे बनाएं देखें।

यह भी देखें कि SQL सर्वर में एक समग्र विदेशी कुंजी कैसे बनाएं एक उदाहरण के लिए जो इसे एक बहु-स्तंभ विदेशी कुंजी के साथ एक कदम आगे ले जाता है जो उपरोक्त समग्र प्राथमिक कुंजी का संदर्भ देता है।