Löschen Sie alle Tabellen, gespeicherten Prozeduren, Trigger, Einschränkungen und alle Abhängigkeiten in einer SQL-Anweisung

287

Gibt es eine Möglichkeit, eine Datenbank in SQl Server 2005 zu bereinigen, indem alle Tabellen gelöscht und gespeicherte Prozeduren, Trigger, Einschränkungen und alle Abhängigkeiten in einer SQL-Anweisung gelöscht werden?

GRUND FÜR ANFRAGE:

Ich möchte ein DB-Skript zum Bereinigen einer vorhandenen DB haben, das nicht verwendet wird, anstatt neue zu erstellen, insbesondere wenn Sie eine Anfrage an Ihren DB-Administrator senden und eine Weile warten müssen, bis dies erledigt ist!

renegadeMind
quelle

Antworten:

604

Dieses Skript bereinigt alle Ansichten, SPS, Funktions-PKs, FKs und Tabellen.

/* Drop all non-system stored procs */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'P' AND category = 0 ORDER BY [name])

WHILE @name is not null
BEGIN
    SELECT @SQL = 'DROP PROCEDURE [dbo].[' + RTRIM(@name) +']'
    EXEC (@SQL)
    PRINT 'Dropped Procedure: ' + @name
    SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'P' AND category = 0 AND [name] > @name ORDER BY [name])
END
GO

/* Drop all views */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'V' AND category = 0 ORDER BY [name])

WHILE @name IS NOT NULL
BEGIN
    SELECT @SQL = 'DROP VIEW [dbo].[' + RTRIM(@name) +']'
    EXEC (@SQL)
    PRINT 'Dropped View: ' + @name
    SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'V' AND category = 0 AND [name] > @name ORDER BY [name])
END
GO

/* Drop all functions */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] IN (N'FN', N'IF', N'TF', N'FS', N'FT') AND category = 0 ORDER BY [name])

WHILE @name IS NOT NULL
BEGIN
    SELECT @SQL = 'DROP FUNCTION [dbo].[' + RTRIM(@name) +']'
    EXEC (@SQL)
    PRINT 'Dropped Function: ' + @name
    SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] IN (N'FN', N'IF', N'TF', N'FS', N'FT') AND category = 0 AND [name] > @name ORDER BY [name])
END
GO

/* Drop all Foreign Key constraints */
DECLARE @name VARCHAR(128)
DECLARE @constraint VARCHAR(254)
DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' ORDER BY TABLE_NAME)

WHILE @name is not null
BEGIN
    SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
    WHILE @constraint IS NOT NULL
    BEGIN
        SELECT @SQL = 'ALTER TABLE [dbo].[' + RTRIM(@name) +'] DROP CONSTRAINT [' + RTRIM(@constraint) +']'
        EXEC (@SQL)
        PRINT 'Dropped FK Constraint: ' + @constraint + ' on ' + @name
        SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' AND CONSTRAINT_NAME <> @constraint AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
    END
SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' ORDER BY TABLE_NAME)
END
GO

/* Drop all Primary Key constraints */
DECLARE @name VARCHAR(128)
DECLARE @constraint VARCHAR(254)
DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' ORDER BY TABLE_NAME)

WHILE @name IS NOT NULL
BEGIN
    SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
    WHILE @constraint is not null
    BEGIN
        SELECT @SQL = 'ALTER TABLE [dbo].[' + RTRIM(@name) +'] DROP CONSTRAINT [' + RTRIM(@constraint)+']'
        EXEC (@SQL)
        PRINT 'Dropped PK Constraint: ' + @constraint + ' on ' + @name
        SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' AND CONSTRAINT_NAME <> @constraint AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
    END
SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' ORDER BY TABLE_NAME)
END
GO

/* Drop all tables */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'U' AND category = 0 ORDER BY [name])

WHILE @name IS NOT NULL
BEGIN
    SELECT @SQL = 'DROP TABLE [dbo].[' + RTRIM(@name) +']'
    EXEC (@SQL)
    PRINT 'Dropped Table: ' + @name
    SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'U' AND category = 0 AND [name] > @name ORDER BY [name])
