Não é possível truncar a tabela porque ela está sendo referenciada por uma restrição FOREIGN KEY?

459

Usando o MSSQL2005, posso truncar uma tabela com uma restrição de chave estrangeira se primeiro truncar a tabela filho (a tabela com a chave primária do relacionamento FK)?

Eu sei que eu posso

  • Use uma DELETEcláusula sem um onde e depois RESEEDa identidade (ou)
  • Remova o FK, trunque a tabela e recrie o FK.

Eu pensei que, desde que eu truncasse a tabela filho antes do pai, eu ficaria bem sem fazer nenhuma das opções acima, mas estou recebendo este erro:

Não é possível truncar a tabela 'TableName' porque está sendo referenciada por uma restrição FOREIGN KEY.

ctrlShiftBryan
fonte

Respostas:

379

Corrigir; você não pode truncar uma tabela que tenha uma restrição de FK.

Normalmente, meu processo para isso é:

  1. Abandone as restrições
  2. Truncar a tabela
  3. Recrie as restrições.

(Tudo em uma transação, é claro.)

Obviamente, isso só se aplica se a criança já tiver sido truncada. Caso contrário, seguirei uma rota diferente, totalmente dependente da aparência dos meus dados. (Muitas variáveis ​​para entrar aqui.)

O pôster original determinou POR QUE esse é o caso; veja esta resposta para mais detalhes.

John Rudy
fonte
73
Um "DELETE FROM" não redefine as colunas de incremento automático. Um truncado faz. Eles não são funcionalmente equivalentes.
precisa saber é o seguinte
35
Truncar geralmente é exatamente o que você deseja fazer se estiver excluindo grandes quantidades de dados. Truncar um milhão de linhas? Um Bilhão? 1 ms ... então, @ M07, não diga "excluir da abordagem é mais limpo", porque isso não é remotamente preciso.
Ctb # 16/16
1
Após excluir dados grandes, o usuário precisa reduzir as tabelas e os arquivos de log também para recuperar o espaço em disco.
Muhammad Yousaf Sulahria 22/10
2
O botão Magic Shrink (ou script) não é recomendado 99% do tempo.
Tom Stickel
1
E como você faria isso? Solicitações de exemplo?
Jeromej #
356
DELETE FROM TABLENAME
DBCC CHECKIDENT ('DATABASENAME.dbo.TABLENAME',RESEED, 0)

Observe que isso provavelmente não é o que você deseja se tiver milhões + de registros, pois é muito lento.

s15199d
fonte
Essa foi a maneira útil e mais rápida do que desabilitar e habilitar a restrição.
sensei
Isso funcionará apenas para tabelas com menos dados. Concordo com @Pure
Dhanuka777
1
Isso é ótimo para quando você é feito testando um esquema
ohmusama
3
Eu não sugeriria indo por este caminho, como você também pode obter este erro: A instrução DELETE entrou em conflito com a restrição REFERÊNCIA
sksallaj
não funcionou para mim. Ainda obtendo A instrução DELETE entra em conflito com a restrição REFERENCE.
Emirhosseini
192

Por TRUNCATE TABLEser um comando DDL , ele não pode verificar se os registros na tabela estão sendo referenciados por um registro na tabela filho.

É por isso que DELETEfunciona e TRUNCATE TABLEnão funciona : porque o banco de dados pode garantir que não está sendo referenciado por outro registro.

ctrlShiftBryan
fonte
92

Sem ALTER TABLE

-- Delete all records
DELETE FROM [TableName]
-- Set current ID to "1"
-- If table already contains data, use "0"
-- If table is empty and never insert data, use "1"
-- Use SP https://github.com/reduardo7/TableTruncate
DBCC CHECKIDENT ([TableName], RESEED, 0)

Como procedimento armazenado

https://github.com/reduardo7/TableTruncate

Observe que provavelmente não é o que você deseja se tiver milhões de registros, pois é muito lento.

Eduardo Cuomo
fonte
3
usando a reinicialização do novo valor = 1 após DELETE FROM iniciar tudo a partir do ID 2, em vez de 1. Do Technet ( technet.microsoft.com/en-us/library/ms176057%28SQL.90%29.aspx ) Se nenhuma linha tiver sido inserido na tabela desde que foi criado ou todas as linhas foram removidas usando a instrução TRUNCATE TABLE, a primeira linha inserida após a execução do DBCC CHECKIDENT usa new_reseed_value como identidade. Caso contrário, a próxima linha inserida usará new_reseed_value + o valor atual de incremento.
Zoran P.
@ZoranP. consulte a variante de procedimento armazenado: github.com/reduardo7/TableTruncate
Eduardo Cuomo
4
DBCC CHECKIDENT ([TableName], RESEED, 0) não 1
Tico Fortes
1
@TicoFortes Post atualizado. Consulte a variante de procedimento armazenado
Eduardo Cuomo
1
Esta não é uma boa abordagem. Como comentado pelas 700 outras versões desta mesma resposta a esta pergunta. A menos que seu banco de dados esteja no modo de recuperação Simples, para limitar o log de transações.
Pimbrouwers
68

A solução @denver_citizen fornecida acima não funcionou para mim, mas eu gostei do espírito, então modifiquei algumas coisas:

  • tornou um procedimento armazenado
  • mudou a maneira como as chaves estrangeiras são preenchidas e recriadas
  • o script original trunca todas as tabelas referenciadas, isso pode causar erro de violação de chave estrangeira quando a tabela referenciada tem outras referências de chave estrangeira. Este script trunca apenas a tabela especificada como parâmetro. Cabe ao usuário chamar esse procedimento armazenado várias vezes em todas as tabelas na ordem correta

Para o benefício do público, aqui está o script atualizado:

CREATE PROCEDURE [dbo].[truncate_non_empty_table]

  @TableToTruncate                 VARCHAR(64)

AS 

BEGIN

SET NOCOUNT ON

-- GLOBAL VARIABLES
DECLARE @i int
DECLARE @Debug bit
DECLARE @Recycle bit
DECLARE @Verbose bit
DECLARE @TableName varchar(80)
DECLARE @ColumnName varchar(80)
DECLARE @ReferencedTableName varchar(80)
DECLARE @ReferencedColumnName varchar(80)
DECLARE @ConstraintName varchar(250)

DECLARE @CreateStatement varchar(max)
DECLARE @DropStatement varchar(max)   
DECLARE @TruncateStatement varchar(max)
DECLARE @CreateStatementTemp varchar(max)
DECLARE @DropStatementTemp varchar(max)
DECLARE @TruncateStatementTemp varchar(max)
DECLARE @Statement varchar(max)

        -- 1 = Will not execute statements 
 SET @Debug = 0
        -- 0 = Will not create or truncate storage table
        -- 1 = Will create or truncate storage table
 SET @Recycle = 0
        -- 1 = Will print a message on every step
 set @Verbose = 1

 SET @i = 1
    SET @CreateStatement = 'ALTER TABLE [dbo].[<tablename>]  WITH NOCHECK ADD  CONSTRAINT [<constraintname>] FOREIGN KEY([<column>]) REFERENCES [dbo].[<reftable>] ([<refcolumn>])'
    SET @DropStatement = 'ALTER TABLE [dbo].[<tablename>] DROP CONSTRAINT [<constraintname>]'
    SET @TruncateStatement = 'TRUNCATE TABLE [<tablename>]'

