public void Can_clear_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload());
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Equal(1, entitySetMapping.ModificationFunctionMappings.Count());
entitySetMapping.ClearModificationFunctionMappings();
Assert.Equal(0, entitySetMapping.ModificationFunctionMappings.Count());
}
public void Configure_association_set_should_call_configure_function_configurations()
{
var modificationFunctionsConfiguration = new ModificationFunctionsConfiguration();
var mockModificationFunctionConfiguration = new Mock<ModificationFunctionConfiguration>();
modificationFunctionsConfiguration.Insert(mockModificationFunctionConfiguration.Object);
modificationFunctionsConfiguration.Delete(mockModificationFunctionConfiguration.Object);
var entitySet = new EntitySet();
entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
new EntityType("E", "N", DataSpace.CSpace),
new EdmFunction("F", "N", DataSpace.SSpace),
new StorageModificationFunctionParameterBinding[0],
null,
null);
modificationFunctionsConfiguration.Configure(
new StorageAssociationSetModificationFunctionMapping(
new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)),
storageModificationFunctionMapping,
storageModificationFunctionMapping));
mockModificationFunctionConfiguration
.Verify(m => m.Configure(storageModificationFunctionMapping), Times.Exactly(2));
}
public void Can_clear_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload());
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty <StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Equal(1, entitySetMapping.ModificationFunctionMappings.Count());
entitySetMapping.ClearModificationFunctionMappings();
Assert.Equal(0, entitySetMapping.ModificationFunctionMappings.Count());
}
public void PrimaryParameterBindings_should_omit_original_value_parameters_when_update()
{
var entitySet = new EntitySet();
entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
new EntityType("E", "N", DataSpace.CSpace),
new EdmFunction("F", "N", DataSpace.SSpace),
new[]
{
new StorageModificationFunctionParameterBinding(
new FunctionParameter(),
new StorageModificationFunctionMemberPath(
new EdmMember[]
{
new EdmProperty("M")
},
null),
false)
},
null,
null);
var storageEntityTypeModificationFunctionMapping
= new StorageEntityTypeModificationFunctionMapping(
new EntityType("E", "N", DataSpace.CSpace),
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping);
Assert.Equal(2, storageEntityTypeModificationFunctionMapping.PrimaryParameterBindings.Count());
}
public void PrimaryParameterBindings_should_omit_original_value_parameters_when_update()
{
var entitySet = new EntitySet();
entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
new EntityType("E", "N", DataSpace.CSpace),
new EdmFunction("F", "N", DataSpace.SSpace),
new[]
{
new StorageModificationFunctionParameterBinding(
new FunctionParameter(),
new StorageModificationFunctionMemberPath(
new EdmMember[]
{
new EdmProperty("M")
},
null),
false)
},
null,
null);
var storageEntityTypeModificationFunctionMapping
= new StorageEntityTypeModificationFunctionMapping(
new EntityType("E", "N", DataSpace.CSpace),
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping);
Assert.Equal(2, storageEntityTypeModificationFunctionMapping.PrimaryParameterBindings.Count());
}
public void Configure_should_call_configure_function_configurations()
{
var modificationFunctionsConfiguration = new ModificationFunctionsConfiguration();
var mockModificationFunctionConfiguration = new Mock<ModificationFunctionConfiguration>();
modificationFunctionsConfiguration.Insert(mockModificationFunctionConfiguration.Object);
modificationFunctionsConfiguration.Update(mockModificationFunctionConfiguration.Object);
modificationFunctionsConfiguration.Delete(mockModificationFunctionConfiguration.Object);
var entitySet = new EntitySet();
entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
new EntityType("E", "N", DataSpace.CSpace),
new EdmFunction("F", "N", DataSpace.SSpace),
new StorageModificationFunctionParameterBinding[0],
null,
null);
modificationFunctionsConfiguration.Configure(
new StorageEntityTypeModificationFunctionMapping(
new EntityType("E", "N", DataSpace.CSpace),
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping),
ProviderRegistry.Sql2008_ProviderManifest);
mockModificationFunctionConfiguration
.Verify(
m => m.Configure(storageModificationFunctionMapping, It.IsAny<DbProviderManifest>()),
Times.Exactly(3));
}
internal StorageAssociationSetModificationFunctionMapping(
AssociationSet associationSet,
StorageModificationFunctionMapping deleteFunctionMapping,
StorageModificationFunctionMapping insertFunctionMapping)
{
DebugCheck.NotNull(associationSet);
AssociationSet = associationSet;
DeleteFunctionMapping = deleteFunctionMapping;
InsertFunctionMapping = insertFunctionMapping;
}
internal StorageAssociationSetModificationFunctionMapping(
AssociationSet associationSet,
StorageModificationFunctionMapping deleteFunctionMapping,
StorageModificationFunctionMapping insertFunctionMapping)
{
DebugCheck.NotNull(associationSet);
AssociationSet = associationSet;
DeleteFunctionMapping = deleteFunctionMapping;
InsertFunctionMapping = insertFunctionMapping;
}
internal StorageAssociationSetModificationFunctionMapping(
AssociationSet associationSet,
StorageModificationFunctionMapping deleteFunctionMapping,
StorageModificationFunctionMapping insertFunctionMapping)
{
Contract.Requires(associationSet != null);
AssociationSet = associationSet;
DeleteFunctionMapping = deleteFunctionMapping;
InsertFunctionMapping = insertFunctionMapping;
}
internal StorageEntityTypeModificationFunctionMapping(
EntityType entityType,
StorageModificationFunctionMapping deleteFunctionMapping,
StorageModificationFunctionMapping insertFunctionMapping,
StorageModificationFunctionMapping updateFunctionMapping)
{
Contract.Requires(entityType != null);
EntityType = entityType;
DeleteFunctionMapping = deleteFunctionMapping;
InsertFunctionMapping = insertFunctionMapping;
UpdateFunctionMapping = updateFunctionMapping;
}
internal StorageEntityTypeModificationFunctionMapping(
EntityType entityType,
StorageModificationFunctionMapping deleteFunctionMapping,
StorageModificationFunctionMapping insertFunctionMapping,
StorageModificationFunctionMapping updateFunctionMapping)
{
DebugCheck.NotNull(entityType);
EntityType = entityType;
_deleteFunctionMapping = deleteFunctionMapping;
_insertFunctionMapping = insertFunctionMapping;
_updateFunctionMapping = updateFunctionMapping;
}
internal StorageEntityTypeModificationFunctionMapping(
EntityType entityType,
StorageModificationFunctionMapping deleteFunctionMapping,
StorageModificationFunctionMapping insertFunctionMapping,
StorageModificationFunctionMapping updateFunctionMapping)
{
DebugCheck.NotNull(entityType);
EntityType = entityType;
_deleteFunctionMapping = deleteFunctionMapping;
_insertFunctionMapping = insertFunctionMapping;
_updateFunctionMapping = updateFunctionMapping;
}
public void WriteEntitySetMappingElement_should_write_modification_function_mappings()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(entityContainer));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
storageEntitySetMapping.AddModificationFunctionMapping(
new StorageEntityTypeModificationFunctionMapping(
entityType,
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping));
fixture.Writer.WriteEntitySetMappingElement(storageEntitySetMapping);
Assert.Equal(
@"<EntitySetMapping Name=""ES"">
<EntityTypeMapping TypeName="".E"">
<ModificationFunctionMapping>
<InsertFunction FunctionName=""N.F"" />
<UpdateFunction FunctionName=""N.F"" />
<DeleteFunction FunctionName=""N.F"" />
</ModificationFunctionMapping>
</EntityTypeMapping>
</EntitySetMapping>",
fixture.ToString());
}
public void Can_get_rows_affected_parameter_name()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
Enumerable.Empty <StorageModificationFunctionParameterBinding>(),
new FunctionParameter("rows_affected", new TypeUsage(), ParameterMode.Out),
null);
Assert.Equal("rows_affected", storageModificationFunctionMapping.RowsAffectedParameterName);
}
public void Can_get_rows_affected_parameter_name()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
new FunctionParameter("rows_affected", new TypeUsage(), ParameterMode.Out),
null);
Assert.Equal("rows_affected", storageModificationFunctionMapping.RowsAffectedParameterName);
}
public void Can_get_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsFunctionImport = true
});
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
container.AddFunctionImport(function);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty <StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Same(entityFunctionMappings, entitySetMapping.ModificationFunctionMappings.Single());
}
private void ConfigureParameters(StorageModificationFunctionMapping modificationFunctionMapping)
{
foreach (var keyValue in _parameterNames)
{
var propertyPath = keyValue.Key;
var parameterName = keyValue.Value.Item1;
var originalValueParameterName = keyValue.Value.Item2;
var parameterBindings
= modificationFunctionMapping
.ParameterBindings
.Where(
pb => // First, try and match scalar/complex/many-to-many binding
(((pb.MemberPath.AssociationSetEnd == null)
|| pb.MemberPath.AssociationSetEnd.ParentAssociationSet.ElementType.IsManyToMany())
&& propertyPath.Equals(
new PropertyPath(
pb.MemberPath.Members.OfType<EdmProperty>().Select(m => m.GetClrPropertyInfo()))))
||
// Otherwise, try and match IA FK bindings
((propertyPath.Count == 2)
&& (pb.MemberPath.AssociationSetEnd != null)
&& pb.MemberPath.Members.First().GetClrPropertyInfo().IsSameAs(propertyPath.Last())
&& pb.MemberPath.AssociationSetEnd.ParentAssociationSet.AssociationSetEnds
.Select(ae => ae.CorrespondingAssociationEndMember.GetClrPropertyInfo())
.Where(pi => pi != null)
.Any(pi => pi.IsSameAs(propertyPath.First()))))
.ToList();
if (parameterBindings.Count == 1)
{
var parameterBinding = parameterBindings.Single();
if (!string.IsNullOrWhiteSpace(originalValueParameterName))
{
if (parameterBinding.IsCurrent)
{
throw Error.ModificationFunctionParameterNotFoundOriginal(
propertyPath,
modificationFunctionMapping.Function.Name);
}
}
parameterBinding.Parameter.Name = parameterName;
_configuredParameters.Add(parameterBinding.Parameter);
}
else if (parameterBindings.Count == 2)
{
var parameterBinding = parameterBindings.Single(pb => pb.IsCurrent);
parameterBinding.Parameter.Name = parameterName;
_configuredParameters.Add(parameterBinding.Parameter);
if (!string.IsNullOrWhiteSpace(originalValueParameterName))
{
parameterBinding = parameterBindings.Single(pb => !pb.IsCurrent);
parameterBinding.Parameter.Name = originalValueParameterName;
_configuredParameters.Add(parameterBinding.Parameter);
}
}
else
{
throw Error.ModificationFunctionParameterNotFound(
propertyPath,
modificationFunctionMapping.Function.Name);
}
}
var unconfiguredParameters
= modificationFunctionMapping
.Function
.Parameters
.Except(_configuredParameters);
foreach (var parameter in unconfiguredParameters)
{
parameter.Name
= modificationFunctionMapping
.Function
.Parameters
.Except(new[] { parameter })
.UniquifyName(parameter.Name);
}
}
private void ConfigureRowsAffectedParameter(StorageModificationFunctionMapping modificationFunctionMapping)
{
DebugCheck.NotNull(modificationFunctionMapping);
if (!string.IsNullOrWhiteSpace(_rowsAffectedParameter))
{
if (modificationFunctionMapping.RowsAffectedParameter == null)
{
throw Error.NoRowsAffectedParameter(modificationFunctionMapping.Function.Name);
}
modificationFunctionMapping.RowsAffectedParameter.Name = _rowsAffectedParameter;
_configuredParameters.Add(modificationFunctionMapping.RowsAffectedParameter);
}
}
private void ConfigureSchema(StorageModificationFunctionMapping modificationFunctionMapping)
{
DebugCheck.NotNull(modificationFunctionMapping);
if (!string.IsNullOrWhiteSpace(_schema))
{
modificationFunctionMapping.Function.Schema = _schema;
}
}
private void ConfigureName(StorageModificationFunctionMapping modificationFunctionMapping)
{
DebugCheck.NotNull(modificationFunctionMapping);
if (!string.IsNullOrWhiteSpace(_name))
{
modificationFunctionMapping.Function.Name = _name;
}
}
public virtual void Configure(StorageModificationFunctionMapping modificationFunctionMapping)
{
DebugCheck.NotNull(modificationFunctionMapping);
_configuredParameters = new List<FunctionParameter>();
ConfigureName(modificationFunctionMapping);
ConfigureSchema(modificationFunctionMapping);
ConfigureRowsAffectedParameter(modificationFunctionMapping);
ConfigureParameters(modificationFunctionMapping);
ConfigureResultBindings(modificationFunctionMapping);
}
private static void UniquifyFunctionName(
DbDatabaseMapping databaseMapping,
ModificationFunctionConfiguration modificationFunctionConfiguration,
StorageModificationFunctionMapping functionMapping)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(functionMapping);
if ((modificationFunctionConfiguration == null)
|| string.IsNullOrWhiteSpace(modificationFunctionConfiguration.Name))
{
functionMapping.Function.Name
= databaseMapping.Database.Functions.Except(new[] { functionMapping.Function })
.UniquifyName(functionMapping.Function.Name);
}
}
private StorageModificationFunctionMapping GenerateFunctionMapping(
ModificationOperator modificationOperator,
EntitySetBase entitySetBase,
EntityTypeBase entityTypeBase,
DbDatabaseMapping databaseMapping,
IEnumerable<EdmProperty> parameterProperties,
IEnumerable<Tuple<StorageModificationFunctionMemberPath, EdmProperty>> iaFkProperties,
IList<ColumnMappingBuilder> columnMappings,
IEnumerable<EdmProperty> resultProperties = null)
{
DebugCheck.NotNull(entitySetBase);
DebugCheck.NotNull(entityTypeBase);
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(parameterProperties);
DebugCheck.NotNull(iaFkProperties);
DebugCheck.NotNull(columnMappings);
var useOriginalValues = modificationOperator == ModificationOperator.Delete;
var parameterMappingGenerator
= new FunctionParameterMappingGenerator(_providerManifest);
var parameterBindings
= parameterMappingGenerator
.Generate(
modificationOperator,
parameterProperties,
columnMappings,
new List<EdmProperty>(),
useOriginalValues)
.Concat(
parameterMappingGenerator
.Generate(iaFkProperties, useOriginalValues))
.ToList();
FunctionParameter rowsAffectedParameter = null;
var parameters
= parameterBindings.Select(b => b.Parameter).ToList();
if (parameterBindings
.Any(
pb => !pb.IsCurrent
&& pb.MemberPath.AssociationSetEnd == null
&& ((EdmProperty)pb.MemberPath.Members.Last()).ConcurrencyMode == ConcurrencyMode.Fixed))
{
rowsAffectedParameter
= new FunctionParameter(
"RowsAffected",
_providerManifest.GetStoreType(
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))),
ParameterMode.Out);
parameters.Add(rowsAffectedParameter);
}
UniquifyParameterNames(parameters);
var functionPayload
= new EdmFunctionPayload
{
ReturnParameters = new FunctionParameter[0],
Parameters = parameters.ToArray(),
IsComposable = false
};
var function
= databaseMapping.Database
.AddFunction(
entityTypeBase.Name + "_" + modificationOperator.ToString(),
functionPayload);
var functionMapping
= new StorageModificationFunctionMapping(
entitySetBase,
entityTypeBase,
function,
parameterBindings,
rowsAffectedParameter,
resultProperties != null
? resultProperties.Select(
p => new StorageModificationFunctionResultBinding(
columnMappings.First(cm => cm.PropertyPath.SequenceEqual(new[] { p })).ColumnProperty.Name,
p))
: null);
return functionMapping;
}
public void WriteFunctionMapping_should_write_complex_parameter_bindings()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
new EntityContainer("EC", DataSpace.SSpace).AddEntitySetBase(entitySet);
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
new[]
{
new StorageModificationFunctionParameterBinding(
new FunctionParameter(
"P",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
ParameterMode.In),
new StorageModificationFunctionMemberPath(
new[]
{
EdmProperty.Complex("C1", new ComplexType()),
EdmProperty.Complex("C2", new ComplexType()),
new EdmProperty("M")
},
null),
true)
},
null,
null);
fixture.Writer.WriteFunctionMapping("InsertFunction", storageModificationFunctionMapping);
Assert.Equal(
@"<InsertFunction FunctionName=""N.F"">
<ComplexProperty Name=""C1"" TypeName=""."">
<ComplexProperty Name=""C2"" TypeName=""."">
<ScalarProperty Name=""M"" ParameterName=""P"" Version=""Current"" />
</ComplexProperty>
</ComplexProperty>
</InsertFunction>",
fixture.ToString());
}
public void WriteFunctionMapping(
string functionElement, StorageModificationFunctionMapping functionMapping, bool associationSetMapping = false)
{
DebugCheck.NotNull(functionMapping);
_xmlWriter.WriteStartElement(functionElement);
_xmlWriter.WriteAttributeString(StorageMslConstructs.FunctionNameAttribute, functionMapping.Function.FullName);
if (functionMapping.RowsAffectedParameter != null)
{
_xmlWriter.WriteAttributeString(
StorageMslConstructs.RowsAffectedParameterAttribute,
functionMapping.RowsAffectedParameter.Name);
}
if (!associationSetMapping)
{
WritePropertyParameterBindings(functionMapping.ParameterBindings);
WriteAssociationParameterBindings(functionMapping.ParameterBindings);
if (functionMapping.ResultBindings != null)
{
WriteResultBindings(functionMapping.ResultBindings);
}
}
else
{
WriteAssociationSetMappingParameterBindings(functionMapping.ParameterBindings);
}
_xmlWriter.WriteEndElement();
}
public void WriteFunctionMapping_should_write_association_end_bindings()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
new EntityContainer("EC", DataSpace.SSpace).AddEntitySetBase(entitySet);
var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace));
var associationEndMember1 = new AssociationEndMember("Source", new EntityType("E", "N", DataSpace.CSpace));
associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember1));
var associationEndMember2 = new AssociationEndMember("Target", new EntityType("E", "N", DataSpace.CSpace));
associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember2));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
new[]
{
new StorageModificationFunctionParameterBinding(
new FunctionParameter(
"P",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
ParameterMode.In),
new StorageModificationFunctionMemberPath(
new EdmMember[]
{
new EdmProperty("K"),
associationEndMember1
},
associationSet),
true)
},
null,
null);
fixture.Writer.WriteFunctionMapping("InsertFunction", storageModificationFunctionMapping);
Assert.Equal(
@"<InsertFunction FunctionName=""N.F"">
<AssociationEnd AssociationSet=""AS"" From=""Source"" To=""Target"">
<ScalarProperty Name=""K"" ParameterName=""P"" Version=""Current"" />
</AssociationEnd>
</InsertFunction>",
fixture.ToString());
}
public void WriteAssociationSetMapping_should_write_modification_function_mapping()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
new EntityContainer("EC", DataSpace.SSpace).AddEntitySetBase(entitySet);
var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace));
var associationEndMember1 = new AssociationEndMember("Source", new EntityType("E", "N", DataSpace.CSpace));
associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember1));
var associationEndMember2 = new AssociationEndMember("Target", new EntityType("E", "N", DataSpace.CSpace));
associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember2));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
associationSet,
associationSet.ElementType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
new[]
{
new StorageModificationFunctionParameterBinding(
new FunctionParameter(
"P",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
ParameterMode.In),
new StorageModificationFunctionMemberPath(
new EdmMember[]
{
new EdmProperty("K"),
associationEndMember1
},
associationSet),
true),
new StorageModificationFunctionParameterBinding(
new FunctionParameter(
"P",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
ParameterMode.In),
new StorageModificationFunctionMemberPath(
new EdmMember[]
{
new EdmProperty("K"),
associationEndMember2
},
associationSet),
false)
},
null,
null);
var associationSetMapping
= new StorageAssociationSetMapping(
associationSet,
entitySet)
{
SourceEndMapping
= new StorageEndPropertyMapping
{
EndMember = associationEndMember1
},
TargetEndMapping
= new StorageEndPropertyMapping
{
EndMember = associationEndMember2
},
ModificationFunctionMapping = new StorageAssociationSetModificationFunctionMapping(
associationSet,
storageModificationFunctionMapping,
storageModificationFunctionMapping)
};
fixture.Writer.WriteAssociationSetMappingElement(associationSetMapping);
Assert.Equal(
@"<AssociationSetMapping Name=""AS"" TypeName="".A"" StoreEntitySet=""E"">
<EndProperty Name=""Source"" />
<EndProperty Name=""Target"" />
<ModificationFunctionMapping>
<InsertFunction FunctionName=""N.F"">
<EndProperty Name=""Source"">
<ScalarProperty Name=""K"" ParameterName=""P"" Version=""Current"" />
</EndProperty>
<EndProperty Name=""Target"">
<ScalarProperty Name=""K"" ParameterName=""P"" Version=""Original"" />
</EndProperty>
</InsertFunction>
<DeleteFunction FunctionName=""N.F"">
<EndProperty Name=""Source"">
<ScalarProperty Name=""K"" ParameterName=""P"" Version=""Current"" />
</EndProperty>
<EndProperty Name=""Target"">
<ScalarProperty Name=""K"" ParameterName=""P"" Version=""Original"" />
</EndProperty>
</DeleteFunction>
</ModificationFunctionMapping>
</AssociationSetMapping>",
fixture.ToString());
}
public void Can_get_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsFunctionImport = true
});
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
container.AddFunctionImport(function);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Same(entityFunctionMappings, entitySetMapping.ModificationFunctionMappings.Single());
}
public void WriteFunctionMapping_should_write_simple_parameter_and_result_bindings_and_rows_affected_parameter()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
new EntityContainer("EC", DataSpace.SSpace).AddEntitySetBase(entitySet);
var property = new EdmProperty("M");
var typeUsage = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
new[]
{
new StorageModificationFunctionParameterBinding(
new FunctionParameter(
"P",
typeUsage,
ParameterMode.In),
new StorageModificationFunctionMemberPath(
new[] { property },
null),
true),
new StorageModificationFunctionParameterBinding(
new FunctionParameter(
"P_Original",
typeUsage,
ParameterMode.In),
new StorageModificationFunctionMemberPath(
new[] { property },
null),
false)
},
new FunctionParameter("RowsAffected", typeUsage, ParameterMode.Out),
new[]
{
new StorageModificationFunctionResultBinding("C", property)
});
fixture.Writer.WriteFunctionMapping("InsertFunction", storageModificationFunctionMapping);
Assert.Equal(
@"<InsertFunction FunctionName=""N.F"" RowsAffectedParameter=""RowsAffected"">
<ScalarProperty Name=""M"" ParameterName=""P"" Version=""Current"" />
<ScalarProperty Name=""M"" ParameterName=""P_Original"" Version=""Original"" />
<ResultBinding Name=""M"" ColumnName=""C"" />
</InsertFunction>",
fixture.ToString());
}
private void ConfigureResultBindings(StorageModificationFunctionMapping modificationFunctionMapping)
{
DebugCheck.NotNull(modificationFunctionMapping);
foreach (var keyValue in _resultBindings)
{
var propertyInfo = keyValue.Key;
var columnName = keyValue.Value;
var resultBinding
= (modificationFunctionMapping
.ResultBindings ?? Enumerable.Empty<StorageModificationFunctionResultBinding>())
.SingleOrDefault(rb => propertyInfo.IsSameAs(rb.Property.GetClrPropertyInfo()));
if (resultBinding == null)
{
throw Error.ResultBindingNotFound(
propertyInfo.Name,
modificationFunctionMapping.Function.Name);
}
resultBinding.ColumnName = columnName;
}
}
private void ConfigureRowsAffectedParameter(
StorageModificationFunctionMapping modificationFunctionMapping, DbProviderManifest providerManifest)
{
DebugCheck.NotNull(modificationFunctionMapping);
DebugCheck.NotNull(providerManifest);
if (!string.IsNullOrWhiteSpace(_rowsAffectedParameter))
{
if (modificationFunctionMapping.RowsAffectedParameter == null)
{
var rowsAffectedParameter
= new FunctionParameter(
"_RowsAffected_",
providerManifest.GetStoreType(
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))),
ParameterMode.Out);
modificationFunctionMapping.Function.AddParameter(rowsAffectedParameter);
modificationFunctionMapping.RowsAffectedParameter = rowsAffectedParameter;
}
modificationFunctionMapping.RowsAffectedParameter.Name = _rowsAffectedParameter;
_configuredParameters.Add(modificationFunctionMapping.RowsAffectedParameter);
}
}
public void Configure_should_introduce_rows_affected_parameter_when_configured()
{
var modificationFunctionConfiguration = new ModificationFunctionConfiguration();
modificationFunctionConfiguration.RowsAffectedParameter("rows_affected");
var entitySet = new EntitySet();
entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
new EntityType("E", "N", DataSpace.CSpace),
new EdmFunction("F", "N", DataSpace.SSpace),
new StorageModificationFunctionParameterBinding[0],
null,
null);
modificationFunctionConfiguration.Configure(
storageModificationFunctionMapping,
ProviderRegistry.Sql2008_ProviderManifest);
Assert.Equal("rows_affected", storageModificationFunctionMapping.RowsAffectedParameterName);
}
public void GetComplexParameterBindings_should_return_all_complex_parameter_bindings_for_type()
{
var databaseMapping
= new DbDatabaseMapping()
.Initialize(
new EdmModel(DataSpace.CSpace),
new EdmModel(DataSpace.SSpace));
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = databaseMapping.Model.AddEntitySet("ES", entityType);
var entitySetMapping = databaseMapping.AddEntitySetMapping(entitySet);
var complexType1 = new ComplexType();
complexType1.Annotations.SetClrType(typeof(string));
var complexType2 = new ComplexType();
complexType2.Annotations.SetClrType(typeof(object));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace),
new[]
{
new StorageModificationFunctionParameterBinding(
new FunctionParameter(),
new StorageModificationFunctionMemberPath(
new EdmMember[]
{
EdmProperty.Complex("C1", complexType1),
EdmProperty.Complex("C2", complexType2),
new EdmProperty("M")
},
null),
true
)
},
null,
null);
entitySetMapping.AddModificationFunctionMapping(
new StorageEntityTypeModificationFunctionMapping(
entityType,
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping));
Assert.Equal(3, databaseMapping.GetComplexParameterBindings(typeof(string)).Count());
Assert.Equal(3, databaseMapping.GetComplexParameterBindings(typeof(object)).Count());
}