Hitta beroenden i SQL Server:sql_expression_dependencies

I SQL Server kan du använda sys.sql_expression_dependencies systemkatalogvy för att returnera alla beroenden på en användardefinierad enhet i den aktuella databasen. Detta inkluderar beroenden mellan inbyggt kompilerade, skalära användardefinierade funktioner och andra SQL Server-moduler.

Du kan använda den här vyn för att:

• Returnera enheter som är beroende av en given enhet
• Returnera enheter som en given enhet är beroende av

Så till exempel kan du använda den för att returnera alla objekt som refererar till en specifik tabell. Du kan också använda den för att returnera alla objekt som en specifik lagrad procedur refererar till i sin kod.

Specifikt sys.sql_expression_dependencies visa rapportberoendeinformation för följande enheter:

• Schemabundna enheter.
• Icke-schemabundna enheter.
• Entiteter över databaser och servrar. Enhetsnamn rapporteras; enhets-ID:n löses dock inte.
• Beroenden på kolumnnivå av schemabundna enheter. Kolumnnivåberoenden för icke-schemabundna objekt kan returneras genom att använda sys.dm_sql_referenced_entities.
• DDL på servernivå utlöses när den är i huvuddatabasen.

Exempel 1 – Alla kolumner returnerade

Här är ett snabbt exempel som väljer alla kolumner från sys.sql_expression_dependencies . Detta visar oss vilken data som faktiskt returneras i vyn, och vi kan använda vilken som helst av dessa kolumner i våra frågor för att returnera bara den data vi är intresserade av.

SELECT TOP(1) * 
FROM sys.sql_expression_dependencies;

Resultat (med vertikal utdata):

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

Det här exemplet använder vertikal utdata för att göra det lättare att se kolumnnamnen utan att behöva rulla horisontellt. Därför listas kolumnnamnen till vänster och deras respektive värden är till höger.

För korthetens skull använde jag också TOP(1) för att begränsa resultaten till bara den första raden.

Exempel 2 – Hitta enheter som är beroende av en enhet

För att hitta objekt som är beroende av en given entitet, använd den entitetens referencing_id när du väljer från vyn.

Exempel:

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');

Resultat:

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

Här får jag alla entiteter som refereras till i uspGetClient lagrad procedur.

Här är den faktiska definitionen för uspGetClient :

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

Så vi kan se att den väljer data från en tabell som heter Client , och den accepterar ett argument som heter @ClientCode med en (användardefinierad alias) datatyp clientcode .

Exempel 3 – Hitta enheter som en enhet är beroende av

Du kan också växla runt det och få de objekt som en given enhet beror på. För att göra det, använd referenced_id (istället för referencing_id ) när du väljer från vyn.

Exempel:

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 exemplet ville jag se vilka enheter som är beroende av Client tabell (dvs. vilka enheter som refererar till den tabellen i sin SQL-kod).

Du kommer att märka att jag också valde olika kolumner. Det beror på att jag letar efter information om referensen enhet, inte den refererade enhet som i föregående exempel.

Exempel 4 – Hämta mer information

Du kan ansluta den här vyn med andra vyer och/eller tabeller för att returnera mer information.

Du kan till exempel ansluta den med sys.objects för att få referensobjektets typ:

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');

Resultat:

+----------------------+----------------------+----------+---------------------+------------+
| 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 |
+----------------------+----------------------+----------+---------------------+------------+

I det här exemplet lade jag också till COALESCE() funktion för att returnera (n/a) när referencing_minor_id är NULL . Denna funktion är ett av flera sätt du kan ersätta ett NULL-värde med en sträng i SQL Server.

Exempel 5 – Cross-Databas &Cross-Server Entities

Som nämnts, sql_expression_dependencies fungerar även på entiteter över databaser och servrar. I det här fallet rapporteras dock enhetsnamn men enhets-ID:n löses inte.

Det här exemplet använder exakt samma kod som i exempel 2, förutom att den här gången är för en annan enhet. Den här gången vill jag hitta enheter som är beroende av 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');

Resultat:

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

I det här exemplet har den refererade servern och refererade databasen ett värde (istället för att vara NULL som i det tidigare exemplet). Det beror på att uspGetAlbumsByArtist lagrad procedur använder ett fyrdelat namn för att referera till enheten på en länkad server (den lagrade proceduren från det tidigare exemplet använde inte ett fyrdelat namn, och den använde inte heller ett tredelat namn för att specificera DB) .

I det här exemplet, Homer är namnet på den länkade servern och Music är databasen som den lagrade proceduren frågar efter.

Vi kan se detta i uspGetAlbumsByArtist definition:

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

Officiell dokumentation

För mer detaljerad information och exempel, se sys.sql_expression_dependencies på Microsofts webbplats.

Här är en annan Microsoft-artikel som innehåller instruktioner för att få beroenden via SSMS.