In SQL Server puoi usare sp_rename stored procedure per rinominare un oggetto, inclusa una tabella.
La maggior parte degli altri principali RDBM ti consente di rinominare una tabella con ALTER TABLE istruzione, ma questo non è il caso di SQL Server.
Esempio
Ecco un esempio da dimostrare:
EXEC sp_rename 't1', 't2';
Questo rinomina la tabella chiamata t1 a t2 .
Incluso il nome dello schema
Puoi anche qualificare la prima tabella con il nome dello schema, nel qual caso potrebbe assomigliare a questo:
EXEC sp_rename 'dbo.t1', 't2';
In questo esempio, dbo è il nome dello schema, ma dovrai utilizzare qualsiasi schema applicabile.
Compresi i nomi dei parametri
Come con qualsiasi procedura memorizzata, puoi anche includere i nomi dei parametri quando chiami sp_rename :
EXEC sp_rename
@objname = 'dbo.t1',
@newname = 't2';
Il sp_rename la procedura accetta anche un @objtype parametro, ma questo non è richiesto (o supportato) durante la ridenominazione delle tabelle.
Controlla i riferimenti
Quando rinomini una tabella in SQL Server, probabilmente vedrai un messaggio come questo:
Caution: Changing any part of an object name could break scripts and stored procedures.
Questo perché quando si rinomina una tabella, SQL Server non rinominare automaticamente tutti i riferimenti a quella tabella. Questo vale anche quando rinomini una colonna.
Nonostante il messaggio di avvertimento sopra, la tabella viene comunque rinominata.
Pertanto, prima di rinominare qualsiasi tabella, è sempre necessario verificare la presenza di script e stored procedure che fanno riferimento a tale tabella. Sarà necessario aggiornare tali script e procedure per fare riferimento al nuovo nome della tabella.
Puoi usare sys.sql_expression_dependencies vista del catalogo di sistema per eseguire questo controllo.
Esempio:
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');
In questo caso l'ho unito con sys.objects per restituire maggiori informazioni.
Ecco il risultato che ottengo prima di cambiare il nome del t1 tabella:
+----------------------+----------------------+----------+---------------------+----------+ | 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 | +----------------------+----------------------+----------+---------------------+----------+
Questo mi mostra che c'è una vista, una procedura memorizzata e una colonna calcolata che dipendono da t1 tavolo. La colonna calcolata (c2 ) fa riferimento a c1 colonna nella stessa tabella.
Come accennato, è importante eseguire questo controllo prima di modificare il nome della tabella. Ecco il risultato che ottengo eseguendo lo stesso script dopo aver cambiato il nome della tabella.
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');Risultato:
(0 rows affected)
In questo caso, ho utilizzato il nome originale della tabella (t1 ), quindi è abbastanza ovvio che non abbiamo nemmeno scelto come target la tabella corretta (t2 ).
Anche la semplice modifica di questo script per fare riferimento al nuovo nome della tabella non funzionerà. Ad esempio, eseguendo il seguente script dopo aver cambiato il nome della tabella da t1 a t2 restituisce solo una dipendenza (la colonna calcolata).
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');Risultato:
+----------------------+------------+----------+---------------------+----------+ | Referencing Entity | Type | Column | Referenced Entity | Column | |----------------------+------------+----------+---------------------+----------| | t2 | USER_TABLE | c2 | t2 | c1 | +----------------------+------------+----------+---------------------+----------+
La buona notizia è che viene restituita la colonna calcolata. La cattiva notizia è che la vista e la stored procedure non vengono restituite.
In conclusione:verifica le dipendenze prima di rinominare la tabella. Quindi aggiorna manualmente tutti gli oggetti che fanno riferimento alla tabella rinominata.