END
GO
Mark Cidade
quelle
14
Was ist, wenn ich einige Tabellen habe, die nicht im DBO-Schema enthalten sind?
StuffHappens
8
Dieses Skript berücksichtigt definitiv keine anderen Schemata (außer dbo). Ich habe es getestet und es läuft für immer. Ich kann mir vorstellen, dass es für dieses Szenario optimiert werden könnte.
W3Max
1
Dieses Skript funktioniert ganz gut. Da einige Dinge fehlen, müssen Sie Assemblys und benutzerdefinierte Typen berücksichtigen. Führen Sie als Beispiel in Ihrer Löschprozedur [Typ] = 'P' ODER [Typ] = 'PC' aus, auch wenn Sie die Baugruppe löschen, führen Sie eine Bestellung mit Assembly_ID desc aus, damit Abhängigkeiten in der richtigen Reihenfolge gelöscht werden.
Brian
1
Es scheint unnötig, alle Primärschlüssel separat zu löschen. Das Fallenlassen der Tische sollte sich darum kümmern
erikkallen
1
@erikkallen Der Grund, warum die Primärschlüssel zuerst gelöscht werden müssen, ist, dass die Tabellen dann in beliebiger Reihenfolge gelöscht werden können, ohne Rücksicht auf Fremdschlüsselabhängigkeiten. Ohne dies müsste eine komplexe Löschreihenfolge verwendet werden, um sicherzustellen, dass alle schwachen Entitätstypen vor den starken Entitätstypen gelöscht werden. Andernfalls würde das Skript bei Verstößen gegen die referenzielle Integritätsbeschränkung fehlschlagen.
Jeff Puckett
118

Ich verwende dieses Skript von Adam Anderson, das aktualisiert wurde, um Objekte in anderen Schemas als dbo zu unterstützen.

declare @n char(1)
set @n = char(10)

declare @stmt nvarchar(max)

-- procedures
select @stmt = isnull( @stmt + @n, '' ) +
    'drop procedure [' + schema_name(schema_id) + '].[' + name + ']'
from sys.procedures


-- check constraints
select @stmt = isnull( @stmt + @n, '' ) +
'alter table [' + schema_name(schema_id) + '].[' + object_name( parent_object_id ) + ']    drop constraint [' + name + ']'
from sys.check_constraints

-- functions
select @stmt = isnull( @stmt + @n, '' ) +
    'drop function [' + schema_name(schema_id) + '].[' + name + ']'
from sys.objects
where type in ( 'FN', 'IF', 'TF' )

-- views
select @stmt = isnull( @stmt + @n, '' ) +
    'drop view [' + schema_name(schema_id) + '].[' + name + ']'
from sys.views

-- foreign keys
select @stmt = isnull( @stmt + @n, '' ) +
    'alter table [' + schema_name(schema_id) + '].[' + object_name( parent_object_id ) + '] drop constraint [' + name + ']'
from sys.foreign_keys

-- tables
select @stmt = isnull( @stmt + @n, '' ) +
    'drop table [' + schema_name(schema_id) + '].[' + name + ']'
from sys.tables

-- user defined types
select @stmt = isnull( @stmt + @n, '' ) +
    'drop type [' + schema_name(schema_id) + '].[' + name + ']'
from sys.types
where is_user_defined = 1


exec sp_executesql @stmt

Quelle: ein Adam Anderson Blog-Beitrag

Vlad Iliescu
quelle
3
fast perfekt, aber es gibt einen verrückten / dummen Randfall: eine Tabelle mit einer berechneten Spalte unter Verwendung einer Funktion. Aber verschieben Sie einfach den Teil mit den Drop-Funktionen, und Sie können loslegen!
Akos Lukacs
1
funktioniert hervorragend, es wird versucht, die Ansicht sys.database_firewall_rules zu löschen, wenn Sie dies für eine Azure PAAS SQL-Datenbank ausführen, aber Azure verhindert, dass sie gelöscht wird.
Simon
Ich habe dies nach "from sys.views" hinzugefügt, um das Azure SQL-Problem zu beheben: WHERE schema_name (schema_id)! = 'Sys'
UnionP
Sie haben dies verpasst: -- system-versioned tables SELECT @stmt = isnull(@stmt + CHAR(10), '') + 'alter table [' + schema_name(schema_id) + '].[' + name + '] SET ( SYSTEM_VERSIONING = OFF)' FROM sys.tables WHERE TEMPORAL_TYPE = 2;
Christopher Shortt
93

Das Beste ist " Skripte für Drop generieren ".

Wählen Sie Datenbank -> Rechtsklick -> Aufgaben -> Skripte generieren - wird der Assistent zum Generieren von Skripten geöffnet

