public async Task Generates_sequential_values <TValue>(bool async)
{
const int blockSize = 4;
var sequence = new Model().SqlServer().GetOrAddSequence("Foo");
sequence.IncrementBy = blockSize;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var generator = new SqlServerSequenceHiLoValueGenerator <TValue>(
new FakeRawSqlCommandBuilder(blockSize),
new SqlServerUpdateSqlGenerator(
new UpdateSqlGeneratorDependencies(
new SqlServerSqlGenerationHelper(
new RelationalSqlGenerationHelperDependencies())),
new SqlServerTypeMapper(
new RelationalTypeMapperDependencies())),
state,
CreateConnection());
for (var i = 1; i <= 27; i++)
{
var value = async
? await generator.NextAsync(null)
: generator.Next(null);
Assert.Equal(i, (int)Convert.ChangeType(value, typeof(int), CultureInfo.InvariantCulture));
}
}
public async Task Generates_sequential_values <TValue>(bool async)
{
const int blockSize = 4;
var sequence = ((IMutableModel) new Model()).AddSequence("Foo");
sequence.IncrementBy = blockSize;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var generator = new SqlServerSequenceHiLoValueGenerator <TValue>(
new FakeRawSqlCommandBuilder(blockSize),
new SqlServerUpdateSqlGenerator(
new UpdateSqlGeneratorDependencies(
new SqlServerSqlGenerationHelper(
new RelationalSqlGenerationHelperDependencies()),
new SqlServerTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>()))),
state,
CreateConnection(),
new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>());
for (var i = 1; i <= 27; i++)
{
var value = async
? await generator.NextAsync(null)
: generator.Next(null);
Assert.Equal(i, (int)Convert.ChangeType(value, typeof(int), CultureInfo.InvariantCulture));
}
}
private async Task <IEnumerable <List <long> > > GenerateValuesInMultipleThreads(int threadCount, int valueCount)
{
const int blockSize = 10;
var serviceProvider = SqlServerTestHelpers.Instance.CreateServiceProvider();
var sequence = ((IMutableModel) new Model()).AddSequence("Foo");
sequence.IncrementBy = blockSize;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var executor = new FakeRawSqlCommandBuilder(blockSize);
var sqlGenerator = new SqlServerUpdateSqlGenerator(
new UpdateSqlGeneratorDependencies(
new SqlServerSqlGenerationHelper(
new RelationalSqlGenerationHelperDependencies()),
new SqlServerTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>())));
var logger = new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>();
var tests = new Func <Task> [threadCount];
var generatedValues = new List <long> [threadCount];
for (var i = 0; i < tests.Length; i++)
{
var testNumber = i;
generatedValues[testNumber] = new List <long>();
tests[testNumber] = async() =>
{
for (var j = 0; j < valueCount; j++)
{
var connection = CreateConnection(serviceProvider);
var generator = new SqlServerSequenceHiLoValueGenerator <long>(executor, sqlGenerator, state, connection, logger);
var value = j % 2 == 0
? await generator.NextAsync(null)
: generator.Next(null);
generatedValues[testNumber].Add(value);
}
};
}
var tasks = tests.Select(Task.Run).ToArray();
foreach (var t in tasks)
{
await t;
}
return(generatedValues);
}
public void Does_not_generate_temp_values()
{
var sequence = Sequence.GetOrAddSequence(new Model(), RelationalFullAnnotationNames.Instance.SequencePrefix, "Foo");
sequence.IncrementBy = 4;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var generator = new SqlServerSequenceHiLoValueGenerator <int>(
new FakeRawSqlCommandBuilder(4),
new SqlServerUpdateSqlGenerator(new SqlServerSqlGenerationHelper(), new SqlServerTypeMapper()),
state,
CreateConnection());
Assert.False(generator.GeneratesTemporaryValues);
}
public void Does_not_generate_temp_values()
{
var state = new SqlServerSequenceValueGeneratorState(
new Sequence(
new Model(), RelationalAnnotationNames.Prefix, "Foo")
{
IncrementBy = 4
});
var generator = new SqlServerSequenceHiLoValueGenerator <int>(
new FakeSqlStatementExecutor(4),
new SqlServerUpdateSqlGenerator(new SqlServerSqlGenerator()),
state,
CreateConnection());
Assert.False(generator.GeneratesTemporaryValues);
}
private async Task <IEnumerable <List <long> > > GenerateValuesInMultipleThreads(int threadCount, int valueCount)
{
const int blockSize = 10;
var serviceProvider = SqlServerTestHelpers.Instance.CreateServiceProvider();
var sequence = Sequence.GetOrAddSequence(new Model(), RelationalFullAnnotationNames.Instance.SequencePrefix, "Foo");
sequence.IncrementBy = blockSize;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var executor = new FakeRawSqlCommandBuilder(blockSize);
var sqlGenerator = new SqlServerUpdateSqlGenerator(new SqlServerSqlGenerationHelper(), new SqlServerTypeMapper());
var tests = new Func <Task> [threadCount];
var generatedValues = new List <long> [threadCount];
for (var i = 0; i < tests.Length; i++)
{
var testNumber = i;
generatedValues[testNumber] = new List <long>();
tests[testNumber] = async() =>
{
for (var j = 0; j < valueCount; j++)
{
var connection = CreateConnection(serviceProvider);
var generator = new SqlServerSequenceHiLoValueGenerator <long>(executor, sqlGenerator, state, connection);
var value = j % 2 == 0
? await generator.NextAsync(null)
: generator.Next(null);
generatedValues[testNumber].Add(value);
}
};
}
var tasks = tests.Select(Task.Run).ToArray();
foreach (var t in tasks)
{
await t;
}
return(generatedValues);
}
public void Does_not_generate_temp_values()
{
var sequence = new Model().SqlServer().GetOrAddSequence("Foo");
sequence.IncrementBy = 4;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var generator = new SqlServerSequenceHiLoValueGenerator <int>(
new FakeRawSqlCommandBuilder(4),
new SqlServerUpdateSqlGenerator(
new UpdateSqlGeneratorDependencies(
new SqlServerSqlGenerationHelper(
new RelationalSqlGenerationHelperDependencies()),
TestServiceFactory.Instance.Create <SqlServerTypeMapper>())),
state,
CreateConnection());
Assert.False(generator.GeneratesTemporaryValues);
}
public void Generates_sequential_values <TValue>()
{
const int blockSize = 4;
var sequence = Sequence.GetOrAddSequence(new Model(), RelationalFullAnnotationNames.Instance.SequencePrefix, "Foo");
sequence.IncrementBy = blockSize;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var generator = new SqlServerSequenceHiLoValueGenerator <TValue>(
new FakeRawSqlCommandBuilder(blockSize),
new SqlServerUpdateSqlGenerator(new SqlServerSqlGenerationHelper(), new SqlServerTypeMapper()),
state,
CreateConnection());
for (var i = 1; i <= 27; i++)
{
Assert.Equal(i, (int)Convert.ChangeType(generator.Next(null), typeof(int), CultureInfo.InvariantCulture));
}
}
public void Does_not_generate_temp_values()
{
var sequence = ((IMutableModel)new Model()).AddSequence("Foo");
sequence.IncrementBy = 4;
var state = new SqlServerSequenceValueGeneratorState(sequence);
var generator = new SqlServerSequenceHiLoValueGenerator<int>(
new FakeRawSqlCommandBuilder(4),
new SqlServerUpdateSqlGenerator(
new UpdateSqlGeneratorDependencies(
new SqlServerSqlGenerationHelper(
new RelationalSqlGenerationHelperDependencies()),
new SqlServerTypeMappingSource(
TestServiceFactory.Instance.Create<TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create<RelationalTypeMappingSourceDependencies>()))),
state,
CreateConnection(),
new FakeDiagnosticsLogger<DbLoggerCategory.Database.Command>());
Assert.False(generator.GeneratesTemporaryValues);
}
private IEnumerable <List <long> > GenerateValuesInMultipleThreads(int threadCount, int valueCount)
{
const int blockSize = 10;
var serviceProvider = SqlServerTestHelpers.Instance.CreateServiceProvider();
var state = new SqlServerSequenceValueGeneratorState(
new Sequence(
new Model(), RelationalAnnotationNames.Prefix, "Foo")
{
IncrementBy = blockSize
});
var executor = new FakeSqlStatementExecutor(blockSize);
var sqlGenerator = new SqlServerUpdateSqlGenerator(new SqlServerSqlGenerator());
var tests = new Action[threadCount];
var generatedValues = new List <long> [threadCount];
for (var i = 0; i < tests.Length; i++)
{
var testNumber = i;
generatedValues[testNumber] = new List <long>();
tests[testNumber] = () =>
{
for (var j = 0; j < valueCount; j++)
{
var connection = CreateConnection(serviceProvider);
var generator = new SqlServerSequenceHiLoValueGenerator <long>(executor, sqlGenerator, state, connection);
generatedValues[testNumber].Add(generator.Next());
}
};
}
Parallel.Invoke(tests);
return(generatedValues);
}
public void Generates_sequential_values <TValue>()
{
const int blockSize = 4;
var state = new SqlServerSequenceValueGeneratorState(
new Sequence(
new Model(), RelationalAnnotationNames.Prefix, "Foo")
{
IncrementBy = blockSize
});
var generator = new SqlServerSequenceHiLoValueGenerator <TValue>(
new FakeSqlStatementExecutor(blockSize),
new SqlServerUpdateSqlGenerator(new SqlServerSqlGenerator()),
state,
CreateConnection());
for (var i = 1; i <= 27; i++)
{
Assert.Equal(i, (int)Convert.ChangeType(generator.Next(), typeof(int), CultureInfo.InvariantCulture));
}
}
