Zoek afhankelijkheden in SQL Server:sql_expression_dependencies

In SQL Server kunt u de sys.sql_expression_dependencies . gebruiken systeemcatalogusweergave om alle afhankelijkheden van een door de gebruiker gedefinieerde entiteit in de huidige database te retourneren. Dit omvat afhankelijkheden tussen native gecompileerde, scalaire door de gebruiker gedefinieerde functies en andere SQL Server-modules.

U kunt deze weergave gebruiken om:

• Entiteiten retourneren die afhankelijk zijn van een bepaalde entiteit
• Entiteiten retourneren waarvan een bepaalde entiteit afhankelijk is

U kunt het dus bijvoorbeeld gebruiken om alle objecten te retourneren die naar een specifieke tabel verwijzen. Je zou het ook kunnen gebruiken om alle objecten te retourneren waarnaar een specifieke opgeslagen procedure verwijst in zijn code.

In het bijzonder de sys.sql_expression_dependencies bekijk rapporten over afhankelijkheidsinformatie voor de volgende entiteiten:

• Schemagebonden entiteiten.
• Niet-schemagebonden entiteiten.
• Cross-database en cross-server entiteiten. Entiteitsnamen worden gerapporteerd; entiteit-ID's worden echter niet opgelost.
• Afhankelijkheden op kolomniveau van schemagebonden entiteiten. Afhankelijkheden op kolomniveau voor niet-schemagebonden objecten kunnen worden geretourneerd met sys.dm_sql_referenced_entities.
• DDL op serverniveau wordt geactiveerd in de context van de hoofddatabase.

Voorbeeld 1 – Alle kolommen geretourneerd

Hier is een snel voorbeeld dat alle kolommen selecteert uit sys.sql_expression_dependencies . Dit laat ons zien welke gegevens daadwerkelijk worden geretourneerd in de weergave, en we kunnen elk van deze kolommen in onze zoekopdrachten gebruiken om alleen de gegevens te retourneren waarin we geïnteresseerd zijn.

SELECT TOP(1) * 
FROM sys.sql_expression_dependencies;

Resultaat (met verticale uitvoer):

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

In dit voorbeeld wordt verticale uitvoer gebruikt om het gemakkelijker te maken om de kolomnamen te zien zonder horizontaal te hoeven scrollen. Daarom worden de kolomnamen aan de linkerkant weergegeven en hun respectieve waarden aan de rechterkant.

Eveneens, kortheidshalve gebruikte ik TOP(1) om de resultaten te beperken tot alleen de eerste rij.

Voorbeeld 2 – Vind entiteiten die afhankelijk zijn van een entiteit

Om objecten te vinden die afhankelijk zijn van een bepaalde entiteit, gebruikt u de referencing_id . van die entiteit bij het selecteren uit de weergave.

Voorbeeld:

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

Resultaat:

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

Hier krijg ik alle entiteiten waarnaar wordt verwezen in de uspGetClient opgeslagen procedure.

Hier is de daadwerkelijke definitie voor uspGetClient :

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

We kunnen dus zien dat het gegevens selecteert uit een tabel met de naam Client , en het accepteert een argument genaamd @ClientCode met een (door de gebruiker gedefinieerde alias) gegevenstype clientcode .

Voorbeeld 3 – Vind entiteiten waarvan een entiteit afhankelijk is

Je kunt het ook omdraaien en de objecten krijgen waarvan een bepaalde entiteit afhankelijk is. Gebruik hiervoor referenced_id (in plaats van referencing_id ) bij het selecteren in de weergave.

Voorbeeld:

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

Resultaat:

+----------------------+----------------------------+------------------+------------+
| 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 dit voorbeeld wilde ik zien welke entiteiten afhankelijk zijn van de Client tabel (d.w.z. welke entiteiten verwijzen naar die tabel in hun SQL-code).

Je zult merken dat ik ook verschillende kolommen heb geselecteerd. Dit komt omdat ik op zoek ben naar informatie over de verwijzingen entiteit, niet de verwezen entiteit zoals in het vorige voorbeeld.

Voorbeeld 4 – Meer informatie ophalen

U kunt deze weergave samenvoegen met andere weergaven en/of tabellen om meer informatie terug te geven.

U kunt er bijvoorbeeld aan deelnemen met sys.objects om het type van het verwijzende object te krijgen:

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

Resultaat:

+----------------------+----------------------+----------+---------------------+------------+
| 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 dit voorbeeld heb ik ook de COALESCE() . toegevoegd functie om (n/a) . terug te geven wanneer referencing_minor_id is NULL . Deze functie is een van de vele manieren waarop u een NULL-waarde kunt vervangen door een tekenreeks in SQL Server.

Voorbeeld 5 – Cross-Database &Cross-Server Entiteiten

Zoals vermeld, sql_expression_dependencies werkt ook op cross-database en cross-server entiteiten. In dit geval worden echter entiteitsnamen gerapporteerd, maar entiteit-ID's niet opgelost.

In dit voorbeeld wordt exact dezelfde code gebruikt als bij voorbeeld 2, behalve dat het deze keer voor een andere entiteit is. Deze keer wil ik entiteiten vinden die afhankelijk zijn van 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');

Resultaat:

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

In dit voorbeeld hebben de server waarnaar wordt verwezen en de database waarnaar wordt verwezen een waarde (in plaats van NULL zoals in het eerdere voorbeeld). Dat komt omdat de uspGetAlbumsByArtist opgeslagen procedure gebruikt een vierdelige naam om te verwijzen naar de entiteit op een gekoppelde server (de opgeslagen procedure uit het eerdere voorbeeld gebruikte geen vierdelige naam en ook geen driedelige naam om de DB op te geven) .

In dit voorbeeld, Homer is de naam van de gekoppelde server, en Music is de database die door de opgeslagen procedure wordt opgevraagd.

We kunnen dit zien in uspGetAlbumsByArtist ‘s definitie:

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

Officiële documentatie

Voor meer gedetailleerde informatie en voorbeelden, zie sys.sql_expression_dependencies op de Microsoft-website.

Hier is nog een Microsoft-artikel met instructies voor het verkrijgen van afhankelijkheden via SSMS.