private static SnapshotTableDifferences SortTable(SnapshotTableDifferences tableDifferences) { Func <IEnumerable <RowDifference>, IEnumerable <RowDifference> > sorter = null; foreach (var fieldSortSpec in SortFieldOrderer.Order(tableDifferences.TableDefinition.SortColumns)) { var fieldName = fieldSortSpec.Field; Func <RowDifference, object> fetch = (r) => r.After.GetField(fieldName) ?? r.Before.GetField(fieldName); Func <IEnumerable <RowDifference>, IEnumerable <RowDifference> > nextSorter; if (fieldSortSpec.SortOrder == SortOrder.Ascending) { nextSorter = r => r.OrderBy(fetch, ValueComparer.Comparer); } else { nextSorter = r => r.OrderByDescending(fetch, ValueComparer.Comparer); } if (sorter == null) { sorter = nextSorter; } else { var currentSorter = sorter; sorter = r => currentSorter(nextSorter(r)); } } Debug.Assert(sorter != null); var rowDifferences = sorter(tableDifferences.RowDifferences).ToList(); return(new SnapshotTableDifferences(rowDifferences, tableDifferences.TableDefinition)); }
private static IEnumerable <object> ColumnValues(string column, SnapshotTableDifferences tableForValues) { var items = tableForValues.RowDifferences.SelectMany(rd => rd.Differences.Differences.Where(d => d.Name == column)); foreach (var item in items) { var columnValue = item.Before ?? item.After; yield return(columnValue); if (item.Before != null && item.After != null && !item.Before.Equals(item.After)) { yield return(item.After); } } }
/// <summary> /// Add mandatory rows to a difference set as references if they do not currently exist. /// </summary> /// <param name="collection">The collection that generated the differences.</param> /// <param name="tableDiffs">The difference set.</param> /// <param name="rows">The rows that are mandatory.</param> /// <param name="additionalRows">The rows that are mandatory.</param> /// <param name="differenceSide">One of the snapshots - it does not generally matter which because rows that were not extracted should be identical in both snapshots.</param> internal static List <SnapshotTableDifferences> RequireRows(SnapshotCollection collection, List <SnapshotTableDifferences> tableDiffs, AdditionalReferencedRows additionalRows, Snapshot differenceSide) { var result = new List <SnapshotTableDifferences>(); foreach (var table in collection.TablesInDefinitionOrder) { var current = tableDiffs.SingleOrDefault(t => t.TableDefinition.TableName == table.TableName); var additional = additionalRows.Tables.SingleOrDefault(t => t.TableDefinition.TableName == table.TableName); if (additional == null && current != null) { result.Add(current); } else if (additional != null) { var snapRows = differenceSide.Rows(additional.TableDefinition.TableName).ToList(); var addRows = additional.Keys.Select(rowRequest => snapRows.SingleOrDefault(r => r.GetField(rowRequest.ColumnName)?.Equals(rowRequest.RequestedValue) ?? false)) .Where(r => r != null) .ToList(); var requiredSnapRows = snapRows.Select((r, i) => new { Index = i, SnapRow = r, Difference = current?.RowDifferences.SingleOrDefault(d => ReferenceEquals(d.After, r) || ReferenceEquals(d.Before, r)), Additional = additional.Keys.FirstOrDefault(a => r.GetField(a.ColumnName)?.Equals(a.RequestedValue) ?? false) }) .Where(req => req.Additional != null || req.Difference != null) .ToList(); var allDiffs = requiredSnapRows .Select(r => r.Difference ?? new RowDifference(new SnapshotRowKey(r.SnapRow, table), DifferenceType.Reference, r.SnapRow, r.SnapRow)); if (current != null && current.RowDifferences.Any()) { //Add in any rows from the original differences that were not matched in the required rows. allDiffs = allDiffs.Concat(current.RowDifferences.Where(r => !requiredSnapRows.Any(sr => ReferenceEquals(sr.Difference, r)))); } var newDiffs = new SnapshotTableDifferences(allDiffs.ToList(), additional.TableDefinition); result.Add(newDiffs); } } return(result); }
private static void ReportDifferences(ReportParameters <RowDifference> rep, SnapshotTableDifferences tableDifferences, Output output, ChangeReportOptions changeReportOptions) { var differenceCols = tableDifferences.RowDifferences .Where(r => r.Differences?.Differences != null) .SelectMany(r => r.Differences.Differences.Select(d => d.Name)).Distinct(); var allCols = tableDifferences.TableDefinition.Columns.Where(c => differenceCols.Contains(c.Name)).Select(c => c.Name); rep.Title(tableDifferences.TableDefinition.TableName); rep.RemoveBufferLimit(); rep.AddColumn(rd => rd.DifferenceType.ToString(), cc => cc.Heading("Difference")); foreach (var col in allCols) { rep.AddColumn(rep.Lambda(rd => DifferenceDisplay(rd, col)), cc => cc.Heading(col)); } }
public static List <SnapshotTableDifferences> RequireColumns(SnapshotCollection collection, List <SnapshotTableDifferences> diffs, TableDefinition table, IEnumerable <string> requiredColumns, Snapshot before) { var result = new List <SnapshotTableDifferences>(); var columnList = requiredColumns.ToList(); foreach (var differences in diffs) { if (differences.TableDefinition.TableName == table.TableName) { var rowDiffs = differences.RowDifferences.Select(r => RequireColumns(r, columnList)).ToList(); var newDiffs = new SnapshotTableDifferences(rowDiffs, differences.TableDefinition); result.Add(newDiffs); } else { result.Add(differences); } } return(result); }
private static SnapshotTableDifferences SubstituteDiff(SnapshotTableDifferences tableDiff, List <SubstituteValues> substituteValues) { var amendedDiffs = tableDiff.RowDifferences.Select(rd => SubstituteRowDiffs(tableDiff.TableDefinition, rd, substituteValues)).ToList(); return(new SnapshotTableDifferences(amendedDiffs, tableDiff.TableDefinition)); }