In SQL Server können Sie den sp_rename verwenden gespeicherte Prozedur zum Umbenennen eines Objekts, einschließlich einer Tabelle.
Bei den meisten anderen wichtigen RDBMs können Sie eine Tabelle mit ALTER TABLE umbenennen -Anweisung, aber das ist bei SQL Server nicht der Fall.
Beispiel
Hier ist ein Beispiel zur Veranschaulichung:
EXEC sp_rename 't1', 't2';
Dadurch wird die Tabelle mit dem Namen t1 umbenannt bis t2 .
Einschließlich des Schemanamens
Sie können die erste Tabelle auch mit dem Schemanamen qualifizieren, in diesem Fall könnte sie etwa so aussehen:
EXEC sp_rename 'dbo.t1', 't2';
In diesem Beispiel dbo ist der Schemaname, aber Sie müssen das anwendbare Schema verwenden.
Einschließlich der Parameternamen
Wie bei jeder gespeicherten Prozedur können Sie auch die Parameternamen beim Aufruf von sp_rename einschließen :
EXEC sp_rename
@objname = 'dbo.t1',
@newname = 't2';
Die sp_rename Die Prozedur akzeptiert auch einen @objtype -Parameter, aber dies ist beim Umbenennen von Tabellen nicht erforderlich (oder unterstützt).
Nach Referenzen suchen
Wenn Sie eine Tabelle in SQL Server umbenennen, sehen Sie wahrscheinlich eine Meldung wie diese:
Caution: Changing any part of an object name could break scripts and stored procedures.
Dies liegt daran, dass SQL Server nicht eine Tabelle umbenennt alle Verweise auf diese Tabelle automatisch umbenennen. Dies gilt auch, wenn Sie eine Spalte umbenennen.
Trotz obiger Warnmeldung wird die Tabelle trotzdem umbenannt.
Bevor Sie Tabellen umbenennen, sollten Sie daher immer nach Skripts und gespeicherten Prozeduren suchen, die auf diese Tabelle verweisen. Sie müssen solche Skripte und Prozeduren aktualisieren, um auf den neuen Tabellennamen zu verweisen.
Sie können die sys.sql_expression_dependencies verwenden Systemkatalogansicht, um diese Prüfung durchzuführen.
Beispiel:
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 diesem Fall habe ich es mit sys.objects verbunden um weitere Informationen zurückzugeben.
Hier ist das Ergebnis, das ich bekomme, bevor ich den Namen von t1 geändert habe Tabelle:
+----------------------+----------------------+----------+---------------------+----------+ | 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 | +----------------------+----------------------+----------+---------------------+----------+
Dies zeigt mir, dass es eine Ansicht, eine gespeicherte Prozedur und eine berechnete Spalte gibt, die von t1 abhängen Tisch. Die berechnete Spalte (c2 ) verweist auf c1 Spalte in derselben Tabelle.
Wie bereits erwähnt, ist es wichtig, diese Prüfung durchzuführen, bevor Sie den Namen der Tabelle ändern. Hier ist das Ergebnis, das ich erhalte, wenn ich dasselbe Skript ausführe, nachdem ich den Namen der Tabelle geändert habe.
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');Ergebnis:
(0 rows affected)
In diesem Fall habe ich den ursprünglichen Namen der Tabelle verwendet (t1 ), also ist es ziemlich offensichtlich, dass wir nicht einmal auf die richtige Tabelle abzielen (t2 ).
Das einfache Ändern dieses Skripts, um auf den neuen Tabellennamen zu verweisen, funktioniert auch nicht. Führen Sie beispielsweise das folgende Skript aus, nachdem wir den Namen der Tabelle von t1 geändert haben bis t2 gibt nur eine Abhängigkeit zurück (die berechnete Spalte).
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');Ergebnis:
+----------------------+------------+----------+---------------------+----------+ | Referencing Entity | Type | Column | Referenced Entity | Column | |----------------------+------------+----------+---------------------+----------| | t2 | USER_TABLE | c2 | t2 | c1 | +----------------------+------------+----------+---------------------+----------+
Die gute Nachricht ist, dass die berechnete Spalte zurückgegeben wird. Die schlechte Nachricht ist, dass die Ansicht und die gespeicherte Prozedur nicht zurückgegeben werden.
Fazit:Suchen Sie nach Abhängigkeiten, bevor Sie die Tabelle umbenennen. Aktualisieren Sie dann manuell alle Objekte, die auf die umbenannte Tabelle verweisen.
