Comparar dos DataTables para determinar las filas en una pero no en la otra

Question

Tengo dos DataTables, A y B, producidos a partir de archivos CSV. Necesito poder verificar qué filas existen en B que no existen en A.

¿Hay alguna manera de hacer una consulta para mostrar las diferentes filas o tendré que repetir cada fila de cada DataTable para comprobar si son las mismas? La última opción parece ser muy intensa si las tablas se vuelven grandes.

Answer 1

tendré que repetir cada fila de cada DataTable para comprobar si son iguales.

Como has cargado los datos de un archivo CSV, no vas a tener ningún índice ni nada, por lo que en algún punto, algo tendrá que iterar en cada fila, ya sea su código, o una biblioteca, o lo que sea.

De todos modos, esta es una pregunta algoritmos, que no es mi especialidad, pero mi enfoque ingenuo sería la siguiente:

1: Se puede explotar cualquier propiedades de los datos? ¿Son únicas todas las filas de cada tabla y puede ordenarlas con los mismos criterios? Si es así, puede hacer esto:

• Ordene ambas tablas por su ID (usando algo útil como un quicksort). Si ya están clasificados, entonces ganas a lo grande.
• Pase por ambas tablas a la vez, omitiendo los huecos en las ID en cualquiera de las tablas. Los identificadores coincidentes significan registros duplicados.

Esto le permite hacerlo en (tiempo de ordenación * 2) + una pasada, por lo tanto, si mi notación en "O" es correcta, sería (cualquier tiempo de ordenación) + O (m + n) que es bastante bueno.
(Revisión: este es el enfoque que ΤΖΩΤΖΙΟΥ describes)

2: Un enfoque alternativo, que puede ser más o menos eficaz dependiendo de lo grande que sus datos son:

• Ejecutar a través de la tabla 1, y para cada fila, pegue su ID (o código hash calculado, o alguna otra ID única para esa fila) en un diccionario (o hashtable si prefiere llamarlo así).
• Ejecute la tabla 2, y para cada fila, vea si la ID (o código hash, etc.) está presente en el diccionario. Está explotando el hecho de que los diccionarios son realmente rápidos, ¿O (1) creo? buscar. Este paso será realmente rápido, pero habrá pagado el precio haciendo todos los insertos de diccionario.

estaría muy interesado en ver lo que la gente con mejor conocimiento de algoritmos que yo mismo ocurre para éste :-)

Answer 2

Se pueden utilizar los métodos de combinación y GetChanges en el DataTable para hacer esto:

A.Merge(B); // this will add to A any records that are in B but not A 
return A.GetChanges(); // returns records originally only in B 

Answer 3

Para su información:

En términos generales acerca de los algoritmos, la comparación de dos conjuntos de ordenable (como identificadores normalmente son) es no es una operación O (M * N/2), sino O (M + N) si los dos conjuntos están ordenados. Así escanear una tabla con un puntero al comienzo de la otra, y:

other_item= A.first() 
only_in_B= empty_list() 
for item in B: 
    while other_item > item: 
     other_item= A.next() 
     if A.eof(): 
      only_in_B.add(all the remaining B items) 
      return only_in_B 
    if item < other_item: 
     empty_list.append(item) 
return only_in_B 

El código anterior es, obviamente, pseudocódigo, pero debe darle la esencia general si decide codificar por sí mismo.

Answer 4

Asumiendo que tiene una columna de ID, que es de un tipo apropiado (es decir, da un código hash y pone en práctica la igualdad) - cadena en este ejemplo, que es ligeramente pseudocódigo porque no estoy familiarizado con tablas de datos y no tienen tiempo para mirar a todo sólo ahora :)

IEnumerable<string> idsInA = tableA.AsEnumerable().Select(row => (string)row["ID"]); 
IEnumerable<string> idsInB = tableB.AsEnumerable().Select(row => (string)row["ID"]); 
IEnumerable<string> bNotA = idsInB.Except(idsInA); 

Answer 5

Las respuestas hasta ahora suponga que simplemente está buscando claves primarias duplicadas. Ese es un problema bastante fácil: puede usar el método Merge(), por ejemplo.

Pero entiendo que su pregunta significa que está buscando DataRows duplicados. (A partir de su descripción del problema, con ambas tablas importadas de archivos CSV, incluso supondría que las filas originales no tenían valores de clave primaria, y que las claves principales se asignan mediante Autonumérico durante la importación).

La implementación ingenua (para cada fila en A, compare su ItemArray con la de cada fila en B) va a ser de hecho computacionalmente costosa.

