Supprimez toutes les tables, procédures stockées, déclencheurs, contraintes et toutes les dépendances dans une seule instruction SQL

287

Existe-t-il un moyen de nettoyer une base de données dans SQl Server 2005 en supprimant toutes les tables et en supprimant les procédures stockées, les déclencheurs, les contraintes et toutes les dépendances dans une seule instruction SQL?

MOTIF DE LA DEMANDE:

Je veux avoir un script de base de données pour nettoyer une base de données existante qui n'est pas utilisée plutôt que d'en créer de nouvelles, surtout lorsque vous devez soumettre une demande à votre administrateur de base de données et attendre un certain temps pour le faire!

renegadeMind
la source

Réponses:

604

ce script nettoie toutes les vues, SPS, fonctions PKs, FKs et tables.

/* 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
la source
14
Que faire si j'ai des tables qui ne sont pas dans le schéma dbo?
StuffHappens
8
Ce script ne prend définitivement pas en compte les autres schémas (autres que dbo). Je l'ai testé et il fonctionne pour toujours. J'imagine qu'il pourrait être modifié pour ce scénario.
W3Max
1
Ce script fonctionne assez bien. Il manque quelques éléments, vous devez tenir compte des assemblys et des types définis par l'utilisateur. Ainsi, à titre d'exemple dans votre procédure de suppression, faites [type] = 'P' OU [type] = 'PC' également lorsque vous supprimez l'assembly, effectuez une commande par assembly_ID desc afin que les dépendances soient supprimées dans le bon ordre.
Brian
1
Il semble inutile de supprimer toutes les clés primaires séparément; laisser tomber les tables devrait s'en occuper
erikkallen
1
@erikkallen la raison pour laquelle les clés primaires doivent être supprimées en premier est pour que les tables puissent ensuite être supprimées dans n'importe quel ordre sans se soucier des dépendances de clé étrangère. Sans cela, un ordre de suppression complexe devrait être utilisé pour garantir que tous les types d'entités faibles sont supprimés avant les types d'entités solides, sinon le script échouerait avec des violations de contraintes d'intégrité référentielle.
Jeff Puckett
118

J'utilise ce script d'Adam Anderson, mis à jour pour prendre en charge des objets dans d'autres schémas que dbo.

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

Source: un article de blog d'Adam Anderson

Vlad Iliescu
la source
3
presque parfait, mais il y a un cas de bord fou / stupide: un tableau avec une colonne calculée en utilisant une fonction. Mais déplacez simplement la partie des fonctions de dépôt et vous êtes prêt à partir!
Akos Lukacs
1
fonctionne très bien, il essaiera de supprimer la vue sys.database_firewall_rules si vous l'exécutez sur une base de données SQL Azure PAAS mais comme l'azur l'empêche de tomber.
Simon
J'ai ajouté ceci après "from sys.views" pour résoudre le problème Azure SQL: WHERE schema_name (schema_id)! = 'Sys'
UnionP
Vous avez manqué ceci: -- 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

La meilleure chose à faire est " Générer des scripts pour Drop "

Sélectionnez Base de données -> Clic droit -> Tâches -> Générer des scripts - ouvrira l' assistant de génération de scripts

après avoir choisi des objets dans l'option de script définie, cliquez sur le bouton Avancé

  • -> Définissez l'option 'Script à créer' sur true (souhaitez créer)

  • -> Définissez l'option " Script à supprimer" sur true (souhaitez supprimer)

  • -> Cochez la case pour sélectionner les objets qui souhaitent créer un script

  • -> Sélectionnez le choix pour écrire le script (Fichier, Nouvelle fenêtre, Presse-papiers)

  • Il inclut les objets dépendants par défaut (et supprimera la contrainte au début)

    Exécutez le script

De cette façon, nous pouvons personnaliser notre script.

JP Emvia
la source
Dans quelle version cette fonctionnalité est-elle disponible? En 2012 je ne le vois pas.
Veverke
1
Il est là dans SQL Studio 2012.
Bernhard Döbler
oui, en 2012 quand peu différent quand on choisit Script à déposerScript à déposer et Script à créer dans une même liste déroulante.
Sk Asraf
2
Cela inclut-il des séquences?
Markus Pscheidt
C'est la meilleure option, merci @JP
Abdul Azeez
49

Pour supprimer toutes les tables:

exec sp_MSforeachtable 'DROP TABLE ?'

Bien entendu, cela supprimera toutes les contraintes, déclencheurs, etc., tout sauf les procédures stockées.

Pour les procédures stockées, je crains que vous n'ayez besoin d'une autre procédure stockée master.

Quassnoi
la source
Je ne sais pas si sp_MSforeachtable fonctionnera ici. Il peut essayer de supprimer une table qui contient encore des FK et qui échouerait.
Tom H
7
Fonctionne très bien ouais. Si des clés étrangères sont présentes, il vous suffit de l'exécuter plusieurs fois.
Mathias Lykkegaard Lorenzen
Impossible de supprimer l'objet 'dbo.sometable' car il est référencé par une contrainte FOREIGN KEY.
Devil's Advocate
consultez cet article pour supprimer stored proceduresetc.
shaijut
juste pour référence, cela ne fonctionnera pas pour les bases de données SQL Azure PAAS.
Simon
14

Je le ferais en deux déclarations: DROP DATABASE ???

puis CREATE DATABASE ???

Xn0vv3r
la source
6
Si vous ne disposez pas de ces droits et que vous ne pouvez pas donner le script à quelqu'un qui a les droits d'exécution, vous ne devriez pas envisager de le faire. Il y a une raison pour laquelle les développeurs n'obtiennent pas ces droits.
HLGEM
@HLGEM Certains dba ne savent pas comment configurer les droits. L'hébergeur de mon site Web ne me permet pas de supprimer ma propre base de données. Je pense que vous avez besoin de droits élevés spéciaux pour supprimer des bases de données, ce qui pourrait vous permettre de supprimer d'autres bases de données d'utilisateurs, ce qui est un gros non et un risque pour la sécurité.
Tony_Henrich
1
Dans le cas d'AWS RDS, la recréation de db prend au moins 15-20 minutes et ne veut pas recréer db
Kamran Qadir
9

J'ai essayé certains des scripts ici, mais ils n'ont pas fonctionné pour moi, car j'ai mes tables dans les schémas. J'ai donc mis en place ce qui suit. Notez que ce script prend une liste de schémas, puis les supprime en séquence. Vous devez vous assurer que vous avez une commande complète dans vos schémas. S'il existe des dépendances circulaires, cela échouera.

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
la source
@StuffHappens cela supprimera les tables qui ne sont pas dans le schéma dbo.
David Roussel
Je ne sais pas pourquoi je suis rétrogradé lorsque ma réponse fonctionne et supprime toutes les tables, vues et proc stockés, pas seulement ceux de dbo (contrairement à la réponse principale qui ne fonctionnait pas pour moi)
David Roussel
7

Sauvegardez une base de données complètement vide. Au lieu de supprimer tous les objets, restaurez simplement la sauvegarde.

AK
la source
3
un bon exemple de base de données à sauvegarder et restaurer sur votre base de données serait la base de données modèle, car c'est là que CREATE DATABASE obtient le modèle pour les nouvelles bases de données.
David Parvin
7

Voici ce que j'ai essayé:

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

Quelle que soit la sortie imprimée, il suffit de tout copier et coller dans la nouvelle requête et d'appuyer sur Exécuter. Cela supprimera toutes les tables.

DareDevil
la source
3

J'ai accidentellement exécuté un script d'initialisation db contre ma base de données master ce soir. Quoi qu'il en soit, je suis rapidement tombé sur ce fil. J'ai utilisé: exec sp_MSforeachtable 'DROP TABLE?' réponse, mais a dû l'exécuter plusieurs fois jusqu'à ce qu'il ne se soit pas produit d'erreur (dépendances.) Après cela, je suis tombé sur d'autres threads et j'ai reconstitué cela pour supprimer toutes les procédures et fonctions stockées.

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
la source
2

Essaye ça

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
la source
2

En plus de la réponse de @ Ivan, tous les types doivent être inclus

    /* 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
la source
1

Vous devez désactiver tout triggerset d' constraintsabord.

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

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

Après cela, vous pouvez générer les scripts pour supprimer les objets comme

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

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

Exécutez les instructions générées.

Jesalcv
la source
0

Cela me semble une caractéristique plutôt dangereuse. Si vous implémentez quelque chose comme ça, je m'assurerais de le sécuriser correctement de manière à ce que vous ne puissiez pas exécuter cela par accident.

Comme suggéré précédemment, vous pouvez créer vous-même une sorte de procédure stockée. Dans SQL Server 2005, vous pouvez consulter cette table système pour déterminer et rechercher les objets que vous souhaitez supprimer.

select * from sys.objects
Roel Snetselaar
la source
0

Ici, j'ai trouvé une nouvelle requête pour supprimer tous les sp, fonctions et déclencheurs

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
la source
0

Pour ajouter à la réponse d'Ivan, j'ai également eu besoin de supprimer tous les types définis par l'utilisateur, j'ai donc ajouté ceci au script:

/* 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
la source
0

Aucune déclaration ne peut être utilisée pour atteindre cet objectif.

Vous pouvez bien sûr vous créer un stored procedure que vous pourriez utiliser pour effectuer ces différentes tâches administratives.

Vous pouvez ensuite exécuter la procédure à l'aide de cette seule instruction.

Exec sp_CleanDatabases @DatabaseName='DBname'
John Sansom
la source
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
gabarit
la source
0

Pour supprimer tous les objets dans Oracle:

1) Dynamique

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) Statique

    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
la source
0

essayez ceci avec sql2012 ou supérieur,

ce sera aider à supprimer tous les objets par le schéma sélectionné

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
la source
0

Une autre alternative serait:

DROP SCHEMA public CASCADE;
CREATE SCHEMA public;
carkod
la source
-1

essaye ça....

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
la source