Estrutura de entidade. Excluir todas as linhas da tabela

Como posso remover rapidamente todas as linhas da tabela usando o Entity Framework?

Atualmente, estou usando:

var rows = from o in dataDb.Table
           select o;
foreach (var row in rows)
{
    dataDb.Table.Remove(row);
}
dataDb.SaveChanges();

No entanto, leva muito tempo para ser executado.

Existem alternativas?

Para aqueles que pesquisam isso no Google e acabaram aqui como eu, é assim que você faz atualmente no EF5 e EF6:

context.Database.ExecuteSqlCommand("TRUNCATE TABLE [TableName]");

Assumindo que o contexto é um System.Data.Entity.DbContext

Aviso: O seguinte é adequado apenas para tabelas pequenas (pense <1000 linhas)

Aqui está uma solução que usa a estrutura da entidade (não o SQL) para excluir as linhas, portanto, não é específico do SQL Engine (R / DBM).

Isso pressupõe que você esteja fazendo isso para testes ou situações semelhantes. Ou

• A quantidade de dados é pequena ou
• O desempenho não importa

Basta ligar para:

VotingContext.Votes.RemoveRange(VotingContext.Votes);

Assumindo este contexto:

public class VotingContext : DbContext
{
    public DbSet<Vote> Votes{get;set;}
    public DbSet<Poll> Polls{get;set;}
    public DbSet<Voter> Voters{get;set;}
    public DbSet<Candidacy> Candidates{get;set;}
}

Para código mais organizado, você pode declarar o seguinte método de extensão:

public static class EntityExtensions
{
    public static void Clear<T>(this DbSet<T> dbSet) where T : class
    {
        dbSet.RemoveRange(dbSet);
    }
}

Então o acima se torna:

VotingContext.Votes.Clear();
VotingContext.Voters.Clear();
VotingContext.Candidacy.Clear();
VotingContext.Polls.Clear();
await VotingTestContext.SaveChangesAsync();

Recentemente, usei essa abordagem para limpar meu banco de dados de teste para cada execução do caso de teste (é obviamente mais rápido do que recriar o banco de dados a partir do zero a cada vez, embora eu não tenha verificado a forma dos comandos de exclusão que foram gerados).

Por que isso pode ser lento?

1. A EF obterá TODAS as linhas (VotingContext.Votes)
2. e, em seguida, usará seus IDs (não sei exatamente como, não importa), para excluí-los.

Portanto, se você estiver trabalhando com uma quantidade séria de dados, você matará o processo do servidor SQL (ele consumirá toda a memória) e a mesma coisa para o processo IIS, já que o EF armazenará todos os dados da mesma maneira que o servidor SQL. Não use este se sua tabela contiver uma quantidade séria de dados.

O uso do TRUNCATE TABLEcomando SQL será o mais rápido, pois opera na tabela e não em linhas individuais.

dataDb.ExecuteStoreCommand("TRUNCATE TABLE [Table]");

Supondo que dataDbseja um DbContext(não um ObjectContext), você pode agrupá-lo e usar o método como este:

var objCtx = ((System.Data.Entity.Infrastructure.IObjectContextAdapter)dataDb).ObjectContext;
objCtx.ExecuteStoreCommand("TRUNCATE TABLE [Table]");

var all = from c in dataDb.Table select c;
dataDb.Table.RemoveRange(all);
dataDb.SaveChanges();

using (var context = new DataDb())
{
     var ctx = ((System.Data.Entity.Infrastructure.IObjectContextAdapter)context).ObjectContext;
     ctx.ExecuteStoreCommand("DELETE FROM [TableName] WHERE Name= {0}", Name);
}

ou

using (var context = new DataDb())
{
     context.Database.ExecuteSqlCommand("TRUNCATE TABLE [TableName]");
}

Você pode fazer isso sem o Foreach

dataDB.Table.RemoveRange(dataDB.Table);
dataDB.SaveChanges();

Isso removerá todas as linhas

Isso evita o uso de qualquer sql

using (var context = new MyDbContext())
{
    var itemsToDelete = context.Set<MyTable>();
    context.MyTables.RemoveRange(itemsToDelete);
    context.SaveChanges();
}

Me deparei com essa pergunta quando tive que lidar com um caso específico: atualização completa do conteúdo em uma tabela "folha" (sem FKs apontando para ele). Isso envolveu a remoção de todas as linhas e a colocação de novas informações sobre as linhas, e isso deve ser feito de maneira transacional (não quero terminar com uma tabela vazia, se as inserções falharem por qualquer motivo).

Eu tentei a public static void Clear<T>(this DbSet<T> dbSet)abordagem, mas novas linhas não são inseridas. Outra desvantagem é que todo o processo é lento, pois as linhas são excluídas uma a uma.

Então, mudei para TRUNCATEabordagem, pois é muito mais rápido e também é ROLLBACKable . Também redefine a identidade.

Exemplo usando padrão de repositório:

public class Repository<T> : IRepository<T> where T : class, new()
{
    private readonly IEfDbContext _context;

