Trova le dipendenze in SQL Server:sql_expression

In SQL Server puoi usare sys.sql_expression_dependencies vista del catalogo di sistema per restituire tutte le dipendenze su un'entità definita dall'utente nel database corrente. Ciò include le dipendenze tra le funzioni scalari definite dall'utente compilate in modo nativo e altri moduli di SQL Server.

Puoi utilizzare questa visualizzazione per:

Restituire entità che dipendono da una determinata entità
Entità di ritorno da cui dipende una determinata entità

Quindi, ad esempio, puoi usarlo per restituire tutti gli oggetti che fanno riferimento a una tabella specifica. Puoi anche usarlo per restituire tutti gli oggetti a cui fa riferimento una specifica procedura memorizzata all'interno del suo codice.

In particolare, le sys.sql_expression_dependencies visualizzare le informazioni sulle dipendenze dei rapporti per le seguenti entità:

Entità legate allo schema.
Entità non legate allo schema.
Entità cross-database e cross-server. I nomi delle entità sono riportati; tuttavia, gli ID entità non vengono risolti.
Dipendenze a livello di colonna da entità associate allo schema. Le dipendenze a livello di colonna per oggetti non associati a schemi possono essere restituite utilizzando sys.dm_sql_referenced_entities.
DDL a livello di server si attiva nel contesto del database master.

Esempio 1 – Tutte le colonne restituite

Ecco un rapido esempio che seleziona tutte le colonne da sys.sql_expression_dependencies . Questo ci mostra quali dati vengono effettivamente restituiti nella vista e possiamo utilizzare una qualsiasi di queste colonne nelle nostre query per restituire solo i dati che ci interessano.

SELECT TOP(1) * 
FROM sys.sql_expression_dependencies;

