I SQL Server kan du använda OBJECT_ID() funktion för att returnera ett objekts ID, baserat på dess namn.
Detta kan vara användbart när du behöver ett objekts ID, men du bara känner till dess namn.
Den officiella definitionen av OBJECT_ID() är att den returerar databasobjektets identifieringsnummer för ett schema-omfattat objekt
.
Exempel 1 – Grundläggande användning
Här är ett grundläggande exempel för att visa hur det fungerar.
SELECT OBJECT_ID('Artists') AS Result;
Resultat:
+-----------+ | Result | |-----------| | 885578193 | +-----------+
I det här fallet innehåller den aktuella databasen ett objekt som heter Albums , och dess ID är 885578193. Detta är ID:t som du kan hitta i object_id kolumnen i sys.objects systemkatalogvy.
Exempel 2 – Kontrollera vyn sys.objects
Här är ett annat grundläggande exempel för att verifiera det jag just sa.
SELECT name, object_id, OBJECT_ID(name) AS [OBJECT_ID(name)] FROM sys.objects WHERE name = 'Artists';
Resultat:
+---------+-------------+-------------------+ | name | object_id | OBJECT_ID(name) | |---------+-------------+-------------------| | Artists | 885578193 | 885578193 | +---------+-------------+-------------------+
sys.objects systemkatalogvyn innehåller en rad för varje användardefinierat objekt med schemaomfattning som skapas i en databas.
I det här exemplet visar de två första kolumnerna objektets name och object_id respektive.
I den tredje kolumnen i detta exempel använder jag OBJECT_ID() för att returnera objektets ID baserat på dess namn. För att göra detta skickar jag namnkolumnen till OBJECT_ID() funktion.
Detta är uppenbarligen bara ett exempel och använder OBJECT_ID() var onödigt i det här fallet eftersom sys.objects returnerar redan objektets ID.
Exempel 3 – Ett mer användbart exempel
I det här exemplet använder jag OBJECT_ID() i en WHERE klausul så att jag bara får resultat relaterade till tabellen som heter 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');
Resultat:
+----------------------+----------------------------+------------------+------------+ | 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 | +----------------------+----------------------------+------------------+------------+
I det här fallet ville jag se vilka enheter som är beroende av Client tabell (dvs. vilka enheter som refererar till den tabellen i sin SQL-kod). referenced_id kolumnen använder objektets ID, så genom att använda OBJECT_ID() , kunde jag få ID för Client tabell och jämför den med referenced_id .
Se Hitta beroenden i SQL Server:sql_expression_dependencies för en mer detaljerad förklaring av denna fråga och relaterade exempel.
Exempel 4 – Fullständigt kvalificerade namn
Du har också möjlighet att kvalificera objektnamnet med schemanamnet och även databasnamnet om så önskas.
Här är ett enkelt exempel att visa:
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];
Resultat:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Här är den igen, denna gång med hakparenteser som avgränsare:
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];
Resultat:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Samma resultat.
Om du någonsin får ett NULL-resultat trots att du vet att objektet finns, försök att kvalificera det med schemat (och till och med databasnamnet).
Exempel 5 – Korsdatabasfrågor
Som standard antar SQL Server att objektnamnet är i sammanhanget för den aktuella databasen. Du kan använda ett tredelat namn för att specificera ett objekt i en annan databas.
Här är samma kod från föregående exempel, förutom den här gången kör jag koden två gånger:första gången den körs i Music databas, andra gången den körs i WideWorldImportersDW databas:
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];
Resultat:
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)
I det första resultatet returnerar alla tre kolumnerna rätt ID. Detta beror på att objektet råkar vara i Music databas.
I det andra resultatet är det bara tredelarnas namn som kan hitta rätt objekt. Detta kan förväntas, eftersom 1 delen och 2 delens namn inte anger namnet på databasen, därför antar det att objektet finns i WideWorldImportersDW (fel) databas.
Exempel 6 – Ange objekttyp
OBJECT_ID() funktion accepterar också ett argument för objekttypen. Detta argument, om det tillhandahålls, kommer efter objektets namn.
Exempel:
SELECT
OBJECT_ID('Artists', 'U') AS [Table];
Resultat:
+-----------+ | Table | |-----------| | 885578193 | +-----------+
Här anger jag att objekttypen är U , vilket betyder "Tabell (användardefinierad)".
Om jag försöker ange en annan objekttyp får jag NULL :
SELECT
OBJECT_ID('Artists', 'U') AS [Table],
OBJECT_ID('Artists', 'V') AS [View],
OBJECT_ID('Artists', 'P') AS [Stored Procedure];
Resultat:
+-----------+--------+--------------------+ | Table | View | Stored Procedure | |-----------+--------+--------------------| | 885578193 | NULL | NULL | +-----------+--------+--------------------+
Här är den igen, men med namnet på en vy istället:
SELECT
OBJECT_ID('RockAlbums', 'U') AS [Table],
OBJECT_ID('RockAlbums', 'V') AS [View],
OBJECT_ID('RockAlbums', 'P') AS [Stored Procedure];
Resultat:
+---------+------------+--------------------+ | Table | View | Stored Procedure | |---------+------------+--------------------| | NULL | 1525580473 | NULL | +---------+------------+--------------------+