-- Drop Temporary tables

IF OBJECT_ID('tempdb..#FKs') IS NOT NULL
    DROP TABLE #FKs

-- GET FKs
SELECT ROW_NUMBER() OVER (ORDER BY OBJECT_NAME(parent_object_id), clm1.name) as ID,
       OBJECT_NAME(constraint_object_id) as ConstraintName,
       OBJECT_NAME(parent_object_id) as TableName,
       clm1.name as ColumnName, 
       OBJECT_NAME(referenced_object_id) as ReferencedTableName,
       clm2.name as ReferencedColumnName
  INTO #FKs
  FROM sys.foreign_key_columns fk
       JOIN sys.columns clm1 
         ON fk.parent_column_id = clm1.column_id 
            AND fk.parent_object_id = clm1.object_id
       JOIN sys.columns clm2
         ON fk.referenced_column_id = clm2.column_id 
            AND fk.referenced_object_id= clm2.object_id
 --WHERE OBJECT_NAME(parent_object_id) not in ('//tables that you do not wont to be truncated')
 WHERE OBJECT_NAME(referenced_object_id) = @TableToTruncate
 ORDER BY OBJECT_NAME(parent_object_id)


-- Prepare Storage Table
IF Not EXISTS(SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Internal_FK_Definition_Storage')
   BEGIN
        IF @Verbose = 1
     PRINT '1. Creating Process Specific Tables...'

  -- CREATE STORAGE TABLE IF IT DOES NOT EXISTS
  CREATE TABLE [Internal_FK_Definition_Storage] 
  (
   ID int not null identity(1,1) primary key,
   FK_Name varchar(250) not null,
   FK_CreationStatement varchar(max) not null,
   FK_DestructionStatement varchar(max) not null,
   Table_TruncationStatement varchar(max) not null
  ) 
   END 
ELSE
   BEGIN
        IF @Recycle = 0
            BEGIN
                IF @Verbose = 1
       PRINT '1. Truncating Process Specific Tables...'

    -- TRUNCATE TABLE IF IT ALREADY EXISTS
    TRUNCATE TABLE [Internal_FK_Definition_Storage]    
      END
      ELSE
         PRINT '1. Process specific table will be recycled from previous execution...'
   END


IF @Recycle = 0
   BEGIN

  IF @Verbose = 1
     PRINT '2. Backing up Foreign Key Definitions...'

  -- Fetch and persist FKs             
  WHILE (@i <= (SELECT MAX(ID) FROM #FKs))
   BEGIN
    SET @ConstraintName = (SELECT ConstraintName FROM #FKs WHERE ID = @i)
    SET @TableName = (SELECT TableName FROM #FKs WHERE ID = @i)
    SET @ColumnName = (SELECT ColumnName FROM #FKs WHERE ID = @i)
    SET @ReferencedTableName = (SELECT ReferencedTableName FROM #FKs WHERE ID = @i)
    SET @ReferencedColumnName = (SELECT ReferencedColumnName FROM #FKs WHERE ID = @i)

    SET @DropStatementTemp = REPLACE(REPLACE(@DropStatement,'<tablename>',@TableName),'<constraintname>',@ConstraintName)
    SET @CreateStatementTemp = REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(@CreateStatement,'<tablename>',@TableName),'<column>',@ColumnName),'<constraintname>',@ConstraintName),'<reftable>',@ReferencedTableName),'<refcolumn>',@ReferencedColumnName)
    SET @TruncateStatementTemp = REPLACE(@TruncateStatement,'<tablename>',@TableName) 

    INSERT INTO [Internal_FK_Definition_Storage]
                        SELECT @ConstraintName, @CreateStatementTemp, @DropStatementTemp, @TruncateStatementTemp

    SET @i = @i + 1

    IF @Verbose = 1
       PRINT '  > Backing up [' + @ConstraintName + '] from [' + @TableName + ']'

    END   
    END   
    ELSE 
       PRINT '2. Backup up was recycled from previous execution...'

       IF @Verbose = 1
     PRINT '3. Dropping Foreign Keys...'

    -- DROP FOREING KEYS
    SET @i = 1
    WHILE (@i <= (SELECT MAX(ID) FROM [Internal_FK_Definition_Storage]))
          BEGIN
             SET @ConstraintName = (SELECT FK_Name FROM [Internal_FK_Definition_Storage] WHERE ID = @i)
    SET @Statement = (SELECT FK_DestructionStatement FROM [Internal_FK_Definition_Storage] WITH (NOLOCK) WHERE ID = @i)

    IF @Debug = 1 
       PRINT @Statement
    ELSE
       EXEC(@Statement)

    SET @i = @i + 1


    IF @Verbose = 1
       PRINT '  > Dropping [' + @ConstraintName + ']'

             END     


    IF @Verbose = 1
       PRINT '4. Truncating Tables...'

    -- TRUNCATE TABLES
-- SzP: commented out as the tables to be truncated might also contain tables that has foreign keys
-- to resolve this the stored procedure should be called recursively, but I dont have the time to do it...          
 /*
    SET @i = 1
    WHILE (@i <= (SELECT MAX(ID) FROM [Internal_FK_Definition_Storage]))
          BEGIN

    SET @Statement = (SELECT Table_TruncationStatement FROM [Internal_FK_Definition_Storage] WHERE ID = @i)

    IF @Debug = 1 
       PRINT @Statement
    ELSE
       EXEC(@Statement)

    SET @i = @i + 1

    IF @Verbose = 1
       PRINT '  > ' + @Statement
          END
*/          


    IF @Verbose = 1
       PRINT '  > TRUNCATE TABLE [' + @TableToTruncate + ']'

    IF @Debug = 1 
        PRINT 'TRUNCATE TABLE [' + @TableToTruncate + ']'
    ELSE
        EXEC('TRUNCATE TABLE [' + @TableToTruncate + ']')


    IF @Verbose = 1
       PRINT '5. Re-creating Foreign Keys...'

    -- CREATE FOREING KEYS
    SET @i = 1
    WHILE (@i <= (SELECT MAX(ID) FROM [Internal_FK_Definition_Storage]))
          BEGIN
             SET @ConstraintName = (SELECT FK_Name FROM [Internal_FK_Definition_Storage] WHERE ID = @i)
    SET @Statement = (SELECT FK_CreationStatement FROM [Internal_FK_Definition_Storage] WHERE ID = @i)

    IF @Debug = 1 
       PRINT @Statement
    ELSE
       EXEC(@Statement)

    SET @i = @i + 1


    IF @Verbose = 1
       PRINT '  > Re-creating [' + @ConstraintName + ']'

          END

    IF @Verbose = 1
       PRINT '6. Process Completed'


END
Peter Szanto
fonte
11
Esta resposta merece mais votos! Na verdade, eu ficaria feliz em comprar uma cerveja para você, se eu pudesse, Peter :) #
23415 nsimeonov
Hoje, foi uma grande ajuda para mim limpar rapidamente algumas tabelas grandes de seus dados para teste. Obrigado pelo trabalho de qualidade nisso.
Craig Selbert
4
Obrigado por este pedaço de código. Mas cuidado, você deve adicionar uma lógica adicional para verificar os FKs desativados. Caso contrário, você ativará as restrições atualmente desativadas.
Andre Figueiredo
2
Fiz uma versão com as sugestões de @AndreFigueiredo. Estou colocando no Gitlab: gitlab.com/ranolfi/truncate-referenced-table . Sinta-se livre para incorporar o código à sua resposta.
Marc.2377
1
Isso é ótimo, mas observe que não funcionará se suas tabelas não estiverem no esquema padrão (dbo).
Sidewinder94
19

use o seguinte comando após a exclusão de todas as linhas nessa tabela usando a instrução delete

delete from tablename

DBCC CHECKIDENT ('tablename', RESEED, 0)

Edição: sintaxe corrigida para o SQL Server

abdelwahed
fonte
9
TRUNCATEevita o log e é consideravelmente mais rápido do que DELETEpara tabelas grandes. Como tal, esta não é uma solução equivalente verdadeira.
siride
1
Como é esta resposta diferente do que um , que foi dada um ano antes?
Ofer Zelig
17

Bem, como não encontrei exemplos da solução muito simples que usei, que é:

  1. Soltar chave estrangeira;
  2. Truncar tabela
  3. Recriar chave estrangeira

Aqui vai:

1) Encontre o nome da chave estrangeira que está causando a falha (por exemplo: FK_PROBLEM_REASON, com campo ID, da tabela TABLE_OWNING_CONSTRAINT) 2) Remova essa chave da tabela:

ALTER TABLE TABLE_OWNING_CONSTRAINT DROP CONSTRAINT FK_PROBLEM_REASON

3) Truncar tabela desejada

