public void TestTesterClassesWithMultipleConstructors()
{
GenericObjectBuilder.ClearConstructorDelegatesCache();
var obj1 = GenericObjectBuilder.Build <TesterClass>(10);
var obj2 = GenericObjectBuilder.Build <TesterClass>(20);
Assert.AreEqual(10, obj1.A);
Assert.AreEqual(20, obj2.A);
Assert.AreEqual(1, GenericObjectBuilder.CachedConstructorDelegatesCount);
var obj3 = GenericObjectBuilder.Build <TesterClass2>(10);
var obj4 = GenericObjectBuilder.Build <TesterClass2>(20);
Assert.AreEqual(10, obj3.A);
Assert.AreEqual(20, obj4.A);
Assert.AreEqual(2, GenericObjectBuilder.CachedConstructorDelegatesCount);
obj1 = GenericObjectBuilder.Build <TesterClass>(10, 20);
obj2 = GenericObjectBuilder.Build <TesterClass>(20, 30);
Assert.AreEqual(30, obj1.A);
Assert.AreEqual(50, obj2.A);
Assert.AreEqual(3, GenericObjectBuilder.CachedConstructorDelegatesCount);
obj3 = GenericObjectBuilder.Build <TesterClass2>(10, 20);
obj4 = GenericObjectBuilder.Build <TesterClass2>(20, 30);
Assert.AreEqual(30, obj3.A);
Assert.AreEqual(50, obj4.A);
Assert.AreEqual(4, GenericObjectBuilder.CachedConstructorDelegatesCount);
}
public void Pump(string sourceSql,
DbConnection sourceConnection,
IEnumerable <ITargetAdapter <PoolEntry <object[]> > > dataPipelineTargetAdapters,
int rowsPoolCapacity = SourceAdapterSqlBase.DefaultRowsCapacity)
{
using var cmd = GenericObjectBuilder.Build <TCmd>(sourceSql, sourceConnection);
Pump(cmd, dataPipelineTargetAdapters, rowsPoolCapacity);
}
public void Pump(DbDataReader source,
IEnumerable <ITargetAdapter <PoolEntry <object[]> > > dataPipelineTargetAdapters,
int rowsPoolCapacity = SourceAdapterSqlBase.DefaultRowsCapacity)
{
var adapter = GenericObjectBuilder.Build <TAdapter>(source, rowsPoolCapacity);
Pump(adapter, dataPipelineTargetAdapters);
}
public void Pump(DbDataReader source,
ITargetAdapter <PoolEntry <object[]> > targetAdapter,
int rowsPoolCapacity = SourceAdapterSqlBase.DefaultRowsCapacity)
{
var adapter = GenericObjectBuilder.Build <TAdapter>(source, rowsPoolCapacity);
Pump(adapter, targetAdapter);
}
public virtual void Prepare()
{
if (_prepared)
{
throw new InvalidOperationException("DataReplicator already prepared.");
}
try
{
var sqlBuilder = (IClassSqlBuilder)typeof(TSourceAdapter);
_sourceCmds = new List <DbCommand>();
foreach (var sqlStatement in _sourceTables)
{
_sourceCmds.Add(sqlStatement.Item4 ?? sqlBuilder.BuildCommand(sqlStatement.Item2, null));
sqlStatement.Item4 = null;
}
_sourceConnections = new DbConnection[_sourceCmds.Count];
_targetConnections = new TTargetConn[_sourceCmds.Count];
ColumnMetadataLists = new ColumnMetadataList[_sourceCmds.Count];
_readers = new List <DbDataReader> {
Capacity = _sourceCmds.Count
};
for (var i = 0; i < _sourceCmds.Count; i++)
{
_readers.Add(null);
}
_parallelRunner = new BoundedParallel(1, ParallelismLevel);
_parallelRunner.For(0, _sourceCmds.Count, i =>
{
if (_sourceTables[i].Item4 != null)
{
_sourceConnections[i] = _sourceTables[i].Item4.Connection;
}
else
{
_sourceConnections[i] = sqlBuilder.BuildConnection(_sourceConnStr);
}
_sourceConnections[i].Open();
_sourceCmds[i].Connection = _sourceConnections[i];
var reader = _sourceCmds[i].ExecuteReader();
_readers[i] = reader;
ColumnMetadataLists[i] = new ColumnMetadataListFromDbReader(reader);
_targetConnections[i] = GenericObjectBuilder.Build <TTargetConn>(_targetConnStr);
_targetConnections[i].Open();
});
_prepared = true;
}
catch (Exception)
{
UnPrepare(true);
throw;
}
}
public void TestTesterPerformanceUsingGenericObjectBuilderDirectBuild()
{
var paramTypes = new[] { typeof(int) };
for (var i = 0; i < 1024 * 1024; i++)
{
GenericObjectBuilder.Build <TesterClass>(paramTypes, 20);
GenericObjectBuilder.Build <TesterClass>(paramTypes, 20);
}
}
public void TestObjectConstructor()
{
var sourceQueue = new Queue <string>();
sourceQueue.Enqueue("hello");
var newQueue = GenericObjectBuilder.Build <Queue <string> >(sourceQueue);
var firstItem = sourceQueue.Dequeue();
var secondItem = newQueue.Dequeue();
Assert.AreEqual(firstItem, secondItem);
}
public void TestTesterPerformanceUsingGenericObjectBuilderThoroughBuilder()
{
var paramTypes = new[] { typeof(int) };
var builder = GenericObjectBuilder.Builder <TesterClass>(paramTypes);
for (var i = 0; i < 1024 * 1024; i++)
{
builder(10);
builder(20);
}
}
public void TestObjectConstructorsSameClass()
{
GenericObjectBuilder.ClearConstructorDelegatesCache();
var sourceArray = new List <string> {
"hello"
};
GenericObjectBuilder.Build <List <string> >(sourceArray);
GenericObjectBuilder.Build <List <string> >(1);
Assert.AreEqual(2, GenericObjectBuilder.CachedConstructorDelegatesCount);
}
public virtual void Replicate(int readBufferSize, int insertBatchSize)
{
if (!_prepared)
{
throw new InvalidOperationException("DataReplicator not prepared. Can't run.");
}
try
{
_parallelRunner.For(0, _readers.Count, i =>
{
EnsureTableCreated(i);
_readers[i] ??= _sourceCmds[i].ExecuteReader();
var sourceAdapter = GenericObjectBuilder.Build <TSourceAdapter>(_readers[i], readBufferSize);
sourceAdapter.AbortOnReadException = true;
var columnNames = new List <string>();
foreach (var meta in ColumnMetadataLists[i])
{
columnNames.Add(meta.ColumnName);
}
var targetAdapter = GenericObjectBuilder.Build <TTargetAdapter>(_sourceTables[i].Item1, columnNames, _targetConnections[i], insertBatchSize);
targetAdapter.UseNativeTypeConvertor = UseNativeTypeConvertor;
targetAdapter.AbortOnProcessException = true;
targetAdapter.LiteralParamBinding = LiteralParamBinding;
var pipeline = new TDataPipeline();
ConfigureTargetConnection(_targetConnections[i], columnNames.Count, insertBatchSize);
var tran = UseTransaction ? _targetConnections[i].BeginTransaction() : null;
try
{
if (tran != null)
{
targetAdapter.BeforeCommandPrepare += (adapter, cmd) => cmd.Transaction = tran;
}
pipeline.Pump(sourceAdapter, targetAdapter);
tran?.Commit();
}
catch (Exception)
{
tran?.Rollback();
throw;
}
});
}
finally
{
Disposer.Dispose(_readers);
}
}
private void EnsureTableCreated(int tableNumber)
{
var tableDef = ColumnMetadataLists[tableNumber];
if (tableDef.Count <= 0)
{
throw new InvalidOperationException("Found table definition with no columns");
}
var tableName = _sourceTables[tableNumber].Item1;
var customCommands = _sourceTables[tableNumber].Item3;
if (ReplicateMode == ReplicateModes.DropTableAndPump || !TableExists(tableName, _targetConnections[tableNumber]))
{
var dropTableStatement = BuildDropTableStatement(tableName);
using var dropTableCmd = GenericObjectBuilder.Build <TTargetCmd>(dropTableStatement, _targetConnections[tableNumber]);
try
{
dropTableCmd.ExecuteNonQuery();
}
catch (Exception)
{
if (!IgnoreDropTableException)
{
throw;
}
}
var createTableStatement = BuildCreateTableStatement(tableName, tableDef);
using var createTableCmd = GenericObjectBuilder.Build <TTargetCmd>(createTableStatement, _targetConnections[tableNumber]);
createTableCmd.ExecuteNonQuery();
if (customCommands == null)
{
return;
}
foreach (var customCommandStatement in customCommands)
{
using var customCommand = GenericObjectBuilder.Build <TTargetCmd>(customCommandStatement, _targetConnections[tableNumber]);
customCommand.ExecuteNonQuery();
}
}
else if (ReplicateMode == ReplicateModes.TruncateAndPump)
{
using var truncateTableCmd = GenericObjectBuilder.Build <TTargetCmd>(BuildTruncateTableStatement(tableName), _targetConnections[tableNumber]);
truncateTableCmd.ExecuteNonQuery();
}
}
public void TestCreateMultipleObjects()
{
GenericObjectBuilder.ClearConstructorDelegatesCache();
var sourceQueue = new Queue <string>();
sourceQueue.Enqueue("hello");
var newQueue = GenericObjectBuilder.Build <Queue <string> >(sourceQueue);
var thirdQueue = GenericObjectBuilder.Build <Queue <string> >(sourceQueue);
var firstItem = sourceQueue.Dequeue();
var secondItem = newQueue.Dequeue();
var thirdItem = thirdQueue.Dequeue();
Assert.AreEqual(firstItem, secondItem);
Assert.AreEqual(firstItem, thirdItem);
Assert.AreEqual(1, GenericObjectBuilder.CachedConstructorDelegatesCount);
}
public void TestObjectConstructorWithTwoTypes()
{
var sourceQueue = new Queue <string>();
sourceQueue.Enqueue("hello");
var newQueue = GenericObjectBuilder.Build <Queue <string> >(sourceQueue);
var firstItem = sourceQueue.Dequeue();
var secondItem = newQueue.Dequeue();
var sourceArray = new List <string> {
"hello"
};
var newArray = GenericObjectBuilder.Build <List <string> >(sourceArray);
var firstArrayItem = sourceArray[0];
var secondArrayItem = newArray[0];
Assert.AreEqual(firstItem, secondItem);
Assert.AreEqual(firstArrayItem, secondArrayItem);
}
public void TestObjectConstructorSucceedsPassingNullParam()
{
var e = Assert.ThrowsException <ArgumentNullException>(() => GenericObjectBuilder.Build <Queue <string> >(new[] { typeof(Queue <string>) }, new object[] { null }));
Assert.AreEqual("collection", e.ParamName);
}
public void TestObjectConstructorFailsPassingNullParam()
{
GenericObjectBuilder.ClearConstructorDelegatesCache();
Assert.ThrowsException <ArgumentException>(() => GenericObjectBuilder.Build <Queue <string> >(new object[] { null }));
}
public void CheckEqual <TSourceAdapter1, TSourceAdapter2>(
string connStr1, string sqlText1, string connStr2, string sqlText2)
where TSourceAdapter1 : SourceAdapterSqlBase
where TSourceAdapter2 : SourceAdapterSqlBase
{
var pipeline = new JoinerDataPipeline <PoolEntry <object[]> >();
var source1 = GenericObjectBuilder.Build <TSourceAdapter1>(connStr1, sqlText1);
source1.RowsPoolSize = int.MaxValue;
var source2 = GenericObjectBuilder.Build <TSourceAdapter2>(connStr2, sqlText2);
source2.RowsPoolSize = int.MaxValue;
var columnCount = 0;
RowCount = 0;
try
{
pipeline.Pump(new ISourceAdapter <PoolEntry <object[]> >[] { source1, source2 }, rowsRowsList =>
{
foreach (var entry in rowsRowsList)
{
if (columnCount == 0)
{
columnCount = entry.Value.Length;
}
if (columnCount != entry.Value.Length)
{
throw new DataPipelineComparerColumnCountMismatch(columnCount, entry.Value.Length);
}
}
for (var i = 0; i < columnCount; i++)
{
var firstValueOriginal = rowsRowsList[0].Value[i];
var firstValueDownConverted = source1.DownConvertToText(rowsRowsList[0].Value[i]);
var firstValueCanBeDecimal = decimal.TryParse(firstValueOriginal.ToString(), out var firstValueAsDecimal);
for (var j = 1; j < rowsRowsList.Count; j++)
{
var secondValueCanBeDecimal = decimal.TryParse(rowsRowsList[j].Value[i].ToString(), out var secondValueAsDecimal);
if (!(firstValueOriginal.GetType() == rowsRowsList[j].Value[i].GetType() &&
firstValueOriginal == rowsRowsList[j].Value[i] ||
firstValueDownConverted == source2.DownConvertToText(rowsRowsList[j].Value[i]) ||
firstValueCanBeDecimal && secondValueCanBeDecimal && firstValueAsDecimal == secondValueAsDecimal))
{
throw new DataPipelineComparerDataMismatch(firstValueOriginal, rowsRowsList[j].Value[i],
source1.ColumnMetadatas[i].ColumnName);
}
}
}
RowCount++;
});
}
catch (AggregateException exceptions)
{
CheckAggregateException(exceptions);
throw;
}
catch (DataPipelineAbortedException)
{
throw new DataPipelineComparerOutOfBalance(AdaptersOutOfBalance);
}
}
