SQL सर्वर में, आप OBJECT_ID() . का उपयोग कर सकते हैं किसी ऑब्जेक्ट की आईडी उसके नाम के आधार पर वापस करने के लिए कार्य करता है।
यह तब उपयोगी हो सकता है जब आपको किसी वस्तु की आईडी की आवश्यकता हो, लेकिन आप केवल उसका नाम जानते हैं।
OBJECT_ID() . की आधिकारिक परिभाषा यह है कि यह स्कीमा-स्कोप्ड ऑब्जेक्ट की डेटाबेस ऑब्जेक्ट पहचान संख्या देता है
।
उदाहरण 1 - मूल उपयोग
यह कैसे काम करता है, यह दिखाने के लिए यहां एक बुनियादी उदाहरण दिया गया है।
SELECT OBJECT_ID('Artists') AS Result;
परिणाम:
+-----------+ | Result | |-----------| | 885578193 | +-----------+
इस मामले में, वर्तमान डेटाबेस में Albums . नामक एक ऑब्जेक्ट होता है , और इसकी आईडी 885578193 है। यह वह आईडी है जिसे आप object_id में पा सकते हैं sys.objects . का कॉलम सिस्टम कैटलॉग व्यू।
उदाहरण 2 - sys.objects देखें देखें
मैंने अभी जो कहा है उसे सत्यापित करने के लिए यहां एक और बुनियादी उदाहरण दिया गया है।
SELECT name, object_id, OBJECT_ID(name) AS [OBJECT_ID(name)] FROM sys.objects WHERE name = 'Artists';
परिणाम:
+---------+-------------+-------------------+ | name | object_id | OBJECT_ID(name) | |---------+-------------+-------------------| | Artists | 885578193 | 885578193 | +---------+-------------+-------------------+
sys.objects सिस्टम कैटलॉग दृश्य में प्रत्येक उपयोगकर्ता-परिभाषित, स्कीमा-स्कोप्ड ऑब्जेक्ट के लिए एक पंक्ति होती है जो एक डेटाबेस के भीतर बनाई जाती है।
इस उदाहरण में, पहले दो कॉलम ऑब्जेक्ट का name . प्रदर्शित करते हैं और object_id क्रमश।
इस उदाहरण के तीसरे कॉलम में, मैं OBJECT_ID() . का उपयोग करता हूं ऑब्जेक्ट की आईडी उसके नाम के आधार पर वापस करने के लिए। ऐसा करने के लिए, मैं नाम कॉलम को OBJECT_ID() . पर पास करता हूं समारोह।
यह स्पष्ट रूप से सिर्फ एक उदाहरण है, और OBJECT_ID() . का उपयोग करके इस मामले में अनावश्यक था, क्योंकि sys.objects पहले से ही वस्तु की आईडी लौटाता है।
उदाहरण 3 - एक अधिक उपयोगी उदाहरण
इस उदाहरण में, मैं OBJECT_ID() . का उपयोग करता हूं एक WHERE . में खंड ताकि मुझे केवल Client . नामक तालिका से संबंधित परिणाम मिले ।
SELECT
OBJECT_NAME(referencing_id) AS [Referencing Entity],
OBJECT_NAME(referencing_minor_id) AS [Referencing Minor Entity],
referencing_class_desc AS [Class],
COL_NAME(referenced_id, referenced_minor_id) AS [Column]
FROM sys.sql_expression_dependencies
WHERE referenced_id = OBJECT_ID('Client');
परिणाम:
+----------------------+----------------------------+------------------+------------+ | Referencing Entity | Referencing Minor Entity | Class | Column | |----------------------+----------------------------+------------------+------------| | uspGetClient | NULL | OBJECT_OR_COLUMN | NULL | | uspGetOrdersByClient | NULL | OBJECT_OR_COLUMN | NULL | | chkClientCode | NULL | OBJECT_OR_COLUMN | ClientCode | +----------------------+----------------------------+------------------+------------+
इस मामले में मैं देखना चाहता था कि कौन सी संस्थाएं Client . पर निर्भर करती हैं तालिका (यानी कौन सी संस्थाएं उस तालिका को उनके SQL कोड में संदर्भित करती हैं)। referenced_id कॉलम ऑब्जेक्ट की आईडी का उपयोग करता है, इसलिए OBJECT_ID() . का उपयोग करके , मैं Client . की आईडी प्राप्त करने में सक्षम था तालिका और इसकी तुलना referenced_id . से करें ।
इस क्वेरी और संबंधित उदाहरणों की अधिक विस्तृत व्याख्या के लिए SQL सर्वर में निर्भरता खोजें:sql_expression_dependencies देखें।
उदाहरण 4 - पूरी तरह से योग्य नाम
आपके पास ऑब्जेक्ट नाम को स्कीमा नाम के साथ अर्हता प्राप्त करने का विकल्प भी है, और यदि वांछित है तो डेटाबेस नाम भी।
प्रदर्शित करने के लिए यहां एक सरल उदाहरण दिया गया है:
SELECT
OBJECT_ID('Artists') AS [1 Part Name],
OBJECT_ID('dbo.Artists') AS [2 Part Name],
OBJECT_ID('Music.dbo.Artists') AS [3 Part Name];
परिणाम:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
यहाँ यह फिर से है, इस बार सीमांकक के रूप में वर्गाकार कोष्ठकों का उपयोग करना:
SELECT
OBJECT_ID('[Artists]') AS [1 Part Name],
OBJECT_ID('[dbo].[Artists]') AS [2 Part Name],
OBJECT_ID('[Music].[dbo].[Artists]') AS [3 Part Name];
परिणाम:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
वही परिणाम।
यदि आप जानते हैं कि वस्तु मौजूद है, भले ही आपको कभी भी एक पूर्ण परिणाम मिलता है, तो इसे स्कीमा (और यहां तक कि डेटाबेस नाम) के साथ अर्हता प्राप्त करने का प्रयास करें।
उदाहरण 5 - क्रॉस डेटाबेस क्वेरीज़
डिफ़ॉल्ट रूप से, SQL सर्वर मानता है कि ऑब्जेक्ट का नाम वर्तमान डेटाबेस के संदर्भ में है। किसी भिन्न डेटाबेस में किसी ऑब्जेक्ट को निर्दिष्ट करने के लिए आप 3 भाग के नाम का उपयोग कर सकते हैं।
यहां पिछले उदाहरण से समान कोड दिया गया है, इस समय को छोड़कर मैं कोड को दो बार चलाता हूं:पहली बार यह Music में चलाया जाता है डेटाबेस, दूसरी बार इसे WideWorldImportersDW . में चलाया जाता है डेटाबेस:
USE Music;
SELECT
OBJECT_ID('Artists') AS [1 Part Name],
OBJECT_ID('dbo.Artists') AS [2 Part Name],
OBJECT_ID('Music.dbo.Artists') AS [3 Part Name];
USE WideWorldImportersDW;
SELECT
OBJECT_ID('Artists') AS [1 Part Name],
OBJECT_ID('dbo.Artists') AS [2 Part Name],
OBJECT_ID('Music.dbo.Artists') AS [3 Part Name];
परिणाम:
Changed database context to 'Music'. +---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+ (1 row affected) Changed database context to 'WideWorldImportersDW'. +---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | NULL | NULL | 885578193 | +---------------+---------------+---------------+ (1 row affected)
पहले परिणाम में, तीनों कॉलम सही आईडी लौटाते हैं। ऐसा इसलिए है क्योंकि ऑब्जेक्ट Music . में होता है डेटाबेस।
दूसरे परिणाम में, केवल 3 भाग का नाम ही सही वस्तु खोजने में सक्षम है। यह अपेक्षित है, क्योंकि 1 भाग और 2 भाग के नाम डेटाबेस का नाम निर्दिष्ट नहीं करते हैं, इसलिए यह मान लिया जाता है कि ऑब्जेक्ट WideWorldImportersDW में है। (गलत) डेटाबेस।
उदाहरण 6 - ऑब्जेक्ट प्रकार निर्दिष्ट करें
OBJECT_ID() फ़ंक्शन ऑब्जेक्ट प्रकार के लिए एक तर्क भी स्वीकार करता है। यह तर्क, यदि प्रदान किया जाता है, तो वस्तु के नाम के बाद आता है।
उदाहरण:
SELECT
OBJECT_ID('Artists', 'U') AS [Table];
परिणाम:
+-----------+ | Table | |-----------| | 885578193 | +-----------+
यहाँ, मैं निर्दिष्ट करता हूँ कि वस्तु का प्रकार U है , जिसका अर्थ है "तालिका (उपयोगकर्ता-परिभाषित)"।
यदि मैं एक भिन्न ऑब्जेक्ट प्रकार निर्दिष्ट करने का प्रयास करता हूं, तो मुझे NULL . मिलता है :
SELECT
OBJECT_ID('Artists', 'U') AS [Table],
OBJECT_ID('Artists', 'V') AS [View],
OBJECT_ID('Artists', 'P') AS [Stored Procedure];
परिणाम:
+-----------+--------+--------------------+ | Table | View | Stored Procedure | |-----------+--------+--------------------| | 885578193 | NULL | NULL | +-----------+--------+--------------------+
यहाँ यह फिर से है, लेकिन इसके बजाय एक दृश्य के नाम के साथ:
SELECT
OBJECT_ID('RockAlbums', 'U') AS [Table],
OBJECT_ID('RockAlbums', 'V') AS [View],
OBJECT_ID('RockAlbums', 'P') AS [Stored Procedure];
परिणाम:
+---------+------------+--------------------+ | Table | View | Stored Procedure | |---------+------------+--------------------| | NULL | 1525580473 | NULL | +---------+------------+--------------------+