TRUNCATE TABLE TABLE_TO_TRUNCATE

4) Volte a adicionar a chave à primeira tabela:

ALTER TABLE TABLE_OWNING_CONSTRAINT ADD CONSTRAINT FK_PROBLEM_REASON FOREIGN KEY(ID) REFERENCES TABLE_TO_TRUNCATE (ID)

É isso aí.

Lauro Wolff Valente Sobrinho
fonte
Isso não funciona se você tiver várias tabelas com referências de chave estrangeira. Você precisaria remover muitas restrições de chave estrangeira em todo o banco de dados.
precisa saber é
13

Aqui está um script que escrevi para automatizar o processo. Espero que ajude.

SET NOCOUNT ON

-- GLOBAL VARIABLES
DECLARE @i int
DECLARE @Debug bit
DECLARE @Recycle bit
DECLARE @Verbose bit
DECLARE @TableName varchar(80)
DECLARE @ColumnName varchar(80)
DECLARE @ReferencedTableName varchar(80)
DECLARE @ReferencedColumnName varchar(80)
DECLARE @ConstraintName varchar(250)

DECLARE @CreateStatement varchar(max)
DECLARE @DropStatement varchar(max)   
DECLARE @TruncateStatement varchar(max)
DECLARE @CreateStatementTemp varchar(max)
DECLARE @DropStatementTemp varchar(max)
DECLARE @TruncateStatementTemp varchar(max)
DECLARE @Statement varchar(max)

        -- 1 = Will not execute statements 
 SET @Debug = 0
        -- 0 = Will not create or truncate storage table
        -- 1 = Will create or truncate storage table
 SET @Recycle = 0
        -- 1 = Will print a message on every step
 set @Verbose = 1

 SET @i = 1
    SET @CreateStatement = 'ALTER TABLE [dbo].[<tablename>]  WITH NOCHECK ADD  CONSTRAINT [<constraintname>] FOREIGN KEY([<column>]) REFERENCES [dbo].[<reftable>] ([<refcolumn>])'
    SET @DropStatement = 'ALTER TABLE [dbo].[<tablename>] DROP CONSTRAINT [<constraintname>]'
    SET @TruncateStatement = 'TRUNCATE TABLE [<tablename>]'

-- Drop Temporary tables
DROP TABLE #FKs

-- GET FKs
SELECT ROW_NUMBER() OVER (ORDER BY OBJECT_NAME(parent_object_id), clm1.name) as ID,
       OBJECT_NAME(constraint_object_id) as ConstraintName,
       OBJECT_NAME(parent_object_id) as TableName,
       clm1.name as ColumnName, 
       OBJECT_NAME(referenced_object_id) as ReferencedTableName,
       clm2.name as ReferencedColumnName
  INTO #FKs
  FROM sys.foreign_key_columns fk
       JOIN sys.columns clm1 
         ON fk.parent_column_id = clm1.column_id 
            AND fk.parent_object_id = clm1.object_id
       JOIN sys.columns clm2
         ON fk.referenced_column_id = clm2.column_id 
            AND fk.referenced_object_id= clm2.object_id
 WHERE OBJECT_NAME(parent_object_id) not in ('//tables that you do not wont to be truncated')
 ORDER BY OBJECT_NAME(parent_object_id)


