public virtual void AppendUpdateOperation(StringBuilder commandStringBuilder, ModificationCommand command)
{
Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
Check.NotNull(command, nameof(command));
var name = command.TableName;
var schema = command.Schema;
var operations = command.ColumnModifications;
var writeOperations = operations.Where(o => o.IsWrite).ToArray();
var conditionOperations = operations.Where(o => o.IsCondition).ToArray();
var readOperations = operations.Where(o => o.IsRead).ToArray();
AppendUpdateCommand(commandStringBuilder, name, schema, writeOperations, conditionOperations);
if (readOperations.Length > 0)
{
var keyOperations = operations.Where(o => o.IsKey).ToArray();
AppendSelectAffectedCommand(commandStringBuilder, name, schema, readOperations, keyOperations);
}
else
{
AppendSelectAffectedCountCommand(commandStringBuilder, name, schema);
}
}
public override bool AddCommand(ModificationCommand modificationCommand)
{
Check.NotNull(modificationCommand, nameof(modificationCommand));
if (ModificationCommands.Count == 0)
{
ResetCommandText();
}
if (!CanAddCommand(modificationCommand))
{
return false;
}
_modificationCommands.Add(modificationCommand);
if (!IsCommandTextValid())
{
ResetCommandText();
_modificationCommands.RemoveAt(_modificationCommands.Count - 1);
return false;
}
return true;
}
public void ModificationCommand_initialized_correctly_for_added_entities_with_non_temp_generated_key()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.FindPrimaryKey().Properties[0], isTemporary: false);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
Assert.Equal("T1", command.TableName);
Assert.Null(command.Schema);
Assert.Equal(EntityState.Added, command.EntityState);
Assert.Equal(2, command.ColumnModifications.Count);
var columnMod = command.ColumnModifications[0];
Assert.Equal("Col1", columnMod.ColumnName);
Assert.Same(entry, columnMod.Entry);
Assert.Equal("Id", columnMod.Property.Name);
Assert.False(columnMod.IsCondition);
Assert.True(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.True(columnMod.IsWrite);
columnMod = command.ColumnModifications[1];
Assert.Equal("Col2", columnMod.ColumnName);
Assert.Same(entry, columnMod.Entry);
Assert.Equal("Name", columnMod.Property.Name);
Assert.False(columnMod.IsCondition);
Assert.False(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.True(columnMod.IsWrite);
}
public override void AppendUpdateOperation(
StringBuilder commandStringBuilder,
ModificationCommand command)
{
Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
Check.NotNull(command, nameof(command));
var name = command.TableName;
var schemaName = command.SchemaName;
var operations = command.ColumnModifications;
var writeOperations = operations.Where(o => o.IsWrite).ToArray();
var conditionOperations = operations.Where(o => o.IsCondition).ToArray();
var readOperations = operations.Where(o => o.IsRead).ToArray();
AppendUpdateCommandHeader(commandStringBuilder, name, schemaName, writeOperations);
if (readOperations.Length > 0)
{
AppendOutputClause(commandStringBuilder, readOperations);
}
AppendWhereClause(commandStringBuilder, conditionOperations);
commandStringBuilder.Append(BatchCommandSeparator).AppendLine();
if (readOperations.Length == 0)
{
AppendSelectAffectedCountCommand(commandStringBuilder, name, schemaName);
}
}
public override void AppendInsertOperation(
StringBuilder commandStringBuilder,
ModificationCommand command)
{
Check.NotNull(command, nameof(command));
AppendBulkInsertOperation(commandStringBuilder, new[] { command });
}
public override bool AddCommand(ModificationCommand modificationCommand)
{
_resultSetEnd.Add(true);
var added = base.AddCommand(modificationCommand);
if (!added)
{
_resultSetEnd.RemoveAt(_resultSetEnd.Count - 1);
}
return added;
}
public virtual void AppendDeleteOperation(StringBuilder commandStringBuilder, ModificationCommand command)
{
Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
Check.NotNull(command, nameof(command));
var name = command.TableName;
var schema = command.Schema;
var conditionOperations = command.ColumnModifications.Where(o => o.IsCondition).ToArray();
AppendDeleteCommand(commandStringBuilder, name, schema, conditionOperations);
AppendSelectAffectedCountCommand(commandStringBuilder, name, schema);
}
public void AddCommand_does_not_add_command_if_resulting_sql_is_invalid()
{
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
batch.ShouldAddCommand = true;
batch.ShouldValidateSql = false;
batch.AddCommand(command);
Assert.Equal(1, batch.ModificationCommands.Count);
Assert.Equal(".", batch.CommandText);
}
public void AddCommand_does_not_add_command_if_not_possible()
{
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
batch.ShouldAddCommand = false;
batch.ShouldValidateSql = true;
batch.AddCommand(command);
Assert.Equal(1, batch.ModificationCommands.Count);
Assert.Equal(".", batch.CommandText);
}
public void AddCommand_adds_command_if_possible()
{
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
batch.ShouldAddCommand = true;
batch.ShouldValidateSql = true;
batch.AddCommand(command);
Assert.Equal(2, batch.ModificationCommands.Count);
Assert.Same(command, batch.ModificationCommands[0]);
Assert.Equal("..", batch.CommandText);
}
public void UpdateCommandText_compiles_inserts()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var sqlGeneratorMock = new Mock<IUpdateSqlGenerator>();
var batch = new ModificationCommandBatchFake(sqlGeneratorMock.Object);
batch.AddCommand(command);
batch.UpdateCachedCommandTextBase(0);
sqlGeneratorMock.Verify(g => g.AppendBatchHeader(It.IsAny<StringBuilder>()));
sqlGeneratorMock.Verify(g => g.AppendInsertOperation(It.IsAny<StringBuilder>(), command));
}
protected override bool CanAddCommand(ModificationCommand modificationCommand)
{
if (_maxBatchSize <= ModificationCommands.Count)
{
return false;
}
var additionalParameterCount = CountParameters(modificationCommand);
if (_parameterCount + additionalParameterCount >= MaxParameterCount)
{
return false;
}
_parameterCount += additionalParameterCount;
return true;
}
private int CountParameters(ModificationCommand modificationCommand)
{
var parameterCount = 0;
foreach (var columnModification in modificationCommand.ColumnModifications)
{
if (columnModification.ParameterName != null)
{
parameterCount++;
}
if (columnModification.OriginalParameterName != null)
{
parameterCount++;
}
}
return parameterCount;
}
public void ModificationCommand_initialized_correctly_for_added_entities_with_explicitly_specified_key_value()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
Assert.Equal("T1", command.TableName);
Assert.Null(command.Schema);
Assert.Equal(EntityState.Added, command.EntityState);
Assert.Equal(2, command.ColumnModifications.Count);
var columnMod = command.ColumnModifications[0];
Assert.Equal("Col1", columnMod.ColumnName);
Assert.Same(entry, columnMod.Entry);
Assert.Equal("Id", columnMod.Property.Name);
Assert.False(columnMod.IsCondition);
Assert.True(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.True(columnMod.IsWrite);
columnMod = command.ColumnModifications[1];
Assert.Equal("Col2", columnMod.ColumnName);
Assert.Same(entry, columnMod.Entry);
Assert.Equal("Name", columnMod.Property.Name);
Assert.False(columnMod.IsCondition);
Assert.False(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.True(columnMod.IsWrite);
}
public void RequiresResultPropagation_false_for_Update_operation_if_no_non_key_store_generated_columns_exist()
{
var entry = CreateEntry(EntityState.Modified, generateKeyValues: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
Assert.False(command.RequiresResultPropagation);
}
public virtual void AppendDeleteOperation(StringBuilder commandStringBuilder, ModificationCommand command)
{
Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
Check.NotNull(command, nameof(command));
var name = command.TableName;
var schema = command.Schema;
var conditionOperations = command.ColumnModifications.Where(o => o.IsCondition).ToArray();
AppendDeleteCommand(commandStringBuilder, name, schema, conditionOperations);
AppendSelectAffectedCountCommand(commandStringBuilder, name, schema);
}
public async Task ExecuteAsync_saves_store_generated_values_when_updating()
{
var entry = CreateEntry(
EntityState.Modified, generateKeyValues: true, computeNonKeyValue: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col2" }, new List<object[]> { new object[] { "FortyTwo" } }).Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
await batch.ExecuteAsync(transaction, new ConcreteTypeMapper(), new Mock<DbContext>().Object, new Mock<ILogger>().Object);
Assert.Equal(1, entry[entry.EntityType.GetProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.GetProperty("Name")]);
}
public override void AppendInsertOperation(StringBuilder commandStringBuilder, ModificationCommand command)
{
if (!string.IsNullOrEmpty(command.Schema))
{
commandStringBuilder.Append(command.Schema + ".");
}
commandStringBuilder.Append(command.TableName);
}
public async Task Exception_not_thrown_for_more_than_one_row_returned_for_single_command()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var mockReader = CreateDataReaderMock(new[] { "Col1" }, new List<object[]>
{
new object[] { 42 },
new object[] { 43 }
});
var batch = new ModificationCommandBatchFake(mockReader.Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
await batch.ExecuteAsync(transaction, new ConcreteTypeMapper(), new Mock<DbContext>().Object, new Mock<ILogger>().Object);
Assert.Equal(42, entry[entry.EntityType.GetProperty("Id")]);
}
protected abstract bool CanAddCommand([NotNull] ModificationCommand modificationCommand);
public async Task Exception_not_thrown_for_more_than_one_row_returned_for_single_command()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.FindPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(
new[] { "Col1" },
new List<object[]>
{
new object[] { 42 },
new object[] { 43 }
}));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
await batch.ExecuteAsync(connection);
Assert.Equal(42, entry[entry.EntityType.FindProperty("Id")]);
}
public async Task ExecuteAsync_saves_store_generated_values_when_updating()
{
var entry = CreateEntry(
EntityState.Modified, generateKeyValues: true, computeNonKeyValue: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(new[] { "Col2" }, new List<object[]> { new object[] { "FortyTwo" } }));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
await batch.ExecuteAsync(connection);
Assert.Equal(1, entry[entry.EntityType.FindProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.FindProperty("Name")]);
}
public virtual void AppendUpdateOperation(StringBuilder commandStringBuilder, ModificationCommand command)
{
Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
Check.NotNull(command, nameof(command));
var name = command.TableName;
var schema = command.Schema;
var operations = command.ColumnModifications;
var writeOperations = operations.Where(o => o.IsWrite).ToArray();
var conditionOperations = operations.Where(o => o.IsCondition).ToArray();
var readOperations = operations.Where(o => o.IsRead).ToArray();
AppendUpdateCommand(commandStringBuilder, name, schema, writeOperations, conditionOperations);
if (readOperations.Length > 0)
{
var keyOperations = operations.Where(o => o.IsKey).ToArray();
AppendSelectAffectedCommand(commandStringBuilder, name, schema, readOperations, keyOperations);
}
else
{
AppendSelectAffectedCountCommand(commandStringBuilder, name, schema);
}
}
public abstract bool AddCommand([NotNull] ModificationCommand modificationCommand);
public virtual ResultSetMapping AppendInsertOperation(StringBuilder commandStringBuilder, ModificationCommand command, int commandPosition)
{
Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
Check.NotNull(command, nameof(command));
var name = command.TableName;
var schema = command.Schema;
var operations = command.ColumnModifications;
var writeOperations = operations.Where(o => o.IsWrite).ToArray();
var readOperations = operations.Where(o => o.IsRead).ToArray();
AppendInsertCommand(commandStringBuilder, name, schema, writeOperations);
if (readOperations.Length > 0)
{
var keyOperations = operations.Where(o => o.IsKey).ToArray();
return(AppendSelectAffectedCommand(commandStringBuilder, name, schema, readOperations, keyOperations, commandPosition));
}
return(ResultSetMapping.NoResultSet);
}
public void UpdateCommandText_compiles_multiple_commands()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var fakeSqlGenerator = new FakeSqlGenerator();
var batch = new ModificationCommandBatchFake(fakeSqlGenerator);
batch.AddCommand(command);
batch.AddCommand(command);
Assert.Equal("..", batch.CommandText);
Assert.Equal(1, fakeSqlGenerator.AppendBatchHeaderCalls);
}
public void RequiresResultPropagation_false_for_Delete_operation()
{
var entry = CreateEntry(
EntityState.Deleted, generateKeyValues: true, computeNonKeyValue: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
Assert.False(command.RequiresResultPropagation);
}
public async Task ExecuteAsync_executes_batch_commands_and_consumes_reader()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var mockReader = CreateDataReaderMock();
var batch = new ModificationCommandBatchFake(mockReader.Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
await batch.ExecuteAsync(transaction, new ConcreteTypeMapper(), new Mock<DbContext>().Object, new Mock<ILogger>().Object);
mockReader.Verify(r => r.ReadAsync(It.IsAny<CancellationToken>()), Times.Once);
mockReader.Verify(r => r.GetInt32(0), Times.Once);
}
public void RequiresResultPropagation_true_for_Insert_operation_if_store_generated_columns_exist()
{
var entry = CreateEntry(
EntityState.Added, generateKeyValues: true, computeNonKeyValue: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
Assert.True(command.RequiresResultPropagation);
}
public async Task Exception_thrown_if_rows_returned_for_command_without_store_generated_values_is_not_1()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(new[] { "Col1" }, new List<object[]> { new object[] { 42 } }));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
Assert.Equal(RelationalStrings.UpdateConcurrencyException(1, 42),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(connection))).Message);
}
protected override bool CanAddCommand(ModificationCommand modificationCommand) => ModificationCommands.Count == 0;
public async Task Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List<object[]>()).Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
Assert.Equal(Strings.UpdateConcurrencyException(1, 0),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(
transaction,
new ConcreteTypeMapper(),
new Mock<DbContext>().Object,
new Mock<ILogger>().Object))).Message);
}
public async Task Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.FindPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(new[] { "Col1" }, new List<object[]>()));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
Assert.Equal(RelationalStrings.UpdateConcurrencyException(1, 0),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(connection))).Message);
}
protected override bool CanAddCommand(ModificationCommand modificationCommand)
{
return ShouldAddCommand;
}
public void ModificationCommand_throws_for_unknown_entities()
{
var entry = CreateEntry(EntityState.Detached);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
Assert.Equal(
RelationalStrings.ModificationFunctionInvalidEntityState(EntityState.Detached),
Assert.Throws<NotSupportedException>(() => command.AddEntry(entry)).Message);
}
protected override bool CanAddCommand(ModificationCommand modificationCommand)
=> ModificationCommands.Count == 0;
public virtual bool AddCommand(
ModificationCommandBatch modificationCommandBatch,
ModificationCommand modificationCommand)
=> Check.NotNull(modificationCommandBatch, nameof(modificationCommandBatch))
.AddCommand(Check.NotNull(modificationCommand, nameof(modificationCommand)));