Una forma mucho menos costosa de hacer esto es con un algoritmo hash. Para cada DataRow, concatene los valores de cadena de sus columnas en una sola cadena y luego llame a GetHashCode() en esa cadena para obtener un valor int. Cree un Dictionary<int, DataRow> que contenga una entrada, codificada en el código hash, para cada DataRow en DataTable B. Luego, para cada DataRow en DataTable A, calcule el código hash y vea si está contenido en el diccionario. Si no es así, usted sabe que el DataRow no existe en DataTable B.

Este enfoque tiene dos puntos débiles que surgen del hecho de que dos cadenas pueden ser desiguales pero producen el mismo código hash. Si encuentra una fila en A cuyo hash está en el diccionario, debe verificar el DataRow en el diccionario para verificar que las dos filas sean realmente iguales.

La segunda debilidad es más grave: es poco probable, pero es posible, que dos DataRows diferentes en B puedan hacer hash con el mismo valor de clave. Por esta razón, el diccionario debería ser realmente un Dictionary<int, List<DataRow>>, y debería realizar la comprobación descrita en el párrafo anterior frente a cada DataRow en la lista.

Se necesita bastante trabajo para que funcione, pero es un algoritmo O (m + n), que creo que va a ser todo lo bueno que se pueda.

Answer 6

Gracias por toda la retroalimentación.

Desafortunadamente no tengo ningún índice. Daré un poco más de información sobre mi situación.

Tenemos un programa de informes (Crystal Reports reemplazado) que está instalado en 7 servidores en toda la UE. Estos servidores tienen muchos informes sobre ellos (no todos iguales para cada país). Son invocados por una aplicación de línea de comandos que usa archivos XML para su configuración. Así que un archivo XML puede llamar a varios informes.

La aplicación de línea de comandos está programada y controlada por nuestro proceso durante la noche. Entonces el archivo XML podría ser llamado desde múltiples lugares.

El objetivo del CSV es generar una lista de todos los informes que se usan y de dónde se llaman.

Estoy revisando los archivos XML para todas las referencias, consultando el programa de programación y produciendo una lista de todos los informes. (esto no es tan malo)

El problema que tengo es que tengo que mantener una lista de todos los informes que podrían haberse eliminado de la producción. Entonces necesito comparar el viejo CSV con los nuevos datos. Para esto, pensé que era mejor incluirlo en DataTables y comparar la información (este podría ser el enfoque equivocado. Supongo que podría crear un objeto que lo tenga y comparar la diferencia y luego crear una iteración a través de ellos).

Los datos que tengo sobre cada informe es el siguiente:

String - Nombre de la tarea String - Nombre de acción Int - ActionID (el ID de acción puede estar en varios registros en una sola acción puede llamar a muchos informes, es decir, un archivo XML). Cadena - Archivo XML llamado Cadena - Nombre del informe

Intentaré con la idea de fusión propuesta por MusiGenesis (gracias). (Releyendo algunas de las publicaciones no estoy seguro de si la combinación funcionará, pero vale la pena intentarlo ya que no he oído hablar de ella antes, por lo que hay algo nuevo que aprender).

La idea de HashCode también parece interesante.

Gracias por todos los consejos.

Answer 7

public DataTable compareDataTables(DataTable First, DataTable Second) 
{ 
     First.TableName = "FirstTable"; 
     Second.TableName = "SecondTable"; 

     //Create Empty Table 
     DataTable table = new DataTable("Difference"); 
     DataTable table1 = new DataTable(); 
     try 
     { 
      //Must use a Dataset to make use of a DataRelation object 
      using (DataSet ds4 = new DataSet()) 
      { 
       //Add tables 
       ds4.Tables.AddRange(new DataTable[] { First.Copy(), Second.Copy() }); 

       //Get Columns for DataRelation 
       DataColumn[] firstcolumns = new DataColumn[ds4.Tables[0].Columns.Count]; 
       for (int i = 0; i < firstcolumns.Length; i++) 
       { 
        firstcolumns[i] = ds4.Tables[0].Columns[i]; 
       } 
       DataColumn[] secondcolumns = new DataColumn[ds4.Tables[1].Columns.Count]; 
       for (int i = 0; i < secondcolumns.Length; i++) 
       { 
        secondcolumns[i] = ds4.Tables[1].Columns[i]; 
       } 
       //Create DataRelation 
       DataRelation r = new DataRelation(string.Empty, firstcolumns, secondcolumns, false); 
       ds4.Relations.Add(r); 
       //Create columns for return table 
       for (int i = 0; i < First.Columns.Count; i++) 
       { 
        table.Columns.Add(First.Columns[i].ColumnName, First.Columns[i].DataType); 
       } 
       //If First Row not in Second, Add to return table. 
       table.BeginLoadData(); 
       foreach (DataRow parentrow in ds4.Tables[0].Rows) 
       { 
        DataRow[] childrows = parentrow.GetChildRows(r); 

        if (childrows == null || childrows.Length == 0) 
         table.LoadDataRow(parentrow.ItemArray, true); 
        table1.LoadDataRow(childrows, false); 

       } 
       table.EndLoadData(); 
      } 
     } 
     catch (Exception ex) 
     { 
      Console.WriteLine(ex.Message); 
     } 
     return table; 
} 