nach Objekten im Set Scripting Option klicken Auswahl Erweiterte Schaltfläche

  • -> Setzen Sie die Option 'Skript zum Erstellen' auf true (erstellen möchten)
  • -> Setzen Sie die Option ' Script to Drop ' auf true (möchten Sie löschen)
  • -> Aktivieren Sie das Kontrollkästchen, um Objekte auszuwählen, die ein Skript erstellen möchten
  • -> Wählen Sie die Option zum Schreiben eines Skripts (Datei, Neues Fenster, Zwischenablage).
  • Es enthält standardmäßig abhängige Objekte (und lässt zunächst die Einschränkung fallen).

    Führen Sie das Skript aus

Auf diese Weise können wir unser Skript anpassen.

JP Emvia
quelle
In welcher Version ist diese Funktion verfügbar? 2012 sehe ich es nicht.
Veverke
1
Es ist dort in SQL Studio 2012.
Bernhard Döbler
ja, im Jahr 2012 , wenn wenig anders , wenn wir wählten Script Tropfen dort Script zu Tropfen und Skript zur Erstellung in einem gleichen Dropdown - Menü.
Sk Asraf
2
Umfasst dies Sequenzen?
Markus Pscheidt
Dies ist die beste Option, danke @JP
Abdul Azeez
49

So löschen Sie alle Tabellen:

exec sp_MSforeachtable 'DROP TABLE ?'

Dadurch werden natürlich alle Einschränkungen, Trigger usw. gelöscht, alles außer den gespeicherten Prozeduren.

Ich fürchte, für die gespeicherten Prozeduren benötigen Sie eine andere gespeicherte Prozedur, die in gespeichert ist master.

Quassnoi
quelle
Ich weiß nicht, ob sp_MSforeachtable hier funktioniert. Möglicherweise wird versucht, eine Tabelle zu löschen, die noch FKs enthält, und dies würde fehlschlagen.
Tom H
7
Funktioniert super ja. Wenn Fremdschlüssel vorhanden sind, müssen Sie diese nur einige Male ausführen.
Mathias Lykkegaard Lorenzen
Das Objekt 'dbo.sometable' konnte nicht gelöscht werden, da es durch eine FOREIGN KEY-Einschränkung referenziert wird.
Devil's Advocate
stored procedures
Schauen
Nur als Referenz funktioniert dies nicht für Azure PAAS SQL-Datenbanken.
Simon
14

Ich würde es in zwei Aussagen tun: DROP DATABASE ???

und dann CREATE DATABASE ???

Xn0vv3r
quelle
6
Wenn Sie diese Rechte nicht haben und das Skript nicht an jemanden weitergeben können, der über die Ausführungsrechte verfügt, sollten Sie nicht darüber nachdenken, dies zu tun. Es gibt einen Grund, warum Entwickler diese Rechte nicht erhalten.
HLGEM
@HLGEM Einige dba's wissen nicht, wie man Rechte einrichtet. Mein Website-Host erlaubt mir nicht, meine eigene Datenbank zu löschen. Ich denke, Sie benötigen spezielle erhöhte Rechte, um Datenbanken zu löschen, die es Ihnen möglicherweise ermöglichen, Datenbanken anderer Benutzer zu löschen, was ein großes Nein-Nein- und Sicherheitsrisiko darstellt.
Tony_Henrich
1
Im Fall von AWS RDS dauert die Neuerstellung der Datenbank mindestens 15 bis 20 Minuten und Sie möchten die Datenbank nicht neu erstellen
Kamran Qadir
9

Ich habe hier einige Skripte ausprobiert, aber sie haben bei mir nicht funktioniert, da ich meine Tabellen in Schemata habe. Also habe ich folgendes zusammengestellt. Beachten Sie, dass dieses Skript eine Liste von Schemas erstellt und diese dann nacheinander löscht. Sie müssen sicherstellen, dass Ihre Schemas eine vollständige Bestellung enthalten. Wenn es zirkuläre Abhängigkeiten gibt, schlägt dies fehl.

PRINT 'Dropping whole database'
GO

------------------------------------------
-- Drop constraints
------------------------------------------
DECLARE @Sql NVARCHAR(500) DECLARE @Cursor CURSOR