Risultato (usando l'output verticale):

referencing_id            | 114099447
referencing_minor_id      | 0
referencing_class         | 1
referencing_class_desc    | OBJECT_OR_COLUMN
is_schema_bound_reference | 0
referenced_class          | 1
referenced_class_desc     | OBJECT_OR_COLUMN
referenced_server_name    | NULL
referenced_database_name  | NULL
referenced_schema_name    | dbo
referenced_entity_name    | Client
referenced_id             | 434100587
referenced_minor_id       | 0
is_caller_dependent       | 0
is_ambiguous              | 0

Questo esempio utilizza l'output verticale in modo da semplificare la visualizzazione dei nomi delle colonne senza dover scorrere orizzontalmente. Pertanto, i nomi delle colonne sono elencati a sinistra ei rispettivi valori sono a destra.

Inoltre, per brevità ho usato TOP(1) per limitare i risultati solo alla prima riga.

Esempio 2 – Trova entità che dipendono da un'entità

Per trovare oggetti che dipendono da una determinata entità, utilizza il referencing_id di tale entità quando si seleziona dalla vista.

Esempio:

SELECT
    referenced_server_name AS [Referenced Server],
    referenced_database_name AS [Referenced DB],
    referenced_schema_name AS [Referenced Schema],
    referenced_entity_name AS [Referenced Entity],
    referenced_class_desc AS [Referenced Entity Class] 
FROM sys.sql_expression_dependencies
WHERE referencing_id = OBJECT_ID('uspGetClient');

Risultato:

+---------------------+-----------------+---------------------+---------------------+---------------------------+
| Referenced Server   | Referenced DB   | Referenced Schema   | Referenced Entity   | Referenced Entity Class   |
|---------------------+-----------------+---------------------+---------------------+---------------------------|
| NULL                | NULL            | dbo                 | Client              | OBJECT_OR_COLUMN          |
| NULL                | NULL            | NULL                | clientcode          | TYPE                      |
+---------------------+-----------------+---------------------+---------------------+---------------------------+

Qui ottengo tutte le entità a cui si fa riferimento in uspGetClient procedura memorizzata.

Ecco la definizione effettiva di uspGetClient :

CREATE PROCEDURE [dbo].[uspGetClient] @ClientCode clientcode AS
SELECT 
    FirstName,
    LastName
FROM [dbo].[Client]
WHERE ClientCode = @ClientCode;

Quindi possiamo vedere che seleziona i dati da una tabella chiamata Client e accetta un argomento chiamato @ClientCode con un tipo di dati (alias definito dall'utente) di clientcode .

Esempio 3 – Trova entità da cui dipende un'entità

Puoi anche cambiarlo e ottenere gli oggetti da cui dipende una determinata entità. Per farlo, usa referenced_id (invece di referencing_id ) quando si seleziona dalla vista.

Esempio:

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 esempio volevo vedere quali entità dipendono dal Client tabella (ovvero quali entità fanno riferimento a quella tabella nel loro codice SQL).

Noterai che ho selezionato anche colonne diverse. Questo perché sto cercando informazioni sui riferimenti entità, non il riferito entità come nell'esempio precedente.

Esempio 4:recuperare ulteriori informazioni

È possibile unire questa visualizzazione con altre visualizzazioni e/o tabelle per restituire ulteriori informazioni.

Ad esempio, puoi unirti con sys.objects per ottenere il tipo di oggetto di riferimento:

SELECT OBJECT_NAME(referencing_id) AS [Referencing Entity],   
    o.type_desc AS [Type],   
    COALESCE(COL_NAME(referencing_id, referencing_minor_id), '(n/a)') AS [Column],
    referenced_entity_name AS [Referenced Entity],   
    COALESCE(COL_NAME(referenced_id, referenced_minor_id), '(n/a)') AS [Column]
FROM sys.sql_expression_dependencies AS sed  
INNER JOIN sys.objects AS o ON sed.referencing_id = o.object_id  
WHERE referenced_id = OBJECT_ID(N'Client');

Risultato:

+----------------------+----------------------+----------+---------------------+------------+
| Referencing Entity   | Type                 | Column   | Referenced Entity   | Column     |
|----------------------+----------------------+----------+---------------------+------------|
| uspGetClient         | SQL_STORED_PROCEDURE | (n/a)    | Client              | (n/a)      |
| uspGetOrdersByClient | SQL_STORED_PROCEDURE | (n/a)    | Client              | (n/a)      |
| chkClientCode        | CHECK_CONSTRAINT     | (n/a)    | Client              | ClientCode |
+----------------------+----------------------+----------+---------------------+------------+

In questo esempio ho anche aggiunto il COALESCE() funzione per restituire (n/a) ogni volta che referencing_minor_id è NULL . Questa funzione è uno dei tanti modi in cui puoi sostituire un valore NULL con una stringa in SQL Server.

Esempio 5 – Entità tra database e server multipli

Come accennato, sql_expression_dependencies funziona anche su entità cross-database e cross-server. Tuttavia, in questo caso, i nomi delle entità vengono segnalati ma gli ID entità non vengono risolti.

Questo esempio utilizza esattamente lo stesso codice dell'esempio 2, tranne che questa volta è per un'entità diversa. Questa volta, voglio trovare entità che dipendono da uspGetAlbumsByArtist :

SELECT
    referenced_server_name AS [Referenced Server],
    referenced_database_name AS [Referenced DB],
    referenced_schema_name AS [Referenced Schema],
    referenced_entity_name AS [Referenced Entity],
    referenced_class_desc AS [Referenced Entity Class] 
FROM sys.sql_expression_dependencies
WHERE referencing_id = OBJECT_ID('uspGetAlbumsByArtist');

Risultato:

+---------------------+-----------------+---------------------+---------------------+---------------------------+
| Referenced Server   | Referenced DB   | Referenced Schema   | Referenced Entity   | Referenced Entity Class   |
|---------------------+-----------------+---------------------+---------------------+---------------------------|
| Homer               | Music           | dbo                 | Albums              | OBJECT_OR_COLUMN          |
+---------------------+-----------------+---------------------+---------------------+---------------------------+

In questo esempio, il server di riferimento e il database di riferimento hanno un valore (invece di essere NULL come nell'esempio precedente). Questo perché uspGetAlbumsByArtist stored procedure utilizza un nome in quattro parti per fare riferimento all'entità su un server collegato (la stored procedure dell'esempio precedente non utilizzava un nome in quattro parti e non utilizzava nemmeno un nome in tre parti per specificare il DB) .

In questo esempio, Homer è il nome del server collegato e Music è il database interrogato dalla procedura memorizzata.

Possiamo vederlo in uspGetAlbumsByArtist 's definizione:

CREATE PROCEDURE [dbo].[uspGetAlbumsByArtist] @ArtistId int AS
SELECT AlbumName
FROM [Homer].[Music].[dbo].[Albums]
WHERE ArtistId = @ArtistId;

Documentazione ufficiale

Per informazioni ed esempi più dettagliati, vedere sys.sql_expression_dependencies sul sito Web Microsoft.

Ecco un altro articolo Microsoft che include istruzioni per ottenere le dipendenze tramite SSMS.

Trova le dipendenze in SQL Server:sql_expression_dependencies

Esempio 1 – Tutte le colonne restituite

Esempio 2 – Trova entità che dipendono da un'entità

Esempio 3 – Trova entità da cui dipende un'entità

Esempio 4:recuperare ulteriori informazioni

Esempio 5 – Entità tra database e server multipli

Documentazione ufficiale