-- Prepare Storage Table
IF Not EXISTS(SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Internal_FK_Definition_Storage')
   BEGIN
        IF @Verbose = 1
     PRINT '1. Creating Process Specific Tables...'

  -- CREATE STORAGE TABLE IF IT DOES NOT EXISTS
  CREATE TABLE [Internal_FK_Definition_Storage] 
  (
   ID int not null identity(1,1) primary key,
   FK_Name varchar(250) not null,
   FK_CreationStatement varchar(max) not null,
   FK_DestructionStatement varchar(max) not null,
   Table_TruncationStatement varchar(max) not null
  ) 
   END 
ELSE
   BEGIN
        IF @Recycle = 0
            BEGIN
                IF @Verbose = 1
       PRINT '1. Truncating Process Specific Tables...'

    -- TRUNCATE TABLE IF IT ALREADY EXISTS
    TRUNCATE TABLE [Internal_FK_Definition_Storage]    
      END
      ELSE
         PRINT '1. Process specific table will be recycled from previous execution...'
   END

IF @Recycle = 0
   BEGIN

  IF @Verbose = 1
     PRINT '2. Backing up Foreign Key Definitions...'

  -- Fetch and persist FKs             
  WHILE (@i <= (SELECT MAX(ID) FROM #FKs))
   BEGIN
    SET @ConstraintName = (SELECT ConstraintName FROM #FKs WHERE ID = @i)
    SET @TableName = (SELECT TableName FROM #FKs WHERE ID = @i)
    SET @ColumnName = (SELECT ColumnName FROM #FKs WHERE ID = @i)
    SET @ReferencedTableName = (SELECT ReferencedTableName FROM #FKs WHERE ID = @i)
    SET @ReferencedColumnName = (SELECT ReferencedColumnName FROM #FKs WHERE ID = @i)

    SET @DropStatementTemp = REPLACE(REPLACE(@DropStatement,'<tablename>',@TableName),'<constraintname>',@ConstraintName)
    SET @CreateStatementTemp = REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(@CreateStatement,'<tablename>',@TableName),'<column>',@ColumnName),'<constraintname>',@ConstraintName),'<reftable>',@ReferencedTableName),'<refcolumn>',@ReferencedColumnName)
    SET @TruncateStatementTemp = REPLACE(@TruncateStatement,'<tablename>',@TableName) 

    INSERT INTO [Internal_FK_Definition_Storage]
                        SELECT @ConstraintName, @CreateStatementTemp, @DropStatementTemp, @TruncateStatementTemp

    SET @i = @i + 1

    IF @Verbose = 1
       PRINT '  > Backing up [' + @ConstraintName + '] from [' + @TableName + ']'

   END
    END   
    ELSE 
       PRINT '2. Backup up was recycled from previous execution...'

       IF @Verbose = 1
     PRINT '3. Dropping Foreign Keys...'

    -- DROP FOREING KEYS
    SET @i = 1
    WHILE (@i <= (SELECT MAX(ID) FROM [Internal_FK_Definition_Storage]))
          BEGIN
             SET @ConstraintName = (SELECT FK_Name FROM [Internal_FK_Definition_Storage] WHERE ID = @i)
    SET @Statement = (SELECT FK_DestructionStatement FROM [Internal_FK_Definition_Storage] WITH (NOLOCK) WHERE ID = @i)

    IF @Debug = 1 
       PRINT @Statement
    ELSE
       EXEC(@Statement)

    SET @i = @i + 1

    IF @Verbose = 1
       PRINT '  > Dropping [' + @ConstraintName + ']'
             END     

    IF @Verbose = 1
       PRINT '4. Truncating Tables...'

    -- TRUNCATE TABLES
    SET @i = 1
    WHILE (@i <= (SELECT MAX(ID) FROM [Internal_FK_Definition_Storage]))
          BEGIN
    SET @Statement = (SELECT Table_TruncationStatement FROM [Internal_FK_Definition_Storage] WHERE ID = @i)

    IF @Debug = 1 
       PRINT @Statement
    ELSE
       EXEC(@Statement)

    SET @i = @i + 1

    IF @Verbose = 1
       PRINT '  > ' + @Statement
          END

    IF @Verbose = 1
       PRINT '5. Re-creating Foreign Keys...'

    -- CREATE FOREING KEYS
    SET @i = 1
    WHILE (@i <= (SELECT MAX(ID) FROM [Internal_FK_Definition_Storage]))
          BEGIN
             SET @ConstraintName = (SELECT FK_Name FROM [Internal_FK_Definition_Storage] WHERE ID = @i)
    SET @Statement = (SELECT FK_CreationStatement FROM [Internal_FK_Definition_Storage] WHERE ID = @i)

    IF @Debug = 1 
       PRINT @Statement
    ELSE
       EXEC(@Statement)

    SET @i = @i + 1

    IF @Verbose = 1
       PRINT '  > Re-creating [' + @ConstraintName + ']'
          END

    IF @Verbose = 1
       PRINT '6. Process Completed'
denver_citizen
fonte
2
Seja cuidadoso. Eu também adicionaria ações referenciais nas chaves do seu script ou você perderá as configurações em cascata.
alphadogg
1
isso não funcionou para mim, mas gostei do espírito, modifiquei algumas coisas: transformou um procedimento armazenado alterando a maneira como as chaves estrangeiras são preenchidas e recriadas, o script original trunca todas as tabelas referenciadas; isso pode estar errado quando as referências A tabela não pode ser truncada porque também possui referências de chave estrangeira. Nesta versão apenas a tabela especificada como parâmetro será truncado, todos tabela referenciada deve ser truncado manualmente antes de chamar esse script eu postei o tolution atualizado para esta discussão aqui stackoverflow.com/a/13249209/157591
Peter Szanto
1
@alphadogg Existe alguma maneira de encontrar essas ações referenciais? Venho vasculhando a Internet e não consigo encontrá-los. Posso postá-lo como uma pergunta formal, se você preferir.
Michael - Onde está Clay Shirky?
1
Nota para futuros visitantes: está na sys.foreign_keystabela. ( Referência )
Michael - Onde está Clay Shirky
13

Você pode seguir esta etapa. Ao reseeding tableexcluir os dados da tabela.

delete from table_name
dbcc checkident('table_name',reseed,0)

se ocorrer algum erro, será necessário reenviar a tabela principal.

Rajneesh Kumar
fonte
1
Lembre-se de que, embora isso funcione bem, o log de transações aumentará pelo número de registros na tabela vs. 'tabela truncada', que coloca apenas um registro no log de transações. Não é grande coisa para a maioria das tabelas, mas se houver milhões + linhas, pode ser um problema.
David David
9
SET FOREIGN_KEY_CHECKS = 0; 

truncate table "yourTableName";

SET FOREIGN_KEY_CHECKS = 1;
Victor Jimenez
fonte
8
Esta pergunta é sobre o MS SQL Server, que não tem uma configuração
FOREIGN_KEY_CHECKS
1
Eu acho que isso iria funcionar a partir do MySQL, mas não MS SQL Server
Cocowalla
8

Se bem entendi, o que você deseja fazer é ter um ambiente limpo a ser configurado para o banco de dados envolvendo testes de integração.

Minha abordagem aqui seria descartar todo o esquema e recriá-lo mais tarde.

Razões:

  1. Você provavelmente já possui um script "criar esquema". Reutilizá-lo para isolamento de teste é fácil.
  2. Criar um esquema é bem rápido.
  3. Com essa abordagem, é muito fácil configurar seu script para que cada dispositivo crie um novo esquema (com um nome temporário) e, em seguida, você pode começar a executar dispositivos de teste em paralelo, tornando a parte mais lenta do seu conjunto de testes muito mais rápida. .
Ken Egozi
fonte
1
Gostaria de 'truncar' todo o esquema, não descartá-lo. Eu gostaria de fazê-lo no método de instalação dos testes de integração. Chamar o script de criação de banco de dados a partir de testes de integração não é ... a primeira solução que irei.
Ripper234
7

Encontrado em outro lugar na web

EXEC sp_MSForEachTable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'
EXEC sp_MSForEachTable 'ALTER TABLE ? DISABLE TRIGGER ALL'
-- EXEC sp_MSForEachTable 'DELETE FROM ?' -- Uncomment to execute
EXEC sp_MSForEachTable 'ALTER TABLE ? CHECK CONSTRAINT ALL'
EXEC sp_MSForEachTable 'ALTER TABLE ? ENABLE TRIGGER ALL'
Freddie Bell
fonte
3
Provavelmente deve ser 'ALTER TABLE? COM CHECK CHECK CONSTRAINT ALL '.
Andriy M
20
-1: Apenas confirmei que isso não funciona com o comando truncate, conforme solicitado pela pergunta. Veja stackoverflow.com/questions/3843806/…
Lynn Crumbling
7

Você não pode truncar uma tabela se não eliminar as restrições. Uma desativação também não funciona. você precisa largar tudo. Eu criei um script que descarta todas as restrições e depois recria.

Certifique-se de envolvê-lo em uma transação;)

SET NOCOUNT ON
GO

DECLARE @table TABLE(
RowId INT PRIMARY KEY IDENTITY(1, 1),
ForeignKeyConstraintName NVARCHAR(200),
ForeignKeyConstraintTableSchema NVARCHAR(200),
ForeignKeyConstraintTableName NVARCHAR(200),
ForeignKeyConstraintColumnName NVARCHAR(200),
PrimaryKeyConstraintName NVARCHAR(200),
PrimaryKeyConstraintTableSchema NVARCHAR(200),
PrimaryKeyConstraintTableName NVARCHAR(200),
PrimaryKeyConstraintColumnName NVARCHAR(200)
)

INSERT INTO @table(ForeignKeyConstraintName, ForeignKeyConstraintTableSchema, ForeignKeyConstraintTableName, ForeignKeyConstraintColumnName)
SELECT
U.CONSTRAINT_NAME,
U.TABLE_SCHEMA,
U.TABLE_NAME,
U.COLUMN_NAME
FROM
INFORMATION_SCHEMA.KEY_COLUMN_USAGE U
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS C
ON U.CONSTRAINT_NAME = C.CONSTRAINT_NAME
WHERE
C.CONSTRAINT_TYPE = 'FOREIGN KEY'

UPDATE @table SET
PrimaryKeyConstraintName = UNIQUE_CONSTRAINT_NAME
FROM
@table T
INNER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS R
ON T.ForeignKeyConstraintName = R.CONSTRAINT_NAME

UPDATE @table SET
PrimaryKeyConstraintTableSchema = TABLE_SCHEMA,
PrimaryKeyConstraintTableName = TABLE_NAME
FROM @table T
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS C
ON T.PrimaryKeyConstraintName = C.CONSTRAINT_NAME

UPDATE @table SET
PrimaryKeyConstraintColumnName = COLUMN_NAME
FROM @table T
INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE U
ON T.PrimaryKeyConstraintName = U.CONSTRAINT_NAME

--DROP CONSTRAINT:

DECLARE @dynSQL varchar(MAX);

DECLARE cur CURSOR FOR
SELECT
'
ALTER TABLE [' + ForeignKeyConstraintTableSchema + '].[' + ForeignKeyConstraintTableName + ']
DROP CONSTRAINT ' + ForeignKeyConstraintName + '
'
FROM
@table

OPEN cur

FETCH cur into @dynSQL
WHILE @@FETCH_STATUS = 0 
BEGIN
    exec(@dynSQL)
    print @dynSQL

    FETCH cur into @dynSQL
END
CLOSE cur
DEALLOCATE cur
---------------------



   --HERE GOES YOUR TRUNCATES!!!!!
   --HERE GOES YOUR TRUNCATES!!!!!
   --HERE GOES YOUR TRUNCATES!!!!!

    truncate table your_table

   --HERE GOES YOUR TRUNCATES!!!!!
   --HERE GOES YOUR TRUNCATES!!!!!
   --HERE GOES YOUR TRUNCATES!!!!!

---------------------
--ADD CONSTRAINT:

DECLARE cur2 CURSOR FOR
SELECT
'
ALTER TABLE [' + ForeignKeyConstraintTableSchema + '].[' + ForeignKeyConstraintTableName + ']
ADD CONSTRAINT ' + ForeignKeyConstraintName + ' FOREIGN KEY(' + ForeignKeyConstraintColumnName + ') REFERENCES [' + PrimaryKeyConstraintTableSchema + '].[' + PrimaryKeyConstraintTableName + '](' + PrimaryKeyConstraintColumnName + ')
'
FROM
@table

OPEN cur2

FETCH cur2 into @dynSQL
WHILE @@FETCH_STATUS = 0 
BEGIN
    exec(@dynSQL)

    print @dynSQL

    FETCH cur2 into @dynSQL
END
CLOSE cur2
DEALLOCATE cur2
renanleandrof
fonte
6

As respostas de @denver_citizen e @Peter Szanto não funcionaram para mim, mas eu as modifiquei para dar conta:

  1. Chaves compostas
  2. Ações On Delete e On Update
  3. Verificando o índice ao adicionar novamente
  4. Esquemas diferentes de dbo
  5. Várias tabelas ao mesmo tempo
DECLARE @Debug bit = 0;

-- List of tables to truncate
select
    SchemaName, Name
into #tables
from (values 
    ('schema', 'table')
    ,('schema2', 'table2')
) as X(SchemaName, Name)


BEGIN TRANSACTION TruncateTrans;

with foreignKeys AS (
     SELECT 
        SCHEMA_NAME(fk.schema_id) as SchemaName
        ,fk.Name as ConstraintName
        ,OBJECT_NAME(fk.parent_object_id) as TableName
        ,SCHEMA_NAME(t.SCHEMA_ID) as ReferencedSchemaName
        ,OBJECT_NAME(fk.referenced_object_id) as ReferencedTableName
        ,fc.constraint_column_id
        ,COL_NAME(fk.parent_object_id, fc.parent_column_id) AS ColumnName
        ,COL_NAME(fk.referenced_object_id, fc.referenced_column_id) as ReferencedColumnName
        ,fk.delete_referential_action_desc
        ,fk.update_referential_action_desc
    FROM sys.foreign_keys AS fk
        JOIN sys.foreign_key_columns AS fc
            ON fk.object_id = fc.constraint_object_id
        JOIN #tables tbl 
            ON OBJECT_NAME(fc.referenced_object_id) = tbl.Name
        JOIN sys.tables t on OBJECT_NAME(t.object_id) = tbl.Name 
            and SCHEMA_NAME(t.schema_id) = tbl.SchemaName
            and t.OBJECT_ID = fc.referenced_object_id
)



select
    quotename(fk.ConstraintName) AS ConstraintName
    ,quotename(fk.SchemaName) + '.' + quotename(fk.TableName) AS TableName
    ,quotename(fk.ReferencedSchemaName) + '.' + quotename(fk.ReferencedTableName) AS ReferencedTableName
    ,replace(fk.delete_referential_action_desc, '_', ' ') AS DeleteAction
    ,replace(fk.update_referential_action_desc, '_', ' ') AS UpdateAction
    ,STUFF((
        SELECT ',' + quotename(fk2.ColumnName)
        FROM foreignKeys fk2 
        WHERE fk2.ConstraintName = fk.ConstraintName and fk2.SchemaName = fk.SchemaName
        ORDER BY fk2.constraint_column_id
        FOR XML PATH('')
    ),1,1,'') AS ColumnNames
    ,STUFF((
        SELECT ',' + quotename(fk2.ReferencedColumnName)
        FROM foreignKeys fk2 
        WHERE fk2.ConstraintName = fk.ConstraintName and fk2.SchemaName = fk.SchemaName
        ORDER BY fk2.constraint_column_id
        FOR XML PATH('')
    ),1,1,'') AS ReferencedColumnNames
into #FKs
from foreignKeys fk
GROUP BY fk.SchemaName, fk.ConstraintName, fk.TableName, fk.ReferencedSchemaName, fk.ReferencedTableName, fk.delete_referential_action_desc, fk.update_referential_action_desc



-- Drop FKs
select 
    identity(int,1,1) as ID,
    'ALTER TABLE ' + fk.TableName + ' DROP CONSTRAINT ' + fk.ConstraintName AS script
into #scripts
from #FKs fk

-- Truncate 
insert into #scripts
select distinct 
    'TRUNCATE TABLE ' + quotename(tbl.SchemaName) + '.' + quotename(tbl.Name) AS script
from #tables tbl

-- Recreate
insert into #scripts
select 
    'ALTER TABLE ' + fk.TableName + 
    ' WITH CHECK ADD CONSTRAINT ' + fk.ConstraintName + 
    ' FOREIGN KEY ('+ fk.ColumnNames +')' + 
    ' REFERENCES ' + fk.ReferencedTableName +' ('+ fk.ReferencedColumnNames +')' +
    ' ON DELETE ' + fk.DeleteAction COLLATE Latin1_General_CI_AS_KS_WS + ' ON UPDATE ' + fk.UpdateAction COLLATE Latin1_General_CI_AS_KS_WS AS script
from #FKs fk


DECLARE @script nvarchar(MAX);

DECLARE curScripts CURSOR FOR 
    select script
    from #scripts
    order by ID

OPEN curScripts

WHILE 1=1 BEGIN
    FETCH NEXT FROM curScripts INTO @script
    IF @@FETCH_STATUS != 0 BREAK;

    print @script;
    IF @Debug = 0
        EXEC (@script);
END
CLOSE curScripts
DEALLOCATE curScripts


drop table #scripts
drop table #FKs
drop table #tables


COMMIT TRANSACTION TruncateTrans;
GhotiPhud
fonte
4

truncado não funcionou para mim, excluir + reeditar é a melhor saída. Caso haja alguns de vocês por aí que precisam iterar um grande número de tabelas para executar exclusão + propagação, você pode ter problemas com algumas tabelas que não possuem uma coluna de identidade, o código a seguir verifica se existe uma coluna de identidade antes de tentar reenviar

    EXEC ('DELETE FROM [schemaName].[tableName]')
    IF EXISTS (Select * from sys.identity_columns where object_name(object_id) = 'tableName')
    BEGIN
        EXEC ('DBCC CHECKIDENT ([schemaName.tableName], RESEED, 0)')
    END
Ji_in_coding
fonte
4

Escrevi as seguintes maneiras e tentei parametrizá-las, para que você possa executá-las em um Query documentOu Tornar um útil SPcom elas facilmente .

A) Excluir

Se sua tabela não possui milhões de registros, isso funciona bem e não possui nenhum comando Alter :

---------------------------------------------------------------
------------------- Just Fill Parameters Value ----------------
---------------------------------------------------------------
DECLARE @DbName AS NVARCHAR(30) = 'MyDb'         --< Db Name
DECLARE @Schema AS NVARCHAR(30) = 'dbo'          --< Schema
DECLARE @TableName AS NVARCHAR(30) = 'Book'      --< Table Name
------------------ /Just Fill Parameters Value ----------------

DECLARE @Query AS NVARCHAR(500) = 'Delete FROM ' + @TableName

EXECUTE sp_executesql @Query
SET @Query=@DbName+'.'+@Schema+'.'+@TableName
DBCC CHECKIDENT (@Query,RESEED, 0)
  • Na resposta acima, o método para resolver o problema mencionado na pergunta é baseado na resposta @ s15199d .

B) Truncar

Se sua tabela possui milhões de registros ou você não tem nenhum problema com o comando Alter nos seus códigos, use este:

--   Book                               Student
--
--   |  BookId  | Field1 |              | StudentId |  BookId  |
--   ---------------------              ------------------------ 
--   |    1     |    A   |              |     2     |    1     |  
--   |    2     |    B   |              |     1     |    1     |
--   |    3     |    C   |              |     2     |    3     |  

---------------------------------------------------------------
------------------- Just Fill Parameters Value ----------------
---------------------------------------------------------------
DECLARE @DbName AS NVARCHAR(30) = 'MyDb'
DECLARE @Schema AS NVARCHAR(30) = 'dbo'
DECLARE @TableName_ToTruncate AS NVARCHAR(30) = 'Book'

DECLARE @TableName_OfOwnerOfConstraint AS NVARCHAR(30) = 'Student' --< Decelations About FK_Book_Constraint
DECLARE @Ref_ColumnName_In_TableName_ToTruncate AS NVARCHAR(30) = 'BookId' --< Decelations About FK_Book_Constraint
DECLARE @FK_ColumnName_In_TableOfOwnerOfConstraint AS NVARCHAR(30) = 'Fk_BookId' --< Decelations About FK_Book_Constraint
DECLARE @FK_ConstraintName AS NVARCHAR(30) = 'FK_Book_Constraint'                --< Decelations About FK_Book_Constraint
------------------ /Just Fill Parameters Value ----------------

DECLARE @Query AS NVARCHAR(2000)

SET @Query= 'ALTER TABLE '+@TableName_OfOwnerOfConstraint+' DROP CONSTRAINT '+@FK_ConstraintName
EXECUTE sp_executesql @Query

SET @Query= 'Truncate Table '+ @TableName_ToTruncate
EXECUTE sp_executesql @Query

SET @Query= 'ALTER TABLE '+@TableName_OfOwnerOfConstraint+' ADD CONSTRAINT '+@FK_ConstraintName+' FOREIGN KEY('+@FK_ColumnName_In_TableOfOwnerOfConstraint+') REFERENCES '+@TableName_ToTruncate+'('+@Ref_ColumnName_In_TableName_ToTruncate+')'
EXECUTE sp_executesql @Query
  • Na resposta acima, o método para resolver o problema mencionado na pergunta é baseado na resposta @LauroWolffValenteSobrinho .

  • Se você tiver mais de um CONSTRAINT, deverá anexar seus códigos como eu à consulta acima

  • Também é possível alterar a resposta @SerjSagan da base de código acima para desativar e ativar a restrição

RAM
fonte
3

É a minha solução para esse problema. Eu usei para alterar PK, mas a mesma idéia. Espero que isso seja útil)