Answer 8

 try 
     { 
      if (ds.Tables[0].Columns.Count == ds1.Tables[0].Columns.Count) 
      { 
       for (int i = 0; i < ds.Tables[0].Rows.Count; i++) 
       { 
        for (int j = 0; j < ds.Tables[0].Columns.Count; j++) 
        { 
     if (ds.Tables[0].Rows[i][j].ToString() == ds1.Tables[0].Rows[i][j].ToString()) 
         { 


         } 
         else 
         { 

          MessageBox.Show(i.ToString() + "," + j.ToString()); 


         } 

               } 

       } 

      } 
      else 
      { 
       MessageBox.Show("Table has different columns "); 
      } 
     } 
     catch (Exception) 
     { 
      MessageBox.Show("Please select The Table"); 
     } 

Answer 9

estoy continuando la idea de tzot ...

Si tiene dos juegos que se pueden ordenar, a continuación, puedes utilizar:

List<string> diffList = new List<string>(sortedListA.Except(sortedListB)); 

Si necesita objetos más complicados, puede definir un comparador usted mismo y aún así usarlo.

Answer 10

Encontré una manera fácil de resolver esto. A diferencia de las respuestas anteriores de "excepto método", utilizo el método except dos veces. Esto no solo le indica qué filas se eliminaron, sino qué filas se agregaron. Si solo usa uno excepto el método, solo le indicará una diferencia y no ambas. Este código está probado y funciona. Véase más adelante

//Pass in your two datatables into your method 

     //build the queries based on id. 
     var qry1 = datatable1.AsEnumerable().Select(a => new { ID = a["ID"].ToString() }); 
     var qry2 = datatable2.AsEnumerable().Select(b => new { ID = b["ID"].ToString() }); 


     //detect row deletes - a row is in datatable1 except missing from datatable2 
     var exceptAB = qry1.Except(qry2); 

     //detect row inserts - a row is in datatable2 except missing from datatable1 
     var exceptAB2 = qry2.Except(qry1); 

luego ejecutar su código en contra de los resultados

 if (exceptAB.Any()) 
     { 
      foreach (var id in exceptAB) 
      { 
    //execute code here 
      } 


     } 
     if (exceptAB2.Any()) 
     { 
      foreach (var id in exceptAB2) 
      { 
//execute code here 
      } 



     } 

Answer 11

El escenario de uso habitual considera un usuario que tiene un DataTable en la mano y lo cambia por adición, eliminación o modificación de algunos de los DataRows.

Después de realizar los cambios, el DataTable es consciente de lo propio DataRowState para cada fila, y también realiza un seguimiento de la OriginalDataRowVersion de las filas que han cambiado.

En este escenario habitual, uno puede Merge cambiar los cambios a una tabla fuente (en la que todas las filas son Unchanged). Después de la fusión, uno puede obtener un buen resumen de solo las filas modificadas con una llamada al GetChanges().

En un escenario más inusual, un usuario tiene dos DataTables con el mismo esquema (o quizás solo las mismas columnas y sin claves principales).Estos dos DataTables consisten en solo Unchanged filas. El usuario puede querer saber qué cambios necesita aplicar a una de las dos tablas para llegar a la otra. Es decir, qué filas deben agregarse, eliminarse o modificarse.

Definimos aquí una función llamada GetDelta() el que hace el trabajo:

using System; 
using System.Data; 
using System.Xml; 
using System.Linq; 
using System.Collections.Generic; 
using System.Data.DataSetExtensions; 

