En SQL Server, puede usar el OBJECT_ID() función para devolver el ID de un objeto, en función de su nombre.
Esto puede ser útil cuando necesita la identificación de un objeto, pero solo sabe su nombre.
La definición oficial de OBJECT_ID() es que devuelve el número de identificación del objeto de la base de datos de un objeto del ámbito del esquema
.
Ejemplo 1:uso básico
Aquí hay un ejemplo básico para demostrar cómo funciona.
SELECT OBJECT_ID('Artists') AS Result;
Resultado:
+-----------+ | Result | |-----------| | 885578193 | +-----------+
En este caso, la base de datos actual contiene un objeto llamado Albums , y su ID es 885578193. Esta es la ID que puedes encontrar en el object_id columna de sys.objects vista del catálogo del sistema.
Ejemplo 2:compruebe la vista sys.objects
Aquí hay otro ejemplo básico para verificar lo que acabo de decir.
SELECT name, object_id, OBJECT_ID(name) AS [OBJECT_ID(name)] FROM sys.objects WHERE name = 'Artists';
Resultado:
+---------+-------------+-------------------+ | name | object_id | OBJECT_ID(name) | |---------+-------------+-------------------| | Artists | 885578193 | 885578193 | +---------+-------------+-------------------+
Los sys.objects La vista de catálogo del sistema contiene una fila para cada objeto de ámbito de esquema definido por el usuario que se crea dentro de una base de datos.
En este ejemplo, las dos primeras columnas muestran el name del objeto. y object_id respectivamente.
En la tercera columna de este ejemplo, uso OBJECT_ID() para devolver el ID del objeto en función de su nombre. Para hacer esto, paso la columna de nombre al OBJECT_ID() función.
Obviamente, esto es solo un ejemplo, y usando OBJECT_ID() no era necesario en este caso, porque sys.objects ya devuelve el ID del objeto.
Ejemplo 3:un ejemplo más útil
En este ejemplo, uso OBJECT_ID() en un WHERE cláusula para que solo obtenga resultados relacionados con la tabla llamada Client .
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');
Resultado:
+----------------------+----------------------------+------------------+------------+ | 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 | +----------------------+----------------------------+------------------+------------+
En este caso quería ver qué entidades dependen del Client tabla (es decir, qué entidades hacen referencia a esa tabla en su código SQL). El referenced_id columna usa el ID del objeto, por lo que al usar OBJECT_ID() , pude obtener la ID del Client tabla y compárela con referenced_id .
Consulte Buscar dependencias en SQL Server:sql_expression_dependencies para obtener una explicación más detallada de esta consulta y ejemplos relacionados.
Ejemplo 4:nombres totalmente calificados
También tiene la opción de calificar el nombre del objeto con el nombre del esquema y también el nombre de la base de datos si así lo desea.
Aquí hay un ejemplo simple para demostrarlo:
SELECT
OBJECT_ID('Artists') AS [1 Part Name],
OBJECT_ID('dbo.Artists') AS [2 Part Name],
OBJECT_ID('Music.dbo.Artists') AS [3 Part Name];
Resultado:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Aquí está de nuevo, esta vez usando corchetes como delimitadores:
SELECT
OBJECT_ID('[Artists]') AS [1 Part Name],
OBJECT_ID('[dbo].[Artists]') AS [2 Part Name],
OBJECT_ID('[Music].[dbo].[Artists]') AS [3 Part Name];
Resultado:
+---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+
Mismo resultado.
Si alguna vez obtiene un resultado NULL aunque sepa que el objeto existe, intente calificarlo con el esquema (e incluso con el nombre de la base de datos).
Ejemplo 5:Consultas cruzadas de bases de datos
De forma predeterminada, SQL Server asume que el nombre del objeto está en el contexto de la base de datos actual. Puede usar un nombre de 3 partes para especificar un objeto en una base de datos diferente.
Aquí está el mismo código del ejemplo anterior, excepto que esta vez ejecuto el código dos veces:la primera vez que se ejecuta en Music base de datos, la segunda vez que se ejecuta en el WideWorldImportersDW base de datos:
USE Music;
SELECT
OBJECT_ID('Artists') AS [1 Part Name],
OBJECT_ID('dbo.Artists') AS [2 Part Name],
OBJECT_ID('Music.dbo.Artists') AS [3 Part Name];
USE WideWorldImportersDW;
SELECT
OBJECT_ID('Artists') AS [1 Part Name],
OBJECT_ID('dbo.Artists') AS [2 Part Name],
OBJECT_ID('Music.dbo.Artists') AS [3 Part Name];
Resultado:
Changed database context to 'Music'. +---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | 885578193 | 885578193 | 885578193 | +---------------+---------------+---------------+ (1 row affected) Changed database context to 'WideWorldImportersDW'. +---------------+---------------+---------------+ | 1 Part Name | 2 Part Name | 3 Part Name | |---------------+---------------+---------------| | NULL | NULL | 885578193 | +---------------+---------------+---------------+ (1 row affected)
En el primer resultado, las tres columnas devuelven el ID correcto. Esto se debe a que el objeto se encuentra en Music base de datos.
En el segundo resultado, solo el nombre de 3 partes puede encontrar el objeto correcto. Esto es de esperar, porque los nombres de 1 y 2 partes no especifican el nombre de la base de datos, por lo que se supone que el objeto está en WideWorldImportersDW base de datos (incorrecta).
Ejemplo 6:especificar el tipo de objeto
El OBJECT_ID() La función también acepta un argumento para el tipo de objeto. Este argumento, si se proporciona, viene después del nombre del objeto.
Ejemplo:
SELECT
OBJECT_ID('Artists', 'U') AS [Table];
Resultado:
+-----------+ | Table | |-----------| | 885578193 | +-----------+
Aquí, especifico que el tipo de objeto es U , que significa "Tabla (definida por el usuario)".
Si trato de especificar un tipo de objeto diferente, obtengo NULL :
SELECT
OBJECT_ID('Artists', 'U') AS [Table],
OBJECT_ID('Artists', 'V') AS [View],
OBJECT_ID('Artists', 'P') AS [Stored Procedure];
Resultado:
+-----------+--------+--------------------+ | Table | View | Stored Procedure | |-----------+--------+--------------------| | 885578193 | NULL | NULL | +-----------+--------+--------------------+
Aquí está de nuevo, pero con el nombre de una vista en su lugar:
SELECT
OBJECT_ID('RockAlbums', 'U') AS [Table],
OBJECT_ID('RockAlbums', 'V') AS [View],
OBJECT_ID('RockAlbums', 'P') AS [Stored Procedure];
Resultado:
+---------+------------+--------------------+ | Table | View | Stored Procedure | |---------+------------+--------------------| | NULL | 1525580473 | NULL | +---------+------------+--------------------+