PRINT 'Script starts'

DECLARE @foreign_key_name varchar(255)
DECLARE @keycnt int
DECLARE @foreign_table varchar(255)
DECLARE @foreign_column_1 varchar(255)
DECLARE @foreign_column_2 varchar(255)
DECLARE @primary_table varchar(255)
DECLARE @primary_column_1 varchar(255)
DECLARE @primary_column_2 varchar(255)
DECLARE @TablN varchar(255)

-->> Type the primary table name
SET @TablN = ''
---------------------------------------------------------------------------------------    ------------------------------
--Here will be created the temporary table with all reference FKs
---------------------------------------------------------------------------------------------------------------------
PRINT 'Creating the temporary table'
select cast(f.name  as varchar(255)) as foreign_key_name
    , r.keycnt
    , cast(c.name as  varchar(255)) as foreign_table
    , cast(fc.name as varchar(255)) as  foreign_column_1
    , cast(fc2.name as varchar(255)) as foreign_column_2
    , cast(p.name as varchar(255)) as primary_table
    , cast(rc.name as varchar(255))  as primary_column_1
    , cast(rc2.name as varchar(255)) as  primary_column_2
    into #ConTab
    from sysobjects f
    inner join sysobjects c on  f.parent_obj = c.id 
    inner join sysreferences r on f.id =  r.constid
    inner join sysobjects p on r.rkeyid = p.id
    inner  join syscolumns rc on r.rkeyid = rc.id and r.rkey1 = rc.colid
    inner  join syscolumns fc on r.fkeyid = fc.id and r.fkey1 = fc.colid
    left join  syscolumns rc2 on r.rkeyid = rc2.id and r.rkey2 = rc.colid
    left join  syscolumns fc2 on r.fkeyid = fc2.id and r.fkey2 = fc.colid
    where f.type =  'F' and p.name = @TablN
 ORDER BY cast(p.name as varchar(255))
