internal static EdmFunction FindFunctionImport(
MetadataWorkspace workspace,
string containerName,
string functionImportName)
{
EntityContainer entityContainer;
if (!workspace.TryGetEntityContainer(containerName, DataSpace.CSpace, out entityContainer))
{
throw new InvalidOperationException(Strings.EntityClient_UnableToFindFunctionImportContainer((object)containerName));
}
EdmFunction edmFunction = (EdmFunction)null;
foreach (EdmFunction functionImport in entityContainer.FunctionImports)
{
if (functionImport.Name == functionImportName)
{
edmFunction = functionImport;
break;
}
}
if (edmFunction == null)
{
throw new InvalidOperationException(Strings.EntityClient_UnableToFindFunctionImport((object)containerName, (object)functionImportName));
}
if (edmFunction.IsComposableAttribute)
{
throw new InvalidOperationException(Strings.EntityClient_FunctionImportMustBeNonComposable((object)(containerName + "." + functionImportName)));
}
return(edmFunction);
}
// requires: all arguments must be given
internal static EdmFunction FindFunctionImport(MetadataWorkspace workspace, string containerName, string functionImportName)
{
Debug.Assert(null != workspace && null != containerName && null != functionImportName);
// find entity container
EntityContainer entityContainer;
if (!workspace.TryGetEntityContainer(containerName, DataSpace.CSpace, out entityContainer))
{
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.EntityClient_UnableToFindFunctionImportContainer(
containerName));
}
// find function import
EdmFunction functionImport = null;
foreach (EdmFunction candidate in entityContainer.FunctionImports)
{
if (candidate.Name == functionImportName)
{
functionImport = candidate;
break;
}
}
if (null == functionImport)
{
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.EntityClient_UnableToFindFunctionImport(
containerName, functionImportName));
}
if (functionImport.IsComposableAttribute)
{
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.EntityClient_FunctionImportMustBeNonComposable(containerName + "." + functionImportName));
}
return(functionImport);
}
internal void SetDefaultContainer(string defaultContainerName)
{
EntityContainer container = null;
if (!String.IsNullOrEmpty(defaultContainerName))
{
if (!MetadataWorkspace.TryGetEntityContainer(defaultContainerName, DataSpace.CSpace, out container))
{
throw EntityUtil.InvalidDefaultContainerName("defaultContainerName", defaultContainerName);
}
}
_defaultContainer = container;
}
internal void SetDefaultContainer(string defaultContainerName)
{
EntityContainer container = null;
if (!String.IsNullOrEmpty(defaultContainerName))
{
if (!MetadataWorkspace.TryGetEntityContainer(defaultContainerName, DataSpace.CSpace, out container))
{
throw new ArgumentException(
Strings.ObjectContext_InvalidDefaultContainerName(defaultContainerName), "defaultContainerName");
}
}
_defaultContainer = container;
}
protected override EntitySetBase VisitEntitySet(EntitySetBase entitySet)
{
EntityContainer container;
if (_metadata.TryGetEntityContainer(entitySet.EntityContainer.Name, entitySet.EntityContainer.DataSpace, out container))
{
EntitySetBase extent = null;
if (container.BaseEntitySets.TryGetValue(entitySet.Name, false, out extent) &&
extent != null &&
entitySet.BuiltInTypeKind == extent.BuiltInTypeKind) // EntitySet -> EntitySet, AssociationSet -> AssociationSet, etc
{
return(extent);
}
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_EntitySetNotFound(entitySet.EntityContainer.Name, entitySet.Name));
}
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_EntityContainerNotFound(entitySet.EntityContainer.Name));
}
internal static EdmFunction FindFunctionImport(MetadataWorkspace workspace, string containerName, string functionImportName)
{
DebugCheck.NotNull(workspace);
DebugCheck.NotNull(containerName);
DebugCheck.NotNull(functionImportName);
// find entity container
EntityContainer entityContainer;
if (!workspace.TryGetEntityContainer(containerName, DataSpace.CSpace, out entityContainer))
{
throw new InvalidOperationException(
Strings.EntityClient_UnableToFindFunctionImportContainer(
containerName));
}
// find function import
EdmFunction functionImport = null;
foreach (var candidate in entityContainer.FunctionImports)
{
if (candidate.Name == functionImportName)
{
functionImport = candidate;
break;
}
}
if (null == functionImport)
{
throw new InvalidOperationException(
Strings.EntityClient_UnableToFindFunctionImport(
containerName, functionImportName));
}
if (functionImport.IsComposableAttribute)
{
throw new InvalidOperationException(
Strings.EntityClient_FunctionImportMustBeNonComposable(containerName + "." + functionImportName));
}
return(functionImport);
}
// requires: all arguments must be given
internal static EdmFunction FindFunctionImport(MetadataWorkspace workspace, string containerName, string functionImportName)
{
Debug.Assert(null != workspace && null != containerName && null != functionImportName);
// find entity container
EntityContainer entityContainer;
if (!workspace.TryGetEntityContainer(containerName, DataSpace.CSpace, out entityContainer))
{
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.EntityClient_UnableToFindFunctionImportContainer(
containerName));
}
// find function import
EdmFunction functionImport = null;
foreach (EdmFunction candidate in entityContainer.FunctionImports)
{
if (candidate.Name == functionImportName)
{
functionImport = candidate;
break;
}
}
if (null == functionImport)
{
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.EntityClient_UnableToFindFunctionImport(
containerName, functionImportName));
}
if (functionImport.IsComposableAttribute)
{
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.EntityClient_FunctionImportMustBeNonComposable(containerName + "." + functionImportName));
}
return functionImport;
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
public DbMapping(DbContext context)
{
_context = context;
_contextTypeName = context.GetType().FullName;
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
MetadataWorkspace metadataWorkspace = objectContext.MetadataWorkspace;
MapperBase mapper;
EntityContainer entityContainer;
if (metadataWorkspace.TryGetEntityContainer("CodeFirstDatabase", true, DataSpace.SSpace, out entityContainer))
{
mapper = new CodeFirstMapper(metadataWorkspace, entityContainer);
}
else
{
ReadOnlyCollection <EntityContainer> readOnlyCollection;
#if EF6
readOnlyCollection = metadataWorkspace.GetItems <EntityContainer>(DataSpace.SSpace);
#else
readOnlyCollection = metadataWorkspace.GetItems <EntityContainer>(DataSpace.CSpace);
#endif
entityContainer = readOnlyCollection[0];
mapper = new DbFirstMapper(metadataWorkspace, entityContainer);
}
var typeMappings = mapper.TypeMappings;
int depth = 0;
while (true)
{
if (depth > 100)
{
throw new Exception("Type mapping has reached unreasonable depth.");
}
if (typeMappings.Count == 0)
{
break;
}
var nextLevel = new Dictionary <string, EntityType>();
foreach (var kvp in typeMappings)
{
EntityMap entityMap;
try
{
entityMap = mapper.MapEntity(kvp.Key, kvp.Value);
}
catch (ParentNotMappedYetException)
{
nextLevel.Add(kvp.Key, kvp.Value);
continue;
}
if (entityMap == null)
{
continue;
}
//tableMapping.DbMapping = this;
_tableMappings.Add(kvp.Key, entityMap);
}
typeMappings = nextLevel;
depth++;
}
mapper.BindForeignKeys();
}
// <summary>
// Get an entity container based upon the strong name of the container
// If no entity container is found, returns null, else returns the first one//
// </summary>
// <param name="name"> name of the entity container </param>
// <param name="ignoreCase"> true for case-insensitive lookup </param>
// <param name="entityContainer"> returns the entity container if a match is found </param>
// <returns> returns true if a match is found, otherwise false </returns>
internal virtual bool TryGetEntityContainer(string name, bool ignoreCase, out EntityContainer entityContainer)
{
return(MetadataWorkspace.TryGetEntityContainer(name, ignoreCase, TargetDataspace, out entityContainer));
}
// Verifies the given extent is present in the given workspace.
private static void VerifyExtent(MetadataWorkspace workspace, EntitySetBase extent)
{
// get the container to which the given extent belongs
EntityContainer actualContainer = extent.EntityContainer;
// try to retrieve the container in the given workspace
EntityContainer referenceContainer = null;
if (null != actualContainer)
{
workspace.TryGetEntityContainer(
actualContainer.Name, actualContainer.DataSpace, out referenceContainer);
}
// determine if the given extent lives in a container from the given workspace
// (the item collections for each container are reference equivalent when they are declared in the
// same item collection)
if (null == actualContainer || null == referenceContainer ||
!Object.ReferenceEquals(actualContainer, referenceContainer))
{
//
throw EntityUtil.Update(System.Data.Entity.Strings.Update_WorkspaceMismatch, null);
}
}
// requires: all arguments must be given
internal static EdmFunction FindFunctionImport(MetadataWorkspace workspace, string containerName, string functionImportName)
{
DebugCheck.NotNull(workspace);
DebugCheck.NotNull(containerName);
DebugCheck.NotNull(functionImportName);
// find entity container
EntityContainer entityContainer;
if (!workspace.TryGetEntityContainer(containerName, DataSpace.CSpace, out entityContainer))
{
throw new InvalidOperationException(
Strings.EntityClient_UnableToFindFunctionImportContainer(
containerName));
}
// find function import
EdmFunction functionImport = null;
foreach (var candidate in entityContainer.FunctionImports)
{
if (candidate.Name == functionImportName)
{
functionImport = candidate;
break;
}
}
if (null == functionImport)
{
throw new InvalidOperationException(
Strings.EntityClient_UnableToFindFunctionImport(
containerName, functionImportName));
}
if (functionImport.IsComposableAttribute)
{
throw new InvalidOperationException(
Strings.EntityClient_FunctionImportMustBeNonComposable(containerName + "." + functionImportName));
}
return functionImport;
}