public class Program 
{ 
    private static DataTable GetDelta(DataTable table1, DataTable table2) 
    { 
     // Modified2 : row1 keys match rowOther keys AND row1 does not match row2: 
     IEnumerable<DataRow> modified2 = (
      from row1 in table1.AsEnumerable() 
      from row2 in table2.AsEnumerable() 
      where table1.PrimaryKey.Aggregate(true, (boolAggregate, keycol) => boolAggregate & row1[keycol].Equals(row2[keycol.Ordinal])) 
        && !row1.ItemArray.SequenceEqual(row2.ItemArray) 
      select row2); 

     // Modified1 : 
     IEnumerable<DataRow> modified1 = (
      from row1 in table1.AsEnumerable() 
      from row2 in table2.AsEnumerable() 
      where table1.PrimaryKey.Aggregate(true, (boolAggregate, keycol) => boolAggregate & row1[keycol].Equals(row2[keycol.Ordinal])) 
        && !row1.ItemArray.SequenceEqual(row2.ItemArray) 
      select row1); 

     // Added : row2 not in table1 AND row2 not in modified2 
     IEnumerable<DataRow> added = table2.AsEnumerable().Except(modified2, DataRowComparer.Default).Except(table1.AsEnumerable(), DataRowComparer.Default); 

     // Deleted : row1 not in row2 AND row1 not in modified1 
     IEnumerable<DataRow> deleted = table1.AsEnumerable().Except(modified1, DataRowComparer.Default).Except(table2.AsEnumerable(), DataRowComparer.Default); 


     Console.WriteLine(); 
     Console.WriteLine("modified count =" + modified1.Count()); 
     Console.WriteLine("added count =" + added.Count()); 
     Console.WriteLine("deleted count =" + deleted.Count()); 

     DataTable deltas = table1.Clone(); 

     foreach (DataRow row in modified2) 
     { 
      // Match the unmodified version of the row via the PrimaryKey 
      DataRow matchIn1 = modified1.Where(row1 => table1.PrimaryKey.Aggregate(true, (boolAggregate, keycol) => boolAggregate & row1[keycol].Equals(row[keycol.Ordinal]))).First(); 
      DataRow newRow = deltas.NewRow(); 

      // Set the row with the original values 
      foreach(DataColumn dc in deltas.Columns) 
       newRow[dc.ColumnName] = matchIn1[dc.ColumnName]; 
      deltas.Rows.Add(newRow); 
      newRow.AcceptChanges(); 

      // Set the modified values 
      foreach (DataColumn dc in deltas.Columns) 
       newRow[dc.ColumnName] = row[dc.ColumnName]; 
      // At this point newRow.DataRowState should be : Modified 
     } 

     foreach (DataRow row in added) 
     { 
      DataRow newRow = deltas.NewRow(); 
      foreach (DataColumn dc in deltas.Columns) 
       newRow[dc.ColumnName] = row[dc.ColumnName]; 
      deltas.Rows.Add(newRow); 
      // At this point newRow.DataRowState should be : Added 
     } 


     foreach (DataRow row in deleted) 
     { 
      DataRow newRow = deltas.NewRow(); 
      foreach (DataColumn dc in deltas.Columns) 
       newRow[dc.ColumnName] = row[dc.ColumnName]; 
      deltas.Rows.Add(newRow); 
      newRow.AcceptChanges(); 
      newRow.Delete(); 
      // At this point newRow.DataRowState should be : Deleted 
     } 

     return deltas; 
    } 

    private static void DemonstrateGetDelta() 
    { 
     DataTable table1 = new DataTable("Items"); 

     // Add columns 
     DataColumn column1 = new DataColumn("id1", typeof(System.Int32)); 
     DataColumn column2 = new DataColumn("id2", typeof(System.Int32)); 
     DataColumn column3 = new DataColumn("item", typeof(System.Int32)); 
     table1.Columns.Add(column1); 
     table1.Columns.Add(column2); 
     table1.Columns.Add(column3); 

     // Set the primary key column. 
     table1.PrimaryKey = new DataColumn[] { column1, column2 }; 


     // Add some rows. 
     DataRow row; 
     for (int i = 0; i <= 4; i++) 
     { 
      row = table1.NewRow(); 
      row["id1"] = i; 
      row["id2"] = i*i; 
      row["item"] = i; 
      table1.Rows.Add(row); 
     } 

     // Accept changes. 
     table1.AcceptChanges(); 
     PrintValues(table1, "table1:"); 

     // Create a second DataTable identical to the first. 
     DataTable table2 = table1.Clone(); 

     // Add a row that exists in table1: 
     row = table2.NewRow(); 
     row["id1"] = 0; 
     row["id2"] = 0; 
     row["item"] = 0; 
     table2.Rows.Add(row); 

     // Modify the values of a row that exists in table1: 
     row = table2.NewRow(); 
     row["id1"] = 1; 
     row["id2"] = 1; 
     row["item"] = 455; 
     table2.Rows.Add(row); 

     // Modify the values of a row that exists in table1: 
     row = table2.NewRow(); 
     row["id1"] = 2; 
     row["id2"] = 4; 
     row["item"] = 555; 
     table2.Rows.Add(row); 

     // Add a row that does not exist in table1: 
     row = table2.NewRow(); 
     row["id1"] = 13; 
     row["id2"] = 169; 
     row["item"] = 655; 
     table2.Rows.Add(row); 

     table2.AcceptChanges(); 

     Console.WriteLine(); 
     PrintValues(table2, "table2:"); 

     DataTable delta = GetDelta(table1,table2); 

     Console.WriteLine(); 
     PrintValues(delta,"delta:"); 

     // Verify that the deltas DataTable contains the adequate Original DataRowVersions: 
     DataTable originals = table1.Clone(); 
     foreach (DataRow drow in delta.Rows) 
     { 
      if (drow.RowState != DataRowState.Added) 
      { 
       DataRow originalRow = originals.NewRow(); 
       foreach (DataColumn dc in originals.Columns) 
        originalRow[dc.ColumnName] = drow[dc.ColumnName, DataRowVersion.Original]; 
       originals.Rows.Add(originalRow); 
      } 
     } 
     originals.AcceptChanges(); 

     Console.WriteLine(); 
     PrintValues(originals,"delta original values:"); 
    } 

