Utilisez OBJECT_NAME() pour obtenir le nom d'un objet à partir de son object_id dans SQL Server

Lors de l'utilisation de SQL Server, si jamais vous êtes sur le point de faire une jointure avec sys.objects vue du catalogue système afin d'obtenir le nom d'un objet, arrêtez-vous peut-être et lisez-le d'abord.

Transact-SQL a une fonction intégrée appelée OBJECT_NAME() qui renvoie le nom d'un objet, basé sur son ID.

En d'autres termes, si vous avez l'ID de l'objet (par exemple, le object_id colonne), vous pouvez simplement transmettre cet ID à OBJECT_NAME() fonction, et elle renverra le nom de l'objet pour vous - aucune jointure n'est requise !

Exemple 1 - Utilisation de base

Voici un exemple de base pour montrer comment cela fonctionne.

SELECT 
  name,
  object_id,
  OBJECT_NAME(object_id) AS [OBJECT_NAME(object_id)]
FROM sys.objects
WHERE name = 'Artists';

Résultat :

+---------+-------------+--------------------------+
| name    | object_id   | OBJECT_NAME(object_id)   |
|---------+-------------+--------------------------|
| Artists | 885578193   | Artists                  |
+---------+-------------+--------------------------+

Ici, nous pouvons voir que les deux premières colonnes affichent respectivement le nom et l'ID de l'objet. La troisième colonne utilise le OBJECT_NAME() fonction pour renvoyer le nom de l'ID.

Ce n'est évidemment qu'un exemple, mais dans ce cas, en utilisant OBJECT_NAME() n'était pas nécessaire car sys.objects renvoie déjà le nom de l'objet.

L'exemple suivant montre où OBJECT_NAME() peut être utile.

Exemple 2 - Un exemple plus utile

Dans cet exemple, je retourne des informations sur une clé étrangère en interrogeant le sys.foreign_keys vue du catalogue système.

Commençons par sélectionner toutes les colonnes pour voir ce qui est renvoyé par cette vue :

USE Music;
SELECT * 
FROM sys.foreign_keys
WHERE name = 'FK_Artists_Country';

Résultat (en utilisant la sortie verticale) :

name                           | FK_Artists_Country
object_id                      | 1253579504
principal_id                   | NULL
schema_id                      | 1
parent_object_id               | 885578193
type                           | F 
type_desc                      | FOREIGN_KEY_CONSTRAINT
create_date                    | 2019-08-27 16:14:39.560
modify_date                    | 2019-08-28 03:28:07.040
is_ms_shipped                  | 0
is_published                   | 0
is_schema_published            | 0
referenced_object_id           | 1205579333
key_index_id                   | 1
is_disabled                    | 0
is_not_for_replication         | 0
is_not_trusted                 | 0
delete_referential_action      | 0
delete_referential_action_desc | NO_ACTION
update_referential_action      | 0
update_referential_action_desc | NO_ACTION
is_system_named                | 0

Cette vue renvoie le nom de la clé étrangère, mais pas le nom de son objet parent. Il ne renvoie pas non plus le nom de l'objet référencé de la clé étrangère. Il ne renvoie que l'ID de ces objets (à savoir, parent_object_id et referenced_object_id ).

Donc, si nous devions le réduire à ces colonnes, nous obtiendrions quelque chose comme ceci :

USE Music;
SELECT
  name,
  parent_object_id,
  referenced_object_id
FROM sys.foreign_keys
WHERE name = 'FK_Artists_Country';

Résultat :

+--------------------+--------------------+------------------------+
| name               | parent_object_id   | referenced_object_id   |
|--------------------+--------------------+------------------------|
| FK_Artists_Country | 885578193          | 1205579333             |
+--------------------+--------------------+------------------------+

Heureusement, nous pouvons passer les deux dernières colonnes à OBJECT_NAME() afin de récupérer les noms d'objets.

Voici ce que nous pouvons faire pour renvoyer les noms.

USE Music;
SELECT
  name AS [Foreign Key],
  OBJECT_NAME(parent_object_id) AS [Parent Object Name],
  OBJECT_NAME(referenced_object_id) AS [Referenced Object Name]
FROM sys.foreign_keys
WHERE name = 'FK_Artists_Country';

Résultat :

+--------------------+----------------------+--------------------------+
| Foreign Key        | Parent Object Name   | Referenced Object Name   |
|--------------------+----------------------+--------------------------|
| FK_Artists_Country | Artists              | Country                  |
+--------------------+----------------------+--------------------------+

Pour les deux dernières colonnes, je passe les valeurs pertinentes au OBJECT_NAME() pour qu'elle renvoie le nom de chaque objet parent.

Exemple 3 – Utilisation de OBJECT_NAME() dans une clause WHERE

Voici un exemple d'utilisation de OBJECT_NAME() dans un WHERE clause.

SELECT 
  name, 
  object_id, 
  type_desc  
FROM sys.objects  
WHERE name = OBJECT_NAME(1253579504);

Résultat :

+--------------------+-------------+------------------------+
| name               | object_id   | type_desc              |
|--------------------+-------------+------------------------|
| FK_Artists_Country | 1253579504  | FOREIGN_KEY_CONSTRAINT |
+--------------------+-------------+------------------------+

Requêtes inter-bases de données

Par défaut, SQL Server suppose que l'ID d'objet se trouve dans le contexte de la base de données actuelle. Une requête qui fait référence à un ID dans une autre base de données renvoie des résultats NULL ou incorrects.

Si vous avez besoin de trouver un nom d'objet dans une base de données différente, vous pouvez fournir l'ID de cette base de données comme deuxième argument lors de l'appel de OBJECT_NAME() .

Voir Comment obtenir un OBJECT_NAME() à partir d'une autre base de données dans SQL Server pour des exemples.