[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] //For EdmItemCollection constructor call.
//Since we pass in empty collection for paths, we do not have any resource exposure here.
private IList<EdmSchemaError> InternalGenerateMetadata()
{
if (_modelEntityContainer != null)
{
_modelEntityContainer = null;
_mappingLookups = null;
_edmItemCollection = null;
}
LoadMethodSessionState session = new LoadMethodSessionState();
try
{
session.EdmItemCollection = new EdmItemCollection();
if (this.GenerateForeignKeyProperties && this._targetEntityFrameworkVersion < EntityFrameworkVersions.Version2)
{
session.AddError(Strings.UnableToGenerateForeignKeyPropertiesForV1, ModelBuilderErrorCode.UnableToGenerateForeignKeyPropertiesForV1, EdmSchemaErrorSeverity.Error, null);
return session.Errors;
}
List<AssociationSet> storeAssociationSets = new List<AssociationSet>();
CollectAllFkProperties(session);
EntityContainer modelEntityContainer = new EntityContainer(_modelEntityContainerName, DataSpace.CSpace);
// create the EntityTypes and EntitySets, and save up the AssociationSets for later.
foreach (EntitySetBase storeSet in _storeEntityContainer.BaseEntitySets)
{
switch (storeSet.BuiltInTypeKind)
{
case BuiltInTypeKind.AssociationSet:
// save these, and create them after the EntityTypes and EntitySets have been created
string errorMessage;
if (this.GenerateForeignKeyProperties || !EntityStoreSchemaGenerator.IsFkPartiallyContainedInPK(((AssociationSet)storeSet).ElementType, out errorMessage))
{
storeAssociationSets.Add((AssociationSet)storeSet);
}
else
{
session.AddError(errorMessage, ModelBuilderErrorCode.UnsupportedForeinKeyPattern, EdmSchemaErrorSeverity.Error, null);
}
break;
case BuiltInTypeKind.EntitySet:
EntitySet set = (EntitySet)storeSet;
session.CandidateCollapsedAssociations.Add(set, new OneToOneMappingSerializer.CollapsedEntityAssociationSet(set));
break;
default:
// error
throw EDesignUtil.MissingGenerationPatternForType(storeSet.BuiltInTypeKind);
}
}
foreach (AssociationSet storeAssociationSet in storeAssociationSets)
{
SaveAssociationForCollapsedAssociationCandidate(session, storeAssociationSet);
}
Set<AssociationSet> associationSetsFromCollapseCandidateRejects = new Set<AssociationSet>();
IEnumerable<OneToOneMappingSerializer.CollapsedEntityAssociationSet> invalidCandidates = FindAllInvalidCollapsedAssociationCandidates(session);
// now that we have gone through all of the association sets,
foreach (OneToOneMappingSerializer.CollapsedEntityAssociationSet collapsed in invalidCandidates)
{
session.CandidateCollapsedAssociations.Remove(collapsed.EntitySet);
// just create the entity set and save the association set to be added later
EntitySet entitySet = CreateModelEntitySet(session, collapsed.EntitySet);
modelEntityContainer.AddEntitySetBase(entitySet);
associationSetsFromCollapseCandidateRejects.AddRange(collapsed.AssociationSets);
}
// create all the associations for the invalid collapsed entity association candidates
foreach (AssociationSet storeAssociationSet in (IEnumerable<AssociationSet>)associationSetsFromCollapseCandidateRejects)
{
if (!IsAssociationPartOfCandidateCollapsedAssociation(session, storeAssociationSet))
{
AssociationSet set = CreateModelAssociationSet(session, storeAssociationSet);
modelEntityContainer.AddEntitySetBase(set);
}
}
// save the set that needs to be created and mapped
session.MappingLookups.CollapsedEntityAssociationSets.AddRange(session.CandidateCollapsedAssociations.Values);
// do this in a seperate loop so we are sure all the necessary EntitySets have been created
foreach (OneToOneMappingSerializer.CollapsedEntityAssociationSet collapsed in session.MappingLookups.CollapsedEntityAssociationSets)
{
AssociationSet set = CreateModelAssociationSet(session, collapsed);
modelEntityContainer.AddEntitySetBase(set);
}
if (this._targetEntityFrameworkVersion >= EntityFrameworkVersions.Version2)
{
Debug.Assert(EntityFrameworkVersions.Latest == EntityFrameworkVersions.Version3, "Did you add a new framework version");
// add LazyLoadingEnabled=true to the EntityContainer
MetadataProperty lazyLoadingAttribute =
new MetadataProperty(
DesignXmlConstants.EdmAnnotationNamespace + ":" + DesignXmlConstants.LazyLoadingEnabled,
TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(
PrimitiveTypeKind.String),
false,
false),
true);
modelEntityContainer.AddMetadataProperties(new List<MetadataProperty>() { lazyLoadingAttribute });
this._hasAnnotationNamespace = true;
}
// Map store functions to function imports.
MapFunctions(session, modelEntityContainer);
if (!EntityStoreSchemaGenerator.HasErrorSeverityErrors(session.Errors))
{
// add them to the collection so they will work if someone wants to use the collection
foreach (EntityType type in session.MappingLookups.StoreEntityTypeToModelEntityType.Values)
{
type.SetReadOnly();
session.EdmItemCollection.AddInternal(type);
}
foreach (AssociationType type in session.MappingLookups.StoreAssociationTypeToModelAssociationType.Values)
{
type.SetReadOnly();
session.EdmItemCollection.AddInternal(type);
}
foreach (OneToOneMappingSerializer.CollapsedEntityAssociationSet set in session.MappingLookups.CollapsedEntityAssociationSets)
{
set.ModelAssociationSet.ElementType.SetReadOnly();
session.EdmItemCollection.AddInternal(set.ModelAssociationSet.ElementType);
}
modelEntityContainer.SetReadOnly();
session.EdmItemCollection.AddInternal(modelEntityContainer);
_modelEntityContainer = modelEntityContainer;
_mappingLookups = session.MappingLookups;
_edmItemCollection = session.EdmItemCollection;
}
}
catch (Exception e)
{
if (MetadataUtil.IsCatchableExceptionType(e))
{
// an exception in the code is definitely an error
string message = EDesignUtil.GetMessagesFromEntireExceptionChain(e);
session.AddError(message,
ModelBuilderErrorCode.UnknownError,
EdmSchemaErrorSeverity.Error,
e);
}
else
{
throw;
}
}
return session.Errors;
}
private IList<EdmSchemaError> DoGenerateStoreMetadata(IEnumerable<EntityStoreSchemaFilterEntry> filters, Version targetEntityFrameworkVersion)
{
if (_entityContainer != null)
{
_entityContainer = null;
_storeItemCollection = null;
_errorsLookup = null;
_invalidTypes = null;
}
_targetEntityFrameworkVersion = targetEntityFrameworkVersion;
LoadMethodSessionState session = new LoadMethodSessionState(targetEntityFrameworkVersion);
try
{
_loader.Open();
DbConnection connection = _loader.InnerConnection;
DbProviderFactory providerFactory = DbProviderServices.GetProviderFactory(_loader.ProviderInvariantName);
DbProviderServices providerServices = DbProviderServices.GetProviderServices(providerFactory);
_providerManifestToken = providerServices.GetProviderManifestToken(connection);
DbProviderManifest storeManifest = providerServices.GetProviderManifest(_providerManifestToken);
session.Filters = filters;
Debug.Assert(_namespaceName != null, "_namespaceName should not be null at this point, did you add a new ctor?");
session.ItemCollection = new StoreItemCollection(providerFactory, providerServices.GetProviderManifest(_providerManifestToken), _providerManifestToken);
CreateTableEntityTypes(session);
CreateViewEntityTypes(session);
string entityContainerName = this._namespaceName.Replace(".", string.Empty) + CONTAINER_SUFFIX;
Debug.Assert(entityContainerName != null, "We should always have a container name");
EntityContainer entityContainer = new EntityContainer(entityContainerName, DataSpace.SSpace);
foreach (EntityType type in session.GetAllEntities())
{
Debug.Assert(type.KeyMembers.Count > 0, "Why do we have Entities without keys in our valid Entities collection");
session.ItemCollection.AddInternal(type);
EntitySet entitySet = CreateEntitySet(session, type);
session.EntityTypeToSet.Add(type, entitySet);
entityContainer.AddEntitySetBase(entitySet);
}
CreateAssociationTypes(session);
foreach (AssociationType type in session.AssociationTypes)
{
session.ItemCollection.AddInternal(type);
AssociationSet set = CreateAssociationSet(session, type);
entityContainer.AddEntitySetBase(set);
}
entityContainer.SetReadOnly();
session.ItemCollection.AddInternal(entityContainer);
FixupKeylessEntitySets(entityContainer, session);
if (_targetEntityFrameworkVersion >= EntityFrameworkVersions.Version3 &&
_loader.StoreSchemaModelVersion >= EntityFrameworkVersions.Version3)
{
CreateTvfReturnRowTypes(session);
}
CreateEdmFunctions(session);
foreach (EdmFunction function in session.Functions)
{
session.ItemCollection.AddInternal(function);
}
if (!HasErrorSeverityErrors(session.Errors))
{
_entityContainer = entityContainer;
_storeItemCollection = session.ItemCollection;
_errorsLookup = session.ItemToErrorsMap;
_invalidTypes = new List<EdmType>(session.InvalidTypes);
}
}
catch (Exception e)
{
if (MetadataUtil.IsCatchableExceptionType(e))
{
string message = EDesignUtil.GetMessagesFromEntireExceptionChain(e);
session.AddErrorsForType(null,
new EdmSchemaError(message,
(int)ModelBuilderErrorCode.UnknownError,
EdmSchemaErrorSeverity.Error,
e));
}
else
{
throw;
}
}
finally
{
_loader.Close();
}
return new List<EdmSchemaError>(session.Errors);
}