/// <summary>
/// Call the View Generator's Generate view method
/// and collect the Views and store it in a local dictionary.
/// </summary>
/// <param name="entityContainerMap"></param>
/// <param name="resultDictionary"></param>
private void SerializedGenerateViews(StorageEntityContainerMapping entityContainerMap, Dictionary <EntitySetBase, GeneratedView> resultDictionary)
{
//If there are no entity set maps, don't call the view generation process
Debug.Assert(entityContainerMap.HasViews);
ViewGenResults viewGenResults = ViewgenGatekeeper.GenerateViewsFromMapping(entityContainerMap, m_config);
KeyToListMap <EntitySetBase, GeneratedView> extentMappingViews = viewGenResults.Views;
if (viewGenResults.HasErrors)
{
// Can get the list of errors using viewGenResults.Errors
throw new MappingException(Helper.CombineErrorMessage(viewGenResults.Errors));
}
foreach (KeyValuePair <EntitySetBase, List <GeneratedView> > keyValuePair in extentMappingViews.KeyValuePairs)
{
//Multiple Views are returned for an extent but the first view
//is the only one that we will use for now. In the future,
//we might start using the other views which are per type within an extent.
GeneratedView generatedView;
//Add the view to the local dictionary
if (!resultDictionary.TryGetValue(keyValuePair.Key, out generatedView))
{
generatedView = keyValuePair.Value[0];
resultDictionary.Add(keyValuePair.Key, generatedView);
}
}
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
internal override void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("EntitySetMapping");
sb.Append(" ");
sb.Append("Name:");
sb.Append(this.Set.Name);
if (this.QueryView != null)
{
sb.Append(" ");
sb.Append("Query View:");
sb.Append(this.QueryView);
}
Console.WriteLine(sb.ToString());
foreach (StorageTypeMapping typeMapping in TypeMappings)
{
typeMapping.Print(index + 5);
}
foreach (StorageEntityTypeModificationFunctionMapping m in m_modificationFunctionMappings)
{
m.Print(index + 10);
}
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("ComplexTypeMapping");
sb.Append(" ");
if (m_isPartial)
{
sb.Append("IsPartial:True");
}
sb.Append(" ");
foreach (ComplexType type in m_types.Values)
{
sb.Append("Types:");
sb.Append(type.FullName);
sb.Append(" ");
}
foreach (ComplexType type in m_isOfTypes.Values)
{
sb.Append("Is-Of Types:");
sb.Append(type.FullName);
sb.Append(" ");
}
Console.WriteLine(sb.ToString());
foreach (StorageConditionPropertyMapping conditionMap in m_conditionProperties.Values)
{
(conditionMap).Print(index + 5);
}
foreach (StoragePropertyMapping propertyMapping in Properties)
{
propertyMapping.Print(index + 5);
}
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal override void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("EntityTypeMapping");
sb.Append(" ");
foreach (EdmType type in m_entityTypes.Values)
{
sb.Append("Types:");
sb.Append(type.FullName);
sb.Append(" ");
}
foreach (EdmType type in m_isOfEntityTypes.Values)
{
sb.Append("Is-Of Types:");
sb.Append(type.FullName);
sb.Append(" ");
}
Console.WriteLine(sb.ToString());
foreach (StorageMappingFragment fragment in MappingFragments)
{
fragment.Print(index + 5);
}
}
private bool SerializedVerifyHashOverMmClosure(StorageEntityContainerMapping entityContainerMapping, EntityViewContainer entityViewContainer)
{
if (MetadataMappingHasherVisitor.GetMappingClosureHash(m_storageMappingItemCollection.MappingVersion, entityContainerMapping) ==
entityViewContainer.HashOverMappingClosure)
{
return(true);
}
return(false);
}
protected virtual void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
{
Visit(storageEntityContainerMapping.EdmEntityContainer);
Visit(storageEntityContainerMapping.StorageEntityContainer);
foreach (var mapping in storageEntityContainerMapping.EntitySetMaps)
{
Visit(mapping);
}
}
internal static string GetMappingClosureHash(double mappingVersion, StorageEntityContainerMapping storageEntityContainerMapping)
{
Debug.Assert(storageEntityContainerMapping != null, "storageEntityContainerMapping is null!");
MetadataMappingHasherVisitor visitor = new MetadataMappingHasherVisitor(mappingVersion);
visitor.Visit(storageEntityContainerMapping);
return(visitor.HashValue);
}
internal void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("Association Set Function Mapping");
sb.Append(" ");
sb.Append(this.ToString());
Console.WriteLine(sb.ToString());
}
/// <summary>
/// This helper method loads items based on contents of in-memory XmlReader instances.
/// Assumption: This method is called only from the constructor because m_extentMappingViews is not thread safe.
/// </summary>
/// <param name="xmlReaders">A list of XmlReader instances</param>
/// <param name="mappingSchemaUris">A list of URIs</param>
/// <returns>A list of schema errors</returns>
private List <EdmSchemaError> LoadItems(IEnumerable <XmlReader> xmlReaders,
List <string> mappingSchemaUris,
Dictionary <EntitySetBase, GeneratedView> userDefinedQueryViewsDict,
Dictionary <OfTypeQVCacheKey, GeneratedView> userDefinedQueryViewsOfTypeDict,
double expectedVersion)
{
Debug.Assert(m_memberMappings.Count == 0, "Assumption: This method is called only once, and from the constructor because m_extentMappingViews is not thread safe.");
List <EdmSchemaError> errors = new List <EdmSchemaError>();
int index = -1;
foreach (XmlReader xmlReader in xmlReaders)
{
index++;
string location = null;
if (mappingSchemaUris == null)
{
som.SchemaManager.TryGetBaseUri(xmlReader, out location);
}
else
{
location = mappingSchemaUris[index];
}
StorageMappingItemLoader mapLoader = new StorageMappingItemLoader(
xmlReader,
this,
location, // ASSUMPTION: location is only used for generating error-messages
m_memberMappings);
errors.AddRange(mapLoader.ParsingErrors);
CheckIsSameVersion(expectedVersion, mapLoader.MappingVersion, errors);
// Process container mapping.
StorageEntityContainerMapping containerMapping = mapLoader.ContainerMapping;
if (mapLoader.HasQueryViews && containerMapping != null)
{
// Compile the query views so that we can report the errors in the user specified views.
CompileUserDefinedQueryViews(containerMapping, userDefinedQueryViewsDict, userDefinedQueryViewsOfTypeDict, errors);
}
// Add container mapping if there are no errors and entity container mapping is not already present.
if (MetadataHelper.CheckIfAllErrorsAreWarnings(errors) && !this.Contains(containerMapping))
{
AddInternal(containerMapping);
}
}
CheckForDuplicateItems(EdmItemCollection, StoreItemCollection, errors);
return(errors);
}
private Dictionary <EntitySetBase, GeneratedView> SerializedGetGeneratedViews(EntityContainer container)
{
Debug.Assert(container != null);
// Note that extentMappingViews will contain both query and update views.
Dictionary <EntitySetBase, GeneratedView> extentMappingViews;
// Get the mapping that has the entity container mapped.
StorageEntityContainerMapping entityContainerMap = MappingMetadataHelper.GetEntityContainerMap(m_storageMappingItemCollection, container);
// We get here because memoizer didn't find an entry for the container.
// It might happen that the entry with generated views already exists for the counterpart container, so check it first.
EntityContainer counterpartContainer = container.DataSpace == DataSpace.CSpace ?
entityContainerMap.StorageEntityContainer : entityContainerMap.EdmEntityContainer;
if (m_generatedViewsMemoizer.TryGetValue(counterpartContainer, out extentMappingViews))
{
return(extentMappingViews);
}
extentMappingViews = new Dictionary <EntitySetBase, GeneratedView>();
if (!entityContainerMap.HasViews)
{
return(extentMappingViews);
}
// If we are in generated views mode.
if (m_generatedViewsMode)
{
if (ObjectItemCollection.ViewGenerationAssemblies != null && ObjectItemCollection.ViewGenerationAssemblies.Count > 0)
{
SerializedCollectViewsFromObjectCollection(this.m_storageMappingItemCollection.Workspace, extentMappingViews);
}
else
{
SerializedCollectViewsFromReferencedAssemblies(this.m_storageMappingItemCollection.Workspace, extentMappingViews);
}
}
if (extentMappingViews.Count == 0)
{
// We should change the mode to runtime generation of views.
this.m_generatedViewsMode = false;
this.SerializedGenerateViews(entityContainerMap, extentMappingViews);
}
Debug.Assert(extentMappingViews.Count > 0, "view should be generated at this point");
return(extentMappingViews);
}
/// <summary>
/// This method compiles all the user defined query views in the <paramref name="entityContainerMapping"/>.
/// </summary>
private static void CompileUserDefinedQueryViews(StorageEntityContainerMapping entityContainerMapping,
Dictionary <EntitySetBase, GeneratedView> userDefinedQueryViewsDict,
Dictionary <OfTypeQVCacheKey, GeneratedView> userDefinedQueryViewsOfTypeDict,
IList <EdmSchemaError> errors)
{
ConfigViewGenerator config = new ConfigViewGenerator();
foreach (StorageSetMapping setMapping in entityContainerMapping.AllSetMaps)
{
if (setMapping.QueryView != null)
{
GeneratedView generatedView;
if (!userDefinedQueryViewsDict.TryGetValue(setMapping.Set, out generatedView))
{
// Parse the view so that we will get back any errors in the view.
if (GeneratedView.TryParseUserSpecifiedView(setMapping,
setMapping.Set.ElementType,
setMapping.QueryView,
true, // includeSubtypes
entityContainerMapping.StorageMappingItemCollection,
config,
/*out*/ errors,
out generatedView))
{
// Add first QueryView
userDefinedQueryViewsDict.Add(setMapping.Set, generatedView);
}
// Add all type-specific QueryViews
foreach (OfTypeQVCacheKey key in setMapping.GetTypeSpecificQVKeys())
{
Debug.Assert(key.First.Equals(setMapping.Set));
if (GeneratedView.TryParseUserSpecifiedView(setMapping,
key.Second.First, // type
setMapping.GetTypeSpecificQueryView(key),
key.Second.Second, // includeSubtypes
entityContainerMapping.StorageMappingItemCollection,
config,
/*out*/ errors,
out generatedView))
{
userDefinedQueryViewsOfTypeDict.Add(key, generatedView);
}
}
}
}
}
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal override void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("AssociationTypeMapping");
sb.Append(" ");
sb.Append("Type Name:");
sb.Append(this.m_relation.Name);
sb.Append(" ");
Console.WriteLine(sb.ToString());
foreach (StorageMappingFragment fragment in MappingFragments)
{
fragment.Print(index + 5);
}
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal override void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("ConditionPropertyMapping");
sb.Append(" ");
if (this.EdmProperty != null)
{
sb.Append("Name:");
sb.Append(this.EdmProperty.Name);
sb.Append(" ");
}
if (this.ColumnProperty != null)
{
sb.Append("Column Name:");
sb.Append(this.ColumnProperty.Name);
sb.Append(" ");
}
if (this.Value != null)
{
sb.Append("Value:");
sb.Append("'" + Value + "'");
sb.Append(" ");
sb.Append("Value CLR Type:");
sb.Append("'" + Value.GetType() + "'");
sb.Append(" ");
}
sb.Append("Value TypeMetadata:");
EdmType memberType = (ColumnProperty != null) ? ColumnProperty.TypeUsage.EdmType : null;
if (memberType != null)
{
sb.Append("'" + memberType.FullName + "'");
sb.Append(" ");
}
if (this.IsNull.HasValue)
{
sb.Append("IsNull:");
sb.Append(this.IsNull);
sb.Append(" ");
}
Console.WriteLine(sb.ToString());
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal override void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("ComplexPropertyMapping");
sb.Append(" ");
if (this.EdmProperty != null)
{
sb.Append("Name:");
sb.Append(this.EdmProperty.Name);
sb.Append(" ");
}
Console.WriteLine(sb.ToString());
foreach (StorageComplexTypeMapping typeMapping in TypeMappings)
{
typeMapping.Print(index + 5);
}
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal virtual void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("MappingFragment");
sb.Append(" ");
sb.Append("Table Name:");
sb.Append(this.m_tableExtent.Name);
Console.WriteLine(sb.ToString());
foreach (StorageConditionPropertyMapping conditionMap in m_conditionProperties.Values)
{
(conditionMap).Print(index + 5);
}
foreach (StoragePropertyMapping propertyMapping in m_properties)
{
propertyMapping.Print(index + 5);
}
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal override void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("ScalarPropertyMapping");
sb.Append(" ");
if (this.EdmProperty != null)
{
sb.Append("Name:");
sb.Append(this.EdmProperty.Name);
sb.Append(" ");
}
if (this.ColumnProperty != null)
{
sb.Append("Column Name:");
sb.Append(this.ColumnProperty.Name);
}
Console.WriteLine(sb.ToString());
}
protected override void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
{
Debug.Assert(storageEntityContainerMapping != null, "storageEntityContainerMapping cannot be null!");
// at the entry point of visitor, we setup the versions
Debug.Assert(m_MappingVersion == storageEntityContainerMapping.StorageMappingItemCollection.MappingVersion, "the original version and the mapping collection version are not the same");
this.m_MappingVersion = storageEntityContainerMapping.StorageMappingItemCollection.MappingVersion;
this.m_EdmVersion = storageEntityContainerMapping.StorageMappingItemCollection.EdmItemCollection.EdmVersion;
this.m_EdmItemCollection = storageEntityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
int index;
if (!this.AddObjectToSeenListAndHashBuilder(storageEntityContainerMapping, out index))
{
// if this has been add to the seen list, then just
return;
}
if (this.m_itemsAlreadySeen.Count > 1)
{
// this means user try another visit over SECM, this is allowed but all the previous visit all lost due to clean
// user can visit different SECM objects by using the same visitor to load the SECM object
this.Clean();
Visit(storageEntityContainerMapping);
return;
}
this.AddObjectStartDumpToHashBuilder(storageEntityContainerMapping, index);
#region Inner data visit
this.AddObjectContentToHashBuilder(storageEntityContainerMapping.Identity);
this.AddV2ObjectContentToHashBuilder(storageEntityContainerMapping.GenerateUpdateViews, this.m_MappingVersion);
base.Visit(storageEntityContainerMapping);
#endregion
this.AddObjectEndDumpToHashBuilder();
}
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
/// <param name="index"></param>
internal override void Print(int index)
{
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("EndPropertyMapping");
sb.Append(" ");
if (this.EndMember != null)
{
sb.Append("Name:");
sb.Append(this.EndMember.Name);
sb.Append(" ");
sb.Append("TypeName:");
sb.Append(this.EndMember.TypeUsage.EdmType.FullName);
}
sb.Append(" ");
Console.WriteLine(sb.ToString());
foreach (StoragePropertyMapping propertyMapping in Properties)
{
propertyMapping.Print(index + 5);
}
}
/// <summary>
/// Generates a single query view for a given Extent and type. It is used to generate OfType and OfTypeOnly views.
/// </summary>
/// <param name="includeSubtypes">Whether the view should include extents that are subtypes of the given entity</param>
private bool TryGenerateQueryViewOfType(EntityContainer entityContainer, EntitySetBase entity, EntityTypeBase type, bool includeSubtypes, out GeneratedView generatedView)
{
Debug.Assert(entityContainer != null);
Debug.Assert(entity != null);
Debug.Assert(type != null);
if (type.Abstract)
{
generatedView = null;
return(false);
}
//Get the mapping that has the entity container mapped.
StorageEntityContainerMapping entityContainerMap = MappingMetadataHelper.GetEntityContainerMap(m_storageMappingItemCollection, entityContainer);
Debug.Assert(!entityContainerMap.IsEmpty, "There are no entity set maps");
bool success;
ViewGenResults viewGenResults = ViewgenGatekeeper.GenerateTypeSpecificQueryView(entityContainerMap, m_config, entity, type, includeSubtypes, out success);
if (!success)
{
generatedView = null;
return(false); //could not generate view
}
KeyToListMap <EntitySetBase, GeneratedView> extentMappingViews = viewGenResults.Views;
if (viewGenResults.HasErrors)
{
throw new MappingException(Helper.CombineErrorMessage(viewGenResults.Errors));
}
Debug.Assert(extentMappingViews.AllValues.Count() == 1, "Viewgen should have produced only one view");
generatedView = extentMappingViews.AllValues.First();
return(true);
}
/// <summary>
/// Construct a new AssociationSetMapping object
/// </summary>
/// <param name="extent">Represents the Association Set Metadata object. Will
/// change this to Extent instead of MemberMetadata.</param>
/// <param name="entityContainerMapping">The entityContainerMapping mapping that contains this Set mapping</param>
internal StorageAssociationSetMapping(AssociationSet extent, StorageEntityContainerMapping entityContainerMapping)
: base(extent, entityContainerMapping)
{
}
/// <summary>
/// Construct a EntitySet mapping object
/// </summary>
/// <param name="extent">EntitySet metadata object</param>
/// <param name="entityContainerMapping">The entity Container Mapping that contains this Set mapping</param>
internal StorageEntitySetMapping(EntitySet extent, StorageEntityContainerMapping entityContainerMapping)
: base(extent, entityContainerMapping)
{
m_modificationFunctionMappings = new List <StorageEntityTypeModificationFunctionMapping>();
m_implicitlyMappedAssociationSetEnds = new List <AssociationSetEnd>();
}
private bool TryGetCorrespondingStorageEntityContainerMapping(EntityViewContainer viewContainer,
IEnumerable <StorageEntityContainerMapping> storageEntityContainerMappingList, out StorageEntityContainerMapping storageEntityContainerMapping)
{
storageEntityContainerMapping = null;
foreach (var entityContainerMapping in storageEntityContainerMappingList)
{
// first check
if (entityContainerMapping.EdmEntityContainer.Name == viewContainer.EdmEntityContainerName &&
entityContainerMapping.StorageEntityContainer.Name == viewContainer.StoreEntityContainerName)
{
storageEntityContainerMapping = entityContainerMapping;
return(true);
}
}
return(false);
}
internal InputForComputingCellGroups(StorageEntityContainerMapping containerMapping, ConfigViewGenerator config)
{
this.ContainerMapping = containerMapping;
this.Config = config;
}
/// <summary>
/// Construct the new StorageSetMapping object.
/// </summary>
/// <param name="extent">Extent metadata object</param>
/// <param name="entityContainerMapping">The EntityContainer mapping that contains this extent mapping</param>
internal StorageSetMapping(EntitySetBase extent, StorageEntityContainerMapping entityContainerMapping)
{
this.m_entityContainerMapping = entityContainerMapping;
this.m_extent = extent;
this.m_typeMappings = new List <StorageTypeMapping>();
}