Linq to Sql: Comment effacer rapidement une table


88

Pour supprimer toutes les lignes d'un tableau, je fais actuellement ce qui suit:

context.Entities.DeleteAllOnSubmit(context.Entities);
context.SubmitChanges();

Cependant, cela semble prendre des siècles. Y at-il un moyen plus rapide?


Une raison pour laquelle vous n'utilisez pas une procédure stockée pour une suppression plus rapide et plus sûre? Vous pouvez avoir le proc mappé sur dbml
Perpetualcoder

1
N'auriez-vous pas à en faire un pour chaque table alors? Ou?
Svish

Réponses:


126

Vous pouvez exécuter une commande SQL normale de troncature ou de suppression à l'aide de la méthode DataContext.ExecuteCommand :

context.ExecuteCommand("DELETE FROM Entity");

Ou

context.ExecuteCommand("TRUNCATE TABLE Entity");

La façon dont vous supprimez prend du temps car Linq to SQL génère une instruction DELETE pour chaque entité , il existe d'autres approches de type sécurisé pour effectuer des suppressions / mises à jour par lots, consultez les articles suivants:


assurez-vous de corriger le mot «SUPPRIMER»
David

9
J'ai attribué +1 à ce contenu. Voici une référence expliquant la différence entre Truncate (ce que je pense que vous voulez faire) et Delete: mssqltips.com/tip.asp?tip=1080
David

1
+1 sur le commentaire de David: tronquer peut être beaucoup plus rapide que supprimer
Fredrik Mörk

1
@David: Ce problème est spécifique à Entity Framework ( Linq-to-Entities ), je l'ai déjà utilisé TRUNCATEsans problème sur Linq-to-SQL
Christian C. Salvadó

1
TRUNCATE effacera toute indexation automatique qui a été établie (généralement une colonne Id) donc soyez prudent si vous ne voulez pas que cela se réinitialise. DELETE FROM ne le fera pas.
JCisar

20

Malheureusement, LINQ-to-SQL n'exécute pas très bien les requêtes basées sur des ensembles.

Vous supposeriez que

context.Entities.DeleteAllOnSubmit(context.Entities); 
context.SubmitChanges(); 

se traduira par quelque chose comme

DELETE FROM [Entities]

mais malheureusement c'est plus comme

DELETE FROM [dbo].[Entities] WHERE ([EntitiesId] = @p0) AND ([Column1] = @p1) ...
DELETE FROM [dbo].[Entities] WHERE ([EntitiesId] = @p0) AND ([Column1] = @p1) ...
DELETE FROM [dbo].[Entities] WHERE ([EntitiesId] = @p0) AND ([Column1] = @p1) ...

Vous trouverez la même chose lorsque vous essayez d'effectuer une mise à jour en bloc dans LINQ-to-SQL. Plus de quelques centaines de lignes à la fois et ça va tout simplement être trop lent.

Si vous devez effectuer des opérations par lots et que vous utilisez LINQ-to-SQL, vous devez écrire des procédures stockées.


12

J'aime utiliser une méthode d'extension, comme suit:

public static class LinqExtension
{
  public static void Truncate<TEntity>(this Table<TEntity> table) where TEntity : class
  {
    var rowType = table.GetType().GetGenericArguments()[0];
    var tableName = table.Context.Mapping.GetTable(rowType).TableName;
    var sqlCommand = String.Format("TRUNCATE TABLE {0}", tableName);
    table.Context.ExecuteCommand(sqlCommand);
  }
}

0

vous pouvez également utiliser ceci:

Public void BorraFilasTabla()
{
 using(basededatos db = new basededatos())
 {
  var ListaParaBorrar = db.Tabla.Tolist();
  db.Tabla.RemoveRange(ListaParaBorrar); 
 }
}

La question est: "Y a-t-il un moyen plus rapide?". Comment serait-ce plus rapide? En outre, ce n'est pas LINQ to SQL.
Gert Arnold le

-1

Le code ci-dessous c # est utilisé pour insérer / mettre à jour / supprimer / supprimer tout sur une table de base de données en utilisant LINQ to SQL

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace PracticeApp
{
    class PracticeApp
    {        
        public void InsertRecord(string Name, string Dept) {
            LinqToSQLDataContext LTDT = new LinqToSQLDataContext();
            LINQTOSQL0 L0 = new LINQTOSQL0 { NAME = Name, DEPARTMENT = Dept };
            LTDT.LINQTOSQL0s.InsertOnSubmit(L0);
            LTDT.SubmitChanges();
        }

        public void UpdateRecord(int ID, string Name, string Dept)
        {
            LinqToSQLDataContext LTDT = new LinqToSQLDataContext();
            LINQTOSQL0 L0 = (from item in LTDT.LINQTOSQL0s where item.ID == ID select item).FirstOrDefault();
            L0.NAME = Name;
            L0.DEPARTMENT = Dept;
            LTDT.SubmitChanges();
        }

        public void DeleteRecord(int ID)
        {
            LinqToSQLDataContext LTDT = new LinqToSQLDataContext();
            LINQTOSQL0 L0;
            if (ID != 0)
            {
                L0 = (from item in LTDT.LINQTOSQL0s where item.ID == ID select item).FirstOrDefault();
                LTDT.LINQTOSQL0s.DeleteOnSubmit(L0);
            }
            else
            {
                IEnumerable<LINQTOSQL0> Data = from item in LTDT.LINQTOSQL0s where item.ID !=0 select item;
                LTDT.LINQTOSQL0s.DeleteAllOnSubmit(Data);
            }           
            LTDT.SubmitChanges();
        }

        static void Main(string[] args) {
            Console.Write("* Enter Comma Separated Values to Insert Records\n* To Delete a Record Enter 'Delete' or To Update the Record Enter 'Update' Then Enter the Values\n* Dont Pass ID While Inserting Record.\n* To Delete All Records Pass 0 as Parameter for Delete.\n");
            var message = "Successfully Completed";
            try
            {
                PracticeApp pa = new PracticeApp();
                var enteredValue = Console.ReadLine();                
                if (Regex.Split(enteredValue, ",")[0] == "Delete") 
                {
                    Console.Write("Delete Operation in Progress...\n");
                    pa.DeleteRecord(Int32.Parse(Regex.Split(enteredValue, ",")[1]));
                }
                else if (Regex.Split(enteredValue, ",")[0] == "Update")
                {
                    Console.Write("Update Operation in Progress...\n");
                    pa.UpdateRecord(Int32.Parse(Regex.Split(enteredValue, ",")[1]), Regex.Split(enteredValue, ",")[2], Regex.Split(enteredValue, ",")[3]);
                }
                else
                {
                    Console.Write("Insert Operation in Progress...\n");
                    pa.InsertRecord(Regex.Split(enteredValue, ",")[0], Regex.Split(enteredValue, ",")[1]);
                }                                
            }
            catch (Exception ex)
            {
                message = ex.ToString();
            }
            Console.Write(message);            
            Console.ReadLine();                        
        }
    }
}

1
ajouter quelques explications
Yahya Hussein
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.