No SQL Server, você pode usar o
sp_rename procedimento armazenado para renomear um objeto, incluindo uma tabela. A maioria dos outros RDBMs principais permitem renomear uma tabela com o
ALTER TABLE instrução, mas esse não é o caso do SQL Server. Exemplo
Segue um exemplo para demonstrar:
EXEC sp_rename 't1', 't2';Isso renomeia a tabela chamada
t1 para t2 . Incluindo o nome do esquema
Você também pode qualificar a primeira tabela com o nome do esquema, nesse caso, pode ser algo assim:
EXEC sp_rename 'dbo.t1', 't2';Neste exemplo,
dbo é o nome do esquema, mas você precisará usar qualquer esquema aplicável. Incluindo os nomes dos parâmetros
Como em qualquer procedimento armazenado, você também pode incluir os nomes dos parâmetros ao chamar
sp_rename :EXEC sp_rename
@objname = 'dbo.t1',
@newname = 't2';O
sp_rename procedimento também aceita um @objtype parâmetro, mas isso não é necessário (ou suportado) ao renomear tabelas. Verificar referências
Ao renomear uma tabela no SQL Server, você provavelmente verá uma mensagem como esta:
Caution: Changing any part of an object name could break scripts and stored procedures.
Isso ocorre porque quando você renomeia uma tabela, o SQL Server não renomear automaticamente quaisquer referências a essa tabela. Isso também é verdade quando você renomeia uma coluna.
Apesar da mensagem de advertência acima, a tabela é renomeada de qualquer maneira.
Portanto, antes de renomear qualquer tabela, você deve sempre verificar os scripts e procedimentos armazenados que fazem referência a essa tabela. Você precisará atualizar esses scripts e procedimentos para fazer referência ao novo nome da tabela.
Você pode usar o
sys.sql_expression_dependencies visão do catálogo do sistema para fazer essa verificação. Exemplo:
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't1');Neste caso eu juntei com
sys.objects para retornar mais informações. Aqui está o resultado que recebo antes de alterar o nome do
t1 tabela:+----------------------+----------------------+----------+---------------------+----------+ | Referencing Entity | Type | Column | Referenced Entity | Column | |----------------------+----------------------+----------+---------------------+----------| | usp_t1 | SQL_STORED_PROCEDURE | (n/a) | t1 | (n/a) | | vt1 | VIEW | (n/a) | t1 | (n/a) | | t1 | USER_TABLE | c2 | t1 | c1 | +----------------------+----------------------+----------+---------------------+----------+
Isso me mostra que há uma exibição, um procedimento armazenado e uma coluna computada que dependem do
t1 tabela. A coluna calculada (c2 ) faz referência ao c1 coluna na mesma tabela. Conforme mencionado, é importante executar essa verificação antes de alterar o nome da tabela. Aqui está o resultado que recebo ao executar o mesmo script após alterar o nome da tabela.
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't1');Resultado:
(0 rows affected)
Neste caso, usei o nome original da tabela (
t1 ), então é bastante óbvio que nem mesmo segmentamos a tabela correta (t2 ). Simplesmente alterar este script para referenciar o novo nome da tabela também não funcionará. Por exemplo, executando o script a seguir depois que alteramos o nome da tabela de
t1 para t2 retorna apenas uma dependência (a coluna computada). 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't2');Resultado:
+----------------------+------------+----------+---------------------+----------+ | Referencing Entity | Type | Column | Referenced Entity | Column | |----------------------+------------+----------+---------------------+----------| | t2 | USER_TABLE | c2 | t2 | c1 | +----------------------+------------+----------+---------------------+----------+
A boa notícia é que a coluna computada é retornada. A má notícia é que a exibição e o procedimento armazenado não são retornados.
Conclusão:verifique as dependências antes de renomear a tabela. Em seguida, atualize manualmente todos os objetos que fazem referência à tabela renomeada.
