SQL सर्वर में, आप sp_special_columns . का उपयोग कर सकते हैं तालिका के लिए एक विशिष्ट पहचानकर्ता की पहचान करने के लिए सिस्टम संग्रहीत प्रक्रिया। विशेष रूप से, यह कॉलम का इष्टतम सेट देता है जो तालिका में एक पंक्ति की विशिष्ट रूप से पहचान करता है। जब लेन-देन द्वारा पंक्ति में कोई मान अपडेट किया जाता है, तो यह स्वचालित रूप से अपडेट किए गए कॉलम भी लौटाता है।
sp_special_columns ODBC में SQLSpecialColumns के बराबर है।
यदि ऐसे कोई स्तंभ नहीं हैं जो तालिका की विशिष्ट रूप से पहचान कर सकते हैं, तो परिणाम सेट खाली है।
सिंटैक्स
वाक्य रचना इस प्रकार है:
sp_special_columns [ @table_name = ] 'table_name'
[ , [ @table_owner = ] 'table_owner' ]
[ , [ @qualifier = ] 'qualifier' ]
[ , [ @col_type = ] 'col_type' ]
[ , [ @scope = ] 'scope' ]
[ , [ @nullable = ] 'nullable' ]
[ , [ @ODBCVer = ] 'ODBCVer' ]
[ ; ]
@table_name तर्क की आवश्यकता है। अन्य वैकल्पिक हैं। प्रत्येक तर्क की विस्तृत व्याख्या के लिए Microsoft दस्तावेज़ देखें।
उदाहरण 1 - प्राथमिक कुंजी कॉलम
यहां PersonId . नामक प्राथमिक कुंजी कॉलम वाली तालिका के सामने एक बुनियादी उदाहरण दिया गया है :
EXEC sp_special_columns Person;
इसे इस तरह भी चलाया जा सकता है:
EXEC sp_special_columns @table_name = 'Person';
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | PersonId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
इस मामले में, प्राथमिक कुंजी कॉलम वापस कर दिया जाता है। मुझे पता है कि यह प्राथमिक कुंजी कॉलम है, क्योंकि मैंने निम्नलिखित कोड के साथ तालिका बनाई है:
CREATE TABLE Person ( PersonId int primary key, PersonName varchar(500) );
तो ऐसा लगता है कि संग्रहीत कार्यविधि ने वास्तव में उस इष्टतम स्तंभ को वापस कर दिया है जो इस तालिका की विशिष्ट रूप से पहचान करता है।
उदाहरण 2 - अद्वितीय कॉलम
इस उदाहरण की तालिका में प्राथमिक कुंजी नहीं है, लेकिन इसमें एक UNIQUE है बाधा।
तालिका बनाने के लिए उपयोग किया गया कोड यहां दिया गया है:
CREATE TABLE Event ( EventId int UNIQUE, EventName varchar(500) );
तो चलिए अब sp_special_columns निष्पादित करते हैं उस तालिका के विरुद्ध:
EXEC sp_special_columns Event;
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | EventId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
इस मामले में, UNIQUE . वाला कॉलम बाधा को इष्टतम विशिष्ट पहचानकर्ता माना जाता है।
हालांकि, इसका मतलब यह नहीं है कि कोई एक UNIQUE . द्वारा सीमित स्तंभ बाधा स्वचालित रूप से एक विशिष्ट पहचानकर्ता के रूप में योग्य हो जाएगी। परिणाम इस बात पर निर्भर कर सकता है कि कैसे अशक्त मूल्यों का इलाज किया जाता है।
उदाहरण 3 - @nullable तर्क
आप @nullable . का उपयोग कर सकते हैं यह निर्दिष्ट करने के लिए तर्क कि क्या विशेष कॉलम एक शून्य मान स्वीकार कर सकते हैं।
यहां, मैं वही कोड फिर से चलाता हूं, इस समय को छोड़कर मैं @nullable = 'O' का उपयोग करता हूं ।
EXEC sp_special_columns Event, @nullable = 'O';
परिणाम:
(0 rows affected)
यहाँ यह @nullable = 'U' . का उपयोग कर रहा है
EXEC sp_special_columns Event, @nullable = 'U';
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | EventId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
O विशेष कॉलम निर्दिष्ट करता है जो शून्य मानों की अनुमति नहीं देता है। U उन स्तंभों को निर्दिष्ट करता है जो आंशिक रूप से अशक्त हैं। U डिफ़ॉल्ट मान है।
अगर मैं कॉलम को NOT NULL . के रूप में बनाता हूं तो यहां क्या होता है? :
DROP TABLE Event; CREATE TABLE Event ( EventId int NOT NULL UNIQUE, EventName varchar(500) ); EXEC sp_special_columns Event, @nullable = 'U'; EXEC sp_special_columns Event, @nullable = 'O';
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | EventId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ (1 row affected) +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | EventId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ (1 row affected)
इस बार दोनों O और U एक ही परिणाम उत्पन्न किया।
यदि आपके पास एक से अधिक UNIQUE वाली तालिका है बाधा कॉलम, और कुछ शून्य मानों की अनुमति देते हैं जबकि अन्य नहीं करते हैं, इस तर्क का प्रभाव हो सकता है जिस पर किसी को इष्टतम अद्वितीय पहचानकर्ता माना जाता है। मेरा क्या मतलब है, इसके उदाहरण के लिए इस आलेख के निचले भाग में उदाहरण 7 देखें।
उदाहरण 4 - पहचान कॉलम
इस उदाहरण की तालिका में प्राथमिक कुंजी या UNIQUE नहीं है बाधा है, लेकिन इसकी एक IDENTITY है कॉलम।
तालिका बनाने के लिए उपयोग किया गया कोड यहां दिया गया है:
CREATE TABLE Product ( ProductId int IDENTITY, ProductName varchar(500) );
तो चलिए अब sp_special_columns निष्पादित करते हैं उस तालिका के विरुद्ध:
EXEC sp_special_columns Product;
परिणाम:
(0 rows affected)
तो ऐसा लगता है कि IDENTITY इस तालिका को विशिष्ट रूप से पहचानने के लिए पर्याप्त नहीं है।
उदाहरण 5 - बहु-स्तंभ प्राथमिक कुंजी
यहाँ एक बहु-स्तंभ प्राथमिक कुंजी के साथ है। इस मामले में प्राथमिक कुंजी के लिए दो स्तंभों का उपयोग किया जाता है।
तालिका बनाने के लिए उपयोग किया गया कोड यहां दिया गया है:
CREATE TABLE PersonProduct ( PersonId int, ProductId int, CONSTRAINT PK_PersonProduct PRIMARY KEY (PersonId, ProductId) );
तो चलिए अब sp_special_columns निष्पादित करते हैं उस तालिका के विरुद्ध:
EXEC sp_special_columns PersonProduct;
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | PersonId | 4 | int | 10 | 4 | 0 | 1 | | 1 | ProductId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
उदाहरण 6 - प्राथमिक कुंजी और अद्वितीय बाधा
क्या होगा यदि कोई प्राथमिक कुंजी और है एक UNIQUE एक ही तालिका में बाधा?
आइए जानें:
CREATE TABLE PersonEvent ( PersonEventId int UNIQUE, PersonId int, EventId int, CONSTRAINT PK_PersonEvent PRIMARY KEY (PersonId, EventId) );
निष्पादित करें sp_special_columns उस तालिका के विरुद्ध:
EXEC sp_special_columns PersonEvent;
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | PersonId | 4 | int | 10 | 4 | 0 | 1 | | 1 | EventId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
प्राथमिक कुंजी जीत गई।
क्या होगा यदि हम प्राथमिक कुंजी और UNIQUE . को बदल दें चारों ओर प्रमुख कॉलम?
ठीक है, चलिए इसके लिए एक और पूरी टेबल बनाते हैं:
CREATE TABLE PersonEvent2 ( PersonEventId int PRIMARY KEY, PersonId int UNIQUE, EventId int UNIQUE );
निष्पादित करें sp_special_columns उस तालिका के विरुद्ध:
EXEC sp_special_columns PersonEvent2;
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | PersonEventId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
तो प्राथमिक कुंजी फिर से जीत गई।
उदाहरण 7 - अनेक अद्वितीय बाधाएं
क्या होगा अगर हर कॉलम में एक UNIQUE है बाधा?
CREATE TABLE Event2 ( EventId int UNIQUE, EventName varchar(500) UNIQUE, StartDate date UNIQUE, EndDate date UNIQUE );
निष्पादित करें sp_special_columns उस तालिका के विरुद्ध:
EXEC sp_special_columns Event2;
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | EndDate | -9 | date | 10 | 20 | NULL | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
लेकिन देखते हैं कि क्या होता है यदि हम उन स्तंभों में से एक को NOT NULL . पर सेट करते हैं , फिर @nullable = 'O' . का उपयोग करें :
DROP TABLE Event2; CREATE TABLE Event2 ( EventId int NOT NULL UNIQUE, EventName varchar(500) UNIQUE, StartDate date UNIQUE, EndDate date UNIQUE );
निष्पादित करें sp_special_columns @nullable = 'O' . के साथ :
EXEC sp_special_columns Event2, @nullable = 'O';
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | EventId | 4 | int | 10 | 4 | 0 | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
इसलिए "नॉनबलेबल नहीं" कॉलम को अब इष्टतम विशिष्ट पहचानकर्ता के रूप में चुना गया है।
अब sp_special_columns execute को निष्पादित करते हैं @nullable = 'U' . के साथ :
EXEC sp_special_columns Event2, @nullable = 'U';
परिणाम:
+---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+ | SCOPE | COLUMN_NAME | DATA_TYPE | TYPE_NAME | PRECISION | LENGTH | SCALE | PSEUDO_COLUMN | |---------+---------------+-------------+-------------+-------------+----------+---------+-----------------| | 1 | EndDate | -9 | date | 10 | 20 | NULL | 1 | +---------+---------------+-------------+-------------+-------------+----------+---------+-----------------+
अब यह पिछले कॉलम पर वापस आ गया है।
