Entity Framework. Usuń wszystkie wiersze w tabeli

Jak mogę szybko usunąć wszystkie wiersze w tabeli za pomocą Entity Framework?

Obecnie używam:

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

Wykonanie zajmuje jednak dużo czasu.

Czy są jakieś alternatywy?

Dla tych, którzy googlują i skończyli tutaj, jak ja, tak właśnie robisz w EF5 i EF6:

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

Zakładając, że kontekst to System.Data.Entity.DbContext

Ostrzeżenie: Poniższe informacje są odpowiednie tylko dla małych tabel (pomyśl <1000 wierszy)

Oto rozwiązanie, które używa struktury encji (nie SQL) do usuwania wierszy, więc nie jest ono specyficzne dla SQL Engine (R / DBM).

Zakłada się, że robisz to w celu przetestowania lub w podobnej sytuacji. Zarówno

• Ilość danych jest niewielka lub
• Wydajność nie ma znaczenia

Po prostu zadzwoń:

VotingContext.Votes.RemoveRange(VotingContext.Votes);

Zakładając ten kontekst:

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;}
}

W przypadku kodu uporządkowanego można zadeklarować następującą metodę rozszerzenia:

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

Następnie powyższe staje się:

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

Ostatnio zastosowałem to podejście do czyszczenia mojej testowej bazy danych dla każdego uruchomienia zestawu testów (jest to oczywiście szybsze niż za każdym razem odtwarzanie DB od zera, chociaż nie sprawdzałem formy wygenerowanych poleceń usuwania).

Dlaczego może być powolny?

1. EF otrzyma WSZYSTKIE wiersze (VotingContext.Votes)
2. a następnie użyje ich identyfikatorów (nie wiem dokładnie, jak to nie ma znaczenia), aby je usunąć.

Więc jeśli pracujesz z poważną ilością danych, zabijesz proces serwera SQL (zajmie to całą pamięć) i to samo dla procesu IIS, ponieważ EF będzie buforował wszystkie dane w taki sam sposób jak serwer SQL. Nie używaj tego, jeśli twoja tabela zawiera poważne ilości danych.

Korzystanie z TRUNCATE TABLEpolecenia SQL będzie najszybsze, ponieważ działa on na tabeli, a nie na poszczególnych wierszach.

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

Zakładając, że dataDbjest DbContext(nie an ObjectContext), możesz go owinąć i użyć następującej metody:

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);
}

lub

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

Możesz to zrobić bez Foreach

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

Spowoduje to usunięcie wszystkich wierszy

Pozwala to uniknąć korzystania z SQL

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

Natknąłem się na to pytanie, kiedy miałem do czynienia z konkretnym przypadkiem: pełną aktualizacją treści w tabeli „liści” (bez FK wskazujących na to). Obejmowało to usunięcie wszystkich wierszy i umieszczenie nowych informacji o wierszach i powinno to zostać wykonane transakcyjnie (nie chcę skończyć z pustą tabelą, jeśli wstawianie nie powiedzie się z jakiegokolwiek powodu).

Próbowałem public static void Clear<T>(this DbSet<T> dbSet) podejścia, ale nowe wiersze nie są wstawiane. Inną wadą jest to, że cały proces jest powolny, ponieważ wiersze są usuwane jeden po drugim.

Zmieniłem więc TRUNCATEpodejście, ponieważ jest ono znacznie szybsze i można je również ODWRÓCIĆ . Resetuje także tożsamość.

Przykład użycia wzorca repozytorium:

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();

Oczywiście, jak już wspomniano, z tego rozwiązania nie mogą korzystać tabele, do których odwołują się klucze obce (TRUNCATE kończy się niepowodzeniem).

Jeśli

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

przyczyny

Nie można obciąć tabeli „MyTable”, ponieważ odwołuje się do niej klucz OBCY.

Używam tego :

      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();

Jeśli chcesz wyczyścić całą bazę danych.

Z powodu ograniczeń klucza obcego ważne jest, w jakiej kolejności tabele są obcinane. Jest to sposób na brutalne użycie tej sekwencji.

    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();
        }
    }

stosowanie:

ClearDatabase<ApplicationDbContext>();

pamiętaj, aby po tym przywrócić DbContext.

Poniższe działa na bazie danych SQLite (przy użyciu Entity Framework)

Wydaje się, że najszybszym sposobem na wyczyszczenie wszystkich tabel db jest użycie „context.Database.ExecuteSqlCommand („ some SQL ”)”, jak również podkreślono niektóre komentarze powyżej. Tutaj pokażę, jak zresetować liczbę „indeksów” tabel.

            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 

Ważną kwestią jest to, że jeśli używasz kluczy obcych w swoich tabelach, musisz najpierw usunąć tabelę podrzędną przed tabelą nadrzędną, więc kolejność (hierarchia) tabel podczas usuwania jest ważna, w przeciwnym razie może wystąpić wyjątek SQLite.

Uwaga: var context = new YourContext ()

Działa to poprawnie w EF 5:

YourEntityModel myEntities = new YourEntityModel();

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

W EFCore (wersja, której używam to 3.1) możesz użyć następujących elementów, aby usunąć wszystkie wiersze -

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

Usuń wszystkie rekordy. Nie resetuj głównego indeksu, np. „Obcinaj”.

/// <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;
}

W moim kodzie tak naprawdę nie miałem ładnego dostępu do obiektu Database, więc możesz to zrobić na DbSet, gdzie możesz także używać dowolnego rodzaju sql. Skończy się to tak:

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

Jeśli MVC, możesz:

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

Upewnij się, że kiedy próbujesz usunąć rodzica, wszystkie dzieci będą kaskadowo przy usuwaniu. Lub dzieci mają zerowy klucz obcy.

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