---------------------------------------------------------------------------------------------------------------------
--Cursor, below, will drop all reference FKs
---------------------------------------------------------------------------------------------------------------------
DECLARE @CURSOR CURSOR
/*Fill in cursor*/

PRINT 'Cursor 1 starting. All refernce FK will be droped'

SET @CURSOR  = CURSOR SCROLL
FOR
select foreign_key_name
    , keycnt
    , foreign_table
    , foreign_column_1
    , foreign_column_2
    , primary_table
    , primary_column_1
    , primary_column_2
    from #ConTab

OPEN @CURSOR

FETCH NEXT FROM @CURSOR INTO @foreign_key_name, @keycnt, @foreign_table,         @foreign_column_1, @foreign_column_2, 
                        @primary_table, @primary_column_1, @primary_column_2

WHILE @@FETCH_STATUS = 0
BEGIN

    EXEC ('ALTER TABLE ['+@foreign_table+'] DROP CONSTRAINT ['+@foreign_key_name+']')

FETCH NEXT FROM @CURSOR INTO @foreign_key_name, @keycnt, @foreign_table, @foreign_column_1, @foreign_column_2, 
                         @primary_table, @primary_column_1, @primary_column_2
END
CLOSE @CURSOR
PRINT 'Cursor 1 finished work'
---------------------------------------------------------------------------------------------------------------------
--Here you should provide the chainging script for the primary table
---------------------------------------------------------------------------------------------------------------------