SET @Cursor = CURSOR FAST_FORWARD FOR
SELECT DISTINCT sql = 'ALTER TABLE ['+tc2.CONSTRAINT_SCHEMA+'].[' + tc2.TABLE_NAME + '] DROP [' + rc1.CONSTRAINT_NAME + ']'
FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc1
LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc2 ON tc2.CONSTRAINT_NAME =rc1.CONSTRAINT_NAME

OPEN @Cursor FETCH NEXT FROM @Cursor INTO @Sql

WHILE (@@FETCH_STATUS = 0)
BEGIN
PRINT @Sql
Exec (@Sql)
FETCH NEXT FROM @Cursor INTO @Sql
END

CLOSE @Cursor DEALLOCATE @Cursor
GO


------------------------------------------
-- Drop views
------------------------------------------

DECLARE @sql VARCHAR(MAX) = ''
        , @crlf VARCHAR(2) = CHAR(13) + CHAR(10) ;

SELECT @sql = @sql + 'DROP VIEW ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(v.name) +';' + @crlf
FROM   sys.views v

PRINT @sql;
EXEC(@sql);
GO
------------------------------------------
-- Drop procs
------------------------------------------
PRINT 'Dropping all procs ...'
GO

DECLARE @sql VARCHAR(MAX) = ''
        , @crlf VARCHAR(2) = CHAR(13) + CHAR(10) ;

SELECT @sql = @sql + 'DROP PROC ' + QUOTENAME(SCHEMA_NAME(p.schema_id)) + '.' + QUOTENAME(p.name) +';' + @crlf
FROM   [sys].[procedures] p

PRINT @sql;
EXEC(@sql);
GO

------------------------------------------
-- Drop tables
------------------------------------------
PRINT 'Dropping all tables ...'
GO
EXEC sp_MSForEachTable 'DROP TABLE ?'
GO

------------------------------------------
-- Drop sequences
------------------------------------------

PRINT 'Dropping all sequences ...'
GO
DECLARE @DropSeqSql varchar(1024)
DECLARE DropSeqCursor CURSOR FOR
SELECT DISTINCT 'DROP SEQUENCE ' + s.SEQUENCE_SCHEMA + '.' + s.SEQUENCE_NAME
    FROM INFORMATION_SCHEMA.SEQUENCES s

OPEN DropSeqCursor

FETCH NEXT FROM DropSeqCursor INTO @DropSeqSql

WHILE ( @@FETCH_STATUS <> -1 )
BEGIN
    PRINT @DropSeqSql
    EXECUTE( @DropSeqSql )
    FETCH NEXT FROM DropSeqCursor INTO @DropSeqSql
END

CLOSE DropSeqCursor
DEALLOCATE DropSeqCursor
GO

------------------------------------------
-- Drop Schemas
------------------------------------------


DECLARE @schemas as varchar(1000) = 'StaticData,Ird,DataImport,Collateral,Report,Cds,CommonTrade,MarketData,TypeCode'
DECLARE @schemasXml as xml = cast(('<schema>'+replace(@schemas,',' ,'</schema><schema>')+'</schema>') as xml)

DECLARE @Sql NVARCHAR(500) DECLARE @Cursor CURSOR

SET @Cursor = CURSOR FAST_FORWARD FOR
SELECT sql = 'DROP SCHEMA ['+schemaName+']' FROM 
(SELECT CAST(T.schemaName.query('text()') as VARCHAR(200)) as schemaName FROM @schemasXml.nodes('/schema') T(schemaName)) as X
JOIN information_schema.schemata S on S.schema_name = X.schemaName

OPEN @Cursor FETCH NEXT FROM @Cursor INTO @Sql

WHILE (@@FETCH_STATUS = 0)
BEGIN
PRINT @Sql
Exec (@Sql)
FETCH NEXT FROM @Cursor INTO @Sql
END

CLOSE @Cursor DEALLOCATE @Cursor
GO
David Roussel
quelle
@StuffHappens Hiermit werden Tabellen gelöscht, die sich nicht im Dbo-Schema befinden.
David Roussel
Ich bin mir nicht sicher, warum ich herabgestuft werde, wenn meine Antwort funktioniert, und lösche alle Tabellen, Ansichten und gespeicherten Prozesse, nicht nur die in dbo (im Gegensatz zu der Hauptantwort, die bei mir nicht funktioniert hat)
David Roussel
7

Sichern Sie eine vollständig leere Datenbank. Anstatt alle Objekte zu löschen, stellen Sie einfach die Sicherung wieder her.