    private static void Row_Changed(object sender, 
     DataRowChangeEventArgs e) 
    { 
     Console.WriteLine("Row changed {0}\t{1}", 
      e.Action, e.Row.ItemArray[0]); 
    } 

    private static void PrintValues(DataTable table, string label) 
    { 
     // Display the values in the supplied DataTable: 
     Console.WriteLine(label); 
     foreach (DataRow row in table.Rows) 
     { 
      foreach (DataColumn col in table.Columns) 
      { 
       Console.Write("\t " + row[col, row.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current].ToString()); 
      } 
      Console.Write("\t DataRowState =" + row.RowState); 
      Console.WriteLine(); 
     } 
    } 

    public static void Main() 
    { 
     DemonstrateGetDelta(); 
    } 
} 

El código anterior se puede probar en https://dotnetfiddle.net/. La salida resultante se muestra a continuación:

table1: 
    0  0  0  DataRowState =Unchanged 
    1  1  1  DataRowState =Unchanged 
    2  4  2  DataRowState =Unchanged 
    3  9  3  DataRowState =Unchanged 
    4  16  4  DataRowState =Unchanged 

table2: 
    0  0  0  DataRowState =Unchanged 
    1  1  455  DataRowState =Unchanged 
    2  4  555  DataRowState =Unchanged 
    13  169  655  DataRowState =Unchanged 

modified count =2 
added count =1 
deleted count =2 

delta: 
    1  1  455  DataRowState =Modified 
    2  4  555  DataRowState =Modified 
    13  169  655  DataRowState =Added 
    3  9  3  DataRowState =Deleted 
    4  16  4  DataRowState =Deleted 

delta original values: 
    1  1  1  DataRowState =Unchanged 
    2  4  2  DataRowState =Unchanged 
    3  9  3  DataRowState =Unchanged 
    4  16  4  DataRowState =Unchanged 

Tenga en cuenta que si sus tablas no tienen un PrimaryKey, la cláusula where en las consultas LINQ se simplifica un poco. Te dejaré que te des cuenta por tu cuenta.

Answer 12

Lograrlo simplemente usando linq.

private DataTable CompareDT(DataTable TableA, DataTable TableB) 
    { 
     DataTable TableC = new DataTable(); 
     try 
     { 

      var idsNotInB = TableA.AsEnumerable().Select(r => r.Field<string>(Keyfield)) 
      .Except(TableB.AsEnumerable().Select(r => r.Field<string>(Keyfield))); 
      TableC = (from row in TableA.AsEnumerable() 
         join id in idsNotInB 
         on row.Field<string>(ddlColumn.SelectedItem.ToString()) equals id 
         select row).CopyToDataTable(); 
     } 
     catch (Exception ex) 
     { 
      lblresult.Text = ex.Message; 
      ex = null; 
     } 
     return TableC; 

    } 

Answer 13

Podría no simplemente comparar los archivos CSV antes de cargarlos en tablas de datos?

string[] a = System.IO.File.ReadAllLines(@"cvs_a.txt"); 
string[] b = System.IO.File.ReadAllLines(@"csv_b.txt"); 

// get the lines from b that are not in a 
IEnumerable<string> diff = b.Except(a); 

//... parse b into DataTable ...