In SQL Server kunt u de OBJECT_ID() functie om de ID van een object te retourneren op basis van de naam.
Dit kan handig zijn als u de ID van een object nodig heeft, maar u alleen de naam weet.
De officiële definitie van OBJECT_ID() is dat het het identificatienummer van het databaseobject van een object met schemabereik retourneert
.
Voorbeeld 1 – Basisgebruik
Hier is een eenvoudig voorbeeld om te laten zien hoe het werkt.
SELECT OBJECT_ID('Artists') AS Result;
Resultaat:
+-----------+ | Result | |-----------| | 885578193 | +-----------+
In dit geval bevat de huidige database wel een object genaamd Albums , en de ID is 885578193. Dit is de ID die u kunt vinden in de object_id kolom van de sys.objects systeemcatalogusweergave.
Voorbeeld 2 – Controleer de weergave sys.objects
Hier is nog een eenvoudig voorbeeld om te verifiëren wat ik zojuist heb gezegd.
SELECT name, object_id, OBJECT_ID(name) AS [OBJECT_ID(name)] FROM sys.objects WHERE name = 'Artists';
Resultaat:
+---------+-------------+-------------------+ | name | object_id | OBJECT_ID(name) | |---------+-------------+-------------------| | Artists | 885578193 | 885578193 | +---------+-------------+-------------------+
De sys.objects systeemcatalogusweergave bevat een rij voor elk door de gebruiker gedefinieerd object met schemabereik dat in een database is gemaakt.
In dit voorbeeld geven de eerste twee kolommen de name van het object weer en object_id respectievelijk.
In de derde kolom van dit voorbeeld gebruik ik OBJECT_ID() om de ID van het object te retourneren op basis van de naam. Om dit te doen, geef ik de naamkolom door aan de OBJECT_ID() functie.
Dit is uiteraard slechts een voorbeeld, en gebruik OBJECT_ID() was in dit geval niet nodig, omdat sys.objects geeft al de ID van het object terug.
Voorbeeld 3 – Een nuttiger voorbeeld
In dit voorbeeld gebruik ik OBJECT_ID() in een WHERE clausule zodat ik alleen resultaten krijg met betrekking tot de tabel met de naam 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');
Resultaat:
+----------------------+----------------------------+------------------+------------+ | 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 | +----------------------+----------------------------+------------------+------------+
In dit geval wilde ik zien welke entiteiten afhankelijk zijn van de Client tabel (d.w.z. welke entiteiten verwijzen naar die tabel in hun SQL-code). De referenced_id kolom gebruikt de ID van het object, dus door OBJECT_ID() . te gebruiken , ik heb de ID van de Client kunnen krijgen tabel en vergelijk het met referenced_id .
Zie Zoek afhankelijkheden in SQL Server:sql_expression_dependencies voor een meer gedetailleerde uitleg van deze query en gerelateerde voorbeelden.
Voorbeeld 4 – Volledig gekwalificeerde namen
U heeft ook de mogelijkheid om de objectnaam te kwalificeren met de schemanaam en desgewenst ook de databasenaam.
Hier is een eenvoudig voorbeeld om te demonstreren:
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];
Resultaat:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Hier is het weer, deze keer met vierkante haken als scheidingstekens:
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];
Resultaat:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Zelfde resultaat.
Als je ooit een NULL-resultaat krijgt, ook al weet je dat het object bestaat, probeer het dan te kwalificeren met het schema (en zelfs de databasenaam).
Voorbeeld 5 – Cross-databasequery's
Standaard gaat SQL Server ervan uit dat de objectnaam zich in de context van de huidige database bevindt. U kunt een 3-delige naam gebruiken om een object in een andere database te specificeren.
Hier is dezelfde code uit het vorige voorbeeld, maar deze keer voer ik de code twee keer uit:de eerste keer dat deze wordt uitgevoerd in de Music database, de tweede keer dat het wordt uitgevoerd in de WideWorldImportersDW databank:
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];
Resultaat:
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)
In het eerste resultaat retourneren alle drie de kolommen de juiste ID. Dit komt omdat het object zich in de Music . bevindt database.
In het tweede resultaat kan alleen de 3-delige naam het juiste object vinden. Dit is te verwachten, omdat de namen van 1 deel en 2 delen niet de naam van de database specificeren, daarom wordt aangenomen dat het object zich in de WideWorldImportersDW bevindt (verkeerde) database.
Voorbeeld 6 – Specificeer het objecttype
De OBJECT_ID() functie accepteert ook een argument voor het objecttype. Dit argument komt, indien opgegeven, achter de naam van het object.
Voorbeeld:
SELECT
OBJECT_ID('Artists', 'U') AS [Table];
Resultaat:
+-----------+ | Table | |-----------| | 885578193 | +-----------+
Hier specificeer ik dat het objecttype U . is , wat "Tabel (door gebruiker gedefinieerd)" betekent.
Als ik een ander objecttype probeer op te geven, krijg ik NULL :
SELECT
OBJECT_ID('Artists', 'U') AS [Table],
OBJECT_ID('Artists', 'V') AS [View],
OBJECT_ID('Artists', 'P') AS [Stored Procedure];
Resultaat:
+-----------+--------+--------------------+ | Table | View | Stored Procedure | |-----------+--------+--------------------| | 885578193 | NULL | NULL | +-----------+--------+--------------------+
Hier is het weer, maar met de naam van een weergave in plaats daarvan:
SELECT
OBJECT_ID('RockAlbums', 'U') AS [Table],
OBJECT_ID('RockAlbums', 'V') AS [View],
OBJECT_ID('RockAlbums', 'P') AS [Stored Procedure];
Resultaat:
+---------+------------+--------------------+ | Table | View | Stored Procedure | |---------+------------+--------------------| | NULL | 1525580473 | NULL | +---------+------------+--------------------+