/// <summary>
/// Apply an angular impulse for the current frame only, affecting the body's position by applying an instantaneous pseudo-torque.
/// </summary>
/// <param name="impulse">The axis direction and magnitude of impulse to apply.</param>
public void ApplyAngularFlashImpulse(ref Vector3 impulse)
{
Vector3 w, zero = Vector3.Zero;
Vector3.Transform(ref impulse, ref MassWorld.InertiaInverse, out w);
var delta = new TransformDelta(ref zero, ref w);
World.ApplyDelta(1f, ref delta);
UpdateWorld();
}
public async Task TransformDeltaPerformance(int rows, TransformDelta.EUpdateStrategy updateStrategy)
{
var source = Helpers.CreateLargeTable(rows);
var targetTable = source.CacheTable.Copy();
targetTable.AddAuditColumns();
Transform target = new ReaderMemory(targetTable);
var transformDelta = new TransformDelta(source, target, updateStrategy, 1, false);
var count = 0;
while (await transformDelta.ReadAsync())
{
count++;
}
//appendupdate and appenddelete will merge all rows in to one.
if (updateStrategy == TransformDelta.EUpdateStrategy.AppendUpdate ||
updateStrategy == TransformDelta.EUpdateStrategy.AppendUpdateDelete)
{
Assert.True(count == 1);
}
//reload has one extract row which is the truncate row.
else if (updateStrategy == TransformDelta.EUpdateStrategy.Reload)
{
Assert.True(count == rows + 1);
}
else
{
Assert.True(count == rows);
}
WriteTransformPerformance(transformDelta);
////write result to a memory table
//ConnectionMemory memoryConnection = new ConnectionMemory();
//TransformWriter writer = new TransformWriter();
//writer.WriteAllRecords(transformDelta, Target.CacheTable, memoryConnection, null, null).Wait();
//Target = memoryConnection.ExecuteReader(Target.CacheTable, null).Result.Value;
//Assert.True(transformDelta.RowsCreated == 100000);
}
public async Task RunDeltaTest_reload()
{
var source = Helpers.CreateSortedTestData();
var targetTable = source.CacheTable.Copy();
targetTable.AddAuditColumns();
var target = new ReaderMemory(targetTable);
//run a reload.
var transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.Reload, 0, false);
await transformDelta.ReadAsync();
Assert.True((char)transformDelta["Operation"] == 'T');
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);
//run an append. (only difference from reload is no truncate record at start.
transformDelta = new TransformDelta(source, target, TransformDelta.EUpdateStrategy.Append, 0, false);
transformDelta.Reset();
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);
}
public override void InitWeapon()
{
TransformDelta swordAttack = new TransformDelta
{
pose1 = new Vector3(-0.25f, 1.75f, -0.1f),
pose2 = new Vector3(0.296f, 0.94f, 0.149f),
rot1 = Quaternion.Euler(-58.6f, -26.7f, 43.7f),
rot2 = Quaternion.Euler(146.696f, -36.06f, -62.05f),
toRearUpTime = 0.41f,
toStrikeTime = 0.2f,
toReleaseTime = 0.7f,
toRearUp = toRearUp,
toStrike = toStrike,
toRelease = toRelease,
rotInclude = true
};
TransformDelta chestMove = new TransformDelta()
{
pose1 = new Vector3(0.0f, 2.1f, 0.8f),
pose2 = new Vector3(0.0f, 0.6f, 1.0f),
toRearUpTime = 0.4f,
toStrikeTime = 0.2f,
toReleaseTime = 0.7f,
toRearUp = toRearUp,
toStrike = toStrike,
toRelease = toRelease,
rotInclude = false
};
mainAttack = new AttackMove
{
moveDeltaWeapon = swordAttack,
moveDeltaChest = chestMove
};
}
/// <summary>
/// Apply a linear impulse for the current frame only, affecting the body's position by applying an instantaneous pseudo-force
/// at a specific point on the body.
/// </summary>
/// <param name="impulse">The direction and magnitude of the impulse to apply.</param>
/// <param name="offset">The point in world coordinates at which to apply the impulse.</param>
public void ApplyFlashImpulse(ref Vector3 impulse, ref Vector3 offset)
{
if (!IsActive)
{
return;
}
float massInv = MassProperties.MassInverse;
Vector3 v;
Vector3.Multiply(ref impulse, massInv, out v);
Vector3 w;
Vector3.Cross(ref offset, ref impulse, out w);
Vector3.Transform(ref w, ref MassWorld.InertiaInverse, out w);
Vector3.Multiply(ref w, 0.25f, out w);
var delta = new TransformDelta(ref v, ref w);
World.ApplyDelta(1f, ref delta);
UpdateWorld();
}
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);
}
/// <summary>
/// Perfromance tests should run in around 1 minute.
/// </summary>
/// <param name="connection"></param>
public async Task PerformanceTransformWriter(Connection connection, string databaseName, long rows)
{
await connection.CreateDatabase(databaseName, CancellationToken.None);
//create a table that utilizes every available datatype.
var table = new Table("LargeTable" + (DataSets.counter++));
table.Columns.Add(
new TableColumn("SurrogateKey", ETypeCode.Int32, TableColumn.EDeltaType.SurrogateKey)
{
IsIncrementalUpdate = true
});
table.Columns.Add(new TableColumn("UpdateTest", ETypeCode.Int32));
foreach (ETypeCode typeCode in Enum.GetValues(typeof(ETypeCode)))
{
if (typeCode == ETypeCode.Binary && connection.CanUseBinary)
{
continue;
}
if (typeCode != ETypeCode.Binary)
{
continue;
}
table.Columns.Add(new TableColumn()
{
Name = "column" + typeCode,
DataType = typeCode,
MaxLength = 50,
DeltaType = TableColumn.EDeltaType.TrackingField
});
}
//create the table
await connection.CreateTable(table, true, CancellationToken.None);
//add rows.
var buffer = 0;
for (var i = 0; i < rows; i++)
{
var row = new object[table.Columns.Count];
row[0] = i;
row[1] = 0;
//load the rows with random values.
for (var j = 2; j < table.Columns.Count; j++)
{
var dataType = DataType.GetType(table.Columns[j].DataType);
if (i % 2 == 0)
{
row[j] = connection.GetConnectionMaxValue(table.Columns[j].DataType, 20);
}
else
{
row[j] = connection.GetConnectionMinValue(table.Columns[j].DataType);
}
}
table.Data.Add(row);
buffer++;
if (buffer >= 5000 || rows == i + 1)
{
//start a datawriter and insert the test data
await connection.DataWriterStart(table);
await connection.ExecuteInsertBulk(table, new ReaderMemory(table), CancellationToken.None);
table.Data.Clear();
buffer = 0;
}
}
var targetTable = table.Copy();
targetTable.AddAuditColumns();
targetTable.Name = "TargetTable";
await connection.CreateTable(targetTable, false, CancellationToken.None);
var targetTransform = connection.GetTransformReader(targetTable);
//count rows using reader
var transform = connection.GetTransformReader(table);
transform = new TransformMapping(transform, true, null, null);
transform = new TransformValidation(transform, null, false);
transform = new TransformDelta(transform, targetTransform, TransformDelta.EUpdateStrategy.Reload, 1, false);
var writer = new TransformWriter();
var writerResult = new TransformWriterResult();
await connection.InitializeAudit(writerResult, 0, "Datalink", 1, 2, "Test", 1, "Source", 2, "Target",
TransformWriterResult.ETriggerMethod.Manual, "Test", CancellationToken.None);
Assert.NotNull(writerResult);
var result = await writer.WriteAllRecords(writerResult, transform, targetTable, connection, null, null,
null, null, CancellationToken.None);
Assert.Equal(rows, writerResult.RowsCreated);
//check the audit table loaded correctly.
var auditTable = await connection.GetTransformWriterResults(0, null, "Datalink", writerResult.AuditKey, null, true,
false, false, null, 1, 2, false, CancellationToken.None);
Assert.Equal(writerResult.RowsCreated, auditTable[0].RowsCreated);
Assert.Equal(rows - 1, Convert.ToInt64(auditTable[0].MaxIncrementalValue));
}
/// <summary>
/// Set the current linear and angular velocity of the body.
/// </summary>
/// <param name="linear">The new linear velocity.</param>
/// <param name="angular">The new angular velocity, defined as an axis direction and magnitude.</param>
public void SetVelocity(Vector3 linear, Vector3 angular)
{
Velocity = new TransformDelta(ref linear, ref angular);
}
public IEnumerator RunAttackMotions(Transform targetTransform, TransformDelta delta, bool chest = false)
{
busy = true;
yield return(null);
float timer = 0.0f;
Vector3 defaultPos = targetTransform.localPosition;
Quaternion defaultRot = targetTransform.localRotation;
float time1;
float time2;
float time3;
time1 = delta.toRearUpTime;
time2 = time1 + delta.toStrikeTime;
time3 = time2 + delta.toReleaseTime;
if (chest)
{
Debug.Log("enabling chestLookAtIK");
chestLookAt.enabled = true;
}
while (timer < time3)
{
timer += Time.fixedDeltaTime;
//first second, we will go to rear up pose.
if (timer < time1)
{
// default pose to rear up
targetTransform.localPosition = Vector3.Lerp(defaultPos, delta.pose1, delta.toRearUp.Evaluate(timer / delta.toRearUpTime));
if (delta.rotInclude)
{
targetTransform.localRotation = Quaternion.Lerp(defaultRot, delta.rot1, delta.toRearUp.Evaluate((timer - 0.05f) / delta.toRearUpTime));
}
if (chest)
{
chestLookAt.solver.IKPositionWeight = Mathf.Lerp(0, 1.0f, delta.toRearUp.Evaluate(timer / delta.toRearUpTime));
}
}
if (timer < time2 && timer > time1)
{
// rear up to attack
targetTransform.localPosition = Vector3.Slerp(delta.pose1, delta.pose2, delta.toStrike.Evaluate((timer - time1) / delta.toStrikeTime));
if (delta.rotInclude)
{
targetTransform.localRotation = Quaternion.Lerp(delta.rot1, delta.rot2, delta.toStrike.Evaluate((timer - time1 - 0.05f) / delta.toStrikeTime));
}
}
if (timer > time2)
{
// attack to default.
targetTransform.localPosition = Vector3.Lerp(delta.pose2, defaultPos, delta.toRelease.Evaluate((timer - time2) / delta.toReleaseTime));
if (delta.rotInclude)
{
targetTransform.localRotation = Quaternion.Lerp(delta.rot2, defaultRot, delta.toRelease.Evaluate((timer - time2 - 0.05f) / delta.toReleaseTime));
}
if (chest)
{
chestLookAt.solver.IKPositionWeight = Mathf.Lerp(1.0f, 0, delta.toRelease.Evaluate((timer - time2) / delta.toReleaseTime));
}
}
yield return(new WaitForFixedUpdate());
}
if (chest)
{
chestLookAt.enabled = false;
}
busy = false;
}
/// <summary>
/// Runs the datalink test and returns the results
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
/// <exception cref="DatalinkTestRunException"></exception>
public async Task <List <TestResult> > Run(CancellationToken cancellationToken)
{
try
{
var ct = CancellationTokenSource.CreateLinkedTokenSource(_cancellationTokenSource.Token,
cancellationToken);
var token = ct.Token;
token.ThrowIfCancellationRequested();
var tempTargetTableKey = -10000;
WriterResult.SetRunStatus(TransformWriterResult.ERunStatus.Started, null, null);
var passed = 0;
var failed = 0;
foreach (var step in _datalinkTest.DexihDatalinkTestSteps.OrderBy(c => c.Position).Where(c => c.IsValid))
{
var datalink = _hub.DexihDatalinks.SingleOrDefault(c => c.IsValid && c.Key == step.DatalinkKey);
if (datalink == null)
{
throw new DatalinkTestRunException($"The datalink test {_datalinkTest.Name} failed as the datalink with the key {step.DatalinkKey} could not be found.");
}
UpdateProgress(1);
// prepare all the relevant tables
foreach (var testTable in step.DexihDatalinkTestTables)
{
await PrepareTestTable(testTable, token);
}
UpdateProgress(2);
datalink.AuditConnectionKey = _datalinkTest.AuditConnectionKey;
var dexihTargetConnection = _hub.DexihConnections.Single(c => c.IsValid && c.Key == step.TargetConnectionKey);
ICollection <DexihTable> targetTables;
// add a target table to store the data when the datalink doesn't have one.
if (!datalink.DexihDatalinkTargets.Any())
{
var target = new DexihDatalinkTarget()
{
TableKey = tempTargetTableKey--,
};
datalink.DexihDatalinkTargets.Add(target);
datalink.UpdateStrategy = EUpdateStrategy.Reload;
datalink.LoadStrategy = TransformWriterTarget.ETransformWriterMethod.Bulk;
// var targetTable = datalink.GetOutputTable();
var table = new DexihTable()
{
Key = target.TableKey,
DexihTableColumns = datalink.GetOutputTable().DexihDatalinkColumns
.Select(c => c.CloneProperties <DexihTableColumn>()).ToArray()
};
// dexihTargetConnection.DexihTables.Add(table);
targetTables = new List <DexihTable> {
table
};
}
else
{
targetTables = datalink.DexihDatalinkTargets.Select(c => _hub.GetTableFromKey(c.TableKey)).ToList();
}
if (targetTables.Count > 1)
{
throw new DatalinkTestRunException("Currently datalink tests can only be used with datalinks containing no more than one target table.");
}
foreach (var table in targetTables)
{
table.ConnectionKey = dexihTargetConnection.Key;
table.Name = step.TargetTableName;
table.Schema = step.TargetSchema;
}
UpdateProgress(50);
// run the datalink
var datalinkRun = new DatalinkRun(_transformSettings, _logger, WriterResult.AuditKey, datalink, _hub, null, _transformWriterOptions, _alertQueue, _alertEmails);
datalinkRun.WriterTarget.WriterResult.AuditType = "DatalinkTestStep";
datalinkRun.WriterTarget.WriterResult.ReferenceKey = step.Key;
// await datalinkRun.Initialize(cancellationToken);
await datalinkRun.Build(token);
await datalinkRun.Run(token);
UpdateProgress(70);
foreach (var table in targetTables)
{
var testResult = new TestResult()
{
Name = step.Name,
StartDate = DateTime.Now,
TestStepKey = step.Key
};
var dexihExpectedConnection = _hub.DexihConnections.Single(c => c.IsValid && c.Key == step.ExpectedConnectionKey);
var dexihExpectedTable = table.CloneProperties();
dexihExpectedTable.ConnectionKey = dexihExpectedConnection.Key;
dexihExpectedTable.Name = step.ExpectedTableName;
dexihExpectedTable.Schema = step.ExpectedSchema;
var expectedConnection = dexihExpectedConnection.GetConnection(_transformSettings);
var expectedTable = dexihExpectedTable.GetTable(_hub, expectedConnection, _transformSettings);
var expectedTransform = expectedConnection.GetTransformReader(expectedTable);
var targetConnection = dexihTargetConnection.GetConnection(_transformSettings);
var targetTable = table.GetTable(_hub, targetConnection, _transformSettings);
var targetTransform = targetConnection.GetTransformReader(targetTable);
// the error table is used to store any rows which do not match.
var dexihErrorConnection = _hub.DexihConnections.SingleOrDefault(c => c.IsValid && c.Key == step.ErrorConnectionKey);
Connection errorConnection = null;
Table errorTable = null;
if (dexihErrorConnection != null)
{
var dexihErrorTable = table.CloneProperties();
dexihErrorTable.ConnectionKey = dexihErrorConnection.Key;
dexihErrorTable.Name = step.ErrorTableName;
dexihErrorTable.Schema = step.ErrorSchema;
errorConnection = dexihErrorConnection.GetConnection(_transformSettings);
errorTable = dexihErrorTable.GetTable(_hub, errorConnection, _transformSettings);
foreach (var column in errorTable.Columns)
{
column.DeltaType = EDeltaType.NonTrackingField;
}
errorTable.Columns.Add(new TableColumn("error_audit_key", ETypeCode.Int64,
EDeltaType.CreateAuditKey));
errorTable.Columns.Add(new TableColumn("error_operation", ETypeCode.CharArray,
EDeltaType.DatabaseOperation)
{
MaxLength = 1
});
errorTable.Columns.Add(new TableColumn("mismatch_reason", ETypeCode.String,
EDeltaType.UpdateReason)
{
AllowDbNull = true
});
}
// use the delta transform to compare expected and target tables.
await using var delta = new TransformDelta(targetTransform, expectedTransform,
EUpdateStrategy.AppendUpdateDelete, 0, false, true);
await delta.Open(0, null, token);
testResult.RowsMismatching = 0;
testResult.RowsMissingFromSource = 0;
testResult.RowsMissingFromTarget = 0;
var operationColumn = delta.CacheTable.Columns.GetOrdinal(EDeltaType.DatabaseOperation);
var updateReasonColumn = delta.CacheTable.Columns.GetOrdinal(EDeltaType.UpdateReason);
var errorCache = new TableCache();
// loop through the delta. any rows which don't match on source/target should filter through, others will be ignored.
while (await delta.ReadAsync(token))
{
testResult.TestPassed = false;
switch (delta[operationColumn])
{
case 'C':
testResult.RowsMissingFromTarget++;
break;
case 'U':
testResult.RowsMismatching++;
break;
case 'D':
testResult.RowsMissingFromSource++;
break;
}
datalinkRun.WriterTarget.WriterResult.Failed++;
WriterResult.Failed++;
WriterResult.IncrementRowsCreated();
if (errorTable != null && errorCache.Count < MaxErrorRows)
{
var row = new object[errorTable.Columns.Count];
for (var i = 0; i < errorTable.Columns.Count; i++)
{
var column = errorTable[i];
switch (column.DeltaType)
{
case EDeltaType.CreateAuditKey:
row[i] = datalinkRun.WriterTarget.WriterResult.AuditKey;
break;
case EDeltaType.DatabaseOperation:
row[i] = delta[operationColumn];
break;
case EDeltaType.UpdateReason:
row[i] = delta[updateReasonColumn];
break;
default:
row[i] = delta[column.Name];
break;
}
}
errorCache.Add(row);
}
}
if (errorCache.Count > 0)
{
errorTable.Data = errorCache;
var createReader = new ReaderMemory(errorTable);
if (!await errorConnection.TableExists(errorTable, cancellationToken))
{
await errorConnection.CreateTable(errorTable, false, cancellationToken);
}
await errorConnection.ExecuteInsertBulk(errorTable, createReader, cancellationToken);
}
WriterResult.RowsIgnored += delta.TotalRowsIgnored;
WriterResult.RowsPreserved += delta.TotalRowsPreserved;
if (testResult.TestPassed == false)
{
failed++;
}
else
{
passed++;
}
if (datalinkRun.WriterTarget.WriterResult.RunStatus == TransformWriterResult.ERunStatus.Finished)
{
if (testResult.TestPassed)
{
datalinkRun.WriterTarget.WriterResult.SetRunStatus(TransformWriterResult.ERunStatus.Passed, "Datalink test passed", null);
}
else
{
datalinkRun.WriterTarget.WriterResult.SetRunStatus(TransformWriterResult.ERunStatus.Failed, $"Datalink test failed, {testResult.RowsMissingFromSource} rows missing from expected, {testResult.RowsMissingFromTarget} rows missing from actual, {testResult.RowsMismatching} rows with mismatching columns.", null);
}
}
TestResults.Add(testResult);
}
}
if (WriterResult.Failed > 0)
{
WriterResult.SetRunStatus(TransformWriterResult.ERunStatus.Failed, $"{passed} tests passed, {failed} test failed.", null);
}
else
{
WriterResult.SetRunStatus(TransformWriterResult.ERunStatus.Passed, $"{passed} tests passed.", null);
}
await WriterResult.CompleteDatabaseWrites();
return(TestResults);
}
catch (Exception ex)
{
WriterResult.SetRunStatus(TransformWriterResult.ERunStatus.Abended, ex.Message, ex);
return(TestResults);
}
}
public async Task Transform(Connection connection, string databaseName)
{
Table table = DataSets.CreateTable();
await connection.CreateDatabase(databaseName, CancellationToken.None);
//create a new table and write some data to it.
Transform reader = DataSets.CreateTestData();
await connection.CreateTable(table, true, CancellationToken.None);
TransformWriter writer = new TransformWriter();
TransformWriterResult writerResult = new TransformWriterResult();
await connection.InitializeAudit(writerResult, 0, "DataLink", 1, 2, "Test", 1, "Source", 2, "Target", TransformWriterResult.ETriggerMethod.Manual, "Test", CancellationToken.None);
var writeRecords = await writer.WriteAllRecords(writerResult, reader, table, connection, null, null, null, null, CancellationToken.None);
Assert.True(writeRecords, $"WriteAllRecords failed with message {writerResult.Message}. Details:{writerResult.ExceptionDetails}");
//check database can sort
if (connection.CanSort)
{
//use the new table test the data base is sorting
reader = connection.GetTransformReader(table);
SelectQuery query = new SelectQuery()
{
Sorts = new List <Sort>()
{
new Sort("IntColumn", Sort.EDirection.Descending)
}
};
await reader.Open(0, query, CancellationToken.None);
int sortValue = 10;
while (await reader.ReadAsync())
{
Assert.Equal(sortValue, Convert.ToInt32(reader["IntColumn"]));
sortValue--;
}
Assert.Equal(0, sortValue);
}
//check database can filter
if (connection.CanFilter)
{
//use the new table to test database is filtering
reader = connection.GetTransformReader(table);
SelectQuery query = new SelectQuery()
{
Filters = new List <Filter>()
{
new Filter("IntColumn", Filter.ECompare.LessThanEqual, 5)
}
};
await reader.Open(0, query, CancellationToken.None);
int count = 0;
while (await reader.ReadAsync())
{
Assert.True(Convert.ToInt32(reader["IntColumn"]) <= 5);
count++;
}
Assert.Equal(5, count);
}
Table deltaTable = DataSets.CreateTable();
deltaTable.AddAuditColumns();
deltaTable.Name = "DeltaTable";
await connection.CreateTable(deltaTable, true, CancellationToken.None);
Transform targetReader = connection.GetTransformReader(deltaTable);
reader = connection.GetTransformReader(table);
TransformDelta transformDelta = new TransformDelta(reader, targetReader, TransformDelta.EUpdateStrategy.AppendUpdate, 1, false);
writerResult = new TransformWriterResult();
await connection.InitializeAudit(writerResult, 0, "Datalink", 1, 2, "Test", 1, "Source", 2, "Target", TransformWriterResult.ETriggerMethod.Manual, "Test", CancellationToken.None);
var writeAllResult = await writer.WriteAllRecords(writerResult, transformDelta, deltaTable, connection, CancellationToken.None);
Assert.True(writeAllResult, writerResult.Message);
Assert.Equal(10L, writerResult.RowsCreated);
//check the audit table loaded correctly.
var auditTable = await connection.GetTransformWriterResults(0, null, "Datalink", writerResult.AuditKey, null, true, false, false, null, 1, null, false, CancellationToken.None);
Assert.Equal(10L, auditTable[0].RowsCreated);
}
public MoveEditAction(GameObject gameObject, TransformDelta delta)
{
this.gameObject = gameObject;
this.delta = delta;
}
/// <summary>
/// Apply an angular impulse for the current frame only, affecting the body's position by applying an instantaneous pseudo-torque.
/// </summary>
/// <param name="impulse">The axis direction and magnitude of impulse to apply.</param>
public void ApplyAngularFlashImpulse(ref Vector3 impulse)
{
Vector3 w, zero = Vector3.Zero;
Vector3.Transform(ref impulse, ref MassWorld.InertiaInverse, out w);
var delta = new TransformDelta(ref zero, ref w);
World.ApplyDelta(1f, ref delta);
UpdateWorld();
}
/// <summary>
/// Apply a linear impulse for the current frame only, affecting the body's position by applying an instantaneous pseudo-force
/// at a specific point on the body.
/// </summary>
/// <param name="impulse">The direction and magnitude of the impulse to apply.</param>
/// <param name="offset">The point in world coordinates at which to apply the impulse.</param>
public void ApplyFlashImpulse(ref Vector3 impulse, ref Vector3 offset)
{
if (!IsActive) return;
float massInv = MassProperties.MassInverse;
Vector3 v;
Vector3.Multiply(ref impulse, massInv, out v);
Vector3 w;
Vector3.Cross(ref offset, ref impulse, out w);
Vector3.Transform(ref w, ref MassWorld.InertiaInverse, out w);
Vector3.Multiply(ref w, 0.25f, out w);
var delta = new TransformDelta(ref v, ref w);
World.ApplyDelta(1f, ref delta);
UpdateWorld();
}
/// <summary>
/// Set the current linear and angular velocity of the body.
/// </summary>
/// <param name="linear">The new linear velocity.</param>
/// <param name="angular">The new angular velocity, defined as an axis direction and magnitude.</param>
public void SetVelocity(Vector3 linear, Vector3 angular)
{
Velocity = new TransformDelta(ref linear, ref angular);
}
