/// <summary>
/// Creates generated view object for the combination of the <paramref name="extent" /> and the <paramref name="type" />.
/// This constructor is used for regular cell-based view generation.
/// </summary>
internal static GeneratedView CreateGeneratedView(
EntitySetBase extent,
EdmType type,
DbQueryCommandTree commandTree,
string eSQL,
StorageMappingItemCollection mappingItemCollection,
ConfigViewGenerator config)
{
// If config.GenerateEsql is specified, eSQL must be non-null.
// If config.GenerateEsql is false, commandTree is non-null except the case when loading pre-compiled eSQL views.
Debug.Assert(!config.GenerateEsql || !String.IsNullOrEmpty(eSQL), "eSQL must be specified");
DiscriminatorMap discriminatorMap = null;
if (commandTree != null)
{
commandTree = ViewSimplifier.SimplifyView(extent, commandTree);
// See if the view matches the "discriminated" pattern (allows simplification of generated store commands)
if (extent.BuiltInTypeKind
== BuiltInTypeKind.EntitySet)
{
if (DiscriminatorMap.TryCreateDiscriminatorMap((EntitySet)extent, commandTree.Query, out discriminatorMap))
{
Debug.Assert(discriminatorMap != null, "discriminatorMap == null after it has been created");
}
}
}
return new GeneratedView(extent, type, commandTree, eSQL, discriminatorMap, mappingItemCollection, config);
}
public static string GetSoftDeleteColumnName(EdmType type)
{
MetadataProperty annotation = type.MetadataProperties
.SingleOrDefault(p => p.Name.EndsWith("customannotation:SoftDeleteColumnName"));
return (string) annotation?.Value;
}
protected override PrepareMappingRes PrepareMapping(string typeFullName, EdmType edmItem)
{
string tableName = GetTableName(typeFullName);
// find existing parent storageEntitySet
// thp derived types does not have storageEntitySet
EntitySet storageEntitySet;
EdmType baseEdmType = edmItem;
while (!EntityContainer.TryGetEntitySetByName(tableName, false, out storageEntitySet))
{
if (baseEdmType.BaseType == null)
{
break;
}
baseEdmType = baseEdmType.BaseType;
}
if (storageEntitySet == null)
{
return null;
}
var isRoot = baseEdmType == edmItem;
if (!isRoot)
{
var parent = _entityMaps.Values.FirstOrDefault(x => x.EdmType == baseEdmType);
// parent table has not been mapped yet
if (parent == null)
{
throw new ParentNotMappedYetException();
}
}
return new PrepareMappingRes { TableName = tableName, StorageEntitySet = storageEntitySet, IsRoot = isRoot, BaseEdmType = baseEdmType };
}
/// <summary>
/// The constructor for constructing a facet description object
/// </summary>
/// <param name="facetName"> The name of this facet </param>
/// <param name="facetType"> The type of this facet </param>
/// <param name="minValue"> The min value for this facet </param>
/// <param name="maxValue"> The max value for this facet </param>
/// <param name="defaultValue"> The default value for this facet </param>
/// <exception cref="System.ArgumentNullException">Thrown if either facetName, facetType or applicableType arguments are null</exception>
internal FacetDescription(
string facetName,
EdmType facetType,
int? minValue,
int? maxValue,
object defaultValue)
{
Check.NotEmpty(facetName, "facetName");
Check.NotNull(facetType, "facetType");
if (minValue.HasValue
|| maxValue.HasValue)
{
Debug.Assert(IsNumericType(facetType), "Min and Max Values can only be specified for numeric facets");
if (minValue.HasValue
&& maxValue.HasValue)
{
Debug.Assert(minValue != maxValue, "minValue should not be equal to maxValue");
}
}
_facetName = facetName;
_facetType = facetType;
_minValue = minValue;
_maxValue = maxValue;
_defaultValue = defaultValue;
}
internal FacetDescription(
string facetName,
EdmType facetType,
int? minValue,
int? maxValue,
object defaultValue,
bool isConstant,
string declaringTypeName)
{
_facetName = facetName;
_facetType = facetType;
_minValue = minValue;
_maxValue = maxValue;
// this ctor doesn't allow you to set the defaultValue to null
if (defaultValue != null)
{
_defaultValue = defaultValue;
}
else
{
_defaultValue = _notInitializedSentinel;
}
_isConstant = isConstant;
Validate(declaringTypeName);
if (_isConstant)
{
UpdateMinMaxValueForConstant(_facetName, _facetType, ref _minValue, ref _maxValue, _defaultValue);
}
}
internal QueryRewriter(EdmType generatedType, ViewgenContext context, ViewGenMode typesGenerationMode)
{
Debug.Assert(typesGenerationMode != ViewGenMode.GenerateAllViews);
_typesGenerationMode = typesGenerationMode;
_context = context;
_generatedType = generatedType;
_domainMap = context.MemberMaps.LeftDomainMap;
_config = context.Config;
_identifiers = context.CqlIdentifiers;
_qp = new RewritingProcessor<Tile<FragmentQuery>>(new DefaultTileProcessor<FragmentQuery>(context.LeftFragmentQP));
_extentPath = new MemberPath(context.Extent);
_keyAttributes = new List<MemberPath>(MemberPath.GetKeyMembers(context.Extent, _domainMap));
// populate _fragmentQueries and _views
foreach (var leftCellWrapper in _context.AllWrappersForExtent)
{
var query = leftCellWrapper.FragmentQuery;
Tile<FragmentQuery> tile = CreateTile(query);
_fragmentQueries.Add(query);
_views.Add(tile);
}
Debug.Assert(_views.Count > 0);
AdjustMemberDomainsForUpdateViews();
// must be done after adjusting domains
_domainQuery = GetDomainQuery(FragmentQueries, generatedType);
_usedViews = new HashSet<FragmentQuery>();
}
public virtual EdmType TryCreateType(Type type, EdmType cspaceType)
{
DebugCheck.NotNull(type);
DebugCheck.NotNull(cspaceType);
Debug.Assert(cspaceType is StructuralType || Helper.IsEnumType(cspaceType), "Structural or enum type expected");
// if one of the types is an enum while the other is not there is no match
if (Helper.IsEnumType(cspaceType)
^ type.IsEnum())
{
LogLoadMessage(
Strings.Validator_OSpace_Convention_SSpaceOSpaceTypeMismatch(cspaceType.FullName, cspaceType.FullName),
cspaceType);
return null;
}
EdmType newOSpaceType;
if (Helper.IsEnumType(cspaceType))
{
TryCreateEnumType(type, (EnumType)cspaceType, out newOSpaceType);
return newOSpaceType;
}
Debug.Assert(cspaceType is StructuralType);
TryCreateStructuralType(type, (StructuralType)cspaceType, out newOSpaceType);
return newOSpaceType;
}
public override void LogError(string errorMessage, EdmType relatedType)
{
var message = _loader.SessionData.LoadMessageLogger
.CreateErrorMessageWithTypeSpecificLoadLogs(errorMessage, relatedType);
_loader.SessionData.EdmItemErrors.Add(new EdmItemError(message));
}
public static string GetTenantColumnName(EdmType type)
{
MetadataProperty annotation =
type.MetadataProperties.SingleOrDefault(
p => p.Name.EndsWith(string.Format("customannotation:{0}", TenantAnnotation)));
return annotation == null ? null : (string)annotation.Value;
}
/// <summary>
/// Gets the type identifier for the specified type.
/// </summary>
/// <param name="edmType">The type.</param>
/// <returns>The identifier.</returns>
public string Type(EdmType edmType)
{
if (edmType == null)
{
throw new ArgumentNullException("edmType");
}
return Identifier(edmType.Name);
}
public ParameterDescriptor(string name, EdmType edmType, bool isOutParam)
{
Debug.Assert(name != null, "name is null");
Debug.Assert(edmType != null, "edmType is null");
_name = name;
_edmType = edmType;
_isOutParam = isOutParam;
}
internal bool TryGetNamespace(EdmType item, out EdmNamespace itemNamespace)
{
if (item != null)
{
return itemToNamespaceMap.TryGetValue(item, out itemNamespace);
}
itemNamespace = null;
return false;
}
/// <summary>
/// Creates generated view object for the combination of the <paramref name="extent" /> and the <paramref name="type" />.
/// This constructor is used for FK association sets only.
/// </summary>
internal static GeneratedView CreateGeneratedViewForFKAssociationSet(
EntitySetBase extent,
EdmType type,
DbQueryCommandTree commandTree,
StorageMappingItemCollection mappingItemCollection,
ConfigViewGenerator config)
{
return new GeneratedView(extent, type, commandTree, null, null, mappingItemCollection, config);
}
internal void LogLoadMessage(string message, EdmType relatedType)
{
if (_logLoadMessage != null)
{
_logLoadMessage(message);
}
LogMessagesWithTypeInfo(message, relatedType);
}
/// <summary>
/// A default mapping (property "Foo" maps by convention to column "Foo"), if allowed, has the lowest precedence.
/// A mapping for a specific type (EntityType="Bar") takes precedence over a mapping for a hierarchy (EntityType="IsTypeOf(Bar)"))
/// If there are two hierarchy mappings, the most specific mapping takes precedence.
/// For instance, given the types Base, Derived1 : Base, and Derived2 : Derived1,
/// w.r.t. Derived1 "IsTypeOf(Derived1)" takes precedence over "IsTypeOf(Base)" when you ask for the rename of Derived1
/// </summary>
/// <param name="lineInfo">Empty for default rename mapping.</param>
internal string GetRename(EdmType type, out IXmlLineInfo lineInfo)
{
Contract.Requires(type != null);
Debug.Assert(type is StructuralType, "we can only rename structural type");
var rename = _renameCache.Evaluate(type as StructuralType);
lineInfo = rename.LineInfo;
return rename.ColumnName;
}
/// <summary>
/// A default mapping (property "Foo" maps by convention to column "Foo"), if allowed, has the lowest precedence.
/// A mapping for a specific type (EntityType="Bar") takes precedence over a mapping for a hierarchy (EntityType="IsTypeOf(Bar)"))
/// If there are two hierarchy mappings, the most specific mapping takes precedence.
/// For instance, given the types Base, Derived1 : Base, and Derived2 : Derived1,
/// w.r.t. Derived1 "IsTypeOf(Derived1)" takes precedence over "IsTypeOf(Base)" when you ask for the rename of Derived1
/// </summary>
/// <param name="lineInfo"> Empty for default rename mapping. </param>
internal string GetRename(EdmType type, out IXmlLineInfo lineInfo)
{
DebugCheck.NotNull(type);
Debug.Assert(type is StructuralType, "we can only rename structural type");
var rename = _renameCache.Evaluate(type as StructuralType);
lineInfo = rename.LineInfo;
return rename.ColumnName;
}
private bool TryCreateStructuralType(Type type, StructuralType cspaceType, out EdmType newOSpaceType)
{
DebugCheck.NotNull(type);
DebugCheck.NotNull(cspaceType);
var referenceResolutionListForCurrentType = new List<Action>();
newOSpaceType = null;
StructuralType ospaceType;
if (Helper.IsEntityType(cspaceType))
{
ospaceType = new ClrEntityType(type, cspaceType.NamespaceName, cspaceType.Name);
}
else
{
Debug.Assert(Helper.IsComplexType(cspaceType), "Invalid type attribute encountered");
ospaceType = new ClrComplexType(type, cspaceType.NamespaceName, cspaceType.Name);
}
if (cspaceType.BaseType != null)
{
if (TypesMatchByConvention(type.BaseType(), cspaceType.BaseType))
{
TrackClosure(type.BaseType());
referenceResolutionListForCurrentType.Add(
() => ospaceType.BaseType = ResolveBaseType((StructuralType)cspaceType.BaseType, type));
}
else
{
var message = Strings.Validator_OSpace_Convention_BaseTypeIncompatible(
type.BaseType().FullName, type.FullName, cspaceType.BaseType.FullName);
LogLoadMessage(message, cspaceType);
return false;
}
}
// Load the properties for this type
if (!TryCreateMembers(type, cspaceType, ospaceType, referenceResolutionListForCurrentType))
{
return false;
}
// Add this to the known type map so we won't try to load it again
LoadedTypes.Add(type.FullName, ospaceType);
// we only add the referenceResolution to the list unless we structrually matched this type
foreach (var referenceResolution in referenceResolutionListForCurrentType)
{
ReferenceResolutions.Add(referenceResolution);
}
newOSpaceType = ospaceType;
return true;
}
private static EdmProperty CreateProperty(string name, EdmType edmType)
{
DebugCheck.NotEmpty(name);
DebugCheck.NotNull(edmType);
var typeUsage = TypeUsage.Create(edmType, new FacetValues());
var property = new EdmProperty(name, typeUsage);
return property;
}
/// <summary>
/// Check to see if the type is already loaded - either in the typesInLoading, or ObjectItemCollection or
/// in the global cache
/// </summary>
/// <param name="clrType"> </param>
/// <param name="edmType"> </param>
/// <returns> </returns>
private bool TryGetLoadedType(Type clrType, out EdmType edmType)
{
if (SessionData.TypesInLoading.TryGetValue(clrType.FullName, out edmType)
||
TryGetCachedEdmType(clrType, out edmType))
{
// Check to make sure the CLR type we got is the same as the given one
if (edmType.ClrType != clrType)
{
SessionData.EdmItemErrors.Add(
new EdmItemError(
Strings.NewTypeConflictsWithExistingType(
clrType.AssemblyQualifiedName, edmType.ClrType.AssemblyQualifiedName)));
edmType = null;
return false;
}
return true;
}
// Let's check to see if this type is a ref type, a nullable type, or a collection type, these are the types that
// we need to take special care of them
if (clrType.IsGenericType)
{
var genericType = clrType.GetGenericTypeDefinition();
// Try to resolve the element type into a type object
EdmType elementType;
if (!TryGetLoadedType(clrType.GetGenericArguments()[0], out elementType))
{
return false;
}
if (typeof(IEnumerable).IsAssignableFrom(clrType))
{
var entityType = elementType as EntityType;
if (entityType == null)
{
// return null and let the caller deal with the error handling
return false;
}
edmType = entityType.GetCollectionType();
}
else
{
edmType = elementType;
}
return true;
}
edmType = null;
return false;
}
public static string GetSoftDeleteColumnName(EdmType type)
{
// TODO Find the soft delete annotation and get the property name
// Name of annotation will be something like:
// http://schemas.microsoft.com/ado/2013/11/edm/customannotation:SoftDeleteColumnName
MetadataProperty annotation = type.MetadataProperties
.Where(p => p.Name.EndsWith("customannotation:SoftDeleteColumnName"))
.SingleOrDefault();
return annotation == null ? null : (string)annotation.Value;
}
public string GetQualifiedPrefix(EdmType item)
{
Debug.Assert(ModelParentMap != null);
string qualifiedPrefix = null;
EdmNamespace parentNamespace;
if (ModelParentMap.TryGetNamespace(item, out parentNamespace))
{
qualifiedPrefix = parentNamespace.Name;
}
return qualifiedPrefix;
}
internal bool TryGetEdmType(string typeName, out EdmType edmType)
{
edmType = null;
foreach (var loadedEdmType in TypesInAssembly)
{
if (loadedEdmType.Identity == typeName)
{
edmType = loadedEdmType;
break;
}
}
return (edmType != null);
}
internal static List<EdmType> GetTypeHierarchy(EdmType edmType)
{
Debug.Assert(edmType != null, "edmType is null");
Debug.Assert(edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType, "entity type expected");
var types = new List<EdmType> {edmType};
while (edmType.BaseType != null)
{
edmType = edmType.BaseType;
types.Add(edmType);
}
return types;
}
private void LogMessagesWithTypeInfo(string message, EdmType relatedType)
{
DebugCheck.NotNull(relatedType);
if (_messages.ContainsKey(relatedType))
{
// if this type already contains loading message, append the new message to the end
_messages[relatedType].AppendLine(message);
}
else
{
_messages.Add(relatedType, new StringBuilder(message));
}
}
private void LogMessagesWithTypeInfo(string message, EdmType relatedType)
{
Debug.Assert(relatedType != null, "have to have a type with this message");
if (_messages.ContainsKey(relatedType))
{
// if this type already contains loading message, append the new message to the end
_messages[relatedType].AppendLine(message);
}
else
{
_messages.Add(relatedType, new StringBuilder(message));
}
}
/// <summary>
/// Returns all the FacetDescriptions for a particular type
/// </summary>
/// <param name="type"> the type to return FacetDescriptions for. </param>
/// <returns> The FacetDescriptions for the type given. </returns>
public override ReadOnlyCollection<FacetDescription> GetFacetDescriptions(EdmType type)
{
Debug.Assert(type is PrimitiveType, "EdmProviderManifest.GetFacetDescriptions(): Argument is not a PrimitiveType");
InitializeFacetDescriptions();
// Some types may not have facets, so just try to get them, if there aren't any, just return an empty list
ReadOnlyCollection<FacetDescription> collection = null;
if (_facetDescriptions.TryGetValue(type as PrimitiveType, out collection))
{
return collection;
}
return Helper.EmptyFacetDescriptionEnumerable;
}
public FunctionDescriptor(string name, IEnumerable<ParameterDescriptor> parameters,
EdmType[] returnTypes, string resultColumnName, string databaseSchema, StoreFunctionKind storeFunctionKind)
{
Debug.Assert(!string.IsNullOrWhiteSpace(name), "invalid name");
Debug.Assert(parameters != null, "parameters is null");
Debug.Assert(parameters.All(p => p.EdmType != null), "invalid parameter type");
Debug.Assert(returnTypes != null && returnTypes.Length > 0, "returnTypes array is null or empty");
Debug.Assert(storeFunctionKind == StoreFunctionKind.StoredProcedure|| returnTypes.Length == 1, "multiple return types for non-sproc");
_name = name;
_returnTypes = returnTypes;
_parameters = parameters.ToArray();
_resultColumnName = resultColumnName;
_databaseSchema = databaseSchema;
_storeFunctionKind = storeFunctionKind;
}
private string GetTypeRelatedLogMessage(EdmType relatedType)
{
Debug.Assert(relatedType != null, "have to pass in a type to get the message");
if (_messages.ContainsKey(relatedType))
{
return new StringBuilder()
.AppendLine()
.AppendLine(Strings.ExtraInfo)
.AppendLine(_messages[relatedType].ToString()).ToString();
}
else
{
return string.Empty;
}
}
// <summary>
// The constructor for MetadataProperty taking in all the ingredients for creating TypeUsage and the actual value
// </summary>
// <param name="name"> The name of the attribute </param>
// <param name="edmType"> The edm type of the attribute </param>
// <param name="isCollectionType"> Whether the collection type of the given edm type should be used </param>
// <param name="value"> The value of the attribute </param>
internal MetadataProperty(string name, EdmType edmType, bool isCollectionType, object value)
{
DebugCheck.NotNull(edmType);
_name = name;
_value = value;
if (isCollectionType)
{
_typeUsage = TypeUsage.Create(edmType.GetCollectionType());
}
else
{
_typeUsage = TypeUsage.Create(edmType);
}
_propertyKind = PropertyKind.System;
}
/// <summary>
/// Construct a new ObjectTypeMapping object
/// </summary>
/// <param name="clrType"></param>
/// <param name="cdmType"></param>
internal ObjectTypeMapping(EdmType clrType, EdmType cdmType)
{
Debug.Assert(clrType.BuiltInTypeKind == cdmType.BuiltInTypeKind, "BuiltInTypeKind must be the same for both types");
m_clrType = clrType;
m_cdmType = cdmType;
identity = clrType.Identity + ObjectMslConstructs.IdentitySeperator + cdmType.Identity;
if (Helper.IsStructuralType(cdmType))
{
m_memberMapping = new Dictionary<string, ObjectMemberMapping>(((StructuralType)cdmType).Members.Count);
}
else
{
m_memberMapping = EmptyMemberMapping;
}
}
// <summary>
// Tries to lookup custom discriminator map for the given type (applies to EntitySets with
// TPH discrimination pattern)
// </summary>
private bool TryGetDiscriminatorMap(md.EdmType type, out ExplicitDiscriminatorMap discriminatorMap)
{
discriminatorMap = null;
// check that there are actually discriminator maps available
if (null == m_discriminatorMaps)
{
return(false);
}
// must be an entity type...
if (type.BuiltInTypeKind
!= md.BuiltInTypeKind.EntityType)
{
return(false);
}
// get root entity type (discriminator maps are mapped from the root)
var rootEntityType = GetRootType((md.EntityType)type);
// find entity set
md.EntitySet entitySet;
if (!m_entityTypeToEntitySetMap.TryGetValue(rootEntityType, out entitySet))
{
return(false);
}
// free floating entity constructors are stored with a null EntitySet
if (entitySet == null)
{
return(false);
}
// look for discriminator map
return(m_discriminatorMaps.TryGetValue(entitySet, out discriminatorMap));
}
internal static bool IsComplexType(EdmType type)
{
return(BuiltInTypeKind.ComplexType == type.BuiltInTypeKind);
}
internal static bool IsEntityType(EdmType type)
{
return(BuiltInTypeKind.EntityType == type.BuiltInTypeKind);
}
// <summary>
// Factory method for creating a TypeUsage with specified EdmType
// </summary>
// <param name="edmType"> EdmType for which to create a type usage </param>
// <returns> new TypeUsage instance with default facet values </returns>
internal static TypeUsage Create(EdmType edmType)
{
return(new TypeUsage(edmType));
}
internal static bool IsPrimitiveType(EdmType type)
{
return(BuiltInTypeKind.PrimitiveType == type.BuiltInTypeKind);
}
private static void AddScalarMember(
Type type, PropertyInfo clrProperty, StructuralType ospaceType, EdmProperty cspaceProperty, EdmType propertyType)
{
DebugCheck.NotNull(type);
DebugCheck.NotNull(clrProperty);
Debug.Assert(clrProperty.CanRead && clrProperty.CanWriteExtended(), "The clr property has to have a setter and a getter.");
DebugCheck.NotNull(ospaceType);
DebugCheck.NotNull(cspaceProperty);
DebugCheck.NotNull(propertyType);
Debug.Assert(Helper.IsScalarType(propertyType), "Property has to be primitive or enum.");
var cspaceType = cspaceProperty.DeclaringType;
var isKeyMember = Helper.IsEntityType(cspaceType) && ((EntityType)cspaceType).KeyMemberNames.Contains(clrProperty.Name);
// the property is nullable only if it is not a key and can actually be set to null (i.e. is not a value type or is a nullable value type)
var nullableFacetValue = !isKeyMember
&&
(!clrProperty.PropertyType.IsValueType() || Nullable.GetUnderlyingType(clrProperty.PropertyType) != null);
var ospaceProperty =
new EdmProperty(
cspaceProperty.Name,
TypeUsage.Create(
propertyType, new FacetValues
{
Nullable = nullableFacetValue
}),
clrProperty,
type);
if (isKeyMember)
{
((EntityType)ospaceType).AddKeyMember(ospaceProperty);
}
else
{
ospaceType.AddMember(ospaceProperty);
}
}
private void CreateAndAddNavigationProperty(
StructuralType cspaceType, StructuralType ospaceType, NavigationProperty cspaceProperty)
{
EdmType ospaceRelationship;
if (CspaceToOspace.TryGetValue(cspaceProperty.RelationshipType, out ospaceRelationship))
{
Debug.Assert(ospaceRelationship is StructuralType, "Structural type expected.");
var foundTarget = false;
EdmType targetType = null;
if (Helper.IsCollectionType(cspaceProperty.TypeUsage.EdmType))
{
EdmType findType;
foundTarget =
CspaceToOspace.TryGetValue(
((CollectionType)cspaceProperty.TypeUsage.EdmType).TypeUsage.EdmType, out findType);
if (foundTarget)
{
Debug.Assert(findType is StructuralType, "Structural type expected.");
targetType = findType.GetCollectionType();
}
}
else
{
EdmType findType;
foundTarget = CspaceToOspace.TryGetValue(cspaceProperty.TypeUsage.EdmType, out findType);
if (foundTarget)
{
Debug.Assert(findType is StructuralType, "Structural type expected.");
targetType = findType;
}
}
Debug.Assert(
foundTarget,
"Since the relationship will only be created if it can find the types for both ends, we will never fail to find one of the ends");
var navigationProperty = new NavigationProperty(cspaceProperty.Name, TypeUsage.Create(targetType));
var relationshipType = (RelationshipType)ospaceRelationship;
navigationProperty.RelationshipType = relationshipType;
// we can use First because o-space relationships are created directly from
// c-space relationship
navigationProperty.ToEndMember =
(RelationshipEndMember)relationshipType.Members.First(e => e.Name == cspaceProperty.ToEndMember.Name);
navigationProperty.FromEndMember =
(RelationshipEndMember)relationshipType.Members.First(e => e.Name == cspaceProperty.FromEndMember.Name);
ospaceType.AddMember(navigationProperty);
}
else
{
var missingType =
cspaceProperty.RelationshipType.RelationshipEndMembers.Select(e => ((RefType)e.TypeUsage.EdmType).ElementType).First(
e => e != cspaceType);
LogError(
Strings.Validator_OSpace_Convention_RelationshipNotLoaded(
cspaceProperty.RelationshipType.FullName, missingType.FullName),
missingType);
}
}
private MetadataPropertyAttribute(EdmType type, bool isCollectionType)
{
this._type = type;
this._isCollectionType = isCollectionType;
}
/// <summary>
/// Check if this type is assignable from otherType
/// </summary>
/// <param name="otherType"> </param>
/// <returns> </returns>
internal virtual bool IsAssignableFrom(EdmType otherType)
{
return(Helper.IsAssignableFrom(this, otherType));
}
internal static bool IsEnumType(EdmType edmType)
{
DebugCheck.NotNull(edmType);
return(BuiltInTypeKind.EnumType == edmType.BuiltInTypeKind);
}
/// <summary>
/// check to see if otherType is among the base types,
/// </summary>
/// <param name="otherType"> </param>
/// <returns> if otherType is among the base types, return true, otherwise returns false. when othertype is same as the current type, return false. </returns>
internal virtual bool IsSubtypeOf(EdmType otherType)
{
return(Helper.IsSubtypeOf(this, otherType));
}
internal static bool IsScalarType(EdmType edmType)
{
return(IsEnumType(edmType) || IsPrimitiveType(edmType));
}
/// <summary>
/// Load metadata of the given type - when you call this method, you should check and make sure that the type has
/// edm attribute. If it doesn't,we won't load the type and it will be returned as null
/// </summary>
/// <param name="clrType"> </param>
/// <param name="context"> </param>
/// <returns> </returns>
private void LoadType(Type clrType)
{
Debug.Assert(clrType.Assembly == SourceAssembly, "Why are we loading a type that is not in our assembly?");
Debug.Assert(!SessionData.TypesInLoading.ContainsKey(clrType.FullName), "Trying to load a type that is already loaded???");
Debug.Assert(!clrType.IsGenericType, "Generic type is not supported");
EdmType edmType = null;
var typeAttributes = (EdmTypeAttribute[])clrType.GetCustomAttributes(typeof(EdmTypeAttribute), false /*inherit*/);
// the CLR doesn't allow types to have duplicate/multiple attribute declarations
if (typeAttributes.Length != 0)
{
if (clrType.IsNested)
{
SessionData.EdmItemErrors.Add(
new EdmItemError(Strings.NestedClassNotSupported(clrType.FullName, clrType.Assembly.FullName)));
return;
}
var typeAttribute = typeAttributes[0];
var cspaceTypeName = String.IsNullOrEmpty(typeAttribute.Name) ? clrType.Name : typeAttribute.Name;
if (String.IsNullOrEmpty(typeAttribute.NamespaceName) &&
clrType.Namespace == null)
{
SessionData.EdmItemErrors.Add(new EdmItemError(Strings.Validator_TypeHasNoNamespace));
return;
}
var cspaceNamespaceName = String.IsNullOrEmpty(typeAttribute.NamespaceName)
? clrType.Namespace
: typeAttribute.NamespaceName;
if (typeAttribute.GetType()
== typeof(EdmEntityTypeAttribute))
{
edmType = new ClrEntityType(clrType, cspaceNamespaceName, cspaceTypeName);
}
else if (typeAttribute.GetType()
== typeof(EdmComplexTypeAttribute))
{
edmType = new ClrComplexType(clrType, cspaceNamespaceName, cspaceTypeName);
}
else
{
Debug.Assert(typeAttribute is EdmEnumTypeAttribute, "Invalid type attribute encountered");
// Note that TryGetPrimitiveType() will return false not only for types that are not primitive
// but also for CLR primitive types that are valid underlying enum types in CLR but are not
// a valid Edm primitive types (e.g. ulong)
PrimitiveType underlyingEnumType;
if (!ClrProviderManifest.Instance.TryGetPrimitiveType(clrType.GetEnumUnderlyingType(), out underlyingEnumType))
{
SessionData.EdmItemErrors.Add(
new EdmItemError(
Strings.Validator_UnsupportedEnumUnderlyingType(clrType.GetEnumUnderlyingType().FullName)));
return;
}
edmType = new ClrEnumType(clrType, cspaceNamespaceName, cspaceTypeName);
}
}
else
{
// not a type we are interested
return;
}
Debug.Assert(
!CacheEntry.ContainsType(edmType.Identity), "This type must not be already present in the list of types for this assembly");
// Also add this to the list of the types for this assembly
CacheEntry.TypesInAssembly.Add(edmType);
// Add this to the known type map so we won't try to load it again
SessionData.TypesInLoading.Add(clrType.FullName, edmType);
// Load properties for structural type
if (Helper.IsStructuralType(edmType))
{
//Load base type only for entity type - not sure if we will allow complex type inheritance
if (Helper.IsEntityType(edmType))
{
TrackClosure(clrType.BaseType);
AddTypeResolver(
() => edmType.BaseType = ResolveBaseType(clrType.BaseType));
}
// Load the properties for this type
LoadPropertiesFromType((StructuralType)edmType);
}
return;
}
/// <summary>
/// Creates a <see cref="T:System.Data.Entity.Core.Metadata.Edm.TypeUsage" /> object with the specified conceptual model type.
/// </summary>
/// <returns>
/// A <see cref="T:System.Data.Entity.Core.Metadata.Edm.TypeUsage" /> object with the default facet values for the specified
/// <see
/// cref="T:System.Data.Entity.Core.Metadata.Edm.EdmType" />
/// .
/// </returns>
/// <param name="edmType">
/// A <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmType" /> for which the
/// <see
/// cref="T:System.Data.Entity.Core.Metadata.Edm.TypeUsage" />
/// object is created.
/// </param>
public static TypeUsage CreateDefaultTypeUsage(EdmType edmType)
{
Check.NotNull(edmType, "edmType");
return(Create(edmType));
}
public override void LogError(string errorMessage, EdmType relatedType)
{
// This is unlikely to happen since CLR types were explicitly configured by Code First
throw new MetadataException(Strings.InvalidSchemaEncountered(errorMessage));
}
public abstract void AddToTypesInAssembly(EdmType type);
internal static bool IsStructuralType(EdmType type)
{
return(IsComplexType(type) || IsEntityType(type) || IsRelationshipType(type) || IsRowType(type));
}
public override void AddToTypesInAssembly(EdmType type)
{
// No need to collect types in assembly when using Code First
}
public override void LogLoadMessage(string message, EdmType relatedType)
{
// No message logging for Code First
}
internal static bool IsEntityTypeBase(EdmType edmType)
{
return(IsEntityType(edmType) ||
IsRelationshipType(edmType));
}
internal static bool TypesMatchByConvention(Type type, EdmType cspaceType)
{
return(type.Name == cspaceType.Name);
}
internal static bool IsRelationshipType(EdmType type)
{
return(BuiltInTypeKind.AssociationType == type.BuiltInTypeKind);
}
public abstract void LogLoadMessage(string message, EdmType relatedType);
private static IEnumerable <Facet> GetDefaultFacetDescriptionsAndOverrideFacetValues(EdmType type, FacetValues values)
{
return(OverrideFacetValues(
type.GetAssociatedFacetDescriptions(),
fd => fd,
fd => fd.DefaultValueFacet,
values));
}
/// <summary>
/// Factory method for creating a TypeUsage with specified EdmType and facets
/// </summary>
/// <param name="edmType"> EdmType for which to create a type usage </param>
/// <param name="facets"> facets to be copied into the new TypeUsage </param>
/// <returns> new TypeUsage instance </returns>
public static TypeUsage Create(EdmType edmType, IEnumerable <Facet> facets)
{
return(new TypeUsage(edmType, facets));
}
/// <summary>
/// Returns the full name of the type described by this <see cref="T:System.Data.Entity.Core.Metadata.Edm.TypeUsage" />.
/// </summary>
/// <returns>
/// The full name of the type described by this <see cref="T:System.Data.Entity.Core.Metadata.Edm.TypeUsage" /> as string.
/// </returns>
public override string ToString()
{
// Note that ToString is actually used to get the full name of the type, so changing the value returned here
// will break code.
return(EdmType.ToString());
}
internal static bool IsTransientType(EdmType edmType)
{
return(IsCollectionType(edmType) ||
IsRefType(edmType) ||
IsRowType(edmType));
}
public abstract void LogError(string errorMessage, EdmType relatedType);
internal CollectionType(EdmType elementType)
: this(TypeUsage.Create(elementType))
{
this.DataSpace = elementType.DataSpace;
}
// <summary>
// Factory method for creating a TypeUsage with specified EdmType
// </summary>
// <param name="edmType"> EdmType for which to create a type usage </param>
// <returns> new TypeUsage instance with default facet values </returns>
internal static TypeUsage Create(EdmType edmType, FacetValues values)
{
return(new TypeUsage(
edmType,
GetDefaultFacetDescriptionsAndOverrideFacetValues(edmType, values)));
}
