In SQL Server puoi utilizzare OBJECT_ID() funzione per restituire l'ID di un oggetto, in base al suo nome.
Questo può essere utile quando hai bisogno dell'ID di un oggetto, ma ne conosci solo il nome.
La definizione ufficiale di OBJECT_ID() è che restituisce il numero di identificazione dell'oggetto del database di un oggetto con ambito schema
.
Esempio 1 – Utilizzo di base
Ecco un esempio di base per dimostrare come funziona.
SELECT OBJECT_ID('Artists') AS Result;
Risultato:
+-----------+ | Result | |-----------| | 885578193 | +-----------+
In questo caso, il database corrente contiene un oggetto chiamato Albums e il suo ID è 885578193. Questo è l'ID che puoi trovare in object_id colonna di sys.objects vista catalogo di sistema.
Esempio 2:controlla la vista sys.objects
Ecco un altro esempio di base per verificare ciò che ho appena detto.
SELECT name, object_id, OBJECT_ID(name) AS [OBJECT_ID(name)] FROM sys.objects WHERE name = 'Artists';
Risultato:
+---------+-------------+-------------------+ | name | object_id | OBJECT_ID(name) | |---------+-------------+-------------------| | Artists | 885578193 | 885578193 | +---------+-------------+-------------------+
Il sys.objects la vista del catalogo di sistema contiene una riga per ogni oggetto definito dall'utente con ambito schema creato all'interno di un database.
In questo esempio, le prime due colonne mostrano il name dell'oggetto e object_id rispettivamente.
Nella terza colonna di questo esempio, utilizzo OBJECT_ID() per restituire l'ID dell'oggetto in base al suo nome. Per fare ciò, passo la colonna del nome a OBJECT_ID() funzione.
Questo è ovviamente solo un esempio e usando OBJECT_ID() non era necessario in questo caso, perché sys.objects restituisce già l'ID dell'oggetto.
Esempio 3:un esempio più utile
In questo esempio, utilizzo OBJECT_ID() in un WHERE clausola in modo da ottenere solo risultati relativi alla tabella denominata 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');
Risultato:
+----------------------+----------------------------+------------------+------------+ | 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 questo caso volevo vedere quali entità dipendono dal Client tabella (ovvero quali entità fanno riferimento a quella tabella nel loro codice SQL). Il referenced_id colonna utilizza l'ID dell'oggetto, quindi utilizzando OBJECT_ID() , sono riuscito a ottenere l'ID del Client tabella e confrontala con referenced_id .
Vedere Trova dipendenze in SQL Server:sql_expression_dependencies per una spiegazione più dettagliata di questa query ed esempi correlati.
Esempio 4 – Nomi completi
Hai anche la possibilità di qualificare il nome dell'oggetto con il nome dello schema e, se lo desideri, anche il nome del database.
Ecco un semplice esempio da dimostrare:
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];
Risultato:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Eccolo di nuovo, questa volta usando parentesi quadre come delimitatori:
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];
Risultato:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Stesso risultato.
Se ottieni un risultato NULL anche se sai che l'oggetto esiste, prova a qualificarlo con lo schema (e anche con il nome del database).
Esempio 5 – Query tra database
Per impostazione predefinita, SQL Server presuppone che il nome dell'oggetto sia nel contesto del database corrente. È possibile utilizzare un nome di 3 parti per specificare un oggetto in un database diverso.
Ecco lo stesso codice dell'esempio precedente, tranne che questa volta eseguo il codice due volte:la prima volta viene eseguito in Music database, la seconda volta che viene eseguito nel WideWorldImportersDW banca dati:
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];
Risultato:
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)
Nel primo risultato, tutte e tre le colonne restituiscono l'ID corretto. Questo perché l'oggetto si trova in Music banca dati.
Nel secondo risultato, solo il nome della parte 3 è in grado di trovare l'oggetto corretto. Questo è prevedibile, perché i nomi 1 parte e 2 parti non specificano il nome del database, quindi presuppone che l'oggetto sia nel WideWorldImportersDW banca dati (errata).
Esempio 6 – Specificare il tipo di oggetto
Il OBJECT_ID() La funzione accetta anche un argomento per il tipo di oggetto. Questo argomento, se fornito, viene dopo il nome dell'oggetto.
Esempio:
SELECT
OBJECT_ID('Artists', 'U') AS [Table];
Risultato:
+-----------+ | Table | |-----------| | 885578193 | +-----------+
Qui, specifico che il tipo di oggetto è U , che significa "Tabella (definita dall'utente)".
Se provo a specificare un tipo di oggetto diverso, ottengo NULL :
SELECT
OBJECT_ID('Artists', 'U') AS [Table],
OBJECT_ID('Artists', 'V') AS [View],
OBJECT_ID('Artists', 'P') AS [Stored Procedure];
Risultato:
+-----------+--------+--------------------+ | Table | View | Stored Procedure | |-----------+--------+--------------------| | 885578193 | NULL | NULL | +-----------+--------+--------------------+
Eccolo di nuovo, ma con il nome di una vista invece:
SELECT
OBJECT_ID('RockAlbums', 'U') AS [Table],
OBJECT_ID('RockAlbums', 'V') AS [View],
OBJECT_ID('RockAlbums', 'P') AS [Stored Procedure];
Risultato:
+---------+------------+--------------------+ | Table | View | Stored Procedure | |---------+------------+--------------------| | NULL | 1525580473 | NULL | +---------+------------+--------------------+