AK
quelle
3
Eine gute Beispieldatenbank zum Sichern und Wiederherstellen über Ihre Datenbank ist die Modelldatenbank, da hier CREATE DATABASE die Vorlage für neue Datenbanken erhält.
David Parvin
7

Folgendes habe ich versucht:

SELECT 'DROP TABLE [' + SCHEMA_NAME(schema_id) + '].[' + name + ']' FROM sys.tables

Was auch immer die Ausgabe sein mag, kopieren Sie einfach alle und fügen Sie eine neue Abfrage ein und drücken Sie Ausführen. Dadurch werden alle Tabellen gelöscht.

Draufgänger
quelle
3

Ich habe heute Abend versehentlich ein DB-Init-Skript für meine Master-Datenbank ausgeführt. Jedenfalls bin ich schnell auf diesen Thread gestoßen. Ich habe Folgendes verwendet: exec sp_MSforeachtable 'DROP TABLE?' antworte, musste es aber mehrmals ausführen, bis es keinen Fehler mehr gab (Abhängigkeiten). Danach bin ich auf einige andere Threads gestoßen und habe diese zusammengesetzt, um alle gespeicherten Prozeduren und Funktionen zu löschen.

DECLARE mycur CURSOR FOR select O.type_desc,schema_id,O.name
from 
    sys.objects             O LEFT OUTER JOIN
    sys.extended_properties E ON O.object_id = E.major_id
WHERE
    O.name IS NOT NULL
    AND ISNULL(O.is_ms_shipped, 0) = 0
    AND ISNULL(E.name, '') <> 'microsoft_database_tools_support'
    AND ( O.type_desc = 'SQL_STORED_PROCEDURE' OR O.type_desc = 'SQL_SCALAR_FUNCTION' )
ORDER BY O.type_desc,O.name;

OPEN mycur;

DECLARE @schema_id int;
DECLARE @fname varchar(256);
DECLARE @sname varchar(256);
DECLARE @ftype varchar(256);

FETCH NEXT FROM mycur INTO @ftype, @schema_id, @fname;

WHILE @@FETCH_STATUS = 0
BEGIN
    SET @sname = SCHEMA_NAME( @schema_id );
    IF @ftype = 'SQL_STORED_PROCEDURE'
        EXEC( 'DROP PROCEDURE "' + @sname + '"."' + @fname + '"' );
    IF @ftype = 'SQL_SCALAR_FUNCTION'
        EXEC( 'DROP FUNCTION "' + @sname + '"."' + @fname + '"' );

    FETCH NEXT FROM mycur INTO @ftype, @schema_id, @fname;
END

CLOSE mycur
DEALLOCATE mycur

GO
Judoka
quelle
2

Versuche dies

Select 'ALTER TABLE ' + Table_Name  +'  drop constraint ' + Constraint_Name  from Information_Schema.CONSTRAINT_TABLE_USAGE

Select 'drop Procedure ' + specific_name  from Information_Schema.Routines where specific_name not like 'sp%' AND specific_name not like 'fn_%'

Select 'drop View ' + table_name  from Information_Schema.tables where Table_Type = 'VIEW'

SELECT 'DROP TRIGGER ' + name FROM sysobjects WHERE type = 'tr'

Select 'drop table ' + table_name  from Information_Schema.tables where Table_Type = 'BASE TABLE'
Sakthivel Murugesan
quelle
2

Zusätzlich zu @ Iwans Antwort müssen alle Typen enthalten sein

    /* Drop all Types */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sys.types where is_user_defined = 1 ORDER BY [name])

WHILE @name IS NOT NULL
BEGIN
    SELECT @SQL = 'DROP TYPE [dbo].[' + RTRIM(@name) +']'
    EXEC (@SQL)
    PRINT 'Dropped Type: ' + @name
    SELECT @name = (SELECT TOP 1 [name] FROM sys.types where is_user_defined = 1 AND [name] > @name ORDER BY [name])
END
GO
Ephraim
quelle
1

Sie müssen alle triggersund constraintszuerst deaktivieren .

EXEC sp_MSforeachtable @command1="ALTER TABLE ? NOCHECK CONSTRAINT ALL"

EXEC sp_MSforeachtable @command1="ALTER TABLE ? DISABLE TRIGGER ALL"