    public void BulkInsert(IEnumerable<T> entities)
    {
        _context.BulkInsert(entities);
    }

    public void Truncate()
    {
        _context.Database.ExecuteSqlCommand($"TRUNCATE TABLE {typeof(T).Name}");
    }
 }

 // usage 
 DataAccess.TheRepository.Truncate();
 var toAddBulk = new List<EnvironmentXImportingSystem>();

 // fill toAddBulk from source system
 // ...

 DataAccess.TheRepository.BulkInsert(toAddBulk);
 DataAccess.SaveChanges();

Obviamente, como já mencionado, esta solução não pode ser usada por tabelas referenciadas por chaves estrangeiras (TRUNCATE falha).

E se

      using(var db = new MyDbContext())
            {
               await db.Database.ExecuteSqlCommandAsync(@"TRUNCATE TABLE MyTable"););
            }

causas

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

Eu uso isso :

      using(var db = new MyDbContext())
               {
                   await db.Database.ExecuteSqlCommandAsync(@"DELETE FROM MyTable WHERE ID != -1");
               }

var data = (from n in db.users select n);
db.users.RemoveRange(data);
db.SaveChanges();

Se você deseja limpar todo o banco de dados.

Devido às restrições de chave estrangeira, é importante qual sequência as tabelas estão truncadas. Essa é uma maneira de forçar brutais essa sequência.

    public static void ClearDatabase<T>() where T : DbContext, new()
    {
        using (var context = new T())
        {
            var tableNames = context.Database.SqlQuery<string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME NOT LIKE '%Migration%'").ToList();
            foreach (var tableName in tableNames)
            {
                foreach (var t in tableNames)
                {
                    try
                    {

                        if (context.Database.ExecuteSqlCommand(string.Format("TRUNCATE TABLE [{0}]", tableName)) == 1)
                            break;

                    }
                    catch (Exception ex)
                    {

                    }
                }
            }

            context.SaveChanges();
        }
    }

uso:

ClearDatabase<ApplicationDbContext>();

lembre-se de restabelecer seu DbContext depois disso.

O seguinte funciona no banco de dados SQLite (usando o Entity Framework)

Parece que a maneira mais rápida de limpar todas as tabelas db é usando 'context.Database.ExecuteSqlCommand ("some SQL")', como destacaram alguns comentários acima. Aqui vou mostrar como redefinir a contagem de tabelas do 'índice'.

            context.Database.ExecuteSqlCommand("delete from TableA");
            context.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='TableA'");//resets the autoindex

            context.Database.ExecuteSqlCommand("delete from TableB");
            context.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='TableB'");//resets the autoindex 

            context.Database.ExecuteSqlCommand("delete from TableC");
            context.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='TableC'");//resets the autoindex 

Um ponto importante é que, se você usar chaves estrangeiras em suas tabelas, deverá primeiro excluir a tabela filha antes da tabela pai, para que a sequência (hierarquia) de tabelas durante a exclusão seja importante, caso contrário, uma exceção SQLite poderá ocorrer.

Nota: var context = new YourContext ()

Isso funciona corretamente no EF 5:

YourEntityModel myEntities = new YourEntityModel();

var objCtx = ((IObjectContextAdapter)myEntities).ObjectContext;
objCtx.ExecuteStoreCommand("TRUNCATE TABLE [TableName]");

No EFCore (a versão que estou usando é 3.1), você pode usar o seguinte para remover todas as linhas -

context.Database.ExecuteSqlRaw("TRUNCATE TABLE [TableName]");

Exclua todos os registros. Não redefina o índice primário como "truncar".

/// <summary>
/// SET - DELETE all record by table - no truncate - return deleted records
/// </summary>
public static int setListDelAllMYTABLE()
{
    // INIT
    int retObj = 0;
    using (MYDBEntities ctx = new MYDBEntities())
    {
        // GET - all record
        var tempAllRecord = ctx.MYTABLE.ToList();
        // RESET
        ctx.MYTABLE.RemoveRange(tempAllRecord);
        // SET - final save
        retObj += ctx.SaveChanges();
    }
    // RET
    return retObj;
}

No meu código, eu realmente não tinha bom acesso ao objeto Database, então você pode fazê-lo no DbSet, onde você também pode usar qualquer tipo de sql. Vai acabar assim:

var p = await _db.Persons.FromSql("truncate table Persons;select top 0 * from Persons").ToListAsync();

Se MVC, você pode fazer:

public async Task<IActionResult> DeleteAll()
{
    var list = await _context.YourClass.ToListAsync();
    _context.YourClass.RemoveRange(list);
    await _context.SaveChangesAsync();
    return RedirectToAction(nameof(Index));
}

Certifique-se de que, ao tentar excluir os pais, todos os filhos se conectem em cascata ao excluir. Ou os filhos têm chave estrangeira anulável.

var list = db.Discounts.ToList().Select(x => x as Discount);
foreach (var item in list)
{
    db.Discounts.Remove(item);
}
db.SaveChanges();