/// <summary>
/// Initializes a new command tree with a given metadata workspace.
/// </summary>
/// <param name="metadata">The metadata workspace against which the command tree should operate.</param>
/// <param name="dataSpace">The logical 'space' that metadata in the expressions used in this command tree must belong to.</param>
internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace)
{
// Ensure the metadata workspace is non-null
//Contract.Requires(metadata != null);
// Ensure that the data space value is valid
if (!IsValidDataSpace(dataSpace))
{
throw new ArgumentException(Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace");
}
//
// Create the tree's metadata workspace and initalize commonly used types.
//
var effectiveMetadata = new MetadataWorkspace();
//While EdmItemCollection and StorageitemCollections are required
//ObjectItemCollection may or may not be registered on the workspace yet.
//So register the ObjectItemCollection if it exists.
ItemCollection objectItemCollection;
if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection))
{
effectiveMetadata.RegisterItemCollection(objectItemCollection);
}
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace));
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace));
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace));
_metadata = effectiveMetadata;
_dataSpace = dataSpace;
}
/// <summary>
/// Initializes a new command tree with a given metadata workspace.
/// </summary>
/// <param name="metadata">The metadata workspace against which the command tree should operate.</param>
/// <param name="dataSpace">The logical 'space' that metadata in the expressions used in this command tree must belong to.</param>
internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace)
{
// Ensure the metadata workspace is non-null
EntityUtil.CheckArgumentNull(metadata, "metadata");
// Ensure that the data space value is valid
if (!DbCommandTree.IsValidDataSpace(dataSpace))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace");
}
//
// Create the tree's metadata workspace and initalize commonly used types.
//
MetadataWorkspace effectiveMetadata = new MetadataWorkspace();
//While EdmItemCollection and StorageitemCollections are required
//ObjectItemCollection may or may not be registered on the workspace yet.
//So register the ObjectItemCollection if it exists.
ItemCollection objectItemCollection;
if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection))
{
effectiveMetadata.RegisterItemCollection(objectItemCollection);
}
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace));
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace));
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace));
this._metadata = effectiveMetadata;
this._dataSpace = dataSpace;
}
public void GetItemCollection_on_both_CS_and_S_space_using_item_collections_with_inconsistent_versions_throws_MetadataException()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(_ssdlV3).CreateReader() });
var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection);
// edmItemCollection and storeItemCollection must have the same version to generate storageMappingItemCollection
// here we override the storeItemCollection so that it's version will be different for the MetadataWorkspace
storeItemCollection =
new StoreItemCollection(
new[]
{
XDocument.Parse(string.Format(CultureInfo.InvariantCulture, SsdlTemplate, XmlConstants.TargetNamespace_2))
.CreateReader()
});
var workspace = new MetadataWorkspace(
() => null,
() => storeItemCollection,
() => storageMappingItemCollection);
workspace.GetItemCollection(DataSpace.SSpace); // this sets up the MetadataWorkspace's expected schema version as the ssdl version i.e. 2.0
Assert.Equal(
Resources.Strings.DifferentSchemaVersionInCollection("StorageMappingItemCollection", 3.0, 2.0),
Assert.Throws <MetadataException>(() => workspace.GetItemCollection(DataSpace.CSSpace)).Message);
}
/// <summary>
/// Initializes a new command tree with a given metadata workspace.
/// </summary>
/// <param name="metadata">The metadata workspace against which the command tree should operate.</param>
/// <param name="dataSpace">The logical 'space' that metadata in the expressions used in this command tree must belong to.</param>
internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace)
{
// Ensure the metadata workspace is non-null
EntityUtil.CheckArgumentNull(metadata, "metadata");
// Ensure that the data space value is valid
if (!DbCommandTree.IsValidDataSpace(dataSpace))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace");
}
//
// Create the tree's metadata workspace and initalize commonly used types.
//
MetadataWorkspace effectiveMetadata = new MetadataWorkspace();
//While EdmItemCollection and StorageitemCollections are required
//ObjectItemCollection may or may not be registered on the workspace yet.
//So register the ObjectItemCollection if it exists.
ItemCollection objectItemCollection;
if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection))
{
effectiveMetadata.RegisterItemCollection(objectItemCollection);
}
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace));
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace));
effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace));
this._metadata = effectiveMetadata;
this._dataSpace = dataSpace;
}
/// <summary>
/// Generates metadata for given item collection.
/// Fetches CLR models from given assembly.
/// </summary>
/// <param name="metadataWorkspace">The metadata workspace.</param>
/// <param name="modelAssembly">The model assembly.</param>
/// <param name="connectionString">The connection string.</param>
/// <returns></returns>
public static Metadata Generate(MetadataWorkspace metadataWorkspace, Assembly modelAssembly, string connectionString) {
metadataWorkspace.RegisterItemCollection(new ObjectItemCollection());
metadataWorkspace.LoadFromAssembly(modelAssembly);
var itemCollection = metadataWorkspace.GetItemCollection(DataSpace.CSpace);
var objectItemCollection = (ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace);
return Generate(metadataWorkspace, itemCollection, objectItemCollection, modelAssembly, connectionString);
}
// <summary>
// Updates the cache of types to entity sets either for the first time or after potentially
// doing some o-space loading.
// </summary>
private void UpdateEntitySetMappings()
{
var objectItemCollection = (ObjectItemCollection)_workspace.GetItemCollection(DataSpace.OSpace);
var ospaceTypes = _workspace.GetItems <EntityType>(DataSpace.OSpace);
var inverseHierarchy = new Stack <EntityType>();
foreach (var ospaceType in ospaceTypes)
{
inverseHierarchy.Clear();
var cspaceType = (EntityType)_workspace.GetEdmSpaceType(ospaceType);
do
{
inverseHierarchy.Push(cspaceType);
cspaceType = (EntityType)cspaceType.BaseType;
}while (cspaceType != null);
EntitySet entitySet = null;
while (entitySet == null &&
inverseHierarchy.Count > 0)
{
cspaceType = inverseHierarchy.Pop();
foreach (var container in _workspace.GetItems <EntityContainer>(DataSpace.CSpace))
{
var entitySets = container.BaseEntitySets.Where(s => s.ElementType == cspaceType).ToList();
var entitySetsCount = entitySets.Count;
if (entitySetsCount > 1 ||
entitySetsCount == 1 && entitySet != null)
{
throw Error.DbContext_MESTNotSupported();
}
if (entitySetsCount == 1)
{
entitySet = (EntitySet)entitySets[0];
}
}
}
// Entity set may be null if the o-space type is a base type that is in the model but is
// not part of any set. For most practical purposes, this type is not in the model since
// there is no way to query etc. for objects of this type.
if (entitySet != null)
{
var ospaceBaseType = (EntityType)_workspace.GetObjectSpaceType(cspaceType);
var clrType = objectItemCollection.GetClrType(ospaceType);
var clrBaseType = objectItemCollection.GetClrType(ospaceBaseType);
_entitySetMappingsCache[clrType] = new EntitySetTypePair(entitySet, clrBaseType);
}
}
}
internal static Type GetClrTypeFromCSpaceType(this MetadataWorkspace workspace, EdmType conceptualType)
{
var itemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
if (conceptualType is StructuralType)
{
var objectSpaceType = workspace.GetObjectSpaceType((StructuralType)conceptualType);
return(itemCollection.GetClrType(objectSpaceType));
}
else if (conceptualType is EnumType)
{
var objectSpaceType = workspace.GetObjectSpaceType((EnumType)conceptualType);
return(itemCollection.GetClrType(objectSpaceType));
}
else if (conceptualType is PrimitiveType)
{
return(((PrimitiveType)conceptualType).ClrEquivalentType);
}
else if (conceptualType is CollectionType)
{
return(workspace.GetClrTypeFromCSpaceType(((CollectionType)conceptualType).TypeUsage.EdmType));
}
else if (conceptualType is RefType)
{
return(workspace.GetClrTypeFromCSpaceType(((RefType)conceptualType).ElementType));
}
else if (conceptualType is EdmFunction)
{
return(workspace.GetClrTypeFromCSpaceType(((EdmFunction)conceptualType).ReturnParameter.TypeUsage.EdmType));
}
return(null);
}
/// <summary>
/// this method do the following check on the generated views in the EntityViewContainer,
/// then add those views all at once to the dictionary
/// 1. there should be one storeageEntityContainerMapping that has the same h
/// C side and S side names as the EnittyViewcontainer
/// 2. Generate the hash for the storageEntityContainerMapping in the MM closure,
/// and this hash should be the same in EntityViewContainer
/// 3. Generate the hash for all of the view text in the EntityViewContainer and
/// this hash should be the same as the stored on in the EntityViewContainer
/// </summary>
/// <param name="entityViewContainer"></param>
private void SerializedAddGeneratedViewsInEntityViewContainer(MetadataWorkspace workspace, EntityViewContainer entityViewContainer, Dictionary <EntitySetBase, GeneratedView> extentMappingViews)
{
StorageEntityContainerMapping storageEntityContainerMapping;
// first check
if (!this.TryGetCorrespondingStorageEntityContainerMapping(entityViewContainer,
workspace.GetItemCollection(DataSpace.CSSpace).GetItems <StorageEntityContainerMapping>(), out storageEntityContainerMapping))
{
return;
}
// second check
if (!this.SerializedVerifyHashOverMmClosure(storageEntityContainerMapping, entityViewContainer))
{
throw new MappingException(Strings.ViewGen_HashOnMappingClosure_Not_Matching(entityViewContainer.EdmEntityContainerName));
}
// third check, prior to the check, we collect all the views in the entity view container to the dictionary
// if the views are changed then we will throw exception out
if (this.VerifyViewsHaveNotChanged(workspace, entityViewContainer))
{
this.SerializedAddGeneratedViews(workspace, entityViewContainer, extentMappingViews);
}
else
{
throw new InvalidOperationException(System.Data.Entity.Strings.Generated_Views_Changed);
}
}
private bool IsComplexType(Type clrType)
{
MetadataWorkspace metadataWorkspace = this.GetObjectContextWithoutDatabaseInitialization().MetadataWorkspace;
ObjectItemCollection objectItemCollection = (ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace);
return(metadataWorkspace.GetItems <ComplexType>(DataSpace.OSpace).Any <ComplexType>((Func <ComplexType, bool>)(t => objectItemCollection.GetClrType((StructuralType)t) == clrType)));
}
internal static IEnumerable <EdmType> GetTypeAndSubtypesOf(
EdmType type,
MetadataWorkspace workspace,
bool includeAbstractTypes)
{
return(MetadataHelper.GetTypeAndSubtypesOf(type, workspace.GetItemCollection(DataSpace.CSpace), includeAbstractTypes));
}
private void ExtractTableColumnEdmMembers()
{
IEnumerable <object> entitySetMaps =
(IEnumerable <object>)_metadataWorkspace
.GetItemCollection(DataSpace.CSSpace)[0]
.GetPrivateFieldValue("EntitySetMaps");
foreach (var entitySetMap in entitySetMaps)
{
IEnumerable <object> typeMappings = (IEnumerable <object>)entitySetMap.GetPrivateFieldValue("TypeMappings");
foreach (var typeMapping in typeMappings)
{
IEnumerable <EdmType> types = (IEnumerable <EdmType>)typeMapping.GetPrivateFieldValue("Types");
foreach (EntityType type in types)
{
string identity = type.FullName;
List <EdmMember> properties = new List <EdmMember>(type.Properties);
properties.AddRange(type.NavigationProperties);
_tableColumnEdmMembers[identity] = properties;
}
}
}
}
public OeEf6EdmModelMetadataProvider(DbContext dbContext)
{
MetadataWorkspace workspace = ((IObjectContextAdapter)dbContext).ObjectContext.MetadataWorkspace;
var itemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
_entityTypes = workspace.GetItems <EntityType>(DataSpace.CSpace).ToDictionary(e => itemCollection.GetClrType(workspace.GetObjectSpaceType(e)));
}
private static EntitySet GetTable(Type type, DbContext context)
{
EntitySet table = null;
MetadataWorkspace metadata = ((IObjectContextAdapter)context).ObjectContext.MetadataWorkspace;
// Get the part of the model that contains info about the actual CLR types
ObjectItemCollection objectItemCollection = (ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace);
// Get the entity type from the model that maps to the CLR type
EntityType entityType = metadata.GetItems <EntityType>(DataSpace.OSpace)
.SingleOrDefault(e => objectItemCollection.GetClrType(e) == type);
if (entityType != null)
{
// Get the entity set that uses this entity type
EntitySet entitySet = metadata.GetItems <EntityContainer>(DataSpace.CSpace)
.SingleOrDefault()
?.EntitySets
?.SingleOrDefault(s => s.ElementType.Name == entityType.Name);
if (entitySet != null)
{
// Find the mapping between conceptual and storage model for this entity set
EntitySetMapping mapping = metadata.GetItems <EntityContainerMapping>(DataSpace.CSSpace)
.SingleOrDefault()
?.EntitySetMappings
?.SingleOrDefault(s => s.EntitySet == entitySet);
// Find the storage entity set (table) that the entity is mapped
table = mapping?.EntityTypeMappings?.SelectMany(m => m.Fragments.Select(f => f.StoreEntitySet)).Distinct().FirstOrDefault();
}
}
return(table);
}
// refs:
// * http://romiller.com/2014/04/08/ef6-1-mapping-between-types-tables/
// * http://blogs.msdn.com/b/appfabriccat/archive/2010/10/22/metadataworkspace-reference-in-wcf-services.aspx
// * http://msdn.microsoft.com/en-us/library/system.data.metadata.edm.dataspace.aspx - describes meaning of OSpace etc
// * http://stackoverflow.com/questions/22999330/mapping-from-iedmentity-to-clr
internal IList <EnumReference> FindEnumReferences(MetadataWorkspace metadataWorkspace)
{
// Get the part of the model that contains info about the actual CLR types
var objectItemCollection = ((ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace));
// OSpace = Object Space
var entities = metadataWorkspace.GetItems <EntityType>(DataSpace.OSpace);
// find and return all the references to enum types
var references = new List <EnumReference>();
foreach (var entityType in entities)
{
var mappingFragment = FindSchemaMappingFragment(metadataWorkspace, entityType);
// child types in TPH don't get mappings
if (mappingFragment == null)
{
continue;
}
references.AddRange(ProcessEdmProperties(entityType.Properties, mappingFragment, objectItemCollection));
}
return(references);
}
public void TestMetadataWorkspace()
{
var asm = Assembly.GetExecutingAssembly();
var asmType = asm.GetType();
Console.WriteLine(asmType.Name);
var workspace =
new MetadataWorkspace(
new[]
{
@".\Model\Data\DataModel.csdl",
@".\Model\Data\DataModel.ssdl",
@".\Model\Data\DataModel.msl"
}, new[] { asm });
foreach (var item in workspace.GetItemCollection(DataSpace.CSSpace))
{
Console.WriteLine(item.ToString());
}
const string assemblyQualifiedName = @"Intersoft.CISSA.DataAccessLayer";
Type anyModelType = Type.GetType(assemblyQualifiedName);
Console.WriteLine(anyModelType != null ? anyModelType.Name : "----");
if (anyModelType != null)
{
Assembly modelAssembly = Assembly.GetAssembly(anyModelType);
Console.WriteLine(modelAssembly.FullName);
}
foreach (var refAssembly in asm.GetReferencedAssemblies())
{
Console.WriteLine(refAssembly.Name);
}
}
public void Registering_c_space_causes_oc_mapping_to_also_be_registered_if_it_is_not_already_registered()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(Csdl).CreateReader() });
var workspace = new MetadataWorkspace();
#pragma warning disable 612,618
workspace.RegisterItemCollection(edmItemCollection);
#pragma warning restore 612,618
Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace));
var ocMappingCollection = (DefaultObjectMappingItemCollection)workspace.GetItemCollection(DataSpace.OCSpace);
Assert.Same(workspace.GetItemCollection(DataSpace.OSpace), ocMappingCollection.ObjectItemCollection);
Assert.Same(edmItemCollection, ocMappingCollection.EdmItemCollection);
}
internal static Type GetClrType(MetadataWorkspace ocWorkspace, EnumType edmType)
{
var oSpaceType = (EnumType)ocWorkspace.GetObjectSpaceType(edmType);
var objectItemCollection = (ObjectItemCollection)(ocWorkspace.GetItemCollection(DataSpace.OSpace));
return(objectItemCollection.GetClrType(oSpaceType));
}
internal static IDbExecutionStrategy GetExecutionStrategy(
DbConnection connection,
MetadataWorkspace metadataWorkspace)
{
StoreItemCollection itemCollection = (StoreItemCollection)metadataWorkspace.GetItemCollection(DataSpace.SSpace);
return(DbProviderServices.GetExecutionStrategy(connection, itemCollection.ProviderFactory, (string)null));
}
public void RegisterFactoryForWorkspace(MetadataWorkspace metadataWorkspace)
{
var storageMappingItemCollection = (StorageMappingItemCollection)metadataWorkspace.GetItemCollection(DataSpace.CSSpace);
storageMappingItemCollection.MappingViewCacheFactory = this;
_logger.Trace(() => $"Registered {nameof(EfMappingViewCacheFactory)} to {nameof(MetadataWorkspace)}.");
}
/// <summary>
/// Gets the <see cref="IExecutionStrategy" /> that will be used to execute methods that use the specified connection.
/// Uses MetadataWorkspace for faster lookup.
/// </summary>
/// <param name="connection">The database connection</param>
/// <returns>
/// A new instance of <see cref="ExecutionStrategyBase" />
/// </returns>
internal static IExecutionStrategy GetExecutionStrategy(
DbConnection connection,
MetadataWorkspace metadataWorkspace)
{
var storeMetadata = (StoreItemCollection)metadataWorkspace.GetItemCollection(DataSpace.SSpace);
return(GetExecutionStrategy(connection, storeMetadata.StoreProviderFactory));
}
public static Type GetTypeFromName(this MetadataWorkspace metadata, string entityName)
{
var objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace));
return(objectItemCollection
.GetItems <EntityType>()
.Select(i => objectItemCollection.GetClrType(i))
.SingleOrDefault(t => t.Name == entityName));
}
private Type GetNavigationTargetType(NavigationProperty navigationProperty)
{
MetadataWorkspace metadataWorkspace = this._internalContext.ObjectContext.MetadataWorkspace;
System.Data.Entity.Core.Metadata.Edm.EntityType entityType = navigationProperty.RelationshipType.RelationshipEndMembers.Single <RelationshipEndMember>((Func <RelationshipEndMember, bool>)(e => navigationProperty.ToEndMember.Name == e.Name)).GetEntityType();
StructuralType objectSpaceType = metadataWorkspace.GetObjectSpaceType((StructuralType)entityType);
return(((ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace)).GetClrType(objectSpaceType));
}
public static EntityType GetObjectSpaceEntityByType <T>(this MetadataWorkspace metadataWorkspace)
{
ObjectItemCollection objectItemCollection = (ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace);
EntityType entityType = objectItemCollection.GetItems <EntityType>()
.FirstOrDefault(x => objectItemCollection.GetClrType(x) == typeof(T));
return(entityType);
}
public static AssociationType ForeignKeyFor(this DbContext context, Type source, Type target)
{
MetadataWorkspace metadata = ((IObjectContextAdapter)context).ObjectContext.MetadataWorkspace;
ItemCollection objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace));
EntityType sourceItem = objectItemCollection.Where(o => o is EntityType && ((EntityType)o).GetReferenceType().ElementType.FullName == GetBaseTypeFor(source).FullName).FirstOrDefault() as EntityType;
NavigationProperty property = (sourceItem as EntityType).NavigationProperties.Where(p => ((p.ToEndMember.MetadataProperties["TypeUsage"].Value as TypeUsage).EdmType.MetadataProperties["ElementType"].Value as EntityType).FullName == GetBaseTypeFor(target).FullName).FirstOrDefault();
return(metadata.GetItems <AssociationType>(DataSpace.CSpace).FirstOrDefault(a => a.IsForeignKey && a.ReferentialConstraints[0].ToRole.Name.Equals(property.FromEndMember.Name) && a.ReferentialConstraints[0].FromRole.Name.Equals(property.ToEndMember.Name)));
}
private static EntityType getObjectType(MetadataWorkspace metadata, System.Type entityType)
{
var objectItemCollection = (ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace);
var edmEntityType = metadata
.GetItems <EntityType>(DataSpace.OSpace)
.First(e => objectItemCollection.GetClrType(e) == entityType);
return(edmEntityType);
}
public static IEnumerable <Type> GetEntityTypes(this MetadataWorkspace metadata)
{
var objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace));
var entityTypes = objectItemCollection
.GetItems <EntityType>()
.Select(i => objectItemCollection.GetClrType(i));
return(entityTypes);
}
private static Type GetClrType(
MetadataWorkspace workspace,
StructuralType edmType)
{
StructuralType oSpaceType = workspace
.GetItem <StructuralType>(edmType.FullName, DataSpace.OSpace);
ObjectItemCollection objectItems =
workspace.GetItemCollection(DataSpace.OSpace) as ObjectItemCollection;
return(objectItems.GetClrType(oSpaceType));
}
internal static DbSpatialDataReader CreateSpatialDataReader(MetadataWorkspace workspace, DbDataReader reader)
{
StoreItemCollection storeItemCollection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);
DbProviderFactory providerFactory = storeItemCollection.StoreProviderFactory;
Debug.Assert(providerFactory != null, "GetProviderSpatialServices requires provider factory to have been initialized");
DbProviderServices providerServices = DbProviderServices.GetProviderServices(providerFactory);
DbSpatialDataReader result = providerServices.GetSpatialDataReader(reader, storeItemCollection.StoreProviderManifestToken);
Debug.Assert(result != null, "DbProviderServices did not throw ProviderIncompatibleException for null IDbSpatialDataReader");
return result;
}
public static string[] GetPrimaryKeys(this MetadataWorkspace metadata, Type entityType)
{
// Get the mapping between CLR types and metadata OSpace
var objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace));
// Get metadata for given CLR type
var entityMetadata = metadata
.GetItems <EntityType>(DataSpace.OSpace)
.Single(e => objectItemCollection.GetClrType(e) == entityType);
return(entityMetadata.KeyProperties.Select(p => p.Name).ToArray());
}
public void Three_delegates_constructor_uses_given_delegates_and_sets_up_default_o_space_and_oc_mapping()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(_ssdlV3).CreateReader() });
var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection);
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace));
Assert.Same(storeItemCollection, workspace.GetItemCollection(DataSpace.SSpace));
Assert.Same(storageMappingItemCollection, workspace.GetItemCollection(DataSpace.CSSpace));
var objectItemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
var ocMappingCollection = (DefaultObjectMappingItemCollection)workspace.GetItemCollection(DataSpace.OCSpace);
Assert.Same(objectItemCollection, ocMappingCollection.ObjectItemCollection);
Assert.Same(edmItemCollection, ocMappingCollection.EdmItemCollection);
}
internal static IEnumerable <AssociationType> GetAllRelationshipsForType(MetadataWorkspace workspace, Type clrType)
{
DebugCheck.NotNull(workspace);
DebugCheck.NotNull(clrType);
// Note that this gets any relationship that the CLR type participates in in any entity set. For MEST, this
// could result in too many relationships being returned, but this doesn't matter since the extra ones will
// not be used. Also, MEST is rare.
return(((ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace)).GetItems <AssociationType>().Where(
a => IsEndMemberForType(a.AssociationEndMembers[0], clrType) ||
IsEndMemberForType(a.AssociationEndMembers[1], clrType)));
}
public void Three_delegates_constructor_uses_given_delegates_and_sets_up_default_o_space_and_oc_mapping()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(Csdl).CreateReader() });
var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(Ssdl).CreateReader() });
var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection);
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace));
Assert.Same(storeItemCollection, workspace.GetItemCollection(DataSpace.SSpace));
Assert.Same(storageMappingItemCollection, workspace.GetItemCollection(DataSpace.CSSpace));
var objectItemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
var ocMappingCollection = (DefaultObjectMappingItemCollection)workspace.GetItemCollection(DataSpace.OCSpace);
Assert.Same(objectItemCollection, ocMappingCollection.ObjectItemCollection);
Assert.Same(edmItemCollection, ocMappingCollection.EdmItemCollection);
}
private static IEnumerable <EntitySet> GetModelTables(MetadataWorkspace workspace)
{
return(workspace
.GetItemCollection(DataSpace.SSpace)
.GetItems <EntityContainer>()
.Single()
.BaseEntitySets
.OfType <EntitySet>()
.Where(
s => !s.MetadataProperties.Contains("Type") ||
(string)s.MetadataProperties["Type"].Value == "Tables"));
}
public void GetItemCollection_on_both_C_and_S_space_using_item_collections_with_inconsistent_versions_throws_MetadataException()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection =
new StoreItemCollection(
new[]
{
XDocument.Parse(string.Format(CultureInfo.InvariantCulture, SsdlTemplate, XmlConstants.TargetNamespace_2))
.CreateReader()
});
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => null);
workspace.GetItemCollection(DataSpace.CSpace); // this sets up the MetadataWorkspace's expected schema version as the csdl version i.e. 3.0
Assert.Equal(
Resources.Strings.DifferentSchemaVersionInCollection("StoreItemCollection", 2.0, 3.0),
Assert.Throws <MetadataException>(() => workspace.GetItemCollection(DataSpace.SSpace)).Message);
}
public static AssociationType ForeignKeyForNavigationProperty(this DbContext context, Type type, PropertyInfo navigationProperty)
{
MetadataWorkspace metadata = ((IObjectContextAdapter)context).ObjectContext.MetadataWorkspace;
ObjectItemCollection objectItemCollection = metadata.GetItemCollection(DataSpace.OSpace) as ObjectItemCollection;
EntityType entityType = metadata.GetItems <EntityType>(DataSpace.OSpace).SingleOrDefault(e => objectItemCollection.GetClrType(e) == GetBaseTypeFor(type));
EntitySet entitySet = metadata.GetItems <EntityContainer>(DataSpace.CSpace).Single().EntitySets.Single(s => s.ElementType.Name == entityType.Name);
EntitySetMapping mapping = metadata.GetItems <EntityContainerMapping>(DataSpace.CSSpace).Single().EntitySetMappings.Single(s => s.EntitySet == entitySet);
string entityIdentity = mapping.EntityTypeMappings.First().EntityType.ToString();
entityType = metadata.GetItem <EntityType>(entityIdentity, DataSpace.CSpace);
return(entityType.NavigationProperties.Single(p => p.Name.Equals(navigationProperty.Name)).ToEndMember.DeclaringType as AssociationType);
}
public static EntityContainer GetEntityContainer(MetadataWorkspace workspace)
{
// Get the Storage Schema Definition
ItemCollection ssdl = workspace.GetItemCollection(DataSpace.SSpace);
EntityContainer entityContainer = ssdl.OfType<EntityContainer>().FirstOrDefault();
if (entityContainer == null)
{
// Invalid SSDL
throw new InvalidOperationException("The Storage Schema Definition does not contain any EntityContainer");
}
return entityContainer;
}
internal static DbSpatialDataReader CreateSpatialDataReader(MetadataWorkspace workspace, DbDataReader reader)
{
var storeItemCollection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);
var providerFactory = storeItemCollection.ProviderFactory;
Debug.Assert(providerFactory != null, "GetProviderSpatialServices requires provider factory to have been initialized");
var providerServices = providerFactory.GetProviderServices();
var result = providerServices.GetSpatialDataReader(reader, storeItemCollection.ProviderManifestToken);
if (result == null)
{
throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices);
}
return result;
}
public static MetadataWorkspace ToMetadataWorkspace(this DbDatabaseMapping databaseMapping)
{
DebugCheck.NotNull(databaseMapping);
var itemCollection = new EdmItemCollection(databaseMapping.Model);
var storeItemCollection = new StoreItemCollection(databaseMapping.Database);
var storageMappingItemCollection = databaseMapping.ToStorageMappingItemCollection(itemCollection, storeItemCollection);
var workspace = new MetadataWorkspace(
() => itemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
new CodeFirstOSpaceLoader().LoadTypes(itemCollection, (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace));
return workspace;
}
// refs:
// * http://romiller.com/2014/04/08/ef6-1-mapping-between-types-tables/
// * http://blogs.msdn.com/b/appfabriccat/archive/2010/10/22/metadataworkspace-reference-in-wcf-services.aspx
// * http://msdn.microsoft.com/en-us/library/system.data.metadata.edm.dataspace.aspx - describes meaning of OSpace etc
// * http://stackoverflow.com/questions/22999330/mapping-from-iedmentity-to-clr
internal IList<EnumReference> FindEnumReferences(MetadataWorkspace metadataWorkspace)
{
// Get the part of the model that contains info about the actual CLR types
var objectItemCollection = ((ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace));
// OSpace = Object Space
var entities = metadataWorkspace.GetItems<EntityType>(DataSpace.OSpace);
// find and return all the references to enum types
var references = new List<EnumReference>();
foreach (var entityType in entities)
{
var mappingFragment = FindSchemaMappingFragment(metadataWorkspace, entityType);
// child types in TPH don't get mappings
if (mappingFragment == null)
{
continue;
}
references.AddRange(ProcessEdmProperties(entityType.Properties, mappingFragment, objectItemCollection));
}
return references;
}
/// <summary>
/// Requires: a public type with a public, default constructor. Returns a column map initializing the type
/// and all properties of the type with a public setter taking a primitive type and having a corresponding
/// column in the reader.
/// </summary>
internal static CollectionColumnMap CreateColumnMapFromReaderAndClrType(DbDataReader reader, Type type, MetadataWorkspace workspace)
{
Debug.Assert(null != reader);
Debug.Assert(null != type);
Debug.Assert(null != workspace);
// we require a default constructor
ConstructorInfo constructor = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
null, Type.EmptyTypes, null);
if (type.IsAbstract || (null == constructor && !type.IsValueType))
{
throw EntityUtil.InvalidOperation(
Strings.ObjectContext_InvalidTypeForStoreQuery(type));
}
// build a LINQ expression used by result assembly to create results
var memberInfo = new List<Tuple<MemberAssignment, int, EdmProperty>>();
foreach (PropertyInfo prop in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
// for enums unwrap the type if nullable
var propertyUnderlyingType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType;
Type propType = propertyUnderlyingType.IsEnum ? propertyUnderlyingType.GetEnumUnderlyingType() : prop.PropertyType;
EdmType modelType;
int ordinal;
if (TryGetColumnOrdinalFromReader(reader, prop.Name, out ordinal) &&
MetadataHelper.TryDetermineCSpaceModelType(propType, workspace, out modelType) &&
(Helper.IsScalarType(modelType)) &&
prop.CanWrite && prop.GetIndexParameters().Length == 0 && null != prop.GetSetMethod(/* nonPublic */true))
{
memberInfo.Add(Tuple.Create(
Expression.Bind(prop, Expression.Parameter(prop.PropertyType, "placeholder")),
ordinal,
new EdmProperty(prop.Name, TypeUsage.Create(modelType))));
}
}
// initialize members in the order in which they appear in the reader
MemberInfo[] members = new MemberInfo[memberInfo.Count];
MemberBinding[] memberBindings = new MemberBinding[memberInfo.Count];
ColumnMap[] propertyMaps = new ColumnMap[memberInfo.Count];
EdmProperty[] modelProperties = new EdmProperty[memberInfo.Count];
int i = 0;
foreach (var memberGroup in memberInfo.GroupBy(tuple => tuple.Item2).OrderBy(tuple => tuple.Key))
{
// make sure that a single column isn't contributing to multiple properties
if (memberGroup.Count() != 1)
{
throw EntityUtil.InvalidOperation(Strings.ObjectContext_TwoPropertiesMappedToSameColumn(
reader.GetName(memberGroup.Key),
String.Join(", ", memberGroup.Select(tuple => tuple.Item3.Name).ToArray())));
}
var member = memberGroup.Single();
MemberAssignment assignment = member.Item1;
int ordinal = member.Item2;
EdmProperty modelProp = member.Item3;
members[i] = assignment.Member;
memberBindings[i] = assignment;
propertyMaps[i] = new ScalarColumnMap(modelProp.TypeUsage, modelProp.Name, 0, ordinal);
modelProperties[i] = modelProp;
i++;
}
NewExpression newExpr = null == constructor ? Expression.New(type) : Expression.New(constructor);
MemberInitExpression init = Expression.MemberInit(newExpr, memberBindings);
InitializerMetadata initMetadata = InitializerMetadata.CreateProjectionInitializer(
(EdmItemCollection)workspace.GetItemCollection(DataSpace.CSpace), init, members);
// column map (a collection of rows with InitializerMetadata markup)
RowType rowType = new RowType(modelProperties, initMetadata);
RecordColumnMap rowMap = new RecordColumnMap(TypeUsage.Create(rowType),
"DefaultTypeProjection", propertyMaps, null);
CollectionColumnMap collectionMap = new SimpleCollectionColumnMap(rowType.GetCollectionType().TypeUsage,
rowType.Name, rowMap, null, null);
return collectionMap;
}
public void Registering_c_space_or_o_space_does_not_cause_oc_mapping_to_be_registered_if_it_is_already_registered()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(Csdl).CreateReader() });
var objectItemCollection = new ObjectItemCollection();
var ocMappingItemCollection = new DefaultObjectMappingItemCollection(edmItemCollection, objectItemCollection);
var workspace = new MetadataWorkspace();
#pragma warning disable 612,618
workspace.RegisterItemCollection(ocMappingItemCollection);
workspace.RegisterItemCollection(edmItemCollection);
workspace.RegisterItemCollection(objectItemCollection);
#pragma warning restore 612,618
Assert.Same(ocMappingItemCollection, workspace.GetItemCollection(DataSpace.OCSpace));
Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace));
Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace));
}
private static bool VerifyViewsHaveNotChanged(MetadataWorkspace workspace, EntityViewContainer viewContainer)
{
//Now check whether the hash of the generated views match the one
//we stored in the code file during design
//Produce the hash and add it to the code
var mappingCollection = (workspace.GetItemCollection(DataSpace.CSSpace) as StorageMappingItemCollection);
Debug.Assert(mappingCollection != null, "Must have Mapping Collection in the Metadataworkspace");
var viewHash = MetadataHelper.GenerateHashForAllExtentViewsContent(
mappingCollection.MappingVersion, viewContainer.ExtentViews);
var storedViewHash = viewContainer.HashOverAllExtentViews;
if (viewHash != storedViewHash)
{
return false;
}
return true;
}
/// <summary>
/// Constructs the EntityConnection from Metadata loaded in memory
/// </summary>
/// <param name="workspace">Workspace containing metadata information.</param>
public EntityConnection(MetadataWorkspace workspace, DbConnection connection)
{
GC.SuppressFinalize(this);
EntityUtil.CheckArgumentNull(workspace, "workspace");
EntityUtil.CheckArgumentNull(connection, "connection");
if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("EdmItemCollection"));
}
if(!workspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("StoreItemCollection"));
}
if(!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("StorageMappingItemCollection"));
}
if (connection.State != ConnectionState.Closed)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.EntityClient_ConnectionMustBeClosed);
}
// Verify that a factory can be retrieved
if (DbProviderFactories.GetFactory(connection) == null)
{
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.EntityClient_DbConnectionHasNoProvider(connection));
}
StoreItemCollection collection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);
_providerFactory = collection.StoreProviderFactory;
_storeConnection = connection;
_userOwnsStoreConnection = true;
_metadataWorkspace = workspace;
_initialized = true;
}
private static void SetupFooFunction(MetadataWorkspace metadataWorkspace)
{
var metadataWorkspaceMock = Mock.Get(metadataWorkspace);
var entityType = (EdmType)new EntityType(
"ReturnedEntity", "FooNamespace", DataSpace.CSpace,
new[] { "key" }, new EdmMember[] { new EdmProperty("key") });
var collectionTypeMock = new Mock<CollectionType>(entityType)
{
CallBase = true
};
metadataWorkspaceMock.Setup(m => m.TryDetermineCSpaceModelType(It.IsAny<Type>(), out entityType))
.Returns(true);
var entityContainer = new EntityContainer("Bar", DataSpace.CSpace);
metadataWorkspaceMock.Setup(m => m.TryGetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>(), out entityContainer))
.Returns(true);
var functionImport = new EdmFunction(
"Foo", "Bar", DataSpace.CSpace,
new EdmFunctionPayload
{
IsComposable = false,
IsFunctionImport = true,
ReturnParameters = new[]
{
new FunctionParameter(
EdmConstants.ReturnType,
TypeUsage.Create(collectionTypeMock.Object),
ParameterMode.ReturnValue),
}
});
entityContainer.AddFunctionImport(functionImport);
entityContainer.AddEntitySetBase(new EntitySet("Foo", "", "", "", (EntityType)entityType));
var edmItemCollection = (EdmItemCollection)metadataWorkspace.GetItemCollection(DataSpace.CSpace);
var storeItemCollection = (StoreItemCollection)metadataWorkspace.GetItemCollection(DataSpace.SSpace);
var containerMappingMock = new Mock<EntityContainerMapping>(entityContainer);
FunctionImportMapping targetFunctionMapping = new FunctionImportMappingNonComposable(
functionImport, functionImport, new List<List<FunctionImportStructuralTypeMapping>>(), edmItemCollection);
containerMappingMock.Setup(
m => m.TryGetFunctionImportMapping(
It.IsAny<EdmFunction>(), out targetFunctionMapping)).Returns(true);
var storageMappingItemCollection = new Mock<StorageMappingItemCollection>(
edmItemCollection, storeItemCollection, new string[0])
{
CallBase = true
};
storageMappingItemCollection.Setup(m => m.GetItems<EntityContainerMapping>())
.Returns(
new ReadOnlyCollection<EntityContainerMapping>(
new List<EntityContainerMapping>
{
containerMappingMock.Object
}));
metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.CSSpace, It.IsAny<bool>()))
.Returns(storageMappingItemCollection.Object);
}
public void GetItemCollection_on_both_CS_and_S_space_using_item_collections_with_inconsistent_versions_throws_MetadataException()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(_ssdlV3).CreateReader() });
var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection);
// edmItemCollection and storeItemCollection must have the same version to generate storageMappingItemCollection
// here we override the storeItemCollection so that it's version will be different for the MetadataWorkspace
storeItemCollection =
new StoreItemCollection(
new[]
{
XDocument.Parse(string.Format(CultureInfo.InvariantCulture, SsdlTemplate, XmlConstants.TargetNamespace_2))
.CreateReader()
});
var workspace = new MetadataWorkspace(
() => null,
() => storeItemCollection,
() => storageMappingItemCollection);
workspace.GetItemCollection(DataSpace.SSpace); // this sets up the MetadataWorkspace's expected schema version as the ssdl version i.e. 2.0
Assert.Equal(
Resources.Strings.DifferentSchemaVersionInCollection("StorageMappingItemCollection", 3.0, 2.0),
Assert.Throws<MetadataException>(() => workspace.GetItemCollection(DataSpace.CSSpace)).Message);
}
internal static IEnumerable<AssociationType> GetAllRelationshipsForType(MetadataWorkspace workspace, Type clrType)
{
DebugCheck.NotNull(workspace);
DebugCheck.NotNull(clrType);
// Note that this gets any relationship that the CLR type participates in in any entity set. For MEST, this
// could result in too many relationships being returned, but this doesn't matter since the extra ones will
// not be used. Also, MEST is rare.
return ((ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace)).GetItems<AssociationType>().Where(
a => IsEndMemberForType(a.AssociationEndMembers[0], clrType)
|| IsEndMemberForType(a.AssociationEndMembers[1], clrType));
}
public void Paths_constructor_loads_collections_from_given_paths_and_sets_up_o_space_and_oc_mapping()
{
RunTestWithTempMetadata(
_csdlV3, _ssdlV3, _mslV3,
paths =>
{
var workspace = new MetadataWorkspace(paths, new Assembly[0]);
var cSpace = (EdmItemCollection)workspace.GetItemCollection(DataSpace.CSpace);
Assert.NotNull(cSpace.GetType("Entity", "AdventureWorksModel"));
var sSpace = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);
Assert.NotNull(sSpace.GetType("Entities", "AdventureWorksModel.Store"));
var csMapping = (StorageMappingItemCollection)workspace.GetItemCollection(DataSpace.CSSpace);
Assert.Same(cSpace, csMapping.EdmItemCollection);
Assert.Same(sSpace, csMapping.StoreItemCollection);
var oSpace = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
var ocMapping = (DefaultObjectMappingItemCollection)workspace.GetItemCollection(DataSpace.OCSpace);
Assert.Same(oSpace, ocMapping.ObjectItemCollection);
Assert.Same(cSpace, ocMapping.EdmItemCollection);
});
}
/// <summary>
/// Gets the <see cref="IExecutionStrategy" /> that will be used to execute methods that use the specified connection.
/// Uses MetadataWorkspace for faster lookup.
/// </summary>
/// <param name="connection">The database connection</param>
/// <returns>
/// A new instance of <see cref="ExecutionStrategyBase" />
/// </returns>
internal static IExecutionStrategy GetExecutionStrategy(
DbConnection connection,
MetadataWorkspace metadataWorkspace)
{
var storeMetadata = (StoreItemCollection)metadataWorkspace.GetItemCollection(DataSpace.SSpace);
return GetExecutionStrategy(connection, storeMetadata.StoreProviderFactory);
}
public void O_space_types_are_discovered_when_using_attribute_based_mapping()
{
var edmItemCollection = new EdmItemCollection(
new[]
{
XDocument.Load(
typeof(AttributeBasedOCLoading).Assembly.GetManifestResourceStream(
"System.Data.Entity.TestModels.TemplateModels.Schemas.MonsterModel.csdl")).CreateReader()
});
var storeItemCollection = new StoreItemCollection(
new[]
{
XDocument.Load(
typeof(AttributeBasedOCLoading).Assembly.GetManifestResourceStream(
"System.Data.Entity.TestModels.TemplateModels.Schemas.MonsterModel.ssdl")).CreateReader()
});
var storageMappingItemCollection = LoadMsl(
edmItemCollection, storeItemCollection, XDocument.Load(
typeof(AttributeBasedOCLoading).Assembly.GetManifestResourceStream(
"System.Data.Entity.TestModels.TemplateModels.Schemas.MonsterModel.msl")));
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => storageMappingItemCollection);
var assembly = BuildEntitiesAssembly(ObjectLayer);
workspace.LoadFromAssembly(assembly);
var oSpaceItems = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
// Sanity checks that types/relationships were actually found
// Entity types
var entityTypes = oSpaceItems
.OfType<EdmType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.EntityType)
.ToList();
Assert.Equal(
new[]
{
"BackOrderLine2Mm", "BackOrderLineMm", "BarcodeDetailMm", "BarcodeMm", "ComplaintMm", "ComputerDetailMm",
"ComputerMm", "CustomerInfoMm", "CustomerMm", "DiscontinuedProductMm", "DriverMm", "IncorrectScanMm",
"LastLoginMm", "LicenseMm", "LoginMm", "MessageMm", "OrderLineMm", "OrderMm", "OrderNoteMm",
"OrderQualityCheckMm", "PageViewMm", "PasswordResetMm", "ProductDetailMm", "ProductMm", "ProductPageViewMm",
"ProductPhotoMm", "ProductReviewMm", "ProductWebFeatureMm", "ResolutionMm", "RSATokenMm", "SmartCardMm",
"SupplierInfoMm", "SupplierLogoMm", "SupplierMm", "SuspiciousActivityMm"
},
entityTypes.Select(i => i.Name).OrderBy(n => n));
Assert.True(entityTypes.All(e => e.NamespaceName == "BuildMonsterModel"));
Assert.True(entityTypes.All(e => oSpaceItems.GetClrType((StructuralType)e).Assembly == assembly));
// Complex types
var complexTypes = oSpaceItems
.OfType<EdmType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.ComplexType)
.ToList();
Assert.Equal(
new[] { "AuditInfoMm", "ConcurrencyInfoMm", "ContactDetailsMm", "DimensionsMm", "PhoneMm" },
complexTypes.Select(i => i.Name).OrderBy(n => n));
Assert.True(complexTypes.All(e => e.NamespaceName == "BuildMonsterModel"));
Assert.True(complexTypes.All(e => oSpaceItems.GetClrType((StructuralType)e).Assembly == assembly));
// Enum types
var enumTypes = oSpaceItems
.OfType<EdmType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.EnumType)
.ToList();
Assert.Equal(
new[] { "LicenseStateMm", "PhoneTypeMm" },
enumTypes.Select(i => i.Name).OrderBy(n => n));
Assert.True(enumTypes.All(e => e.NamespaceName == "BuildMonsterModel"));
Assert.True(enumTypes.All(e => oSpaceItems.GetClrType((EnumType)e).Assembly == assembly));
// Associations
var associations = oSpaceItems
.OfType<AssociationType>()
.Where(i => i.BuiltInTypeKind == BuiltInTypeKind.AssociationType)
.ToList();
Assert.Equal(
new[]
{
"Barcode_BarcodeDetail", "Barcode_IncorrectScanActual", "Barcode_IncorrectScanExpected", "Complaint_Resolution",
"Computer_ComputerDetail", "Customer_Complaints", "Customer_CustomerInfo", "Customer_Logins", "Customer_Orders",
"DiscontinuedProduct_Replacement", "Driver_License", "Husband_Wife", "LastLogin_SmartCard", "Login_LastLogin",
"Login_Orders", "Login_PageViews", "Login_PasswordResets", "Login_ReceivedMessages", "Login_RSAToken",
"Login_SentMessages", "Login_SmartCard", "Login_SuspiciousActivity", "Order_OrderLines", "Order_OrderNotes",
"Order_QualityCheck", "Product_Barcodes", "Product_OrderLines", "Product_ProductDetail", "Product_ProductPageViews",
"Product_ProductPhoto", "Product_ProductReview", "Products_Suppliers", "ProductWebFeature_ProductPhoto",
"ProductWebFeature_ProductReview", "Supplier_BackOrderLines", "Supplier_SupplierInfo", "Supplier_SupplierLogo"
},
associations.Select(i => i.Name).OrderBy(n => n));
Assert.True(associations.All(e => e.NamespaceName == "MonsterNamespace"));
}
/// <summary>
/// this method do the following check on the generated views in the EntityViewContainer,
/// then add those views all at once to the dictionary
/// 1. there should be one storeageEntityContainerMapping that has the same h
/// C side and S side names as the EnittyViewcontainer
/// 2. Generate the hash for the storageEntityContainerMapping in the MM closure,
/// and this hash should be the same in EntityViewContainer
/// 3. Generate the hash for all of the view text in the EntityViewContainer and
/// this hash should be the same as the stored on in the EntityViewContainer
/// </summary>
/// <param name="entityViewContainer"> </param>
private void SerializedAddGeneratedViewsInEntityViewContainer(
MetadataWorkspace workspace, EntityViewContainer entityViewContainer,
Dictionary<EntitySetBase, GeneratedView> extentMappingViews)
{
StorageEntityContainerMapping storageEntityContainerMapping;
// first check
if (!TryGetCorrespondingStorageEntityContainerMapping(
entityViewContainer,
workspace.GetItemCollection(DataSpace.CSSpace).GetItems<StorageEntityContainerMapping>(),
out storageEntityContainerMapping))
{
return;
}
// second check
if (!SerializedVerifyHashOverMmClosure(storageEntityContainerMapping, entityViewContainer))
{
throw new MappingException(
Strings.ViewGen_HashOnMappingClosure_Not_Matching(entityViewContainer.EdmEntityContainerName));
}
// third check, prior to the check, we collect all the views in the entity view container to the dictionary
// if the views are changed then we will throw exception out
if (VerifyViewsHaveNotChanged(workspace, entityViewContainer))
{
SerializedAddGeneratedViews(workspace, entityViewContainer, extentMappingViews);
}
else
{
throw new InvalidOperationException(System.Data.Entity.Resources.Strings.Generated_Views_Changed);
}
}
/// <summary>Gets the CLR type mapped to the specified C-Space type.</summary>
/// <param name="workspace">Workspace in which the type is defined.</param>
/// <param name="edmType">C-Space type whose matching clr type needs to be looked up.</param>
/// <returns>The resolved <see cref="Type"/> for the given <paramref name="edmType"/>.</returns>
internal static Type GetClrTypeForCSpaceType(MetadataWorkspace workspace, StructuralType edmType)
{
Debug.Assert(workspace != null, "workspace != null");
Debug.Assert(edmType != null, "edmType != null");
Debug.Assert(
edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType || edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType,
"Must be entityType or complexType");
StructuralType ospaceType;
if (workspace.TryGetObjectSpaceType(edmType, out ospaceType))
{
ObjectItemCollection objectItemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
return objectItemCollection.GetClrType(ospaceType);
}
return null;
}
/// <summary>
/// this method do the following check on the generated views in the EntityViewContainer,
/// then add those views all at once to the dictionary
/// 1. there should be one storeageEntityContainerMapping that has the same h
/// C side and S side names as the EnittyViewcontainer
/// 2. Generate the hash for the storageEntityContainerMapping in the MM closure,
/// and this hash should be the same in EntityViewContainer
/// 3. Generate the hash for all of the view text in the EntityViewContainer and
/// this hash should be the same as the stored on in the EntityViewContainer
/// </summary>
/// <param name="entityViewContainer"> </param>
private void SerializedAddGeneratedViewsInEntityViewContainer(
MetadataWorkspace workspace, EntityViewContainer entityViewContainer,
Dictionary<EntitySetBase, GeneratedView> extentMappingViews)
{
StorageEntityContainerMapping storageEntityContainerMapping;
// first check
if (!TryGetCorrespondingStorageEntityContainerMapping(
entityViewContainer,
workspace.GetItemCollection(DataSpace.CSSpace).GetItems<StorageEntityContainerMapping>(),
out storageEntityContainerMapping))
{
return;
}
// second check
if (!SerializedVerifyHashOverMmClosure(storageEntityContainerMapping, entityViewContainer))
{
throw new MappingException(
Strings.ViewGen_HashOnMappingClosure_Not_Matching(entityViewContainer.EdmEntityContainerName));
}
SerializedAddGeneratedViews(workspace, entityViewContainer, extentMappingViews);
}
private static void Item_collections_can_be_registered(MetadataWorkspace workspace)
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(_ssdlV3).CreateReader() });
var objectItemCollection = new ObjectItemCollection();
var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection);
var ocMappingItemCollection = new DefaultObjectMappingItemCollection(edmItemCollection, objectItemCollection);
#pragma warning disable 612,618
workspace.RegisterItemCollection(edmItemCollection);
workspace.RegisterItemCollection(storeItemCollection);
workspace.RegisterItemCollection(objectItemCollection);
workspace.RegisterItemCollection(storageMappingItemCollection);
workspace.RegisterItemCollection(ocMappingItemCollection);
#pragma warning restore 612,618
Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace));
Assert.Same(storeItemCollection, workspace.GetItemCollection(DataSpace.SSpace));
Assert.Same(storageMappingItemCollection, workspace.GetItemCollection(DataSpace.CSSpace));
Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace));
Assert.Same(ocMappingItemCollection, workspace.GetItemCollection(DataSpace.OCSpace));
}
// <summary>
// This constructor allows to skip the initialization code for testing purposes.
// </summary>
internal EntityConnection(
MetadataWorkspace workspace,
DbConnection connection,
bool skipInitialization,
bool entityConnectionOwnsStoreConnection)
{
if (!skipInitialization)
{
if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace))
{
throw new ArgumentException(Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("EdmItemCollection"));
}
if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace))
{
throw new ArgumentException(Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("StoreItemCollection"));
}
if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace))
{
throw new ArgumentException(
Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("StorageMappingItemCollection"));
}
// Verify that a factory can be retrieved
var providerFactory = connection.GetProviderFactory();
if (providerFactory == null)
{
throw new ProviderIncompatibleException(Strings.EntityClient_DbConnectionHasNoProvider(connection));
}
var collection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);
_providerFactory = collection.ProviderFactory;
Debug.Assert(_providerFactory == providerFactory);
_initialized = true;
}
_metadataWorkspace = workspace;
_storeConnection = connection;
_entityConnectionOwnsStoreConnection = entityConnectionOwnsStoreConnection;
if (_storeConnection != null)
{
_entityClientConnectionState = DbInterception.Dispatch.Connection.GetState(_storeConnection, InterceptionContext);
}
SubscribeToStoreConnectionStateChangeEvents();
}
Registering_o_space_causes_oc_mapping_to_also_be_registered_if_it_is_not_already_registered_and_c_space_is_registered()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var objectItemCollection = new ObjectItemCollection();
var workspace = new MetadataWorkspace();
#pragma warning disable 612,618
workspace.RegisterItemCollection(edmItemCollection);
workspace.RegisterItemCollection(objectItemCollection);
#pragma warning restore 612,618
Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace));
Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace));
var ocMappingCollection = (DefaultObjectMappingItemCollection)workspace.GetItemCollection(DataSpace.OCSpace);
Assert.Same(objectItemCollection, ocMappingCollection.ObjectItemCollection);
Assert.Same(edmItemCollection, ocMappingCollection.EdmItemCollection);
}
public void GetItemCollection_on_both_C_and_S_space_using_item_collections_with_inconsistent_versions_throws_MetadataException()
{
var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() });
var storeItemCollection =
new StoreItemCollection(
new[]
{
XDocument.Parse(string.Format(CultureInfo.InvariantCulture, SsdlTemplate, XmlConstants.TargetNamespace_2))
.CreateReader()
});
var workspace = new MetadataWorkspace(
() => edmItemCollection,
() => storeItemCollection,
() => null);
workspace.GetItemCollection(DataSpace.CSpace); // this sets up the MetadataWorkspace's expected schema version as the csdl version i.e. 3.0
Assert.Equal(
Resources.Strings.DifferentSchemaVersionInCollection("StoreItemCollection", 2.0, 3.0),
Assert.Throws<MetadataException>(() => workspace.GetItemCollection(DataSpace.SSpace)).Message);
}
public void Registering_o_space_does_not_cause_oc_mapping_to_be_registered_if_c_space_is_not_registered()
{
var objectItemCollection = new ObjectItemCollection();
var workspace = new MetadataWorkspace();
#pragma warning disable 612,618
workspace.RegisterItemCollection(objectItemCollection);
#pragma warning restore 612,618
Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace));
ItemCollection _;
Assert.False(workspace.TryGetItemCollection(DataSpace.OCSpace, out _));
}
/// <summary>
/// This constructor allows to skip the initialization code for testing purposes.
/// </summary>
internal EntityConnection(MetadataWorkspace workspace, DbConnection connection, bool skipInitialization)
{
if (!skipInitialization)
{
if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace))
{
throw new ArgumentException(Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("EdmItemCollection"));
}
if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace))
{
throw new ArgumentException(Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("StoreItemCollection"));
}
if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace))
{
throw new ArgumentException(
Strings.EntityClient_ItemCollectionsNotRegisteredInWorkspace("StorageMappingItemCollection"));
}
if (connection.State
!= ConnectionState.Closed)
{
throw new ArgumentException(Strings.EntityClient_ConnectionMustBeClosed);
}
// Verify that a factory can be retrieved
if (DbProviderFactories.GetFactory(connection) == null)
{
throw new ProviderIncompatibleException(Strings.EntityClient_DbConnectionHasNoProvider(connection));
}
var collection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);
_providerFactory = collection.StoreProviderFactory;
_userOwnsStoreConnection = true;
_initialized = true;
}
_metadataWorkspace = workspace;
_storeConnection = connection;
}