Danach können Sie die Skripte zum Löschen der Objekte als generieren

SELECT 'Drop Table '+name FROM sys.tables WHERE type='U';

SELECT 'Drop Procedure '+name FROM  sys.procedures WHERE type='P';

Führen Sie die generierten Anweisungen aus.

Jesalcv
quelle
0

Scheint mir ein ziemlich gefährliches Feature zu sein. Wenn Sie so etwas implementieren würden, würde ich sicherstellen, dass es so gesichert ist, dass Sie es nicht pro Unfall ausführen können.

Wie bereits vorgeschlagen, können Sie selbst eine gespeicherte Prozedur erstellen. In SQL Server 2005 können Sie diese Systemtabelle durchsuchen, um die Objekte zu ermitteln und zu finden, die Sie löschen möchten.

select * from sys.objects
Roel Snetselaar
quelle
0

Hier habe ich eine neue Abfrage gefunden, um alle SP, Funktionen und Trigger zu löschen

declare @procName varchar(500)
declare cur cursor 

for select [name] from sys.objects where type = 'p'
open cur
fetch next from cur into @procName
while @@fetch_status = 0
begin
    exec('drop procedure ' + @procName)
    fetch next from cur into @procName
end
close cur
deallocate cur
Anant Dabhi
quelle
0

Um Iwans Antwort zu ergänzen, musste ich auch alle benutzerdefinierten Typen löschen, also habe ich dies dem Skript hinzugefügt:

/* Drop all user-defined types */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)

SELECT @name = (select TOP 1 [name] from sys.types where is_user_defined = 1)

WHILE @name IS NOT NULL
BEGIN
    SELECT @SQL = 'DROP TYPE [dbo].[' + RTRIM(@name) +']'
    EXEC (@SQL)
    PRINT 'Dropped Type: ' + @name
    SELECT @name = (select TOP 1 [name] from sys.types where is_user_defined = 1)
END
GO
Soniku
quelle
0

Es gibt keine einzige Aussage, mit der dieses Ziel erreicht werden kann.

Sie können sich natürlich eine erstellen stored procedure , mit der Sie diese verschiedenen Verwaltungsaufgaben ausführen können.

Sie können die Prozedur dann mit dieser einzelnen Anweisung ausführen.

Exec sp_CleanDatabases @DatabaseName='DBname'
John Sansom
quelle
0
DECLARE @name VARCHAR(255)
DECLARE @type VARCHAR(10)
DECLARE @prefix VARCHAR(255)
DECLARE @sql VARCHAR(255)

DECLARE curs CURSOR FOR
SELECT [name], xtype
FROM sysobjects
WHERE xtype IN ('U', 'P', 'FN', 'IF', 'TF', 'V', 'TR') -- Configuration point 1
ORDER BY name

OPEN curs
FETCH NEXT FROM curs INTO @name, @type

WHILE @@FETCH_STATUS = 0
BEGIN
-- Configuration point 2
SET @prefix = CASE @type
WHEN 'U' THEN 'DROP TABLE'
WHEN 'P' THEN 'DROP PROCEDURE'
WHEN 'FN' THEN 'DROP FUNCTION'
WHEN 'IF' THEN 'DROP FUNCTION'
WHEN 'TF' THEN 'DROP FUNCTION'
WHEN 'V' THEN 'DROP VIEW'
WHEN 'TR' THEN 'DROP TRIGGER'
END

SET @sql = @prefix + ' ' + @name
PRINT @sql
EXEC(@sql)
FETCH NEXT FROM curs INTO @name, @type
END

CLOSE curs
DEALLOCATE curs
Jigs
quelle
0

So entfernen Sie alle Objekte im Orakel:

1) Dynamisch

DECLARE
CURSOR IX IS
SELECT * FROM ALL_OBJECTS WHERE OBJECT_TYPE ='TABLE' 
AND OWNER='SCHEMA_NAME';
 CURSOR IY IS
 SELECT * FROM ALL_OBJECTS WHERE OBJECT_TYPE 
IN ('SEQUENCE',
'PROCEDURE',
'PACKAGE',
'FUNCTION',
'VIEW') AND  OWNER='SCHEMA_NAME';
 CURSOR IZ IS
 SELECT * FROM ALL_OBJECTS WHERE OBJECT_TYPE IN ('TYPE') AND  OWNER='SCHEMA_NAME';
