public async Task RunDeltaTest_update() { var source = Helpers.CreateUnSortedTestData(); source.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); var targetTable = source.CacheTable.Copy(); targetTable.AddAuditColumns(); Transform target = new ReaderMemory(targetTable); //run an update load with nothing in the target, which will result in 10 rows created. var transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.AppendUpdate, 0, false); transformDelta.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); var count = 0; while (await transformDelta.ReadAsync()) { Assert.True((char)transformDelta["Operation"] == 'C'); Assert.True((long)transformDelta["SurrogateKey"] == count + 1); Assert.True((int)transformDelta["IntColumn"] == count + 1); count++; } Assert.Equal(10, count); transformDelta.SetRowNumber(0); //write result to a memory table var memoryConnection = new ConnectionMemory(); var writer = new TransformWriter(); var result = new TransformWriterResult(); result.SetProperties(0, 10, "DataLink", 1, 2, "Test", 1, "Source", 2, "Target", null, null, TransformWriterResult.ETriggerMethod.Manual, "Test"); var writeResult = await writer.WriteAllRecords(result, transformDelta, target.CacheTable, memoryConnection, CancellationToken.None); Assert.True(writeResult); target = memoryConnection .GetTransformReader(target.CacheTable); // new ReaderMemory(target.CacheTable, null); target.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); //Set the target pointer back to the start and rerun. Now 10 rows should be ignored. source.SetRowNumber(0); target.SetRowNumber(0); //run an append. (only difference from reload is no truncate record at start. transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.AppendUpdate, 0, false); count = 0; while (await transformDelta.ReadAsync()) { count++; } Assert.Equal(10, transformDelta.TotalRowsIgnored); Assert.Equal(0, count); //change 3 rows. (first, middle, last) to similate target table data changes target.CacheTable.Data[0][4] = 100; target.CacheTable.Data[5][4] = 200; target.CacheTable.Data[9][4] = 300; //add a duplicate in the source var row = new object[target.CacheTable.Columns.Count]; target.CacheTable.Data[9].CopyTo(row, 0); target.CacheTable.Data.Add(row); transformDelta.Reset(); count = 0; while (await transformDelta.ReadAsync()) { count++; Assert.True((char)transformDelta["Operation"] == 'U'); } Assert.True(count == 3); //delete rows from the target, which should trigger two creates. target.CacheTable.Data.RemoveAt(1); target.CacheTable.Data.RemoveAt(7); transformDelta.Reset(); count = 0; var rowsCreated = 0; var rowsUpdated = 0; while (await transformDelta.ReadAsync()) { rowsCreated += (char)transformDelta["Operation"] == 'C' ? 1 : 0; rowsUpdated += (char)transformDelta["Operation"] == 'U' ? 1 : 0; count++; } Assert.Equal(2, rowsCreated); Assert.Equal(3, rowsUpdated); Assert.Equal(5, count); //delete rows from the source, which should not cause any change as delete detection is not on. source.CacheTable.Data.RemoveAt(9); source.CacheTable.Data.RemoveAt(0); //this is the row that was updated, so update now = 2 transformDelta.Reset(); count = 0; rowsCreated = 0; rowsUpdated = 0; while (await transformDelta.ReadAsync()) { rowsCreated += (char)transformDelta["Operation"] == 'C' ? 1 : 0; rowsUpdated += (char)transformDelta["Operation"] == 'U' ? 1 : 0; count++; } Assert.True(rowsCreated == 1); Assert.True(rowsUpdated == 2); Assert.True(count == 3); }
public async Task RunDeltaTest_updatePreserve() { var source = Helpers.CreateUnSortedTestData(); source.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); var targetTable = source.CacheTable.Copy(); targetTable.AddAuditColumns(); long surrrogateKey = 0; Transform target = new ReaderMemory(targetTable); target.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); //run an update load with nothing in the target. var transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.AppendUpdateDeletePreserve, surrrogateKey, false); transformDelta.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); var count = 0; while (await transformDelta.ReadAsync()) { Assert.True((char)transformDelta["Operation"] == 'C'); Assert.True((long)transformDelta["SurrogateKey"] == count + 1); Assert.True((int)transformDelta["IntColumn"] == count + 1); count++; } Assert.True(count == 10); surrrogateKey = transformDelta.SurrogateKey; transformDelta.SetRowNumber(0); //write result to a memory table var memoryConnection = new ConnectionMemory(); var writer = new TransformWriter(); var result = new TransformWriterResult(); result.SetProperties(0, 1, "DataLink", 1, 2, "Test", 1, "Source", 2, "Target", null, null, TransformWriterResult.ETriggerMethod.Manual, "Test"); await writer.WriteAllRecords(result, transformDelta, target.CacheTable, memoryConnection, CancellationToken.None); target = memoryConnection.GetTransformReader(target.CacheTable); target.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); //run an append. (only difference from reload is no truncate record at start. transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.AppendUpdatePreserve, surrrogateKey, false); count = 0; while (await transformDelta.ReadAsync()) { count++; } //change 3 rows. (first, middle, last) target.CacheTable.Data[0][4] = 100; target.CacheTable.Data[5][4] = 200; target.CacheTable.Data[9][4] = 300; //add a duplicate in the source var row = new object[target.CacheTable.Columns.Count]; target.CacheTable.Data[9].CopyTo(row, 0); target.CacheTable.Data.Add(row); transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.AppendUpdatePreserve, surrrogateKey, false); transformDelta.SetCacheMethod(Transform.ECacheMethod.PreLoadCache); count = 0; var rowsCreated = 0; while (await transformDelta.ReadAsync()) { rowsCreated += (char)transformDelta["Operation"] == 'C' ? 1 : 0; count++; } Assert.Equal(3, rowsCreated); Assert.Equal(3, transformDelta.TotalRowsPreserved); Assert.Equal(6, count); //run the delta again. this should ignore all 10 records. transformDelta.SetRowNumber(0); result = new TransformWriterResult(); result.SetProperties(0, 1, "DataLink", 30, 40, "Test", 1, "Source", 2, "Target", null, null, TransformWriterResult.ETriggerMethod.Manual, "Test"); await writer.WriteAllRecords(result, transformDelta, target.CacheTable, memoryConnection, CancellationToken.None); target = memoryConnection.GetTransformReader(target.CacheTable); transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.AppendUpdatePreserve, surrrogateKey, false); count = 0; while (await transformDelta.ReadAsync()) { count++; } Assert.Equal(10, transformDelta.TotalRowsIgnored); Assert.Equal(0, count); }