public void Can_create_with_valid_complex_type()
{
var complexType = new ComplexType();
var complexTypeMapping = new ComplexTypeMapping(complexType);
Assert.Same(complexType, complexTypeMapping.ComplexType);
}
public void Can_generate_scalar_and_complex_properties_when_update()
{
var functionParameterMappingGenerator
= new FunctionParameterMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest);
var property0 = new EdmProperty("P0");
var property1 = new EdmProperty("P1");
var property2 = new EdmProperty("P2");
property2.SetStoreGeneratedPattern(StoreGeneratedPattern.Computed);
property2.ConcurrencyMode = ConcurrencyMode.Fixed;
var complexType = new ComplexType("CT", "N", DataSpace.CSpace);
complexType.AddMember(property1);
var complexProperty = EdmProperty.CreateComplex("C", complexType);
var parameterBindings
= functionParameterMappingGenerator
.Generate(
ModificationOperator.Update,
new[] { property0, complexProperty, property2 },
new[]
{
new ColumnMappingBuilder(new EdmProperty("C0"), new[] { property0 }),
new ColumnMappingBuilder(new EdmProperty("C_P1"), new[] { complexProperty, property1 }),
new ColumnMappingBuilder(new EdmProperty("C2"), new[] { property2 })
},
new List<EdmProperty>(),
useOriginalValues: true)
.ToList();
Assert.Equal(3, parameterBindings.Count());
var parameterBinding = parameterBindings.First();
Assert.Equal("C0", parameterBinding.Parameter.Name);
Assert.Same(property0, parameterBinding.MemberPath.Members.Single());
Assert.Equal("String", parameterBinding.Parameter.TypeName);
Assert.Equal(ParameterMode.In, parameterBinding.Parameter.Mode);
Assert.False(parameterBinding.IsCurrent);
parameterBinding = parameterBindings.ElementAt(1);
Assert.Equal("C_P1", parameterBinding.Parameter.Name);
Assert.Same(complexProperty, parameterBinding.MemberPath.Members.First());
Assert.Same(property1, parameterBinding.MemberPath.Members.Last());
Assert.Equal("String", parameterBinding.Parameter.TypeName);
Assert.Equal(ParameterMode.In, parameterBinding.Parameter.Mode);
Assert.False(parameterBinding.IsCurrent);
parameterBinding = parameterBindings.Last();
Assert.Equal("C2_Original", parameterBinding.Parameter.Name);
Assert.Same(property2, parameterBinding.MemberPath.Members.Single());
Assert.Equal("String", parameterBinding.Parameter.TypeName);
Assert.Equal(ParameterMode.In, parameterBinding.Parameter.Mode);
Assert.False(parameterBinding.IsCurrent);
}
public void Generate_should_flatten_complex_properties_to_columns()
{
var databaseMapping = CreateEmptyModel();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var complexType = new ComplexType("C");
var property = EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
complexType.AddMember(property);
entityType.AddComplexProperty("C1", complexType);
var property1 = EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var entitySet = databaseMapping.Model.AddEntitySet("ESet", entityType);
var type = typeof(object);
entityType.Annotations.SetClrType(type);
new TableMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(entityType, databaseMapping);
var entityTypeMappingFragment
= databaseMapping.GetEntitySetMapping(entitySet).EntityTypeMappings.Single().MappingFragments.Single();
Assert.Equal(2, entityTypeMappingFragment.ColumnMappings.Count());
Assert.Equal(2, entityTypeMappingFragment.Table.Properties.Count());
}
internal FunctionImportComplexTypeMapping(
ComplexType returnType, Collection<FunctionImportReturnTypePropertyMapping> properties, LineInfo lineInfo)
: base(properties, lineInfo)
{
DebugCheck.NotNull(returnType);
DebugCheck.NotNull(properties);
_returnType = returnType;
}
public void Configure_should_set_configuration()
{
var complexType = new ComplexType("C");
var complexTypeConfiguration = new ComplexTypeConfiguration(typeof(object));
complexTypeConfiguration.Configure(complexType);
Assert.Same(complexTypeConfiguration, complexType.GetConfiguration());
}
/// <summary>
/// Initializes a new FunctionImportComplexTypeMapping instance.
/// </summary>
/// <param name="returnType">The return type.</param>
/// <param name="properties">The property mappings for the result type of a function import.</param>
public FunctionImportComplexTypeMapping(
ComplexType returnType,
Collection<FunctionImportReturnTypePropertyMapping> properties)
: this(
Check.NotNull(returnType, "returnType"),
Check.NotNull(properties, "properties"),
LineInfo.Empty)
{
}
public void GetClrType_returns_CLR_type_annotation_for_ComplexType()
{
var complexType = new ComplexType("C", "N", DataSpace.CSpace);
Assert.Null(((EdmType)complexType).GetClrType());
complexType.Annotations.SetClrType(typeof(Random));
Assert.Same(typeof(Random), ((EdmType)complexType).GetClrType());
}
public void Complex_should_create_complex_property()
{
var complexType = new ComplexType();
var property = EdmProperty.CreateComplex("P", complexType);
Assert.NotNull(property);
Assert.NotNull(property.TypeUsage);
Assert.Same(complexType, property.TypeUsage.EdmType);
}
public void IsComplexType_returns_true_when_complex_property()
{
var complexType = new ComplexType();
var property = EdmProperty.CreateComplex("P", complexType);
Assert.False(property.IsPrimitiveType);
Assert.False(property.IsEnumType);
Assert.True(property.IsComplexType);
}
public void Configure_should_throw_when_property_not_found()
{
var complexType = new ComplexType("C");
var complexTypeConfiguration = new ComplexTypeConfiguration(typeof(object));
var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>();
complexTypeConfiguration.Property(new PropertyPath(new MockPropertyInfo()), () => mockPropertyConfiguration.Object);
Assert.Equal(
Strings.PropertyNotFound(("P"), "C"),
Assert.Throws<InvalidOperationException>(() => complexTypeConfiguration.Configure(complexType)).Message);
}
public void AddComplexProperty_should_create_and_add_complex_property()
{
var complexType = new ComplexType("C");
var complexTypeProperty = new ComplexType("D");
var property = complexType.AddComplexProperty("Foo", complexTypeProperty);
Assert.NotNull(property);
Assert.Equal("Foo", property.Name);
Assert.Same(complexTypeProperty, property.ComplexType);
Assert.True(complexType.Properties.Contains(property));
}
public static EdmProperty Complex(string name, ComplexType complexType)
{
Check.NotEmpty(name, "name");
Check.NotNull(complexType, "complexType");
var property = CreateProperty(name, complexType);
property.Nullable = false;
return property;
}
public void AddPrimitiveProperty_should_create_and_add_to_primitive_properties()
{
var complexType = new ComplexType("C");
var property1 = EdmProperty.CreatePrimitive("Foo", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
complexType.AddMember(property1);
var property = property1;
Assert.NotNull(property);
Assert.Equal("Foo", property.Name);
Assert.True(complexType.Properties.Contains(property));
}
public void Properties_list_should_be_live_on_reread()
{
var complexType = new ComplexType("C");
Assert.Empty(complexType.Properties);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
complexType.AddMember(property);
Assert.Equal(1, complexType.Properties.Count);
}
public void Should_be_able_to_get_and_set_clr_type()
{
var complexType = new ComplexType("C");
Assert.Null(complexType.GetClrType());
var type = typeof(object);
complexType.Annotations.SetClrType(type);
Assert.Equal(typeof(object), complexType.GetClrType());
}
public void AddComplexProperty_should_create_and_add_complex_property()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var complexType = new ComplexType("C");
var property = entityType.AddComplexProperty("Foo", complexType);
Assert.NotNull(property);
Assert.Equal("Foo", property.Name);
Assert.Same(complexType, property.ComplexType);
Assert.True(entityType.DeclaredProperties.Contains(property));
}
public void Should_be_able_to_get_and_set_clr_type()
{
var complexType = new ComplexType("C");
Assert.Null(complexType.GetClrType());
var type = typeof(object);
complexType.GetMetadataProperties().SetClrType(type);
Assert.Equal(typeof(object), complexType.GetClrType());
}
public void GetPrimitiveProperty_should_return_correct_property()
{
var complexType = new ComplexType("C");
var property1 = EdmProperty.CreatePrimitive("Foo", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
complexType.AddMember(property1);
var property = property1;
var foundProperty = complexType.Properties.SingleOrDefault(p => p.Name == "Foo");
Assert.NotNull(foundProperty);
Assert.Same(property, foundProperty);
}
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());
}
public static EdmProperty AddComplexProperty(
this ComplexType complexType, string name, ComplexType targetComplexType)
{
DebugCheck.NotNull(complexType);
DebugCheck.NotNull(complexType.Properties);
DebugCheck.NotEmpty(name);
DebugCheck.NotNull(targetComplexType);
var property = EdmProperty.CreateComplex(name, targetComplexType);
complexType.AddMember(property);
return property;
}
public void Cannot_add_property_when_read_only()
{
var complexType = new ComplexType();
var complexTypeMapping = new ComplexTypeMapping(complexType);
complexTypeMapping.SetReadOnly();
var scalarPropertyMapping = new ScalarPropertyMapping(new EdmProperty("P"), new EdmProperty("C", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace })));
Assert.Equal(
Strings.OperationOnReadOnlyItem,
Assert.Throws<InvalidOperationException>(
() => complexTypeMapping.AddPropertyMapping(scalarPropertyMapping)).Message);
}
public void Map_should_map_complex_type_properties()
{
var complexType = new ComplexType("C");
var mappingContext
= new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), new EdmModel(DataSpace.CSpace));
new PropertyMapper(new TypeMapper(mappingContext))
.Map(new MockPropertyInfo(typeof(int), "Foo"), complexType, () => new ComplexTypeConfiguration(typeof(object)));
Assert.Equal(1, complexType.Properties.Count);
var property = complexType.Properties.SingleOrDefault(p => p.Name == "Foo");
Assert.Equal(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), property.PrimitiveType);
}
public void Map(
PropertyInfo propertyInfo, ComplexType complexType,
Func<ComplexTypeConfiguration> complexTypeConfiguration)
{
DebugCheck.NotNull(propertyInfo);
DebugCheck.NotNull(complexType);
var property = MapPrimitiveOrComplexOrEnumProperty(
propertyInfo, complexTypeConfiguration, discoverComplexTypes: true);
if (property != null)
{
complexType.AddMember(property);
}
}
public void Can_add_remove_properties()
{
var complexType = new ComplexType();
var complexTypeMapping = new ComplexTypeMapping(complexType);
var scalarPropertyMapping = new ScalarPropertyMapping(new EdmProperty("P"), new EdmProperty("C", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace })));
Assert.Empty(complexTypeMapping.PropertyMappings);
complexTypeMapping.AddPropertyMapping(scalarPropertyMapping);
Assert.Same(scalarPropertyMapping, complexTypeMapping.PropertyMappings.Single());
complexTypeMapping.RemovePropertyMapping(scalarPropertyMapping);
Assert.Empty(complexTypeMapping.PropertyMappings);
}
public void Can_add_remove_conditions()
{
var complexType = new ComplexType();
var complexTypeMapping = new ComplexTypeMapping(complexType);
var conditionMapping = new IsNullConditionMapping(new EdmProperty("P"), true);
Assert.Empty(complexTypeMapping.Conditions);
complexTypeMapping.AddCondition(conditionMapping);
Assert.Same(conditionMapping, complexTypeMapping.Conditions.Single());
complexTypeMapping.RemoveCondition(conditionMapping);
Assert.Empty(complexTypeMapping.Conditions);
}
public void Configure_should_configure_properties()
{
var complexType = new ComplexType("C");
var property1 = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
complexType.AddMember(property1);
var property = property1;
var complexTypeConfiguration = new ComplexTypeConfiguration(typeof(object));
var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>();
var mockPropertyInfo = new MockPropertyInfo();
complexTypeConfiguration.Property(new PropertyPath(mockPropertyInfo), () => mockPropertyConfiguration.Object);
property.SetClrPropertyInfo(mockPropertyInfo);
complexTypeConfiguration.Configure(complexType);
mockPropertyConfiguration.Verify(p => p.Configure(property));
}
public void GetComplexPropertyMappings_should_return_all_complex_property_mappings_for_type()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var entitySet = new EntitySet
{
Name = "ES"
};
var entitySetMapping = databaseMapping.AddEntitySetMapping(entitySet);
var entityTypeMapping = new StorageEntityTypeMapping(null);
entitySetMapping.AddTypeMapping(entityTypeMapping);
var entityTypeMappingFragment = new StorageMappingFragment(entitySet, entityTypeMapping, false);
entityTypeMapping.AddFragment(entityTypeMappingFragment);
var complexType = new ComplexType("C");
var propertyMapping1
= new ColumnMappingBuilder(
new EdmProperty("C"),
new[]
{
EdmProperty.Complex("P1", complexType),
EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))
});
var type = typeof(object);
complexType.Annotations.SetClrType(type);
entityTypeMappingFragment.AddColumnMapping(propertyMapping1);
var propertyMapping2
= new ColumnMappingBuilder(
new EdmProperty("C"),
new List<EdmProperty>
{
EdmProperty.Complex("P3", complexType),
EdmProperty.Primitive(
"P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
});
entityTypeMappingFragment.AddColumnMapping(propertyMapping2);
Assert.Equal(2, databaseMapping.GetComplexPropertyMappings(typeof(object)).Count());
}
public void WriteEntityContainerMappingElement_should_write_function_import_elements()
{
var typeUsage =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
var complexTypeProperty1 = new EdmProperty("CTProperty1", typeUsage);
var complexTypeProperty2 = new EdmProperty("CTProperty2", typeUsage);
var complexType = new ComplexType("CT", "Ns", DataSpace.CSpace);
complexType.AddMember(complexTypeProperty1);
complexType.AddMember(complexTypeProperty2);
var functionImport =
new EdmFunction(
"f_c", "Ns", DataSpace.CSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = true,
ReturnParameters =
new[]
{
new FunctionParameter(
"ReturnValue",
TypeUsage.CreateDefaultTypeUsage(complexType.GetCollectionType()),
ParameterMode.ReturnValue)
},
Parameters =
new[]
{
new FunctionParameter("param", typeUsage, ParameterMode.Out)
}
});
typeUsage = ProviderRegistry.Sql2008_ProviderManifest.GetStoreType(typeUsage);
var rowTypeProperty1 = new EdmProperty("RTProperty1", typeUsage);
var rowTypeProperty2 = new EdmProperty("RTProperty2", typeUsage);
var rowType = new RowType(new[] { rowTypeProperty1, rowTypeProperty2 });
var storeFunction =
new EdmFunction(
"f_s", "Ns.Store", DataSpace.SSpace,
new EdmFunctionPayload
{
ReturnParameters =
new[]
{
new FunctionParameter(
"Return",
TypeUsage.CreateDefaultTypeUsage(rowType),
ParameterMode.ReturnValue)
},
Parameters =
new[]
{
new FunctionParameter("param", typeUsage, ParameterMode.Out)
}
});
var structuralTypeMapping =
new Tuple <StructuralType, List <ConditionPropertyMapping>, List <PropertyMapping> >(
complexType, new List <ConditionPropertyMapping>(), new List <PropertyMapping>());
structuralTypeMapping.Item3.Add(new ScalarPropertyMapping(complexTypeProperty1, rowTypeProperty1));
structuralTypeMapping.Item3.Add(new ScalarPropertyMapping(complexTypeProperty2, rowTypeProperty2));
var functionImportMapping = new FunctionImportMappingComposable(
functionImport,
storeFunction,
new List <Tuple <StructuralType, List <ConditionPropertyMapping>, List <PropertyMapping> > >
{
structuralTypeMapping
});
var containerMapping = new EntityContainerMapping(new EntityContainer("C", DataSpace.SSpace));
containerMapping.AddFunctionImportMapping(functionImportMapping);
var fixture = new Fixture();
fixture.Writer.WriteEntityContainerMappingElement(containerMapping);
Assert.Equal(
@"<EntityContainerMapping StorageEntityContainer="""" CdmEntityContainer=""C"">
<FunctionImportMapping FunctionName=""Ns.Store.f_s"" FunctionImportName=""f_c"">
<ResultMapping>
<ComplexTypeMapping TypeName=""Ns.CT"">
<ScalarProperty Name=""CTProperty1"" ColumnName=""RTProperty1"" />
<ScalarProperty Name=""CTProperty2"" ColumnName=""RTProperty2"" />
</ComplexTypeMapping>
</ResultMapping>
</FunctionImportMapping>
</EntityContainerMapping>",
fixture.ToString());
}
public void Can_add_remove_complex_type()
{
var model = new EdmModel(DataSpace.SSpace);
var complexType = new ComplexType("C", "N", DataSpace.SSpace);
model.AddItem(complexType);
Assert.True(model.ComplexTypes.Contains(complexType));
Assert.True(model.NamespaceItems.Contains(complexType));
model.RemoveItem(complexType);
Assert.False(model.ComplexTypes.Contains(complexType));
Assert.False(model.NamespaceItems.Contains(complexType));
}
protected virtual void Visit(ComplexType complexType)
{
Visit(complexType.BaseType);
foreach (var member in complexType.Members)
{
Visit(member);
}
foreach (var property in complexType.Properties)
{
Visit(property);
}
}
/// <summary>
/// Initialize all the build in type with the given type attributes and properties
/// </summary>
/// <param name="builtInType">The built In type which is getting initialized</param>
/// <param name="name">name of the built in type</param>
/// <param name="isAbstract">whether the type is abstract or not</param>
/// <param name="isSealed">whether the type is sealed or not</param>
/// <param name="baseType">The base type of the built in type</param>
private static void InitializeBuiltInTypes(
ComplexType builtInType,
string name,
bool isAbstract,
ComplexType baseType)
{
// Initialize item attributes for all ancestor types
EdmType.Initialize(builtInType, name, EdmConstants.EdmNamespace, DataSpace.CSpace, isAbstract, baseType);
}
/// <summary>
/// Removes a complex type from the model.
/// </summary>
/// <param name="item">The ComplexType instance to be removed.</param>
public void RemoveItem(ComplexType item)
{
Check.NotNull(item, "item");
_complexTypes.Remove(item);
}
protected override void VisitComplexType(ComplexType item)
{
_schemaWriter.WriteComplexTypeElementHeader(item);
base.VisitComplexType(item);
_schemaWriter.WriteEndElement();
}
/// <summary>Adds a complex type to the model.</summary>
/// <param name="item">The ComplexType instance to be added.</param>
public void AddItem(ComplexType item)
{
Check.NotNull <ComplexType>(item, nameof(item));
this.ValidateSpace((EdmType)item);
this._complexTypes.Add(item);
}
/// <summary>Removes a complex type from the model.</summary>
/// <param name="item">The ComplexType instance to be removed.</param>
public void RemoveItem(ComplexType item)
{
Check.NotNull <ComplexType>(item, nameof(item));
this._complexTypes.Remove(item);
}
// <summary>
// Validate an ComplexType object
// </summary>
// <param name="item"> The ComplexType object to validate </param>
// <param name="errors"> An error collection for adding validation errors </param>
// <param name="validatedItems"> A dictionary keeping track of items that have been validated </param>
private void ValidateComplexType(ComplexType item, List <EdmItemError> errors, HashSet <MetadataItem> validatedItems)
{
ValidateStructuralType(item, errors, validatedItems);
}
