public static void SetDefaultDiscriminator(
this MappingFragment entityTypeMappingFragment, EdmProperty discriminator)
{
DebugCheck.NotNull(entityTypeMappingFragment);
entityTypeMappingFragment.Annotations.SetAnnotation(DefaultDiscriminatorAnnotation, discriminator);
}
public static EdmProperty IncludeColumn(
EntityType table, EdmProperty templateColumn, Func<EdmProperty, bool> isCompatible, bool useExisting)
{
DebugCheck.NotNull(table);
DebugCheck.NotNull(templateColumn);
var existingColumn = table.Properties.FirstOrDefault(isCompatible);
if (existingColumn == null)
{
templateColumn = templateColumn.Clone();
}
else if (!useExisting
&& !existingColumn.IsPrimaryKeyColumn)
{
templateColumn = templateColumn.Clone();
}
else
{
templateColumn = existingColumn;
}
AddColumn(table, templateColumn);
return templateColumn;
}
public override IConfiguration Discover(EdmProperty property, DbModel model)
{
Debug.Assert(property != null, "property is null.");
Debug.Assert(model != null, "model is null.");
if (!_lengthTypes.Contains(property.PrimitiveType.PrimitiveTypeKind))
{
// Doesn't apply
return null;
}
if (property.IsMaxLength
|| !property.MaxLength.HasValue
|| (property.MaxLength.Value == 128 && property.IsKey()))
{
// By convention
return null;
}
var configuration = property.PrimitiveType.PrimitiveTypeKind == PrimitiveTypeKind.String
? new MaxLengthStringConfiguration()
: new MaxLengthConfiguration();
configuration.MaxLength = property.MaxLength.Value;
return configuration;
}
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 static EdmProperty IncludeColumn(
EntityType table, EdmProperty templateColumn, bool useExisting)
{
DebugCheck.NotNull(table);
DebugCheck.NotNull(templateColumn);
var existingColumn =
table.Properties.SingleOrDefault(c => string.Equals(c.Name, templateColumn.Name, StringComparison.Ordinal));
if (existingColumn == null)
{
templateColumn = templateColumn.Clone();
}
else if (!useExisting
&& !existingColumn.IsPrimaryKeyColumn)
{
templateColumn = templateColumn.Clone();
}
else
{
templateColumn = existingColumn;
}
AddColumn(table, templateColumn);
return templateColumn;
}
internal FunctionImportMappingComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
List<Tuple<StructuralType, List<StorageConditionPropertyMapping>, List<StoragePropertyMapping>>> structuralTypeMappings,
EdmProperty[] targetFunctionKeys,
StorageMappingItemCollection mappingItemCollection)
: base(functionImport, targetFunction)
{
DebugCheck.NotNull(mappingItemCollection);
Debug.Assert(functionImport.IsComposableAttribute, "functionImport.IsComposableAttribute");
Debug.Assert(targetFunction.IsComposableAttribute, "targetFunction.IsComposableAttribute");
Debug.Assert(
functionImport.EntitySet == null || structuralTypeMappings != null,
"Function import returning entities must have structuralTypeMappings.");
Debug.Assert(
structuralTypeMappings == null || structuralTypeMappings.Count > 0, "Non-null structuralTypeMappings must not be empty.");
EdmType resultType;
Debug.Assert(
structuralTypeMappings != null ||
MetadataHelper.TryGetFunctionImportReturnType(functionImport, 0, out resultType) && TypeSemantics.IsScalarType(resultType),
"Either type mappings should be specified or the function import should be Collection(Scalar).");
Debug.Assert(
functionImport.EntitySet == null || targetFunctionKeys != null,
"Keys must be inferred for a function import returning entities.");
Debug.Assert(targetFunctionKeys == null || targetFunctionKeys.Length > 0, "Keys must be null or non-empty.");
m_mappingItemCollection = mappingItemCollection;
// We will use these parameters to target s-space function calls in the generated command tree.
// Since enums don't exist in s-space we need to use the underlying type.
m_commandParameters =
functionImport.Parameters.Select(p => TypeHelpers.GetPrimitiveTypeUsageForScalar(p.TypeUsage).Parameter(p.Name)).ToArray();
m_structuralTypeMappings = structuralTypeMappings;
m_targetFunctionKeys = targetFunctionKeys;
}
internal ConditionPropertyMapping(EdmProperty propertyOrColumn, object value, bool? isNull)
{
DebugCheck.NotNull(propertyOrColumn);
Debug.Assert((isNull.HasValue) || (value != null), "Either Value or IsNull has to be specified on Condition Mapping");
Debug.Assert(!(isNull.HasValue) || (value == null), "Both Value and IsNull can not be specified on Condition Mapping");
var dataSpace = propertyOrColumn.TypeUsage.EdmType.DataSpace;
switch (dataSpace)
{
case DataSpace.CSpace:
base.Property = propertyOrColumn;
break;
case DataSpace.SSpace:
_column = propertyOrColumn;
break;
default:
throw new ArgumentException(
Strings.MetadataItem_InvalidDataSpace(dataSpace, typeof(EdmProperty).Name),
"propertyOrColumn");
}
_value = value;
_isNull = isNull;
}
public IConfiguration Discover(EdmProperty property, DbModel model)
{
Debug.Assert(property != null, "property is null.");
Debug.Assert(model != null, "model is null.");
if (!_precisionTypes.Contains(property.PrimitiveType.PrimitiveTypeKind))
{
// Doesn't apply
return null;
}
var storeProperty = model.GetColumn(property);
var defaultPrecision = (byte)storeProperty.PrimitiveType.FacetDescriptions
.First(d => d.FacetName == DbProviderManifest.PrecisionFacetName).DefaultValue;
// NOTE: This facet is not propagated to the conceptual side of the reverse
// engineered model.
var precision = storeProperty.Precision ?? defaultPrecision;
if (precision == defaultPrecision)
{
// By convention
return null;
}
return new PrecisionDateTimeConfiguration { Precision = precision };
}
public IConfiguration Discover(EdmProperty property, DbModel model)
{
Debug.Assert(property != null, "property is null.");
Debug.Assert(model != null, "model is null.");
var columnProperty = model.GetColumn(property);
if (property.IsKey() && _identityKeyTypes.Contains(property.PrimitiveType.PrimitiveTypeKind))
{
if (columnProperty.IsStoreGeneratedIdentity)
{
// By convention
return null;
}
}
else if (columnProperty.IsTimestamp())
{
// By convention
return null;
}
else if (columnProperty.StoreGeneratedPattern == StoreGeneratedPattern.None)
{
// Doesn't apply
return null;
}
return new DatabaseGeneratedConfiguration { StoreGeneratedPattern = columnProperty.StoreGeneratedPattern };
}
public void Can_get_flattened_properties_for_nested_mapping()
{
var mappingFragment
= new MappingFragment(
new EntitySet(),
new EntityTypeMapping(
new EntitySetMapping(
new EntitySet(),
new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)))), false);
Assert.Empty(mappingFragment.ColumnMappings);
var columnProperty = new EdmProperty("C", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace }));
var property1 = EdmProperty.CreateComplex("P1", new ComplexType("CT"));
var property2 = new EdmProperty("P2");
var columnMappingBuilder1 = new ColumnMappingBuilder(columnProperty, new[] { property1, property2 });
mappingFragment.AddColumnMapping(columnMappingBuilder1);
var columnMappingBuilder2 = new ColumnMappingBuilder(columnProperty, new[] { property2 });
mappingFragment.AddColumnMapping(columnMappingBuilder2);
var columnMappingBuilders = mappingFragment.FlattenedProperties.ToList();
Assert.Equal(2, columnMappingBuilders.Count());
Assert.True(columnMappingBuilder1.PropertyPath.SequenceEqual(columnMappingBuilders.First().PropertyPath));
Assert.True(columnMappingBuilder2.PropertyPath.SequenceEqual(columnMappingBuilders.Last().PropertyPath));
}
internal static void MapPrimitivePropertyFacets(
EdmProperty property, EdmProperty column, TypeUsage typeUsage)
{
DebugCheck.NotNull(property);
DebugCheck.NotNull(column);
DebugCheck.NotNull(typeUsage);
if (IsValidFacet(typeUsage, XmlConstants.FixedLengthElement))
{
column.IsFixedLength = property.IsFixedLength;
}
if (IsValidFacet(typeUsage, XmlConstants.MaxLengthElement))
{
column.IsMaxLength = property.IsMaxLength;
column.MaxLength = property.MaxLength;
}
if (IsValidFacet(typeUsage, XmlConstants.UnicodeElement))
{
column.IsUnicode = property.IsUnicode;
}
if (IsValidFacet(typeUsage, XmlConstants.PrecisionElement))
{
column.Precision = property.Precision;
}
if (IsValidFacet(typeUsage, XmlConstants.ScaleElement))
{
column.Scale = property.Scale;
}
}
protected EdmProperty MapTableColumn(
EdmProperty property,
string columnName,
bool isInstancePropertyOnDerivedType)
{
DebugCheck.NotNull(property);
DebugCheck.NotEmpty(columnName);
var underlyingTypeUsage
= TypeUsage.Create(property.UnderlyingPrimitiveType, property.TypeUsage.Facets);
var storeTypeUsage = _providerManifest.GetStoreType(underlyingTypeUsage);
var tableColumnMetadata
= new EdmProperty(columnName, storeTypeUsage)
{
Nullable = isInstancePropertyOnDerivedType || property.Nullable
};
if (tableColumnMetadata.IsPrimaryKeyColumn)
{
tableColumnMetadata.Nullable = false;
}
var storeGeneratedPattern = property.GetStoreGeneratedPattern();
if (storeGeneratedPattern != null)
{
tableColumnMetadata.StoreGeneratedPattern = storeGeneratedPattern.Value;
}
MapPrimitivePropertyFacets(property, tableColumnMetadata, storeTypeUsage);
return tableColumnMetadata;
}
/// <inheritdoc/>
protected override bool MatchDependentKeyProperty(
AssociationType associationType,
AssociationEndMember dependentAssociationEnd,
EdmProperty dependentProperty,
EntityType principalEntityType,
EdmProperty principalKeyProperty)
{
Check.NotNull(associationType, "associationType");
Check.NotNull(dependentAssociationEnd, "dependentAssociationEnd");
Check.NotNull(dependentProperty, "dependentProperty");
Check.NotNull(principalEntityType, "principalEntityType");
Check.NotNull(principalKeyProperty, "principalKeyProperty");
var otherEnd = associationType.GetOtherEnd(dependentAssociationEnd);
var navigationProperty
= dependentAssociationEnd.GetEntityType().NavigationProperties
.SingleOrDefault(n => n.ResultEnd == otherEnd);
if (navigationProperty == null)
{
return false;
}
return string.Equals(
dependentProperty.Name, navigationProperty.Name + principalKeyProperty.Name,
StringComparison.OrdinalIgnoreCase);
}
private void BuildColumnMapping(string identity, EdmProperty property, string propertyName, ColumnMapping columnMapping)
{
if (_primaryKeysMapping[identity].Contains(propertyName))
{
columnMapping.IsPk = true;
}
foreach (var facet in property.TypeUsage.Facets)
{
switch (facet.Name)
{
case "Nullable":
columnMapping.Nullable = (bool)facet.Value;
break;
case "DefaultValue":
columnMapping.DefaultValue = facet.Value;
break;
case "StoreGeneratedPattern":
columnMapping.IsIdentity = (StoreGeneratedPattern)facet.Value == StoreGeneratedPattern.Identity;
columnMapping.Computed = (StoreGeneratedPattern)facet.Value == StoreGeneratedPattern.Computed;
break;
case "MaxLength":
columnMapping.MaxLength = (int)facet.Value;
break;
}
}
}
public void EdmModel_NameIsTooLong_not_triggered_for_row_and_collection_types()
{
var intType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32);
var properties = new EdmProperty[100];
for (int i = 0; i < 100; i++)
{
properties[i] = EdmProperty.Primitive("Property" + i, intType);
}
var rowType = new RowType(properties);
foreach (var type in new EdmType[] { rowType, rowType.GetCollectionType() })
{
var validationContext
= new EdmModelValidationContext(new EdmModel(DataSpace.SSpace), true);
DataModelErrorEventArgs errorEventArgs = null;
validationContext.OnError += (_, e) => errorEventArgs = e;
EdmModelSyntacticValidationRules
.EdmModel_NameIsTooLong
.Evaluate(validationContext, type);
Assert.Null(errorEventArgs);
}
}
public void Configure_should_rename_columns_when_right_keys_configured()
{
var database = new EdmModel(DataSpace.CSpace);
var associationSetMapping
= new StorageAssociationSetMapping(
new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)),
new EntitySet())
.Initialize();
var column = new EdmProperty("C");
associationSetMapping.TargetEndMapping.AddProperty(new StorageScalarPropertyMapping(new EdmProperty("PK"), column));
var manyToManyAssociationMappingConfiguration
= new ManyToManyAssociationMappingConfiguration();
manyToManyAssociationMappingConfiguration.MapRightKey("NewName");
var mockPropertyInfo = new MockPropertyInfo();
associationSetMapping.SourceEndMapping.EndMember = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationSetMapping.SourceEndMapping.EndMember.SetClrPropertyInfo(mockPropertyInfo);
manyToManyAssociationMappingConfiguration.Configure(associationSetMapping, database, mockPropertyInfo);
Assert.Equal("NewName", column.Name);
}
internal override TypeUsage GetTypeUsage()
{
if (_typeUsage == null)
{
var listOfProperties = new List<EdmProperty>();
foreach (var property in _properties)
{
var edmProperty = new EdmProperty(property.FQName, property.GetTypeUsage());
edmProperty.AddMetadataProperties(property.OtherContent);
//edmProperty.DeclaringType
listOfProperties.Add(edmProperty);
}
var rowType = new RowType(listOfProperties);
if (Schema.DataModel
== SchemaDataModelOption.EntityDataModel)
{
rowType.DataSpace = DataSpace.CSpace;
}
else
{
Debug.Assert(
Schema.DataModel == SchemaDataModelOption.ProviderDataModel,
"Only DataModel == SchemaDataModelOption.ProviderDataModel is expected");
rowType.DataSpace = DataSpace.SSpace;
}
rowType.AddMetadataProperties(OtherContent);
_typeUsage = TypeUsage.Create(rowType);
}
return _typeUsage;
}
/// <summary>
/// Initializes a new ModificationFunctionResultBinding instance.
/// </summary>
/// <param name="columnName">The name of the column to bind from the function result set.</param>
/// <param name="property">The property to be set on the entity.</param>
public ModificationFunctionResultBinding(string columnName, EdmProperty property)
{
Check.NotNull(columnName, "columnName");
Check.NotNull(property, "property");
_columnName = columnName;
_property = property;
}
public ColumnMappingBuilder(EdmProperty columnProperty, IList<EdmProperty> propertyPath)
{
Check.NotNull(columnProperty, "columnProperty");
Check.NotNull(propertyPath, "propertyPath");
_columnProperty = columnProperty;
_propertyPath = propertyPath;
}
internal StorageModificationFunctionResultBinding(string columnName, EdmProperty property)
{
DebugCheck.NotNull(columnName);
DebugCheck.NotNull(property);
ColumnName = columnName;
Property = property;
}
public void Returns_rows_affected_when_there_is_a_reader()
{
var mockPrimitiveType = new Mock<PrimitiveType>();
mockPrimitiveType.Setup(m => m.BuiltInTypeKind).Returns(BuiltInTypeKind.PrimitiveType);
mockPrimitiveType.Setup(m => m.PrimitiveTypeKind).Returns(PrimitiveTypeKind.Int32);
mockPrimitiveType.Setup(m => m.DataSpace).Returns(DataSpace.CSpace);
string memberName = "property";
var edmProperty = new EdmProperty(memberName, TypeUsage.Create(mockPrimitiveType.Object));
var entityType = new EntityType("", "", DataSpace.CSpace, Enumerable.Empty<string>(), new[] { edmProperty });
entityType.SetReadOnly();
var mockUpdateTranslator = new Mock<UpdateTranslator>(MockBehavior.Strict);
mockUpdateTranslator.Setup(m => m.CommandTimeout).Returns(() => null);
var entityConnection = new Mock<EntityConnection>().Object;
mockUpdateTranslator.Setup(m => m.Connection).Returns(entityConnection);
var mockDbModificationCommandTree = new Mock<DbModificationCommandTree>();
mockDbModificationCommandTree.SetupGet(m => m.HasReader).Returns(true);
var mockDynamicUpdateCommand = new Mock<DynamicUpdateCommand>(new Mock<TableChangeProcessor>().Object, mockUpdateTranslator.Object,
ModificationOperator.Delete, PropagatorResult.CreateSimpleValue(PropagatorFlags.NoFlags, value: 0),
PropagatorResult.CreateStructuralValue(new[] { PropagatorResult.CreateSimpleValue(PropagatorFlags.NoFlags, value: 0) },
entityType,
isModified: false),
mockDbModificationCommandTree.Object, /*outputIdentifiers*/ null)
{
CallBase = true
};
var mockDbCommand = new Mock<DbCommand>();
int dbValue = 66;
var mockDbDataReader = new Mock<DbDataReader>();
mockDbDataReader.Setup(m => m.GetValue(It.IsAny<int>())).Returns(dbValue);
int rowsToRead = 2;
mockDbDataReader.Setup(m => m.Read()).Returns(() =>
{
rowsToRead--;
return rowsToRead > 0;
});
mockDbDataReader.Setup(m => m.FieldCount).Returns(1);
mockDbDataReader.Setup(m => m.GetName(0)).Returns(memberName);
mockDbCommand.Protected().Setup<DbDataReader>("ExecuteDbDataReader", CommandBehavior.SequentialAccess).Returns(mockDbDataReader.Object);
var identifierValues = new Dictionary<int, object>();
mockDynamicUpdateCommand.Protected().Setup<DbCommand>("CreateCommand", identifierValues).Returns(mockDbCommand.Object);
var generatedValues = new List<KeyValuePair<PropagatorResult, object>>();
var rowsAffectedResult = mockDynamicUpdateCommand.Object.Execute(identifierValues, generatedValues);
Assert.Equal(1, rowsAffectedResult);
Assert.Equal(1, generatedValues.Count);
Assert.Equal(dbValue, generatedValues[0].Value);
Assert.Equal(0, generatedValues[0].Key.GetSimpleValue());
}
protected override void ConfigureProperty(EdmProperty property)
{
base.ConfigureProperty(property);
if (IsUnicode != null)
{
property.IsUnicode = IsUnicode;
}
}
internal override void Configure(EdmProperty property)
{
base.Configure(property);
if (Precision != null)
{
property.Precision = Precision;
}
}
internal override void Configure(EdmProperty property)
{
base.Configure(property);
if (IsUnicode != null)
{
property.IsUnicode = IsUnicode;
}
}
/// <summary>
/// Construct a new instance of the FieldDescriptor class that describes a property
/// on items of the supplied type.
/// </summary>
/// <param name="itemType"> Type of object whose property is described by this FieldDescriptor. </param>
/// <param name="isReadOnly">
/// <b>True</b> if property value on item can be modified; otherwise <b>false</b> .
/// </param>
/// <param name="property"> EdmProperty that describes the property on the item. </param>
internal FieldDescriptor(Type itemType, bool isReadOnly, EdmProperty property)
: base(property.Name, null)
{
_itemType = itemType;
_property = property;
_isReadOnly = isReadOnly;
_fieldType = DetermineClrType(_property.TypeUsage);
Debug.Assert(_fieldType != null, "FieldDescriptor's CLR type has unexpected value of null.");
}
protected override void ConfigureProperty(EdmProperty property)
{
base.ConfigureProperty(property);
if (Precision != null)
{
property.Precision = Precision;
}
}
internal StateManagerMemberMetadata(ObjectPropertyMapping memberMap, EdmProperty memberMetadata, bool isPartOfKey)
{
DebugCheck.NotNull(memberMap);
DebugCheck.NotNull(memberMetadata);
_clrProperty = memberMap.ClrProperty;
_edmProperty = memberMetadata;
_isPartOfKey = isPartOfKey;
_isComplexType = (Helper.IsEntityType(_edmProperty.TypeUsage.EdmType) ||
Helper.IsComplexType(_edmProperty.TypeUsage.EdmType));
}
public void Can_initialize_column_mapping_builder()
{
var columnProperty = new EdmProperty("C");
var property = new EdmProperty("P");
var columnMappingBuilder = new ColumnMappingBuilder(columnProperty, new[] { property });
Assert.Same(columnProperty, columnMappingBuilder.ColumnProperty);
Assert.Same(property, columnMappingBuilder.PropertyPath.Single());
}
public void Cannot_create_mapping_for_non_primitive_store_column()
{
var modelProperty = EdmProperty.Primitive("p", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
var storeColumn = new EdmProperty("p", TypeUsage.CreateDefaultTypeUsage(new RowType()));
Assert.Equal(
Strings.StorageScalarPropertyMapping_OnlyScalarPropertiesAllowed,
Assert.Throws<ArgumentException>(
() => new StorageScalarPropertyMapping(modelProperty, storeColumn)).Message);
}
public static void AddColumn(this EntityType table, EdmProperty column)
{
DebugCheck.NotNull(table);
DebugCheck.NotNull(column);
column.SetPreferredName(column.Name);
column.Name = table.Properties.UniquifyName(column.Name);
table.AddMember(column);
}
internal void WritePropertyElementHeader(EdmProperty property)
{
DebugCheck.NotNull(property);
_xmlWriter.WriteStartElement(XmlConstants.Property);
_xmlWriter.WriteAttributeString(XmlConstants.Name, property.Name);
_xmlWriter.WriteAttributeString(XmlConstants.TypeAttribute, GetTypeReferenceName(property));
if (property.CollectionKind != CollectionKind.None)
{
_xmlWriter.WriteAttributeString(
XmlConstants.CollectionKind, property.CollectionKind.ToString());
}
if (property.ConcurrencyMode == ConcurrencyMode.Fixed)
{
_xmlWriter.WriteAttributeString(EdmProviderManifest.ConcurrencyModeFacetName, XmlConstants.Fixed);
}
WriteExtendedProperties(property);
if (property.Annotations.GetClrAttributes() != null)
{
var epmCount = 0;
foreach (var a in property.Annotations.GetClrAttributes())
{
if (a.GetType().FullName.Equals(DataServicesMimeTypeAttribute, StringComparison.Ordinal))
{
var mimeType = a.GetType().GetDeclaredProperty("MimeType").GetValue(a, null) as string;
_xmlWriter.WriteAttributeString(DataServicesPrefix, "MimeType", DataServicesNamespace, mimeType);
}
else if (a.GetType().FullName.Equals(
DataServicesEntityPropertyMappingAttribute, StringComparison.Ordinal))
{
var suffix = epmCount == 0
? String.Empty
: string.Format(CultureInfo.InvariantCulture, "_{0}", epmCount);
var sourcePath = a.GetType().GetDeclaredProperty("SourcePath").GetValue(a, null) as string;
var slashIndex = sourcePath.IndexOf("/", StringComparison.Ordinal);
if (slashIndex != -1 &&
slashIndex + 1 < sourcePath.Length)
{
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_SourcePath" + suffix, DataServicesNamespace,
sourcePath.Substring(slashIndex + 1));
}
// There are three ways to write out this attribute
var syndicationItem = a.GetType().GetDeclaredProperty("TargetSyndicationItem").GetValue(a, null);
var keepInContext = a.GetType().GetDeclaredProperty("KeepInContent").GetValue(a, null).ToString();
var criteriaValueProperty = a.GetType().GetDeclaredProperty("CriteriaValue");
string criteriaValue = null;
if (criteriaValueProperty != null)
{
criteriaValue = criteriaValueProperty.GetValue(a, null) as string;
}
if (criteriaValue != null)
{
_xmlWriter.WriteAttributeString(
DataServicesPrefix,
"FC_TargetPath" + suffix,
DataServicesNamespace,
SyndicationItemPropertyToString(syndicationItem));
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_KeepInContent" + suffix, DataServicesNamespace,
keepInContext);
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_CriteriaValue" + suffix, DataServicesNamespace,
criteriaValue);
}
else if (string.Equals(
syndicationItem.ToString(), "CustomProperty", StringComparison.Ordinal))
{
var targetPath = a.GetType().GetDeclaredProperty("TargetPath").GetValue(a, null).ToString();
var targetNamespacePrefix =
a.GetType().GetDeclaredProperty("TargetNamespacePrefix").GetValue(a, null).ToString();
var targetNamespaceUri =
a.GetType().GetDeclaredProperty("TargetNamespaceUri").GetValue(a, null).ToString();
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_TargetPath" + suffix, DataServicesNamespace, targetPath);
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_NsUri" + suffix, DataServicesNamespace,
targetNamespaceUri);
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_NsPrefix" + suffix, DataServicesNamespace,
targetNamespacePrefix);
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_KeepInContent" + suffix, DataServicesNamespace,
keepInContext);
}
else
{
var contextKind = a.GetType().GetDeclaredProperty("TargetTextContentKind").GetValue(a, null);
_xmlWriter.WriteAttributeString(
DataServicesPrefix,
"FC_TargetPath" + suffix,
DataServicesNamespace,
SyndicationItemPropertyToString(syndicationItem));
_xmlWriter.WriteAttributeString(
DataServicesPrefix,
"FC_ContentKind" + suffix,
DataServicesNamespace,
SyndicationTextContentKindToString(contextKind));
_xmlWriter.WriteAttributeString(
DataServicesPrefix, "FC_KeepInContent" + suffix, DataServicesNamespace,
keepInContext);
}
epmCount++;
}
}
}
if (property.IsMaxLength)
{
_xmlWriter.WriteAttributeString(XmlConstants.MaxLengthElement, XmlConstants.Max);
}
else if (!property.IsMaxLengthConstant &&
property.MaxLength.HasValue)
{
_xmlWriter.WriteAttributeString(
XmlConstants.MaxLengthElement,
property.MaxLength.Value.ToString(CultureInfo.InvariantCulture));
}
if (!property.IsFixedLengthConstant &&
property.IsFixedLength.HasValue)
{
_xmlWriter.WriteAttributeString(
XmlConstants.FixedLengthElement,
GetLowerCaseStringFromBoolValue(property.IsFixedLength.Value));
}
if (!property.IsUnicodeConstant &&
property.IsUnicode.HasValue)
{
_xmlWriter.WriteAttributeString(
XmlConstants.UnicodeElement, GetLowerCaseStringFromBoolValue(property.IsUnicode.Value));
}
if (!property.IsPrecisionConstant &&
property.Precision.HasValue)
{
_xmlWriter.WriteAttributeString(
XmlConstants.PrecisionElement,
property.Precision.Value.ToString(CultureInfo.InvariantCulture));
}
if (!property.IsScaleConstant &&
property.Scale.HasValue)
{
_xmlWriter.WriteAttributeString(
XmlConstants.ScaleElement, property.Scale.Value.ToString(CultureInfo.InvariantCulture));
}
if (property.StoreGeneratedPattern != StoreGeneratedPattern.None)
{
_xmlWriter.WriteAttributeString(
XmlConstants.StoreGeneratedPattern,
property.StoreGeneratedPattern == StoreGeneratedPattern.Computed
? XmlConstants.Computed
: XmlConstants.Identity);
}
if (_serializeDefaultNullability || !property.Nullable)
{
_xmlWriter.WriteAttributeString(
EdmConstants.Nullable, GetLowerCaseStringFromBoolValue(property.Nullable));
}
MetadataProperty metadataProperty;
if (property.MetadataProperties.TryGetValue(XmlConstants.StoreGeneratedPatternAnnotation, false, out metadataProperty))
{
_xmlWriter.WriteAttributeString(
XmlConstants.StoreGeneratedPattern, XmlConstants.AnnotationNamespace,
metadataProperty.Value.ToString());
}
}
// <summary>
// Adds a property
// </summary>
// <param name="property"> The property to add </param>
private void AddProperty(EdmProperty property)
{
Check.NotNull(property, "property");
AddMember(property);
}
// <summary>
// Validate an EdmProperty object
// </summary>
// <param name="item"> The EdmProperty 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 ValidateEdmProperty(EdmProperty item, List <EdmItemError> errors, HashSet <MetadataItem> validatedItems)
{
ValidateEdmMember(item, errors, validatedItems);
}
/// <summary>
/// Create a column map for the entitysetid column
/// </summary>
private SimpleColumnMap CreateEntitySetIdColumnMap(md.EdmProperty prop)
{
return(CreateSimpleColumnMap(md.Helper.GetModelTypeUsage(prop), c_EntitySetIdColumnName));
}
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());
}
/// <summary>
/// Try get the new property for the supplied propertyRef
/// </summary>
/// <param name="propertyRef"> property reference (on the old type) </param>
/// <param name="throwIfMissing"> throw if the property is not found </param>
/// <param name="newProperty"> the corresponding property on the new type </param>
internal bool TryGetNewProperty(PropertyRef propertyRef, bool throwIfMissing, out md.EdmProperty newProperty)
{
return(RootType.TryGetNewProperty(propertyRef, throwIfMissing, out newProperty));
}
private void AddProperty(EdmProperty property)
{
Check.NotNull <EdmProperty>(property, nameof(property));
this.AddMember((EdmMember)property);
}
protected internal override void VisitEdmProperty(EdmProperty item)
{
_schemaWriter.WritePropertyElementHeader(item);
base.VisitEdmProperty(item);
_schemaWriter.WriteEndElement();
}
