public override string GetStoreType(EdmProperty property)
{
if (property.TypeUsage.EdmType.Name == "int")
return "INTEGER";
return base.GetStoreType(property);
}
private static bool IsServerGenerated(EdmProperty property) {
MetadataProperty generated;
if (property.MetadataProperties.TryGetValue(StoreGeneratedMetadata, false, out generated)) {
return "Identity" == (string)generated.Value || "Computed" == (string)generated.Value;
}
return false;
}
public string GetGenerationOption(EdmProperty property, EntityType entity)
{
string result = "";
bool isPk = entity.KeyMembers.Contains(property);
MetadataProperty storeGeneratedPatternProperty = null;
string storeGeneratedPatternPropertyValue = "None";
if (property.MetadataProperties.TryGetValue(MetadataConstants.EDM_ANNOTATION_09_02 + ":StoreGeneratedPattern", false, out storeGeneratedPatternProperty))
storeGeneratedPatternPropertyValue = storeGeneratedPatternProperty.Value.ToString();
PrimitiveType edmType = (PrimitiveType)property.TypeUsage.EdmType;
if (edmType == null && property.TypeUsage.EdmType is EnumType)
{
EnumType enumType = property.TypeUsage.EdmType as EnumType;
edmType = enumType.UnderlyingType;
}
if (storeGeneratedPatternPropertyValue == "Computed")
{
result = ".HasDatabaseGeneratedOption(new Nullable<DatabaseGeneratedOption>(DatabaseGeneratedOption.Computed))";
}
else if ((edmType.ClrEquivalentType == typeof(int)) || (edmType.ClrEquivalentType == typeof(short)) || (edmType.ClrEquivalentType == typeof(long)))
{
if (isPk && (storeGeneratedPatternPropertyValue != "Identity"))
result = ".HasDatabaseGeneratedOption(new Nullable<DatabaseGeneratedOption>(DatabaseGeneratedOption.None))";
else if ((!isPk || (entity.KeyMembers.Count > 1)) && (storeGeneratedPatternPropertyValue == "Identity"))
result = ".HasDatabaseGeneratedOption(new Nullable<DatabaseGeneratedOption>(DatabaseGeneratedOption.Identity))";
}
return result;
}
internal FunctionImportMappingComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
List<Tuple<StructuralType, List<StorageConditionPropertyMapping>, List<StoragePropertyMapping>>> structuralTypeMappings,
EdmProperty[] targetFunctionKeys,
StorageMappingItemCollection mappingItemCollection,
string sourceLocation,
LineInfo lineInfo)
: base(functionImport, targetFunction)
{
EntityUtil.CheckArgumentNull(mappingItemCollection, "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<EdmType>(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;
m_sourceLocation = sourceLocation;
m_lineInfo = lineInfo;
}
public override string GetStoreType(EdmProperty property)
{
if (property.TypeUsage.EdmType.Name == "guid")
return "CHAR(36) BINARY";
return base.GetStoreType(property);
}
/// <summary>
/// Get the Var corresponding to a specific property
/// </summary>
/// <param name="p">the requested property</param>
/// <param name="v">the corresponding Var</param>
/// <returns>true, if the Var was found</returns>
internal bool TryGetVar(md.EdmProperty p, out Var v)
{
if (m_propertyToVarMap == null)
{
InitPropertyToVarMap();
}
return(m_propertyToVarMap.TryGetValue(p, out v));
}
internal StorageModificationFunctionResultBinding(string columnName, EdmProperty property)
{
//Contract.Requires(columnName != null);
//Contract.Requires(property != null);
ColumnName = columnName;
Property = property;
}
/// <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);
System.Diagnostics.Debug.Assert(_fieldType != null, "FieldDescriptor's CLR type has unexpected value of null.");
}
/// <summary>
/// Construct a new Scalar EdmProperty mapping object
/// </summary>
/// <param name="member"></param>
/// <param name="columnMember"></param>
internal StorageScalarPropertyMapping(EdmProperty member, EdmProperty columnMember)
: base(member) {
Debug.Assert(columnMember != null);
Debug.Assert(
Helper.IsScalarType(member.TypeUsage.EdmType),
"StorageScalarPropertyMapping must only map primitive or enum types");
Debug.Assert(Helper.IsPrimitiveType(columnMember.TypeUsage.EdmType), "StorageScalarPropertyMapping must only map primitive types");
this.m_columnMember = columnMember;
}
private bool DetermineIsForeignKeyComponent(EdmProperty property) {
var navigationProperties = property.DeclaringType.Members.OfType<NavigationProperty>();
// Look at all NavigationProperties (i.e. strongly-type relationship columns) of the table this column belong to and
// see if there is a foreign key that matches this property
// If this is a 1 to 0..1 relationship and we are processing the more primary side. i.e in the Student in Student-StudentDetail
// and this is the primary key we don't want to check the relationship type since if there are no constraints we will treat the primary key as a foreign key.
return navigationProperties.Any(n => EFCodeFirstAssociationProvider.GetDependentPropertyNames(n, !IsPrimaryKey /* checkRelationshipType */).Contains(property.Name));
}
public override string WriteCreateColumn(EdmProperty property, Version targetVersion)
{
var notnull = (property.Nullable ? "" : "NOT NULL");
var identity = GetIdentity(property, targetVersion);
return string.Format("{0} {1} {2} {3}",
FormatName(property.Name),
GetStoreType(property),
identity, notnull).Trim();
}
/// <summary>
/// Construct a new condition Property mapping object
/// </summary>
/// <param name="cdmMember"></param>
/// <param name="columnMember"></param>
/// <param name="value"></param>
/// <param name="isNull"></param>
internal StorageConditionPropertyMapping(EdmProperty cdmMember, EdmProperty columnMember
, object value, Nullable<bool> isNull) : base(cdmMember) {
Debug.Assert((cdmMember != null) || (columnMember != null), "Both CDM and Column Members can not be specified for Condition Mapping");
Debug.Assert((cdmMember == null) || (columnMember == null), "Either CDM or Column Members has to be specified for Condition Mapping");
Debug.Assert((isNull.HasValue) || (value != null), "Both Value and IsNull can not be specified on Condition Mapping");
Debug.Assert(!(isNull.HasValue) || (value == null), "Either Value or IsNull has to be specified on Condition Mapping");
this.m_columnMember = columnMember;
this.m_value = value;
this.m_isNull = isNull;
}
/// <summary>
/// Adds a <paramref name="property"/> to <paramref name="metadata"/>
/// under type <paramref name="structuredType"/>
/// </summary>
/// <param name="metadata">Metadata document to be added to</param>
/// <param name="property">Property to add</param>
/// <param name="structuredType">Structured type to add property to</param>
private static void AddProperty(ConstructableMetadata metadata, EdmProperty property, IEdmStructuredType structuredType)
{
if (property.BuiltInTypeKind == BuiltInTypeKind.EdmProperty)
{
AddPrimitiveProperty(metadata, DataTypeToSystemType((PrimitiveType)property.TypeUsage.EdmType, IsNullable(property.TypeUsage)), property, structuredType);
}
else if (property.BuiltInTypeKind == BuiltInTypeKind.ComplexType)
{
metadata.AddComplexProperty(structuredType, property.Name, metadata.FindType(property.TypeUsage.EdmType.FullName) as IEdmComplexType);
}
}
internal StateManagerMemberMetadata(ObjectPropertyMapping memberMap, EdmProperty memberMetadata, bool isPartOfKey)
{
// if memberMap is null, then this is a shadowstate
Debug.Assert(null != memberMap, "shadowstate not supported");
Debug.Assert(null != memberMetadata, "CSpace should never be null");
_clrProperty = memberMap.ClrProperty;
_edmProperty = memberMetadata;
_isPartOfKey = isPartOfKey;
_isComplexType = (Helper.IsEntityType(_edmProperty.TypeUsage.EdmType) ||
Helper.IsComplexType(_edmProperty.TypeUsage.EdmType));
}
public override string GetStoreType(EdmProperty property)
{
switch (property.TypeUsage.EdmType.Name)
{
case "datetime":
return "DATE";
case "nvarchar":
return property.ToStoreType().Replace("nvarchar", "VARCHAR");
default:
return base.GetStoreType(property);
}
}
/// <summary>
/// Gets the list of key properties for an entity
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
private static PropertyRefList GetKeyProperties(md.EntityType entityType)
{
PropertyRefList desiredProperties = new PropertyRefList();
foreach (md.EdmMember p in entityType.KeyMembers)
{
md.EdmProperty edmP = p as md.EdmProperty;
PlanCompiler.Assert(edmP != null, "EntityType had non-EdmProperty key member?");
SimplePropertyRef pRef = new SimplePropertyRef(edmP);
desiredProperties.Add(pRef);
}
return(desiredProperties);
}
/// <summary>
/// Add a mapping from the propertyRef (of the old type) to the
/// corresponding property in the new type.
///
/// NOTE: Only to be used by StructuredTypeInfo
/// </summary>
/// <param name="propertyRef"></param>
/// <param name="newProperty"></param>
internal void AddPropertyMapping(PropertyRef propertyRef, md.EdmProperty newProperty)
{
m_propertyMap[propertyRef] = newProperty;
if (propertyRef is TypeIdPropertyRef)
{
m_typeIdProperty = newProperty;
}
else if (propertyRef is EntitySetIdPropertyRef)
{
m_entitySetIdProperty = newProperty;
}
else if (propertyRef is NullSentinelPropertyRef)
{
m_nullSentinelProperty = newProperty;
}
}
/// <summary>
/// Add a mapping from the propertyRef (of the old type) to the
/// corresponding property in the new type.
///
/// NOTE: Only to be used by StructuredTypeInfo
/// </summary>
/// <param name="propertyRef"></param>
/// <param name="newProperty"></param>
internal void AddPropertyMapping(PropertyRef propertyRef, EdmProperty newProperty)
{
m_propertyMap[propertyRef] = newProperty;
if (propertyRef is TypeIdPropertyRef)
{
m_typeIdProperty = newProperty;
}
else if (propertyRef is EntitySetIdPropertyRef)
{
m_entitySetIdProperty = newProperty;
}
else if (propertyRef is NullSentinelPropertyRef)
{
m_nullSentinelProperty = newProperty;
}
}
static string GenerateColumn(EdmProperty property)
{
var column = new StringBuilder();
column.Append(SqlGenerator.QuoteIdentifier(property.Name));
column.Append(" ");
column.Append(SqlGenerator.GetSqlPrimitiveType(property.TypeUsage));
if (MetadataHelpers.IsStoreGeneratedIdentity(property))
{
column.Append(" GENERATED BY DEFAULT AS IDENTITY");
}
if (!property.Nullable)
{
column.Append(" NOT NULL");
}
return column.ToString();
}
/// <summary>
/// Given a property on the principal end of a referential constraint, returns the corresponding property on the dependent end.
/// Requires: The association has a referential constraint, and the specified principalProperty is one of the properties on the principal end.
/// </summary>
public EdmProperty GetCorrespondingDependentProperty(NavigationProperty navProperty, EdmProperty principalProperty)
{
if (navProperty == null)
{
throw new ArgumentNullException("navProperty");
}
if (principalProperty == null)
{
throw new ArgumentNullException("principalProperty");
}
ReadOnlyMetadataCollection<EdmProperty> fromProperties = GetPrincipalProperties(navProperty);
ReadOnlyMetadataCollection<EdmProperty> toProperties = GetDependentProperties(navProperty);
return toProperties[fromProperties.IndexOf(principalProperty)];
}
internal EntityDataSourceMemberPath(MetadataWorkspace ocWorkspace, EntityDataSourceMemberPath parent, EdmProperty property, bool isLocallyInteresting)
{
EntityDataSourceUtil.CheckArgumentNull(ocWorkspace, "ocWorkspace");
EntityDataSourceUtil.CheckArgumentNull(property, "property");
this.property = property;
this.parent = parent;
this.isLocallyInteresting = isLocallyInteresting;
this.clrType = EntityDataSourceUtil.GetMemberClrType(ocWorkspace, property);
this.isKey = IsPropertyAKey(property);
// retrieve PropertyInfo (with respect to parent CLR type)
StructuralType parentType = property.DeclaringType;
Type parentClrType = EntityDataSourceUtil.GetClrType(ocWorkspace, parentType);
this.propertyInfo = EntityDataSourceUtil.GetPropertyInfo(parentClrType, this.property.Name);
}
private static Helpers.PropertyUsageAttributes SetPropertyUsageAttributes(Edm.EdmProperty p)
{
Helpers.PropertyUsageAttributes propertyUsageAttributes = new Helpers.PropertyUsageAttributes();
propertyUsageAttributes.Name = p.Name;
if (p.TypeUsage.EdmType.BuiltInTypeKind == Edm.BuiltInTypeKind.ComplexType)
{
propertyUsageAttributes.IsComplexType = true;
foreach (Edm.EdmProperty property in ((Edm.ComplexType)p.TypeUsage.EdmType).Properties)
{
Helpers.PropertyUsageAttributes subPropertyUsageAttributes = SetPropertyUsageAttributes(property);
propertyUsageAttributes.SubPropertyUsageAttributes.Add(subPropertyUsageAttributes);
}
}
else
{
propertyUsageAttributes.IsComplexType = false;
propertyUsageAttributes.MaxLength = p.TypeUsage.EdmType.Name.ToLower() == "string" ? System.Convert.ToInt32(p.TypeUsage.Facets["MaxLength"].Value) : (-1);
propertyUsageAttributes.Required = !System.Convert.ToBoolean(p.TypeUsage.Facets["Nullable"].Value);
propertyUsageAttributes.Type = p.TypeUsage.EdmType.Name;
}
return(propertyUsageAttributes);
}
private string GetFacetString(EdmProperty column)
{
StringBuilder sql = new StringBuilder();
Facet facet;
Facet fcDateTimePrecision = null;
ReadOnlyMetadataCollection<Facet> facets = column.TypeUsage.Facets;
if (column.TypeUsage.EdmType.BaseType.Name == "String")
{
// types tinytext, mediumtext, text & longtext don't have a length.
if (!column.TypeUsage.EdmType.Name.EndsWith("text", StringComparison.OrdinalIgnoreCase))
{
if (facets.TryGetValue("MaxLength", true, out facet))
sql.AppendFormat(" ({0})", facet.Value);
}
}
else if (column.TypeUsage.EdmType.BaseType.Name == "Decimal")
{
Facet fcScale;
Facet fcPrecision;
if (facets.TryGetValue("Scale", true, out fcScale) && facets.TryGetValue("Precision", true, out fcPrecision))
{
// Enforce scale to a reasonable value.
int scale = fcScale.Value == null ? 0 : ( int )( byte )fcScale.Value;
if (scale == 0)
scale = MySqlProviderManifest.DEFAULT_DECIMAL_SCALE;
sql.AppendFormat("( {0}, {1} ) ", fcPrecision.Value, scale);
}
}
else if (column.TypeUsage.EdmType.BaseType.Name == "DateTime")
{
if (serverVersion >= new Version(5, 6) && facets.TryGetValue("Precision", true, out fcDateTimePrecision))
{
if (Convert.ToByte(fcDateTimePrecision.Value) >= 1)
sql.AppendFormat("( {0} ) ", fcDateTimePrecision.Value);
}
}
if (facets.TryGetValue("Nullable", true, out facet) && (bool)facet.Value == false)
sql.Append(" NOT NULL");
if (facets.TryGetValue("StoreGeneratedPattern", true, out facet))
{
if (facet.Value.Equals(StoreGeneratedPattern.Identity))
{
if (column.TypeUsage.EdmType.BaseType.Name.StartsWith("Int"))
sql.Append(" AUTO_INCREMENT UNIQUE");
else if (column.TypeUsage.EdmType.BaseType.Name == "Guid")
_guidIdentityColumns.Add(column.Name);
else if (serverVersion >= new Version(5, 6) && column.TypeUsage.EdmType.BaseType.Name == "DateTime")
sql.AppendFormat(" DEFAULT CURRENT_TIMESTAMP{0}", fcDateTimePrecision != null && Convert.ToByte(fcDateTimePrecision.Value) >= 1 ? "( " + fcDateTimePrecision.Value.ToString() + " )" : "");
else
throw new MySqlException("Invalid identity column type.");
}
}
return sql.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="property">the corresponding property on the new type</param>
/// <returns></returns>
internal new bool TryGetNewProperty(PropertyRef propertyRef, bool throwIfMissing, out md.EdmProperty property)
{
bool result = m_propertyMap.TryGetValue(propertyRef, out property);
if (throwIfMissing && !result)
{
{
PlanCompiler.Assert(false, "Unable to find property " + propertyRef.ToString() + " in type " + this.Type.EdmType.Identity);
}
}
return(result);
}
/// <summary>
/// Constrcut a new member mapping metadata object
/// </summary>
/// <param name="edmProperty"></param>
/// <param name="clrProperty"></param>
/// <param name="complexTypeMapping"></param>
internal ObjectComplexPropertyMapping(EdmProperty edmProperty, EdmProperty clrProperty, ObjectTypeMapping complexTypeMapping)
: base(edmProperty, clrProperty)
{
m_objectTypeMapping = complexTypeMapping;
}
/// <summary>
/// Constrcut a new member mapping metadata object
/// </summary>
/// <param name="edmProperty"></param>
/// <param name="clrProperty"></param>
internal ObjectPropertyMapping(EdmProperty edmProperty, EdmProperty clrProperty)
:
base(edmProperty, clrProperty)
{
}
/// <summary>
/// Adds a Primitive Property to <paramref name="metadata"/>
/// </summary>
/// <param name="metadata">Metadata document to be added to</param>
/// <param name="type">The type of the primitive property</param>
/// <param name="property">Property to add</param>
/// <param name="structuredType">Structured type to add property to</param>
private static void AddPrimitiveProperty(ConstructableMetadata metadata, Type type, EdmProperty property, IEdmStructuredType structuredType)
{
if (property.DeclaringType is EntityType && ((EntityType)property.DeclaringType).KeyMembers.Contains(property.Name))
{
metadata.AddKeyProperty(structuredType, property.Name, type);
}
else if (type == typeof(Stream))
{
metadata.AddNamedStreamProperty(structuredType, property.Name);
}
else
{
metadata.AddPrimitiveProperty(structuredType, property.Name, type);
}
}
/// <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>
/// <returns></returns>
internal bool TryGetNewProperty(PropertyRef propertyRef, bool throwIfMissing, out md.EdmProperty newProperty)
{
return(this.RootType.TryGetNewProperty(propertyRef, throwIfMissing, out newProperty));
}
/// <summary>
/// Determines whether <paramref name="property"/> is part of an etag based on annotations
/// </summary>
/// <param name="property">Property to check for etag</param>
/// <returns>true if part of an etag otherwise false</returns>
private static bool IsETagProperty(EdmProperty property)
{
return false;
// return property.Annotations.OfType<ConcurrencyTokenAnnotation>().Any();
}
/// <summary>
/// Adds a <paramref name="property"/> to <paramref name="metadata"/>
/// under type <paramref name="structuredType"/>
/// </summary>
/// <param name="metadata">Metadata document to be added to</param>
/// <param name="property">Property to add</param>
/// <param name="structuredType">Structured type to add property to</param>
private static void AddProperty(ConstructableMetadata metadata, EdmProperty property, IEdmStructuredType structuredType)
{
if (property.BuiltInTypeKind == BuiltInTypeKind.EdmProperty)
{
AddPrimitiveProperty(metadata, DataTypeToSystemType((PrimitiveType)property.TypeUsage.EdmType, IsNullable(property.TypeUsage)), property, structuredType);
}
else if (property.BuiltInTypeKind == BuiltInTypeKind.ComplexType)
{
metadata.AddComplexProperty(structuredType, property.Name, metadata.FindType(property.TypeUsage.EdmType.FullName) as IEdmComplexType);
}
}
/// <summary>
/// True if the EdmProperty TypeUsage is Nullable, False otherwise.
/// </summary>
public bool IsNullable(EdmProperty property)
{
return property != null && IsNullable(property.TypeUsage);
}
/// <summary>
/// True if the EdmProperty is a key of its DeclaringType, False otherwise.
/// </summary>
public bool IsKey(EdmProperty property)
{
if (property != null && property.DeclaringType.BuiltInTypeKind == BuiltInTypeKind.EntityType)
{
return ((EntityType)property.DeclaringType).KeyMembers.Contains(property);
}
return false;
}
/// <summary>
/// Create a column map for an entitytype column.
/// Currently, the key columns are not duplicated (ie) they point into the
/// same locations as in the properties list.
/// Note: we also don't handle keys that are properties of nested fields
/// </summary>
/// <param name="typeInfo">Type information for the type</param>
/// <param name="name">column name</param>
/// <param name="superTypeColumnMap">supertype information if any</param>
/// <param name="discriminatorMap">Dictionary of typeid->column map information</param>
/// <param name="allMaps">List of all column maps (including those without typeid)</param>
/// <param name="handleRelProperties">should we handle rel-properties?</param>
/// <returns></returns>
private EntityColumnMap CreateEntityColumnMap(TypeInfo typeInfo, string name, EntityColumnMap superTypeColumnMap,
Dictionary <object, TypedColumnMap> discriminatorMap, List <TypedColumnMap> allMaps, bool handleRelProperties)
{
EntityColumnMap columnMap = null;
List <ColumnMap> propertyColumnMapList = new List <ColumnMap>();
// Copy over information from my supertype if it already exists
if (superTypeColumnMap != null)
{
// get supertype properties
foreach (ColumnMap c in superTypeColumnMap.Properties)
{
propertyColumnMapList.Add(c);
}
// Now add on all of my "specific" properties
foreach (md.EdmMember property in TypeHelpers.GetDeclaredStructuralMembers(typeInfo.Type))
{
ColumnMap propertyColumnMap = CreateColumnMap(md.Helper.GetModelTypeUsage(property), property.Name);
propertyColumnMapList.Add(propertyColumnMap);
}
// create the entity column map w/ information from my supertype
columnMap = new EntityColumnMap(typeInfo.Type, name, propertyColumnMapList.ToArray(), superTypeColumnMap.EntityIdentity);
}
else
{
SimpleColumnMap entitySetIdColumnMap = null;
if (typeInfo.HasEntitySetIdProperty)
{
entitySetIdColumnMap = CreateEntitySetIdColumnMap(typeInfo.EntitySetIdProperty);
}
// build up a list of key columns
List <SimpleColumnMap> keyColumnMapList = new List <SimpleColumnMap>();
// Create a dictionary to look up the key properties
Dictionary <md.EdmProperty, ColumnMap> keyPropertyMap = new Dictionary <md.EdmProperty, ColumnMap>();
foreach (md.EdmMember property in TypeHelpers.GetDeclaredStructuralMembers(typeInfo.Type))
{
ColumnMap propertyColumnMap = CreateColumnMap(md.Helper.GetModelTypeUsage(property), property.Name);
propertyColumnMapList.Add(propertyColumnMap);
// add property to keymap, if this property is part of the key
if (md.TypeSemantics.IsPartOfKey(property))
{
md.EdmProperty edmProperty = property as md.EdmProperty;
PlanCompiler.Assert(edmProperty != null, "EntityType key member is not property?");
keyPropertyMap[edmProperty] = propertyColumnMap;
}
}
// Build up the key list if required
foreach (md.EdmMember keyProperty in TypeHelpers.GetEdmType <md.EntityType>(typeInfo.Type).KeyMembers)
{
md.EdmProperty edmKeyProperty = keyProperty as md.EdmProperty;
PlanCompiler.Assert(edmKeyProperty != null, "EntityType key member is not property?");
SimpleColumnMap keyColumnMap = keyPropertyMap[edmKeyProperty] as SimpleColumnMap;
PlanCompiler.Assert(keyColumnMap != null, "keyColumnMap is null");
keyColumnMapList.Add(keyColumnMap);
}
//
// Create the entity identity.
//
EntityIdentity identity = CreateEntityIdentity((md.EntityType)typeInfo.Type.EdmType, entitySetIdColumnMap, keyColumnMapList.ToArray());
// finally create the entity column map
columnMap = new EntityColumnMap(typeInfo.Type, name, propertyColumnMapList.ToArray(), identity);
}
// if a dictionary is supplied, add myself to the dictionary (abstract types need not be added)
if (discriminatorMap != null)
{
// where DiscriminatedNewInstanceOp is used, there will not be an explicit type id for an abstract type
// or types that do not appear in the QueryView
// (the mapping will not include such information)
if (null != typeInfo.TypeId)
{
discriminatorMap[typeInfo.TypeId] = columnMap;
}
}
if (allMaps != null)
{
allMaps.Add(columnMap);
}
// Finally walk through my subtypes
foreach (TypeInfo subTypeInfo in typeInfo.ImmediateSubTypes)
{
CreateEntityColumnMap(subTypeInfo, name, columnMap, discriminatorMap, allMaps, false);
}
//
// Build up the list of rel property column maps
//
if (handleRelProperties)
{
BuildRelPropertyColumnMaps(typeInfo, true);
}
return(columnMap);
}
internal EntityDataSourceReferenceKeyColumn(MetadataWorkspace workspace, EntityDataSourceReferenceGroup group, EdmProperty keyMember, EntityDataSourceColumn dependent)
: base(CreateDisplayName(group, keyMember), dependent)
{
EntityDataSourceUtil.CheckArgumentNull(group, "group");
EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");
Debug.Assert(EntityDataSourceUtil.IsScalar(keyMember.TypeUsage.EdmType), "Expected primitive or enum type for key members.");
this.group = group;
this.keyMember = keyMember;
this.clrType = EntityDataSourceUtil.GetMemberClrType(workspace, keyMember);
// if the association end is optional (0..1), make sure the CLR type
// is also nullable
if (this.group.End.CorrespondingAssociationEndMember.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne)
{
this.clrType = EntityDataSourceUtil.MakeNullable(clrType);
this.isNullable = true;
}
}
private static string CreateDisplayName(EntityDataSourceReferenceGroup group, EdmProperty keyMember)
{
EntityDataSourceUtil.CheckArgumentNull(group, "group");
EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");
NavigationProperty navigationProperty;
string result;
if (EntityDataSourceUtil.TryGetCorrespondingNavigationProperty(group.End.CorrespondingAssociationEndMember, out navigationProperty))
{
result = navigationProperty.Name + "." + keyMember.Name;
}
else
{
// if there is no Navigation property, use the TargetTole and KeyMember name
// TargetRole.KeyMember
result = group.End.Name + "." + keyMember.Name;
}
return result;
}
/// <summary>
/// Adds a Primitive Property to <paramref name="metadata"/>
/// </summary>
/// <param name="metadata">Metadata document to be added to</param>
/// <param name="type">The type of the primitive property</param>
/// <param name="property">Property to add</param>
/// <param name="structuredType">Structured type to add property to</param>
private static void AddPrimitiveProperty(ConstructableMetadata metadata, Type type, EdmProperty property, IEdmStructuredType structuredType)
{
if (property.DeclaringType is EntityType && ((EntityType)property.DeclaringType).KeyMembers.Contains(property.Name))
{
metadata.AddKeyProperty(structuredType, property.Name, type, IsETagProperty(property));
}
else if (type == typeof(Stream))
{
metadata.AddNamedStreamProperty(structuredType, property.Name);
}
else
{
metadata.AddPrimitiveProperty(structuredType, property.Name, type, IsETagProperty(property));
}
}
private bool IsPropertyAKey(EdmProperty property)
{
bool isKey = false;
EntityType entityType = property.DeclaringType as EntityType;
if (null != entityType)
{
isKey = entityType.KeyMembers.Contains(property);
}
return isKey;
}
/// <summary>
/// Add properties for all the build in complex type
/// </summary>
/// <param name="builtInTypeKind">The type of the built In type whose properties are being added</param>
/// <param name="properties">properties of the built in type</param>
private static void AddBuiltInTypeProperties(BuiltInTypeKind builtInTypeKind, EdmProperty[] properties)
{
ComplexType complexType = (ComplexType)GetBuiltInType(builtInTypeKind);
if (properties != null)
{
for (int i = 0; i < properties.Length; i++)
{
complexType.AddMember(properties[i]);
}
}
}
/// <summary>
/// Construct a new End Property mapping object
/// </summary>
/// <param name="member"></param>
internal StorageEndPropertyMapping(EdmProperty member)
: base(member) {
}
/// <summary>
/// Create a column map for the typeid column
/// </summary>
/// <param name="prop"></param>
/// <returns></returns>
private SimpleColumnMap CreateTypeIdColumnMap(md.EdmProperty prop)
{
return(CreateSimpleColumnMap(md.Helper.GetModelTypeUsage(prop), c_TypeIdColumnName));
}