I SQL Server kan du bruge OBJECT_ID() funktion til at returnere et objekts ID, baseret på dets navn.
Dette kan være nyttigt, når du har brug for et objekts ID, men du kun kender dets navn.
Den officielle definition af OBJECT_ID() er, at den returnerer databaseobjektets identifikationsnummer for et skema-omfattet objekt
.
Eksempel 1 – Grundlæggende brug
Her er et grundlæggende eksempel for at demonstrere, hvordan det virker.
SELECT OBJECT_ID('Artists') AS Result;
Resultat:
+-----------+ | Result | |-----------| | 885578193 | +-----------+
I dette tilfælde indeholder den aktuelle database et objekt kaldet Albums , og dens ID er 885578193. Dette er ID'et, som du kan finde i object_id kolonne i sys.objects systemkatalogvisning.
Eksempel 2 – Tjek sys.objects View
Her er et andet grundlæggende eksempel for at bekræfte, hvad jeg lige har sagt.
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 systemkatalogvisningen indeholder en række for hvert brugerdefineret, skema-omfattet objekt, der oprettes i en database.
I dette eksempel viser de første to kolonner objektets name og object_id henholdsvis.
I den tredje kolonne i dette eksempel bruger jeg OBJECT_ID() for at returnere objektets ID baseret på dets navn. For at gøre dette sender jeg navnekolonnen til OBJECT_ID() funktion.
Dette er åbenbart kun et eksempel og bruger OBJECT_ID() var unødvendig i dette tilfælde, fordi sys.objects returnerer allerede objektets ID.
Eksempel 3 – Et mere brugbart eksempel
I dette eksempel bruger jeg OBJECT_ID() i en WHERE klausul, så jeg kun får resultater relateret til tabellen kaldet 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 dette tilfælde ville jeg se, hvilke entiteter der er afhængige af Client tabel (dvs. hvilke enheder der refererer til den tabel i deres SQL-kode). referenced_id kolonne bruger objektets ID, så ved at bruge OBJECT_ID() , var jeg i stand til at få ID'et for Client tabel og sammenlign den med referenced_id .
Se Find afhængigheder i SQL Server:sql_expression_dependencies for en mere detaljeret forklaring af denne forespørgsel og relaterede eksempler.
Eksempel 4 – Fuldt kvalificerede navne
Du har også mulighed for at kvalificere objektnavnet med skemanavnet og også databasenavnet, hvis det ønskes.
Her er et simpelt eksempel til at demonstrere:
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 | +---------------+---------------+---------------+
Her er det igen, denne gang med firkantede parenteser som afgrænsninger:
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 | +---------------+---------------+---------------+
Samme resultat.
Hvis du nogensinde får et NULL-resultat, selvom du ved, at objektet eksisterer, så prøv at kvalificere det med skemaet (og endda databasenavnet).
Eksempel 5 – Forespørgsler på tværs af databaser
Som standard antager SQL Server, at objektnavnet er i konteksten af den aktuelle database. Du kan bruge et 3-delt navn til at angive et objekt i en anden database.
Her er den samme kode fra det forrige eksempel, bortset fra at denne gang kører jeg koden to gange:første gang den køres i Music database, anden gang den køres i WideWorldImportersDW database:
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ørste resultat returnerer alle tre kolonner det korrekte ID. Dette skyldes, at objektet tilfældigvis er i Music database.
I det andet resultat er det kun de 3 dele, der er i stand til at finde det rigtige objekt. Dette kan forventes, fordi navnene på 1 del og 2 del ikke angiver navnet på databasen, derfor antager det, at objektet er i WideWorldImportersDW (forkert) database.
Eksempel 6 – Angiv objekttypen
OBJECT_ID() funktion accepterer også et argument for objekttypen. Dette argument, hvis det er angivet, kommer efter objektets navn.
Eksempel:
SELECT
OBJECT_ID('Artists', 'U') AS [Table];
Resultat:
+-----------+ | Table | |-----------| | 885578193 | +-----------+
Her angiver jeg, at objekttypen er U , hvilket betyder "Tabel (brugerdefineret)".
Hvis jeg prøver at angive en anden objekttype, får jeg 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 | +-----------+--------+--------------------+
Her er den igen, men med navnet på en udsigt i stedet:
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 | +---------+------------+--------------------+