PRINT 'Altering primary table begin'

TRUNCATE TABLE table_name

PRINT 'Altering finished'

---------------------------------------------------------------------------------------------------------------------
--Cursor, below, will add again all reference FKs
--------------------------------------------------------------------------------------------------------------------

PRINT 'Cursor 2 starting. All refernce FK will added'
SET @CURSOR  = CURSOR SCROLL
FOR
select foreign_key_name
    , keycnt
    , foreign_table
    , foreign_column_1
    , foreign_column_2
    , primary_table
    , primary_column_1
    , primary_column_2
    from #ConTab

OPEN @CURSOR

FETCH NEXT FROM @CURSOR INTO @foreign_key_name, @keycnt, @foreign_table, @foreign_column_1, @foreign_column_2, 
                         @primary_table, @primary_column_1, @primary_column_2

WHILE @@FETCH_STATUS = 0
BEGIN

    EXEC ('ALTER TABLE [' +@foreign_table+ '] WITH NOCHECK ADD  CONSTRAINT [' +@foreign_key_name+ '] FOREIGN KEY(['+@foreign_column_1+'])
        REFERENCES [' +@primary_table+'] (['+@primary_column_1+'])')

    EXEC ('ALTER TABLE [' +@foreign_table+ '] CHECK CONSTRAINT [' +@foreign_key_name+']')

FETCH NEXT FROM @CURSOR INTO @foreign_key_name, @keycnt, @foreign_table, @foreign_column_1, @foreign_column_2, 
                         @primary_table, @primary_column_1, @primary_column_2
END
CLOSE @CURSOR
PRINT 'Cursor 2 finished work'
---------------------------------------------------------------------------------------------------------------------
PRINT 'Temporary table droping'
drop table #ConTab
PRINT 'Finish'
Oleg
fonte
3

Para MS SQL, pelo menos as versões mais recentes, você pode simplesmente desativar as restrições com código como este:

ALTER TABLE Orders
NOCHECK CONSTRAINT [FK_dbo.Orders_dbo.Customers_Customer_Id]
GO

TRUNCATE TABLE Customers
GO

ALTER TABLE Orders
WITH CHECK CHECK CONSTRAINT [FK_dbo.Orders_dbo.Customers_Customer_Id]
GO
Serj Sagan
fonte
Eu acho que nós estabelecemos acima que isso não funciona? Talvez ele faça para versões mais recentes?
amigos estão dizendo
2
Fwiw, isso não está funcionando na versão do OP (2005) e também não está funcionando no seu sucessor (MSSQL2008).
CB
3

O seguinte funciona para mim, mesmo com restrições de FK, e combina as seguintes respostas para eliminar apenas as tabelas especificadas :


USE [YourDB];

DECLARE @TransactionName varchar(20) = 'stopdropandroll';

BEGIN TRAN @TransactionName;
set xact_abort on; /* automatic rollback https://stackoverflow.com/a/1749788/1037948 */
    -- ===== DO WORK // =====

    -- dynamic sql placeholder
    DECLARE @SQL varchar(300);

    -- LOOP: https://stackoverflow.com/a/10031803/1037948
    -- list of things to loop
    DECLARE @delim char = ';';
    DECLARE @foreach varchar(MAX) = 'Table;Names;Separated;By;Delimiter' + @delim + 'AnotherName' + @delim + 'Still Another';
    DECLARE @token varchar(MAX);
    WHILE len(@foreach) > 0
    BEGIN
        -- set current loop token
        SET @token = left(@foreach, charindex(@delim, @foreach+@delim)-1)
        -- ======= DO WORK // ===========

        -- dynamic sql (parentheses are required): https://stackoverflow.com/a/989111/1037948
        SET @SQL = 'DELETE FROM [' + @token + ']; DBCC CHECKIDENT (''' + @token + ''',RESEED, 0);'; -- https://stackoverflow.com/a/11784890
        PRINT @SQL;
        EXEC (@SQL);

        -- ======= // END WORK ===========
        -- continue loop, chopping off token
        SET @foreach = stuff(@foreach, 1, charindex(@delim, @foreach+@delim), '')
    END

    -- ===== // END WORK =====
-- review and commit
SELECT @@TRANCOUNT as TransactionsPerformed, @@ROWCOUNT as LastRowsChanged;
COMMIT TRAN @TransactionName;

Nota:

Eu acho que ainda ajuda a declarar as tabelas na ordem em que você deseja que elas sejam excluídas (ou seja, elimine as dependências primeiro). Como visto nesta resposta , em vez de nomes específicos de loop, você pode substituir todas as tabelas por

EXEC sp_MSForEachTable 'DELETE FROM ?; DBCC CHECKIDENT (''?'',RESEED, 0);';
drzaus
fonte
Realmente não tentei outros scripts, já que todos declararam que não funcionam quando você tem chaves estrangeiras. Então, eu tentei este e este fez o truque para mim.
Vivendi
1
DELETE não é o mesmo que TRUNCATE. Isso irá preencher seus logs de transações.
quer
@ Dan, provavelmente um bom ponto; como mencionei eu só combinou as outras respostas por aqui ...
drzaus
@drzaus Ele funcionará bem para tabelas pequenas / médias, mas um servidor SQL de produção ficou offline devido a um comando delete que preenche o log de transações, que preencheu o disco rígido. No mínimo, verifique se os logs de transações têm um tamanho máximo antes de tentar isso em uma tabela grande.
precisa saber é o seguinte
2

Se nenhuma dessas respostas funcionou como no meu caso, faça o seguinte:

  1. Eliminar restrições
  2. Defina todos os valores para permitir nulos
  3. Truncar tabela
  4. Adicione restrições que foram eliminadas.

Boa sorte!

G Jeny Ramirez
fonte
alguma amostra sql sobre isso?
21418 Kanjet
2

Exclua e redefina o incremento automático:

delete from tablename;

então

ALTER TABLE tablename AUTO_INCREMENT = 1;
mwafi
fonte
Obrigado, isso funcionou bem.
Sr. Polywhirl
1

A única maneira é descartar chaves estrangeiras antes de fazer o truncado. E depois de truncar os dados, você deve recriar os índices.

O script a seguir gera o SQL necessário para eliminar todas as restrições de chave estrangeira.

DECLARE @drop NVARCHAR(MAX) = N'';

SELECT @drop += N'
ALTER TABLE ' + QUOTENAME(cs.name) + '.' + QUOTENAME(ct.name) 
    + ' DROP CONSTRAINT ' + QUOTENAME(fk.name) + ';'
FROM sys.foreign_keys AS fk
INNER JOIN sys.tables AS ct
  ON fk.parent_object_id = ct.[object_id]
INNER JOIN sys.schemas AS cs 
  ON ct.[schema_id] = cs.[schema_id];

SELECT @drop

Em seguida, o script a seguir gera o SQL necessário para recriar chaves estrangeiras.

DECLARE @create NVARCHAR(MAX) = N'';

SELECT @create += N'
ALTER TABLE ' 
   + QUOTENAME(cs.name) + '.' + QUOTENAME(ct.name) 
   + ' ADD CONSTRAINT ' + QUOTENAME(fk.name) 
   + ' FOREIGN KEY (' + STUFF((SELECT ',' + QUOTENAME(c.name)
   -- get all the columns in the constraint table
    FROM sys.columns AS c 
    INNER JOIN sys.foreign_key_columns AS fkc 
    ON fkc.parent_column_id = c.column_id
    AND fkc.parent_object_id = c.[object_id]
    WHERE fkc.constraint_object_id = fk.[object_id]
    ORDER BY fkc.constraint_column_id 
    FOR XML PATH(N''), TYPE).value(N'.[1]', N'nvarchar(max)'), 1, 1, N'')
  + ') REFERENCES ' + QUOTENAME(rs.name) + '.' + QUOTENAME(rt.name)
  + '(' + STUFF((SELECT ',' + QUOTENAME(c.name)
   -- get all the referenced columns
    FROM sys.columns AS c 
    INNER JOIN sys.foreign_key_columns AS fkc 
    ON fkc.referenced_column_id = c.column_id
    AND fkc.referenced_object_id = c.[object_id]
    WHERE fkc.constraint_object_id = fk.[object_id]
    ORDER BY fkc.constraint_column_id 
    FOR XML PATH(N''), TYPE).value(N'.[1]', N'nvarchar(max)'), 1, 1, N'') + ');'
FROM sys.foreign_keys AS fk
INNER JOIN sys.tables AS rt -- referenced table
  ON fk.referenced_object_id = rt.[object_id]
INNER JOIN sys.schemas AS rs 
  ON rt.[schema_id] = rs.[schema_id]
INNER JOIN sys.tables AS ct -- constraint table
  ON fk.parent_object_id = ct.[object_id]
INNER JOIN sys.schemas AS cs 
  ON ct.[schema_id] = cs.[schema_id]
WHERE rt.is_ms_shipped = 0 AND ct.is_ms_shipped = 0;

SELECT @create

Execute o script gerado para descartar todas as chaves estrangeiras, truncar tabelas e, em seguida, execute o script gerado para recriar todas as chaves estrangeiras.

As consultas são retiradas daqui .

Ehsan Mirsaeedi
fonte
0

No SSMS, eu tinha o diagrama aberto mostrando a chave. Depois de excluir a chave e truncar o arquivo, atualizei o foco e voltei ao diagrama e criei uma atualização limpando e restaurando uma caixa de identidade. Salvar o diagrama exibiu uma caixa de diálogo Salvar, em vez da caixa de diálogo "Alterações foram feitas no banco de dados enquanto você estava trabalhando", clicar em Sim restaurou a chave, restaurando-a da cópia trancada no diagrama.

user2584621
fonte
0

Se você estiver fazendo isso com algum tipo de frequência, mesmo com um cronograma, eu absolutamente, inequivocamente, nunca usaria uma declaração DML. O custo de gravação no log de transações é muito alto e SIMPLEé ridículo definir o banco de dados inteiro no modo de recuperação para truncar uma tabela.

Infelizmente, o melhor caminho é o caminho difícil ou trabalhoso. Sendo esse:

  • Eliminar restrições
  • Truncar tabela
  • Recriar restrições

Meu processo para fazer isso envolve as seguintes etapas:

  1. No SSMS, clique com o botão direito do mouse na tabela em questão e selecione Exibir dependências.
  2. Anote as tabelas referenciadas (se houver)
  3. De volta ao Pesquisador de Objetos, expanda o nó Chaves e anote as chaves estrangeiras (se houver)
  4. Iniciar script (soltar / truncar / recriar)

Scripts dessa natureza devem ser feitos dentro de um bloco begin trane commit tran.

pimbrouwers
fonte
-3

Acabei de descobrir que você pode usar a tabela TRUNCATE em uma tabela pai com restrições de chave estrangeira em um filho, desde que você desabilite primeiro as restrições na tabela filho . Por exemplo

Chave estrangeira CONSTRAINT child_par_ref na tabela filho, referências PARENT_TABLE

ALTER TABLE CHILD_TABLE DISABLE CONSTRAINT child_par_ref;
TRUNCATE TABLE CHILD_TABLE;
TRUNCATE TABLE PARENT_TABLE;
ALTER TABLE CHILD_TABLE ENABLE CONSTRAINT child_par_ref;
PWF
fonte
1
Esta não é uma sintaxe válida do SQL Server para ALTER TABLE. Não há {ENABLE | DISABLE} CONSTRAINT. Consulte: msdn.microsoft.com/pt-br/library/ms190273.aspx
jason_ruz
-3

A maneira mais fácil:
1 - Digite phpmyadmin
2 - Clique no nome da tabela na coluna esquerda
3 - Clique em Operação (menu superior)
4 - Clique em "Esvaziar a tabela (TRUNCATE)
5 - Desativar caixa" Ativar verificação de chave estrangeira "
6 - Concluído !

Link para o tutorial da imagem
Tutorial: http://www.imageno.com/wz6gv1wuqajrpic.html
(desculpe, não tenho reputação suficiente para fazer upload de imagens aqui: P)

Marco
fonte
2
OP declarou MSSQL. Você deu uma resposta exclusiva ao MySQL.
reformada
-4

Você poderia tentar DELETE FROM <your table >;.

O servidor mostrará o nome da restrição e a tabela. Ao excluir essa tabela, você pode excluir o que precisa.

Rene
fonte
6
Leia sua segunda frase sobre a questão. Ele sabe que pode fazer isso, mas não é isso que ele quer
renanleandrof
-7
SET FOREIGN_KEY_CHECKS=0;
TRUNCATE table1;
TRUNCATE table2;
SET FOREIGN_KEY_CHECKS=1;

reference - tabela de restrições de chave estrangeira truncada

Trabalhando para mim no MYSQL

JackSparrow
fonte
1
Além da versão especificada, há algo mais errado com isso? Seria recomendável usá-lo ou evitá-lo completamente?
Andy Ibanez
1
@AndyIbanez O MySQL é um produto completamente diferente do MSSQL, não uma versão diferente do MSSQL.
quer
1
a sua resposta correta Eu não sei por que todo mundo dá negativo
Sunil