W SQL Server możesz użyć sys.sql_expression_dependencies widok katalogu systemowego, aby zwrócić wszystkie zależności od encji zdefiniowanej przez użytkownika w bieżącej bazie danych. Obejmuje to zależności między natywnie skompilowanymi, skalarnymi funkcjami zdefiniowanymi przez użytkownika a innymi modułami SQL Server.
Możesz użyć tego widoku do:
- Zwróć jednostki zależne od danej jednostki
- Zwróć encje, od których zależy dana encja
Na przykład możesz go użyć do zwrócenia wszystkich obiektów, które odwołują się do określonej tabeli. Możesz go również użyć do zwrócenia wszystkich obiektów, do których odwołuje się określona procedura składowana w swoim kodzie.
W szczególności sys.sql_expression_dependencies wyświetl informacje o zależnościach raportów dla następujących jednostek:
- Eencje powiązane ze schematem.
- Eencje niezwiązane ze schematem.
- Jednostki międzybazowe i międzyserwerowe. Zgłaszane są nazwy podmiotów; jednak identyfikatory jednostek nie są rozpoznawane.
- Zależności na poziomie kolumny od jednostek powiązanych ze schematem. Zależności na poziomie kolumny dla obiektów niezwiązanych ze schematem mogą być zwracane przy użyciu sys.dm_sql_referenced_entities.
- DDL wyzwalane na poziomie serwera w kontekście głównej bazy danych.
Przykład 1 – Zwrócone wszystkie kolumny
Oto szybki przykład, który wybiera wszystkie kolumny z sys.sql_expression_dependencies . To pokazuje nam, jakie dane są faktycznie zwracane w widoku, i możemy użyć dowolnej z tych kolumn w naszych zapytaniach, aby zwrócić tylko te dane, które nas interesują.
SELECT TOP(1) * FROM sys.sql_expression_dependencies;
Wynik (przy użyciu wyjścia pionowego):
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
Ten przykład używa danych wyjściowych w pionie, aby ułatwić wyświetlanie nazw kolumn bez konieczności przewijania w poziomie. Dlatego nazwy kolumn znajdują się po lewej stronie, a ich wartości po prawej.
Ponadto, ze względu na zwięzłość, użyłem TOP(1) aby ograniczyć wyniki tylko do pierwszego wiersza.
Przykład 2 – Znajdź jednostki zależne od jednostki
Aby znaleźć obiekty zależne od danej encji, użyj referencing_id tej encji podczas wybierania z widoku.
Przykład:
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');
Wynik:
+---------------------+-----------------+---------------------+---------------------+---------------------------+ | Referenced Server | Referenced DB | Referenced Schema | Referenced Entity | Referenced Entity Class | |---------------------+-----------------+---------------------+---------------------+---------------------------| | NULL | NULL | dbo | Client | OBJECT_OR_COLUMN | | NULL | NULL | NULL | clientcode | TYPE | +---------------------+-----------------+---------------------+---------------------+---------------------------+
Tutaj otrzymuję wszystkie jednostki, do których odwołuje się uspGetClient procedura składowana.
Oto rzeczywista definicja uspGetClient :
CREATE PROCEDURE [dbo].[uspGetClient] @ClientCode clientcode AS
SELECT
FirstName,
LastName
FROM [dbo].[Client]
WHERE ClientCode = @ClientCode;
Widzimy więc, że wybiera dane z tabeli o nazwie Client i akceptuje argument o nazwie @ClientCode z (zdefiniowanym przez użytkownika aliasem) typem danych clientcode .
Przykład 3 – Znajdź encje, od których zależy encja
Możesz go również przełączyć i uzyskać obiekty, od których dana encja jest zależna. Aby to zrobić, użyj referenced_id (zamiast referencing_id ) podczas wybierania z widoku.
Przykład:
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');
Wynik:
+----------------------+----------------------------+------------------+------------+ | 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 | +----------------------+----------------------------+------------------+------------+
W tym przykładzie chciałem zobaczyć, które encje zależą od Client tabeli (tj. które jednostki odwołują się do tej tabeli w swoim kodzie SQL).
Zauważysz, że wybrałem też inne kolumny. Dzieje się tak, ponieważ szukam informacji na temat odniesienia podmiot, a nie odwołanie podmiot jak w poprzednim przykładzie.
Przykład 4 – Uzyskaj więcej informacji
Możesz połączyć ten widok z innymi widokami i/lub tabelami, aby uzyskać więcej informacji.
Na przykład możesz dołączyć do niego za pomocą sys.objects aby uzyskać typ obiektu referencyjnego:
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');
Wynik:
+----------------------+----------------------+----------+---------------------+------------+ | 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 | +----------------------+----------------------+----------+---------------------+------------+
W tym przykładzie dodałem również COALESCE() funkcja zwracająca (n/a) kiedykolwiek referencing_minor_id jest NULL . Ta funkcja jest jednym z kilku sposobów zamiany wartości NULL na łańcuch w SQL Server.
Przykład 5 – jednostki międzybazowe i międzyserwerowe
Jak wspomniano, sql_expression_dependencies działa również na jednostkach międzybazowych i międzyserwerowych. Jednak w tym przypadku nazwy jednostek są zgłaszane, ale identyfikatory jednostek nie są rozpoznawane.
W tym przykładzie użyto dokładnie tego samego kodu, co w przykładzie 2, z tym wyjątkiem, że tym razem dotyczy on innej encji. Tym razem chcę znaleźć jednostki zależne od 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');
Wynik:
+---------------------+-----------------+---------------------+---------------------+---------------------------+ | Referenced Server | Referenced DB | Referenced Schema | Referenced Entity | Referenced Entity Class | |---------------------+-----------------+---------------------+---------------------+---------------------------| | Homer | Music | dbo | Albums | OBJECT_OR_COLUMN | +---------------------+-----------------+---------------------+---------------------+---------------------------+
W tym przykładzie serwer odniesienia i baza danych mają wartość (zamiast wartości NULL, jak w poprzednim przykładzie). To dlatego, że uspGetAlbumsByArtist procedura składowana używa czteroczęściowej nazwy do odwoływania się do jednostki na połączonym serwerze (procedura składowana z wcześniejszego przykładu nie używała czteroczęściowej nazwy ani nie używała trzyczęściowej nazwy do określenia bazy danych) .
W tym przykładzie Homer to nazwa połączonego serwera, a Music to baza danych, do której odpytuje procedura składowana.
Możemy to zobaczyć w uspGetAlbumsByArtist Definicja:
CREATE PROCEDURE [dbo].[uspGetAlbumsByArtist] @ArtistId int AS SELECT AlbumName FROM [Homer].[Music].[dbo].[Albums] WHERE ArtistId = @ArtistId;
Oficjalna dokumentacja
Aby uzyskać bardziej szczegółowe informacje i przykłady, zobacz sys.sql_expression_dependencies na stronie Microsoft.
Oto kolejny artykuł firmy Microsoft, który zawiera instrukcje uzyskiwania zależności przez SSMS.