BEGIN
 FOR X IN IX LOOP
   EXECUTE IMMEDIATE('DROP '||X.OBJECT_TYPE||' '||X.OBJECT_NAME|| ' CASCADE CONSTRAINT');
 END LOOP;
 FOR Y IN IY LOOP
   EXECUTE IMMEDIATE('DROP '||Y.OBJECT_TYPE||' '||Y.OBJECT_NAME);
 END LOOP;
 FOR Z IN IZ LOOP
   EXECUTE IMMEDIATE('DROP '||Z.OBJECT_TYPE||' '||Z.OBJECT_NAME||' FORCE ');
 END LOOP;
END;
/

2) Statisch

    SELECT 'DROP TABLE "' || TABLE_NAME || '" CASCADE CONSTRAINTS;' FROM user_tables
        union ALL
        select 'drop '||object_type||' '|| object_name || ';' from user_objects 
        where object_type in ('VIEW','PACKAGE','SEQUENCE', 'PROCEDURE', 'FUNCTION')
        union ALL
        SELECT 'drop '
        ||object_type
        ||' '
        || object_name
        || ' force;'
        FROM user_objects
        WHERE object_type IN ('TYPE');
Goyal Vicky
quelle
0

Versuchen Sie dies mit sql2012 oder höher.

Dies ist hilfreich, um alle Objekte nach ausgewähltem Schema zu löschen

DECLARE @MySchemaName VARCHAR(50)='dbo', @sql VARCHAR(MAX)='';
DECLARE @SchemaName VARCHAR(255), @ObjectName VARCHAR(255), @ObjectType VARCHAR(255), @ObjectDesc VARCHAR(255), @Category INT;

DECLARE cur CURSOR FOR
    SELECT  (s.name)SchemaName, (o.name)ObjectName, (o.type)ObjectType,(o.type_desc)ObjectDesc,(so.category)Category
    FROM    sys.objects o
    INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
    INNER JOIN sysobjects so ON so.name=o.name
    WHERE s.name = @MySchemaName
    AND so.category=0
    AND o.type IN ('P','PC','U','V','FN','IF','TF','FS','FT','PK','TT')

OPEN cur
FETCH NEXT FROM cur INTO @SchemaName,@ObjectName,@ObjectType,@ObjectDesc,@Category

SET @sql='';
WHILE @@FETCH_STATUS = 0 BEGIN    
    IF @ObjectType IN('FN', 'IF', 'TF', 'FS', 'FT') SET @sql=@sql+'Drop Function '+@MySchemaName+'.'+@ObjectName+CHAR(13)
    IF @ObjectType IN('V') SET @sql=@sql+'Drop View '+@MySchemaName+'.'+@ObjectName+CHAR(13)
    IF @ObjectType IN('P') SET @sql=@sql+'Drop Procedure '+@MySchemaName+'.'+@ObjectName+CHAR(13)
    IF @ObjectType IN('U') SET @sql=@sql+'Drop Table '+@MySchemaName+'.'+@ObjectName+CHAR(13)

    --PRINT @ObjectName + ' | ' + @ObjectType
    FETCH NEXT FROM cur INTO @SchemaName,@ObjectName,@ObjectType,@ObjectDesc,@Category
END
CLOSE cur;    
DEALLOCATE cur;
SET @sql=@sql+CASE WHEN LEN(@sql)>0 THEN 'Drop Schema '+@MySchemaName+CHAR(13) ELSE '' END
PRINT @sql
EXECUTE (@sql)
Haseeb
quelle
0

Eine andere Alternative wäre:

DROP SCHEMA public CASCADE;
CREATE SCHEMA public;
Carkod
quelle
-1

Versuche dies....

USE DATABASE
GO
DECLARE @tname VARCHAR(150)
DECLARE @strsql VARCHAR(300)

SELECT @tname = (SELECT TOP 1 [name] FROM sys.objects WHERE [type] = 'U' and [name] like N'TableName%' ORDER BY [name])

WHILE @tname IS NOT NULL
BEGIN
    SELECT @strsql = 'DROP TABLE [dbo].[' + RTRIM(@tname) +']'
    EXEC (@strsql)
    PRINT 'Dropped Table : ' + @tname
    SELECT @tname = (SELECT TOP 1 [name] FROM sys.objects WHERE [type] = 'U' AND [name] like N'TableName%'  AND [name] > @tname ORDER BY [name])
END
Paul S.
quelle