No SQL Server, você pode usar o
OBJECT_ID() função para retornar o ID de um objeto, com base em seu nome. Isso pode ser útil quando você precisa do ID de um objeto, mas sabe apenas seu nome.
A definição oficial de
OBJECT_ID() é que retorna o número de identificação do objeto de banco de dados de um objeto com escopo de esquema.
Exemplo 1 – Uso básico
Aqui está um exemplo básico para demonstrar como funciona.
SELECT OBJECT_ID('Artistas') AS Resultado; Resultado:
+-----------+| Resultado ||-----------|| 885578193 |+-----------+
Neste caso, o banco de dados atual contém um objeto chamado
Albums , e seu ID é 885578193. Este é o ID que você pode encontrar no object_id coluna do sys.objects visualização do catálogo do sistema. Exemplo 2 – Verifique a visualização sys.objects
Aqui está outro exemplo básico para verificar o que acabei de dizer.
SELECT name, object_id, OBJECT_ID(name) AS [OBJECT_ID(name)]FROM sys.objectsWHERE name ='Artists';
Resultado:
+---------+-------------+-----+| nome | object_id | OBJECT_ID(nome) ||---------+----------+-------------------| | Artistas | 885578193 | 885578193 |+---------+-------------+-------------------+
Os
sys.objects A exibição do catálogo do sistema contém uma linha para cada objeto com escopo de esquema definido pelo usuário que é criado em um banco de dados. Neste exemplo, as duas primeiras colunas exibem o
name do objeto e object_id respectivamente. Na terceira coluna deste exemplo, eu uso
OBJECT_ID() para retornar o ID do objeto com base em seu nome. Para fazer isso, passo a coluna name para o OBJECT_ID() função. Este é obviamente apenas um exemplo, e usando
OBJECT_ID() foi desnecessário neste caso, porque sys.objects já retorna o ID do objeto. Exemplo 3 – Um exemplo mais útil
Neste exemplo, eu uso
OBJECT_ID() em um WHERE cláusula para que eu obtenha apenas resultados relacionados à tabela chamada 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_dependenciesWHERE referenced_id =OBJECT_ID(' Cliente'); Resultado:
+----------------------+----------------------- -----+------------------+------------+| Entidade Referenciadora | Entidade Menor Referenciada | Classe | Coluna ||----------------------+------------------------ ----+------------------+------------|| uspGetClient | NULO | OBJECT_OR_COLUMN | NULO || uspGetOrdersByClient | NULO | OBJECT_OR_COLUMN | NULO || chkClientCode | NULO | OBJECT_OR_COLUMN | ClientCode |+-----------------------+------------------------ ----+------------------+------------+
Neste caso eu queria ver quais entidades dependem do
Client table (ou seja, quais entidades fazem referência a essa tabela em seu código SQL). O referenced_id coluna usa o ID do objeto, então usando OBJECT_ID() , consegui obter o ID do Client tabela e compare-a com referenced_id . Consulte Localizar dependências no SQL Server:sql_expression_dependencies para obter uma explicação mais detalhada dessa consulta e exemplos relacionados.
Exemplo 4 – Nomes totalmente qualificados
Você também tem a opção de qualificar o nome do objeto com o nome do esquema e também o nome do banco de dados, se desejar.
Aqui está um exemplo simples para demonstrar:
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 Nome da Parte | 2 Parte Nome | Nome de 3 Partes ||---------------+---------------+------------- --|| 885578193 | 885578193 | 885578193 |+---------------+---------------+--------------- +
Aqui está novamente, desta vez usando colchetes como delimitadores:
SELECT OBJECT_ID('[Artists]') AS [1 Part Name], OBJECT_ID('[dbo].[Artists]') AS [2 Part Name], OBJECT_ID('[Music].[dbo].[ Artistas]') AS [Nome de 3 partes];
Resultado:
+---------------+---------------+-------------- -+| 1 Nome da Parte | 2 Parte Nome | Nome de 3 Partes ||---------------+---------------+------------- --|| 885578193 | 885578193 | 885578193 |+---------------+---------------+--------------- +
Mesmo resultado.
Se você obtiver um resultado NULL mesmo sabendo que o objeto existe, tente qualificá-lo com o esquema (e até mesmo o nome do banco de dados).
Exemplo 5 – Consultas entre bancos de dados
Por padrão, o SQL Server assume que o nome do objeto está no contexto do banco de dados atual. Você pode usar um nome de 3 partes para especificar um objeto em um banco de dados diferente.
Aqui está o mesmo código do exemplo anterior, exceto que desta vez eu executo o código duas vezes:a primeira vez que é executado no Music banco de dados, a segunda vez que é executado no WideWorldImportersDW base de dados:
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:
Alterado o contexto do banco de dados para 'Música'.+---------------+---------------+------ ---------+| 1 Nome da Parte | 2 Parte Nome | Nome de 3 Partes ||---------------+---------------+------------- --|| 885578193 | 885578193 | 885578193 |+---------------+---------------+--------------- +(1 linha afetada) Contexto do banco de dados alterado para 'WideWorldImportersDW'.+---------------+---------------+------- ------------+| 1 Nome da Parte | 2 Parte Nome | Nome de 3 Partes ||---------------+---------------+------------- --|| NULO | NULO | 885578193 |+---------------+---------------+--------------- +(1 linha afetada)
No primeiro resultado, todas as três colunas retornam o ID correto. Isso ocorre porque o objeto está em Music base de dados.
No segundo resultado, apenas o nome de 3 partes é capaz de encontrar o objeto correto. Isso é esperado, porque os nomes de 1 parte e 2 partes não especificam o nome do banco de dados, portanto, assume que o objeto está no WideWorldImportersDW banco de dados (errado).
Exemplo 6 – Especificar o tipo de objeto
O OBJECT_ID() A função também aceita um argumento para o tipo de objeto. Este argumento, se fornecido, vem após o nome do objeto.
Exemplo:
SELECT OBJECT_ID('Artistas', 'U') AS [Tabela];
Resultado:
+-----------+| Tabela ||-----------|| 885578193 |+-----------+
Aqui, eu especifico que o tipo de objeto é U , que significa "Tabela (definida pelo usuário)".
Se eu tentar especificar um tipo de objeto diferente, recebo NULL :
SELECT OBJECT_ID('Artistas', 'U') AS [Tabela], OBJECT_ID('Artistas', 'V') AS [Visualizar], OBJECT_ID('Artistas', 'P') AS [Procedimento armazenado];
Resultado:
+-----------+--------+-------------------+| Tabela | Ver | Procedimento armazenado ||-----------+--------+------|| 885578193 | NULO | NULL |+-----------+--------+-----+
Aqui está novamente, mas com o nome de uma visão:
SELECT OBJECT_ID('RockAlbums', 'U') AS [Table], OBJECT_ID('RockAlbums', 'V') AS [View], OBJECT_ID('RockAlbums', 'P') AS [Stored Procedure];
Resultado:
+---------+------------+-----+| Tabela | Ver | Procedimento armazenado ||---------+------------+--------------------|| NULO | 1525580473 | NULL |+---------+------------+------+
