private ErrorLog GenerateQueryViewForExtentAndType(StorageEntityContainerMapping entityContainerMapping, CqlIdentifiers identifiers, ViewSet views, EntitySetBase entity, EntityTypeBase type, ViewGenMode mode)
{
Debug.Assert(mode != ViewGenMode.GenerateAllViews);
// Keep track of the mapping exceptions that we have generated
ErrorLog errorLog = new ErrorLog();
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("================= Generating {0} Query View for: {1} ===========================",
(mode == ViewGenMode.OfTypeViews) ? "OfType" : "OfTypeOnly",
entity.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
try
{
// (1) view generation (checks that extents are fully mapped)
ViewgenContext context = CreateViewgenContext(entity, ViewTarget.QueryView, identifiers);
QueryRewriter queryRewriter = GenerateViewsForExtentAndType(type, context, identifiers, views, mode);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
errorLog.Merge(exception.ErrorLog);
}
return(errorLog);
}
// internal for testing
internal void WriteEntityContainerMappingElement(StorageEntityContainerMapping containerMapping)
{
DebugCheck.NotNull(containerMapping);
_xmlWriter.WriteStartElement(StorageMslConstructs.EntityContainerMappingElement);
_xmlWriter.WriteAttributeString(StorageMslConstructs.StorageEntityContainerAttribute, _dbSchemaName);
_xmlWriter.WriteAttributeString(
StorageMslConstructs.CdmEntityContainerAttribute, containerMapping.EdmEntityContainer.Name);
foreach (var set in containerMapping.EntitySetMappings)
{
WriteEntitySetMappingElement(set);
}
foreach (var set in containerMapping.AssociationSetMappings)
{
WriteAssociationSetMappingElement(set);
}
foreach (var functionMapping in containerMapping.FunctionImportMappings.OfType <FunctionImportMappingComposable>())
{
WriteFunctionImportMappingElement(functionMapping);
}
_xmlWriter.WriteEndElement();
}
// internal for testing
internal void WriteEntityContainerMappingElement(StorageEntityContainerMapping containerMapping)
{
DebugCheck.NotNull(containerMapping);
_xmlWriter.WriteStartElement(StorageMslConstructs.EntityContainerMappingElement);
_xmlWriter.WriteAttributeString(StorageMslConstructs.StorageEntityContainerAttribute, _dbSchemaName);
_xmlWriter.WriteAttributeString(
StorageMslConstructs.CdmEntityContainerAttribute, containerMapping.EdmEntityContainer.Name);
foreach (var set in containerMapping.EntitySetMappings)
{
WriteEntitySetMappingElement(set);
}
foreach (var set in containerMapping.AssociationSetMappings)
{
WriteAssociationSetMappingElement(set);
}
foreach (var functionMapping in containerMapping.FunctionImportMappings.OfType<FunctionImportMappingComposable>())
{
WriteFunctionImportMappingElement(functionMapping);
}
_xmlWriter.WriteEndElement();
}
public void Can_get_entity_set()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var entitySet = new EntitySet();
var entitySetMapping = new StorageEntitySetMapping(entitySet, entityContainerMapping);
Assert.Same(entitySet, entitySetMapping.EntitySet);
}
/// <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>
public StorageEntitySetMapping(EntitySet extent, StorageEntityContainerMapping entityContainerMapping)
: base(extent, entityContainerMapping)
{
Check.NotNull(extent, "extent");
m_modificationFunctionMappings = new List<StorageEntityTypeModificationFunctionMapping>();
m_implicitlyMappedAssociationSetEnds = new List<AssociationSetEnd>();
}
protected virtual void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
{
Visit(storageEntityContainerMapping.EdmEntityContainer);
Visit(storageEntityContainerMapping.StorageEntityContainer);
foreach (var mapping in storageEntityContainerMapping.EntitySetMaps)
{
Visit(mapping);
}
}
public DynamicToFunctionModificationCommandConverter(
StorageAssociationSetModificationFunctionMapping associationSetModificationFunctionMapping,
StorageEntityContainerMapping entityContainerMapping)
{
DebugCheck.NotNull(associationSetModificationFunctionMapping);
DebugCheck.NotNull(entityContainerMapping);
_associationSetModificationFunctionMapping = associationSetModificationFunctionMapping;
_entityContainerMapping = entityContainerMapping;
}
public void Can_get_container_mapping()
{
var containerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
containerMapping);
Assert.Same(containerMapping, storageSetMapping.EntityContainerMapping);
}
public void Can_get_store_and_entity_containers()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
var storeContainer = new EntityContainer("S", DataSpace.CSpace);
var entityContainerMapping =
new StorageEntityContainerMapping(entityContainer, storeContainer, null, false, false);
Assert.Same(entityContainer, entityContainerMapping.EdmEntityContainer);
Assert.Same(storeContainer, entityContainerMapping.StorageEntityContainer);
}
private static bool HasQueryView(StorageEntityContainerMapping storageEntityContainerMapping)
{
foreach (EntitySetBase extent in storageEntityContainerMapping.EdmEntityContainer.BaseEntitySets)
{
if (storageEntityContainerMapping.HasQueryViewForSetMap(extent.Name))
{
return(true);
}
}
return(false);
}
public void Can_add_container_mappings()
{
var mapping = new DbDatabaseMapping();
Assert.Empty(mapping.EntityContainerMappings);
var containerMapping = new StorageEntityContainerMapping(new EntityContainer());
mapping.AddEntityContainerMapping(containerMapping);
Assert.Same(containerMapping, mapping.EntityContainerMappings.Single());
}
public void Can_add_container_mappings()
{
var mapping = new DbDatabaseMapping();
Assert.Empty(mapping.EntityContainerMappings);
var containerMapping = new StorageEntityContainerMapping(new EntityContainer());
mapping.AddEntityContainerMapping(containerMapping);
Assert.Same(containerMapping, mapping.EntityContainerMappings.Single());
}
/// <summary>
/// Entry point for View Generation
/// </summary>
/// <param name="containerMapping"> </param>
/// <param name="workSpace"> </param>
/// <param name="config"> </param>
/// <returns> Generated Views for EntitySets </returns>
internal static ViewGenResults GenerateViewsFromMapping(StorageEntityContainerMapping containerMapping, ConfigViewGenerator config)
{
DebugCheck.NotNull(containerMapping);
DebugCheck.NotNull(config);
Debug.Assert(containerMapping.HasViews, "Precondition Violated: No mapping exists to generate views for!");
//Create Cells from StorageEntityContainerMapping
var cellCreator = new CellCreator(containerMapping);
var cells = cellCreator.GenerateCells();
var identifiers = cellCreator.Identifiers;
return GenerateViewsFromCells(cells, config, identifiers, containerMapping);
}
/// <summary>
/// Entry point for View Generation
/// </summary>
/// <param name="containerMapping"> </param>
/// <param name="workSpace"> </param>
/// <param name="config"> </param>
/// <returns> Generated Views for EntitySets </returns>
internal static ViewGenResults GenerateViewsFromMapping(StorageEntityContainerMapping containerMapping, ConfigViewGenerator config)
{
DebugCheck.NotNull(containerMapping);
DebugCheck.NotNull(config);
Debug.Assert(containerMapping.HasViews, "Precondition Violated: No mapping exists to generate views for!");
//Create Cells from StorageEntityContainerMapping
var cellCreator = new CellCreator(containerMapping);
var cells = cellCreator.GenerateCells();
var identifiers = cellCreator.Identifiers;
return(GenerateViewsFromCells(cells, config, identifiers, containerMapping));
}
// effects: Creates a ViewGenerator object that is capable of
// producing query or update mapping views given the relevant schema
// given the "cells"
internal ViewGenerator(
CellGroup cellGroup, ConfigViewGenerator config,
List <ForeignConstraint> foreignKeyConstraints,
StorageEntityContainerMapping entityContainerMapping)
{
m_cellGroup = cellGroup;
m_config = config;
m_queryRewriterCache = new Dictionary <EntitySetBase, QueryRewriter>();
m_foreignKeyConstraints = foreignKeyConstraints;
m_entityContainerMapping = entityContainerMapping;
var inheritanceGraph =
MetadataHelper.BuildUndirectedGraphOfTypes(entityContainerMapping.StorageMappingItemCollection.EdmItemCollection);
SetConfiguration(entityContainerMapping);
// We fix all the cells at this point
m_queryDomainMap = new MemberDomainMap(
ViewTarget.QueryView, m_config.IsValidationEnabled, cellGroup,
entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
m_updateDomainMap = new MemberDomainMap(
ViewTarget.UpdateView, m_config.IsValidationEnabled, cellGroup,
entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
// We now go and fix the queryDomain map so that it has all the
// values from the S-side as well -- this is needed for domain
// constraint propagation, i.e., values from the S-side get
// propagated to te oneOfConst on the C-side. So we better get
// the "possiblveValues" stuff to contain those constants as well
MemberDomainMap.PropagateUpdateDomainToQueryDomain(cellGroup, m_queryDomainMap, m_updateDomainMap);
UpdateWhereClauseForEachCell(cellGroup, m_queryDomainMap, m_updateDomainMap, m_config);
// We need to simplify cell queries, yet we don't want the conditions to disappear
// So, add an extra value to the domain, temporarily
var queryOpenDomain = m_queryDomainMap.GetOpenDomain();
var updateOpenDomain = m_updateDomainMap.GetOpenDomain();
// Make sure the WHERE clauses of the cells reflect the changes
foreach (var cell in cellGroup)
{
cell.CQuery.WhereClause.FixDomainMap(queryOpenDomain);
cell.SQuery.WhereClause.FixDomainMap(updateOpenDomain);
cell.CQuery.WhereClause.ExpensiveSimplify();
cell.SQuery.WhereClause.ExpensiveSimplify();
cell.CQuery.WhereClause.FixDomainMap(m_queryDomainMap);
cell.SQuery.WhereClause.FixDomainMap(m_updateDomainMap);
}
}
public void Can_get_entity_type_mappings()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var entitySetMapping = new StorageEntitySetMapping(new EntitySet(), entityContainerMapping);
Assert.Empty(entitySetMapping.EntityTypeMappings);
var entityTypeMapping
= new StorageEntityTypeMapping(
new StorageEntitySetMapping(new EntitySet(), entityContainerMapping));
entitySetMapping.AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, entitySetMapping.EntityTypeMappings.Single());
}
public static DbDatabaseMapping Initialize(
this DbDatabaseMapping databaseMapping, EdmModel model, EdmModel database)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(database);
databaseMapping.Model = model;
databaseMapping.Database = database;
var entityContainerMapping = new StorageEntityContainerMapping(model.Containers.Single());
databaseMapping.EntityContainerMappings.Add(entityContainerMapping);
return(databaseMapping);
}
// effects: Creates a ViewGenerator object that is capable of
// producing query or update mapping views given the relevant schema
// given the "cells"
internal ViewGenerator(
CellGroup cellGroup, ConfigViewGenerator config,
List<ForeignConstraint> foreignKeyConstraints,
StorageEntityContainerMapping entityContainerMapping)
{
m_cellGroup = cellGroup;
m_config = config;
m_queryRewriterCache = new Dictionary<EntitySetBase, QueryRewriter>();
m_foreignKeyConstraints = foreignKeyConstraints;
m_entityContainerMapping = entityContainerMapping;
var inheritanceGraph =
MetadataHelper.BuildUndirectedGraphOfTypes(entityContainerMapping.StorageMappingItemCollection.EdmItemCollection);
SetConfiguration(entityContainerMapping);
// We fix all the cells at this point
m_queryDomainMap = new MemberDomainMap(
ViewTarget.QueryView, m_config.IsValidationEnabled, cellGroup,
entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
m_updateDomainMap = new MemberDomainMap(
ViewTarget.UpdateView, m_config.IsValidationEnabled, cellGroup,
entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
// We now go and fix the queryDomain map so that it has all the
// values from the S-side as well -- this is needed for domain
// constraint propagation, i.e., values from the S-side get
// propagated to te oneOfConst on the C-side. So we better get
// the "possiblveValues" stuff to contain those constants as well
MemberDomainMap.PropagateUpdateDomainToQueryDomain(cellGroup, m_queryDomainMap, m_updateDomainMap);
UpdateWhereClauseForEachCell(cellGroup, m_queryDomainMap, m_updateDomainMap, m_config);
// We need to simplify cell queries, yet we don't want the conditions to disappear
// So, add an extra value to the domain, temporarily
var queryOpenDomain = m_queryDomainMap.GetOpenDomain();
var updateOpenDomain = m_updateDomainMap.GetOpenDomain();
// Make sure the WHERE clauses of the cells reflect the changes
foreach (var cell in cellGroup)
{
cell.CQuery.WhereClause.FixDomainMap(queryOpenDomain);
cell.SQuery.WhereClause.FixDomainMap(updateOpenDomain);
cell.CQuery.WhereClause.ExpensiveSimplify();
cell.SQuery.WhereClause.ExpensiveSimplify();
cell.CQuery.WhereClause.FixDomainMap(m_queryDomainMap);
cell.SQuery.WhereClause.FixDomainMap(m_updateDomainMap);
}
}
public void Can_get_entity_set_mappings()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
Assert.Empty(entityContainerMapping.EntitySetMappings);
Assert.Empty(entityContainerMapping.EntitySetMaps);
var entitySetMapping
= new StorageEntitySetMapping(
new EntitySet("ES", null, null, null, new EntityType("E", "N", DataSpace.CSpace)), entityContainerMapping);
entityContainerMapping.AddEntitySetMapping(entitySetMapping);
Assert.Same(entitySetMapping, entityContainerMapping.EntitySetMappings.Single());
Assert.Same(entitySetMapping, entityContainerMapping.EntitySetMaps.Single());
}
public void Can_get_association_set_mappings()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
Assert.Empty(entityContainerMapping.AssociationSetMappings);
Assert.Empty(entityContainerMapping.RelationshipSetMaps);
var associationSetMapping
= new StorageAssociationSetMapping(
new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), entityContainerMapping);
entityContainerMapping.AddAssociationSetMapping(associationSetMapping);
Assert.Same(associationSetMapping, entityContainerMapping.AssociationSetMappings.Single());
Assert.Same(associationSetMapping, entityContainerMapping.RelationshipSetMaps.Single());
}
internal static IEnumerable <StorageTypeMapping> GetMappingsForEntitySetAndType(StorageMappingItemCollection mappingCollection, EntityContainer container, EntitySetBase entitySet, EntityTypeBase entityType)
{
Debug.Assert(entityType != null, "EntityType parameter should not be null.");
StorageEntityContainerMapping containerMapping = GetEntityContainerMap(mappingCollection, container);
StorageSetMapping extentMap = containerMapping.GetSetMapping(entitySet.Name);
//The Set may have no mapping
if (extentMap != null)
{
//for each mapping fragment of Type we are interested in within the given set
//Check use of IsOfTypes in Code review
foreach (StorageTypeMapping typeMap in extentMap.TypeMappings.Where(map => map.Types.Union(map.IsOfTypes).Contains(entityType)))
{
yield return(typeMap);
}
}
}
public void Can_add_and_get_function_import_mapping()
{
var typeUsage =
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32).GetCollectionType());
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var composableFuntionMapping =
new FunctionImportMappingComposable(
new EdmFunction(
"f", "model", DataSpace.CSpace,
new EdmFunctionPayload()
{
IsComposable = true,
ReturnParameters =
new[]
{
new FunctionParameter(
"ReturnType",
typeUsage,
ParameterMode.ReturnValue),
}
}),
new EdmFunction(
"f", "store", DataSpace.SSpace,
new EdmFunctionPayload()
{
IsComposable = true,
ReturnParameters =
new[]
{
new FunctionParameter(
"ReturnType",
typeUsage,
ParameterMode.ReturnValue),
}
}),
null);
Assert.Empty(entityContainerMapping.FunctionImportMappings);
entityContainerMapping.AddFunctionImportMapping(composableFuntionMapping);
Assert.Same(composableFuntionMapping, entityContainerMapping.FunctionImportMappings.Single());
}
/// <summary>
/// Entry point for View Generation
/// </summary>
/// <param name="containerMapping"></param>
/// <param name="workSpace"></param>
/// <param name="config"></param>
/// <returns>Generated Views for EntitySets</returns>
internal static ViewGenResults GenerateViewsFromMapping(StorageEntityContainerMapping containerMapping, ConfigViewGenerator config)
{
EntityUtil.CheckArgumentNull(containerMapping, "containerMapping");
EntityUtil.CheckArgumentNull(config, "config");
Debug.Assert(containerMapping.HasViews, "Precondition Violated: No mapping exists to generate views for!");
if (config.IsNormalTracing)
{
containerMapping.Print(0);
}
//Create Cells from StorageEntityContainerMapping
CellCreator cellCreator = new CellCreator(containerMapping);
List <Cell> cells = cellCreator.GenerateCells(config);
CqlIdentifiers identifiers = cellCreator.Identifiers;
return(GenerateViewsFromCells(cells, config, identifiers, containerMapping));
}
/// <summary>
/// Entry point for View Generation
/// </summary>
/// <param name="containerMapping"></param>
/// <param name="workSpace"></param>
/// <param name="config"></param>
/// <returns>Generated Views for EntitySets</returns>
internal static ViewGenResults GenerateViewsFromMapping(StorageEntityContainerMapping containerMapping, ConfigViewGenerator config)
{
EntityUtil.CheckArgumentNull(containerMapping, "containerMapping");
EntityUtil.CheckArgumentNull(config, "config");
Debug.Assert(containerMapping.HasViews, "Precondition Violated: No mapping exists to generate views for!");
if (config.IsNormalTracing)
{
containerMapping.Print(0);
}
//Create Cells from StorageEntityContainerMapping
CellCreator cellCreator = new CellCreator(containerMapping);
List<Cell> cells = cellCreator.GenerateCells(config);
CqlIdentifiers identifiers = cellCreator.Identifiers;
return GenerateViewsFromCells(cells, config, identifiers, containerMapping);
}
internal static IEnumerable <StorageEntityTypeModificationFunctionMapping> GetModificationFunctionMappingsForEntitySetAndType(StorageMappingItemCollection mappingCollection, EntityContainer container, EntitySetBase entitySet, EntityTypeBase entityType)
{
StorageEntityContainerMapping containerMapping = GetEntityContainerMap(mappingCollection, container);
StorageSetMapping extentMap = containerMapping.GetSetMapping(entitySet.Name);
StorageEntitySetMapping entitySetMapping = extentMap as StorageEntitySetMapping;
//The Set may have no mapping
if (entitySetMapping != null)
{
if (entitySetMapping != null) //could be association set mapping
{
foreach (var v in entitySetMapping.ModificationFunctionMappings.Where(functionMap => functionMap.EntityType.Equals(entityType)))
{
yield return(v);
}
}
}
}
internal static StorageEntityContainerMapping GetEntityContainerMap(StorageMappingItemCollection mappingCollection, EntityContainer entityContainer)
{
ReadOnlyCollection <StorageEntityContainerMapping> entityContainerMaps = mappingCollection.GetItems <StorageEntityContainerMapping>();
StorageEntityContainerMapping entityContainerMap = null;
foreach (StorageEntityContainerMapping map in entityContainerMaps)
{
if ((entityContainer.Equals(map.EdmEntityContainer)) ||
(entityContainer.Equals(map.StorageEntityContainer)))
{
entityContainerMap = map;
break;
}
}
if (entityContainerMap == null)
{
throw new MappingException(System.Data.Entity.Strings.Mapping_NotFound_EntityContainer(entityContainer.Name));
}
return(entityContainerMap);
}
/// <summary>
/// Entry point for View Generation
/// </summary>
/// <param name="containerMapping"></param>
/// <param name="workSpace"></param>
/// <param name="config"></param>
/// <returns>Generated Views for EntitySets</returns>
internal static ViewGenResults GenerateViewsFromMapping(StorageEntityContainerMapping containerMapping, ConfigViewGenerator config)
{
//Contract.Requires(containerMapping != null);
//Contract.Requires(config != null);
Debug.Assert(containerMapping.HasViews, "Precondition Violated: No mapping exists to generate views for!");
#if DEBUG
if (config.IsNormalTracing)
{
containerMapping.Print(0);
}
#endif
//Create Cells from StorageEntityContainerMapping
var cellCreator = new CellCreator(containerMapping);
var cells = cellCreator.GenerateCells();
var identifiers = cellCreator.Identifiers;
return GenerateViewsFromCells(cells, config, identifiers, containerMapping);
}
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();
}
private void WriteEntityContainerMappingElement(StorageEntityContainerMapping containerMapping)
{
DebugCheck.NotNull(containerMapping);
_xmlWriter.WriteStartElement(StorageMslConstructs.EntityContainerMappingElement);
_xmlWriter.WriteAttributeString(StorageMslConstructs.StorageEntityContainerAttribute, _dbSchemaName);
_xmlWriter.WriteAttributeString(
StorageMslConstructs.CdmEntityContainerAttribute, containerMapping.EdmEntityContainer.Name);
foreach (var set in containerMapping.EntitySetMappings)
{
WriteEntitySetMappingElement(set);
}
foreach (var set in containerMapping.AssociationSetMappings)
{
WriteAssociationSetMappingElement(set);
}
_xmlWriter.WriteEndElement();
}
/// <summary>
/// Given a table EntitySet this function finds out all C-side EntitySets that are mapped to the table.
/// </summary>
internal static IEnumerable <EntitySet> GetInfluencingEntitySetsForTable(EntitySet table, MetadataWorkspace workspace)
{
Debug.Assert(table.EntityContainer.GetDataSpace() == DataSpace.SSpace);
ItemCollection itemCollection = null;
workspace.TryGetItemCollection(DataSpace.CSSpace, out itemCollection);
StorageEntityContainerMapping containerMapping = MappingMetadataHelper.GetEntityContainerMap((StorageMappingItemCollection)itemCollection, table.EntityContainer);
//find EntitySetMappings where one of the mapping fragment maps some type to the given table
return(containerMapping.EntitySetMaps
.Where(
map => map.TypeMappings.Any(
typeMap => typeMap.MappingFragments.Any(
mappingFrag => mappingFrag.TableSet.EdmEquals(table)
)
)
)
.Select(m => m.Set)
.Cast <EntitySet>()
.Distinct());
}
/// <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>();
}
/// <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>();
}
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;
}
private void SetConfiguration(StorageEntityContainerMapping entityContainerMapping)
{
m_config.IsValidationEnabled = entityContainerMapping.Validate;
m_config.GenerateUpdateViews = entityContainerMapping.GenerateUpdateViews;
}
private bool SerializedVerifyHashOverMmClosure(
StorageEntityContainerMapping entityContainerMapping, EntityViewContainer entityViewContainer)
{
if (MetadataMappingHasherVisitor.GetMappingClosureHash(
m_storageMappingItemCollection.MappingVersion, entityContainerMapping)
==
entityViewContainer.HashOverMappingClosure)
{
return true;
}
return false;
}
internal ViewgenContext(ViewTarget viewTarget, EntitySetBase extent, IEnumerable<Cell> extentCells,
CqlIdentifiers identifiers, ConfigViewGenerator config, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, StorageEntityContainerMapping entityContainerMapping)
{
foreach (Cell cell in extentCells)
{
Debug.Assert(extent.Equals(cell.GetLeftQuery(viewTarget).Extent));
Debug.Assert(cell.CQuery.NumProjectedSlots == cell.SQuery.NumProjectedSlots);
}
m_extent = extent;
m_viewTarget = viewTarget;
m_config = config;
m_edmItemCollection = entityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
m_entityContainerMapping = entityContainerMapping;
m_identifiers = identifiers;
// create a copy of updateDomainMap so generation of query views later on is not affected
// it is modified in QueryRewriter.AdjustMemberDomainsForUpdateViews
updateDomainMap = updateDomainMap.MakeCopy();
// Create a signature generator that handles all the
// multiconstant work and generating the signatures
MemberDomainMap domainMap = viewTarget == ViewTarget.QueryView ? queryDomainMap : updateDomainMap;
m_memberMaps = new MemberMaps(viewTarget, MemberProjectionIndex.Create(extent, m_edmItemCollection), queryDomainMap, updateDomainMap);
// Create left fragment KB: includes constraints for the extent to be constructed
FragmentQueryKB leftKB = new FragmentQueryKB();
leftKB.CreateVariableConstraints(extent, domainMap, m_edmItemCollection);
m_leftFragmentQP = new FragmentQueryProcessor(leftKB);
m_rewritingCache = new Dictionary<FragmentQuery, Tile<FragmentQuery>>(
FragmentQuery.GetEqualityComparer(m_leftFragmentQP));
// Now using the signatures, create new cells such that
// "extent's" query (C or S) is described in terms of multiconstants
if (!CreateLeftCellWrappers(extentCells, viewTarget))
{
return;
}
// Create right fragment KB: includes constraints for all extents and association roles of right queries
FragmentQueryKB rightKB = new FragmentQueryKB();
MemberDomainMap rightDomainMap = viewTarget == ViewTarget.QueryView ? updateDomainMap : queryDomainMap;
foreach (LeftCellWrapper leftCellWrapper in m_cellWrappers)
{
EntitySetBase rightExtent = leftCellWrapper.RightExtent;
rightKB.CreateVariableConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
rightKB.CreateAssociationConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
}
if (m_viewTarget == ViewTarget.UpdateView)
{
CreateConstraintsForForeignKeyAssociationsAffectingThisWarapper(rightKB, rightDomainMap);
}
m_rightFragmentQP = new FragmentQueryProcessor(rightKB);
// Check for concurrency control tokens
if (m_viewTarget == ViewTarget.QueryView)
{
CheckConcurrencyControlTokens();
}
// For backward compatibility -
// order wrappers by increasing domain size, decreasing number of attributes
m_cellWrappers.Sort(LeftCellWrapper.Comparer);
}
// effects: Given a list of cells in the schema, generates the query and
// update mapping views for OFTYPE(Extent, Type) combinations in this schema
// container. Returns a list of generated query and update views.
// If it is false and some columns in a table are unmapped, an
// exception is raised
private static ViewGenResults GenerateViewsFromCells(
List <Cell> cells, ConfigViewGenerator config,
CqlIdentifiers identifiers,
StorageEntityContainerMapping containerMapping)
{
DebugCheck.NotNull(cells);
DebugCheck.NotNull(config);
Debug.Assert(cells.Count > 0, "There must be at least one cell in the container mapping");
// Go through each table and determine their foreign key constraints
var container = containerMapping.StorageEntityContainer;
Debug.Assert(container != null);
var viewGenResults = new ViewGenResults();
var tmpLog = EnsureAllCSpaceContainerSetsAreMapped(cells, containerMapping);
if (tmpLog.Count > 0)
{
viewGenResults.AddErrors(tmpLog);
Helpers.StringTraceLine(viewGenResults.ErrorsToString());
return(viewGenResults);
}
var foreignKeyConstraints = ForeignConstraint.GetForeignConstraints(container);
var partitioner = new CellPartitioner(cells, foreignKeyConstraints);
var cellGroups = partitioner.GroupRelatedCells();
foreach (var cellGroup in cellGroups)
{
ViewGenerator viewGenerator = null;
var groupErrorLog = new ErrorLog();
try
{
viewGenerator = new ViewGenerator(cellGroup, config, foreignKeyConstraints, containerMapping);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
groupErrorLog = exception.ErrorLog;
}
if (groupErrorLog.Count == 0)
{
Debug.Assert(viewGenerator != null);
groupErrorLog = viewGenerator.GenerateAllBidirectionalViews(viewGenResults.Views, identifiers);
}
if (groupErrorLog.Count != 0)
{
viewGenResults.AddErrors(groupErrorLog);
}
}
// We used to print the errors here. Now we trace them as they are being thrown
//if (viewGenResults.HasErrors && config.IsViewTracing) {
// Helpers.StringTraceLine(viewGenResults.ErrorsToString());
//}
return(viewGenResults);
}
private static 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;
}
// Loads and registers any function mapping translators for the given extent (and related container)
private void InitializeFunctionMappingTranslators(EntitySetBase entitySetBase, StorageEntityContainerMapping mapping)
{
KeyToListMap <AssociationSet, AssociationEndMember> requiredEnds = new KeyToListMap <AssociationSet, AssociationEndMember>(
EqualityComparer <AssociationSet> .Default);
// see if function mapping metadata needs to be processed
if (!m_functionMappingTranslators.ContainsKey(entitySetBase))
{
// load all function mapping data from the current entity container
foreach (StorageEntitySetMapping entitySetMapping in mapping.EntitySetMaps)
{
if (0 < entitySetMapping.ModificationFunctionMappings.Count)
{
// register the function mapping
m_functionMappingTranslators.Add(entitySetMapping.Set, ModificationFunctionMappingTranslator.CreateEntitySetTranslator(entitySetMapping));
// register "null" function translators for all implicitly mapped association sets
foreach (AssociationSetEnd end in entitySetMapping.ImplicitlyMappedAssociationSetEnds)
{
AssociationSet associationSet = end.ParentAssociationSet;
if (!m_functionMappingTranslators.ContainsKey(associationSet))
{
m_functionMappingTranslators.Add(associationSet, ModificationFunctionMappingTranslator.CreateAssociationSetTranslator(null));
}
// Remember that the current entity set is required for all updates to the collocated
// relationship set. This entity set's end is opposite the target end for the mapping.
AssociationSetEnd oppositeEnd = MetadataHelper.GetOppositeEnd(end);
requiredEnds.Add(associationSet, oppositeEnd.CorrespondingAssociationEndMember);
}
}
else
{
// register null translator (so that we never attempt to process this extent again)
m_functionMappingTranslators.Add(entitySetMapping.Set, null);
}
}
foreach (StorageAssociationSetMapping associationSetMapping in mapping.RelationshipSetMaps)
{
if (null != associationSetMapping.ModificationFunctionMapping)
{
AssociationSet set = (AssociationSet)associationSetMapping.Set;
// use indexer rather than Add since the association set may already have an implicit function
// mapping -- this explicit function mapping takes precedence in such cases
m_functionMappingTranslators.Add(set,
ModificationFunctionMappingTranslator.CreateAssociationSetTranslator(associationSetMapping));
// remember that we've seen a function mapping for this association set, which overrides
// any other behaviors for determining required/optional ends
requiredEnds.AddRange(set, Enumerable.Empty <AssociationEndMember>());
}
else
{
if (!m_functionMappingTranslators.ContainsKey(associationSetMapping.Set))
{
// register null translator (so that we never attempt to process this extent again)
m_functionMappingTranslators.Add(associationSetMapping.Set, null);
}
}
}
}
// register association metadata for all association sets encountered
foreach (AssociationSet associationSet in requiredEnds.Keys)
{
m_associationSetMetadata.Add(associationSet, new AssociationSetMetadata(
requiredEnds.EnumerateValues(associationSet)));
}
}
private void InitializeEntitySet(EntitySetBase entitySetBase, MetadataWorkspace workspace)
{
StorageEntityContainerMapping mapping = (StorageEntityContainerMapping)m_mappingCollection.GetMap(entitySetBase.EntityContainer);
// make sure views have been generated for this sub-graph (trigger generation of the sub-graph
// by retrieving a view for one of its components; not actually using the view here)
if (mapping.HasViews)
{
m_mappingCollection.GetGeneratedView(entitySetBase, workspace);
}
Set <EntitySet> affectedTables = new Set <EntitySet>();
if (null != mapping)
{
Set <EdmMember> isNullConditionColumns = new Set <EdmMember>();
// find extent in the container mapping
StorageSetMapping setMapping;
if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.EntitySet)
{
setMapping = mapping.GetEntitySetMapping(entitySetBase.Name);
// Check for members that have result bindings in a function mapping. If a
// function returns the member values, it indicates they are server-generated
m_serverGenProperties.Unite(GetMembersWithResultBinding((StorageEntitySetMapping)setMapping));
}
else if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.AssociationSet)
{
setMapping = mapping.GetRelationshipSetMapping(entitySetBase.Name);
}
else
{
Debug.Fail("unexpected extent type " + entitySetBase.BuiltInTypeKind);
throw EntityUtil.NotSupported();
}
// gather interesting tables, columns and properties from mapping fragments
foreach (StorageMappingFragment mappingFragment in GetMappingFragments(setMapping))
{
affectedTables.Add(mappingFragment.TableSet);
// get all property mappings to figure out if anything is server generated
m_serverGenProperties.AddRange(FindServerGenMembers(mappingFragment));
// get all columns participating in is null conditions
isNullConditionColumns.AddRange(FindIsNullConditionColumns(mappingFragment));
}
if (0 < isNullConditionColumns.Count)
{
// gather is null condition properties based on is null condition columns
foreach (StorageMappingFragment mappingFragment in GetMappingFragments(setMapping))
{
m_isNullConditionProperties.AddRange(FindPropertiesMappedToColumns(isNullConditionColumns, mappingFragment));
}
}
}
m_affectedTables.Add(entitySetBase, affectedTables.MakeReadOnly());
InitializeFunctionMappingTranslators(entitySetBase, mapping);
// for association sets, initialize AssociationSetMetadata if no function has claimed ownership
// of the association yet
if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.AssociationSet)
{
AssociationSet associationSet = (AssociationSet)entitySetBase;
if (!m_associationSetMetadata.ContainsKey(associationSet))
{
m_associationSetMetadata.Add(associationSet, new AssociationSetMetadata(
m_affectedTables[associationSet], associationSet, workspace));
}
}
}
// effects: Given a list of cells in the schema, generates the query and
// update mapping views for OFTYPE(Extent, Type) combinations in this schema
// container. Returns a list of generated query and update views.
// If it is false and some columns in a table are unmapped, an
// exception is raised
private static ViewGenResults GenerateViewsFromCells(List<Cell> cells, ConfigViewGenerator config,
CqlIdentifiers identifiers,
StorageEntityContainerMapping containerMapping)
{
EntityUtil.CheckArgumentNull(cells, "cells");
EntityUtil.CheckArgumentNull(config, "config");
Debug.Assert(cells.Count > 0, "There must be at least one cell in the container mapping");
// Go through each table and determine their foreign key constraints
EntityContainer container = containerMapping.StorageEntityContainer;
Debug.Assert(container != null);
ViewGenResults viewGenResults = new ViewGenResults();
ErrorLog tmpLog = EnsureAllCSpaceContainerSetsAreMapped(cells, config, containerMapping);
if (tmpLog.Count > 0)
{
viewGenResults.AddErrors(tmpLog);
Helpers.StringTraceLine(viewGenResults.ErrorsToString());
return viewGenResults;
}
List<ForeignConstraint> foreignKeyConstraints = ForeignConstraint.GetForeignConstraints(container);
CellPartitioner partitioner = new CellPartitioner(cells, foreignKeyConstraints);
List<CellGroup> cellGroups = partitioner.GroupRelatedCells();
foreach (CellGroup cellGroup in cellGroups)
{
ViewGenerator viewGenerator = null;
ErrorLog groupErrorLog = new ErrorLog();
try
{
viewGenerator = new ViewGenerator(cellGroup, config, foreignKeyConstraints, containerMapping);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
groupErrorLog = exception.ErrorLog;
}
if (groupErrorLog.Count == 0)
{
Debug.Assert(viewGenerator != null);
groupErrorLog = viewGenerator.GenerateAllBidirectionalViews(viewGenResults.Views, identifiers);
}
if (groupErrorLog.Count != 0)
{
viewGenResults.AddErrors(groupErrorLog);
}
}
// We used to print the errors here. Now we trace them as they are being thrown
//if (viewGenResults.HasErrors && config.IsViewTracing) {
// Helpers.StringTraceLine(viewGenResults.ErrorsToString());
//}
return viewGenResults;
}
// effects: Given a container, ensures that all entity/association
// sets in container on the C-side have been mapped
private static ErrorLog EnsureAllCSpaceContainerSetsAreMapped(IEnumerable<Cell> cells,
ConfigViewGenerator config,
StorageEntityContainerMapping containerMapping)
{
Set<EntitySetBase> mappedExtents = new Set<EntitySetBase>();
string mslFileLocation = null;
EntityContainer container = null;
// Determine the container and name of the file while determining
// the set of mapped extents in the cells
foreach (Cell cell in cells)
{
mappedExtents.Add(cell.CQuery.Extent);
mslFileLocation = cell.CellLabel.SourceLocation;
// All cells are from the same container
container = cell.CQuery.Extent.EntityContainer;
}
Debug.Assert(container != null);
List<EntitySetBase> missingExtents = new List<EntitySetBase>();
// Go through all the extents in the container and determine
// extents that are missing
foreach (EntitySetBase extent in container.BaseEntitySets)
{
if (mappedExtents.Contains(extent) == false
&& !(containerMapping.HasQueryViewForSetMap(extent.Name)))
{
AssociationSet associationSet = extent as AssociationSet;
if (associationSet==null || !associationSet.ElementType.IsForeignKey)
{
missingExtents.Add(extent);
}
}
}
ErrorLog errorLog = new ErrorLog();
// If any extent is not mapped, add an error
if (missingExtents.Count > 0)
{
StringBuilder extentBuilder = new StringBuilder();
bool isFirst = true;
foreach (EntitySetBase extent in missingExtents)
{
if (isFirst == false)
{
extentBuilder.Append(", ");
}
isFirst = false;
extentBuilder.Append(extent.Name);
}
string message = System.Data.Entity.Strings.ViewGen_Missing_Set_Mapping(extentBuilder);
// Find the cell with smallest line number - so that we can
// point to the beginning of the file
int lowestLineNum = -1;
Cell smallestCell = null;
foreach (Cell cell in cells)
{
if (lowestLineNum == -1 || cell.CellLabel.StartLineNumber < lowestLineNum)
{
smallestCell = cell;
lowestLineNum = cell.CellLabel.StartLineNumber;
}
}
Debug.Assert(smallestCell != null && lowestLineNum >= 0);
EdmSchemaError edmSchemaError = new EdmSchemaError(message, (int)ViewGenErrorCode.MissingExtentMapping,
EdmSchemaErrorSeverity.Error, containerMapping.SourceLocation, containerMapping.StartLineNumber,
containerMapping.StartLinePosition, null);
ErrorLog.Record record = new ErrorLog.Record(edmSchemaError);
errorLog.AddEntry(record);
}
return errorLog;
}
// effects: Given a container, ensures that all entity/association
// sets in container on the C-side have been mapped
private static ErrorLog EnsureAllCSpaceContainerSetsAreMapped(
IEnumerable <Cell> cells,
StorageEntityContainerMapping containerMapping)
{
var mappedExtents = new Set <EntitySetBase>();
string mslFileLocation = null;
EntityContainer container = null;
// Determine the container and name of the file while determining
// the set of mapped extents in the cells
foreach (var cell in cells)
{
mappedExtents.Add(cell.CQuery.Extent);
mslFileLocation = cell.CellLabel.SourceLocation;
// All cells are from the same container
container = cell.CQuery.Extent.EntityContainer;
}
Debug.Assert(container != null);
var missingExtents = new List <EntitySetBase>();
// Go through all the extents in the container and determine
// extents that are missing
foreach (var extent in container.BaseEntitySets)
{
if (mappedExtents.Contains(extent) == false &&
!(containerMapping.HasQueryViewForSetMap(extent.Name)))
{
var associationSet = extent as AssociationSet;
if (associationSet == null ||
!associationSet.ElementType.IsForeignKey)
{
missingExtents.Add(extent);
}
}
}
var errorLog = new ErrorLog();
// If any extent is not mapped, add an error
if (missingExtents.Count > 0)
{
var extentBuilder = new StringBuilder();
var isFirst = true;
foreach (var extent in missingExtents)
{
if (isFirst == false)
{
extentBuilder.Append(", ");
}
isFirst = false;
extentBuilder.Append(extent.Name);
}
var message = Strings.ViewGen_Missing_Set_Mapping(extentBuilder);
// Find the cell with smallest line number - so that we can
// point to the beginning of the file
var lowestLineNum = -1;
Cell smallestCell = null;
foreach (var cell in cells)
{
if (lowestLineNum == -1 ||
cell.CellLabel.StartLineNumber < lowestLineNum)
{
smallestCell = cell;
lowestLineNum = cell.CellLabel.StartLineNumber;
}
}
Debug.Assert(smallestCell != null && lowestLineNum >= 0);
var edmSchemaError = new EdmSchemaError(
message, (int)ViewGenErrorCode.MissingExtentMapping,
EdmSchemaErrorSeverity.Error, containerMapping.SourceLocation, containerMapping.StartLineNumber,
containerMapping.StartLinePosition, null);
var record = new ErrorLog.Record(edmSchemaError);
errorLog.AddEntry(record);
}
return(errorLog);
}
/// <summary>
/// Entry point for Type specific generation of Query Views
/// </summary>
internal static ViewGenResults GenerateTypeSpecificQueryView(StorageEntityContainerMapping containerMapping,
ConfigViewGenerator config,
EntitySetBase entity,
EntityTypeBase type,
bool includeSubtypes,
out bool success)
{
EntityUtil.CheckArgumentNull(containerMapping, "containerMapping");
EntityUtil.CheckArgumentNull(config, "config");
EntityUtil.CheckArgumentNull(entity, "entity");
EntityUtil.CheckArgumentNull(type, "type");
Debug.Assert(!type.Abstract, "Can not generate OfType/OfTypeOnly query view for and abstract type");
if (config.IsNormalTracing)
{
Helpers.StringTraceLine("");
Helpers.StringTraceLine("<<<<<<<< Generating Query View for Entity [" + entity.Name + "] OfType" + (includeSubtypes ? "" : "Only") + "(" + type.Name + ") >>>>>>>");
}
if (containerMapping.GetEntitySetMapping(entity.Name).QueryView != null)
{
//Type-specific QV does not exist in the cache, but
// there is a EntitySet QV. So we can't generate the view (no mapping exists for this EntitySet)
// and we rely on Query to call us again to get the EntitySet View.
success = false;
return null;
}
//Compute Cell Groups or get it from Memoizer
InputForComputingCellGroups args = new InputForComputingCellGroups(containerMapping, config);
OutputFromComputeCellGroups result = containerMapping.GetCellgroups(args);
success = result.Success;
if (!success)
{
return null;
}
List<ForeignConstraint> foreignKeyConstraints = result.ForeignKeyConstraints;
// Get a Clone of cell groups from cache since cells are modified during viewgen, and we dont want the cached copy to change
List<CellGroup> cellGroups = cellGroups = result.CellGroups.Select(setOfcells => new CellGroup(setOfcells.Select(cell => new Cell(cell)))).ToList();
List<Cell> cells = result.Cells;
CqlIdentifiers identifiers = result.Identifiers;
ViewGenResults viewGenResults = new ViewGenResults();
ErrorLog tmpLog = EnsureAllCSpaceContainerSetsAreMapped(cells, config, containerMapping);
if (tmpLog.Count > 0)
{
viewGenResults.AddErrors(tmpLog);
Helpers.StringTraceLine(viewGenResults.ErrorsToString());
success = true; //atleast we tried successfully
return viewGenResults;
}
foreach (CellGroup cellGroup in cellGroups)
{
if (!DoesCellGroupContainEntitySet(cellGroup, entity))
{
continue;
}
ViewGenerator viewGenerator = null;
ErrorLog groupErrorLog = new ErrorLog();
try
{
viewGenerator = new ViewGenerator(cellGroup, config, foreignKeyConstraints, containerMapping);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
groupErrorLog = exception.ErrorLog;
}
if (groupErrorLog.Count > 0)
{
break;
}
Debug.Assert(viewGenerator != null); //make sure there is no exception thrown that does not add error to log
ViewGenMode mode = includeSubtypes ? ViewGenMode.OfTypeViews : ViewGenMode.OfTypeOnlyViews;
groupErrorLog = viewGenerator.GenerateQueryViewForSingleExtent(viewGenResults.Views, identifiers, entity, type, mode);
if (groupErrorLog.Count != 0)
{
viewGenResults.AddErrors(groupErrorLog);
}
}
success = true;
return viewGenResults;
}
// effects: Creates a cell creator object for an entity container's
// mappings (specified in "maps")
internal CellCreator(StorageEntityContainerMapping containerMapping)
{
m_containerMapping = containerMapping;
m_identifiers = new CqlIdentifiers();
}
private void SetConfiguration(StorageEntityContainerMapping entityContainerMapping)
{
m_config.IsValidationEnabled = entityContainerMapping.Validate;
m_config.GenerateUpdateViews = entityContainerMapping.GenerateUpdateViews;
}
internal ViewgenContext(
ViewTarget viewTarget, EntitySetBase extent, IList <Cell> extentCells,
CqlIdentifiers identifiers, ConfigViewGenerator config, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, StorageEntityContainerMapping entityContainerMapping)
{
foreach (var cell in extentCells)
{
Debug.Assert(extent.Equals(cell.GetLeftQuery(viewTarget).Extent));
Debug.Assert(cell.CQuery.NumProjectedSlots == cell.SQuery.NumProjectedSlots);
}
m_extent = extent;
m_viewTarget = viewTarget;
m_config = config;
m_edmItemCollection = entityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
m_entityContainerMapping = entityContainerMapping;
m_identifiers = identifiers;
// create a copy of updateDomainMap so generation of query views later on is not affected
// it is modified in QueryRewriter.AdjustMemberDomainsForUpdateViews
updateDomainMap = updateDomainMap.MakeCopy();
// Create a signature generator that handles all the
// multiconstant work and generating the signatures
var domainMap = viewTarget == ViewTarget.QueryView ? queryDomainMap : updateDomainMap;
m_memberMaps = new MemberMaps(
viewTarget, MemberProjectionIndex.Create(extent, m_edmItemCollection), queryDomainMap, updateDomainMap);
// Create left fragment KB: includes constraints for the extent to be constructed
var leftKB = new FragmentQueryKBChaseSupport();
leftKB.CreateVariableConstraints(extent, domainMap, m_edmItemCollection);
m_leftFragmentQP = new FragmentQueryProcessor(leftKB);
m_rewritingCache = new Dictionary <FragmentQuery, Tile <FragmentQuery> >(
FragmentQuery.GetEqualityComparer(m_leftFragmentQP));
// Now using the signatures, create new cells such that
// "extent's" query (C or S) is described in terms of multiconstants
if (!CreateLeftCellWrappers(extentCells, viewTarget))
{
return;
}
// Create right fragment KB: includes constraints for all extents and association roles of right queries
var rightKB = new FragmentQueryKBChaseSupport();
var rightDomainMap = viewTarget == ViewTarget.QueryView ? updateDomainMap : queryDomainMap;
foreach (var leftCellWrapper in m_cellWrappers)
{
var rightExtent = leftCellWrapper.RightExtent;
rightKB.CreateVariableConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
rightKB.CreateAssociationConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
}
if (m_viewTarget == ViewTarget.UpdateView)
{
CreateConstraintsForForeignKeyAssociationsAffectingThisWrapper(rightKB, rightDomainMap);
}
m_rightFragmentQP = new FragmentQueryProcessor(rightKB);
// Check for concurrency control tokens
if (m_viewTarget == ViewTarget.QueryView)
{
CheckConcurrencyControlTokens();
}
// For backward compatibility -
// order wrappers by increasing domain size, decreasing number of attributes
m_cellWrappers.Sort(LeftCellWrapper.Comparer);
}
/// <summary>
/// Entry point for Type specific generation of Query Views
/// </summary>
internal static ViewGenResults GenerateTypeSpecificQueryView(
StorageEntityContainerMapping containerMapping,
ConfigViewGenerator config,
EntitySetBase entity,
EntityTypeBase type,
bool includeSubtypes,
out bool success)
{
DebugCheck.NotNull(containerMapping);
DebugCheck.NotNull(config);
DebugCheck.NotNull(entity);
DebugCheck.NotNull(type);
Debug.Assert(!type.Abstract, "Can not generate OfType/OfTypeOnly query view for and abstract type");
if (config.IsNormalTracing)
{
Helpers.StringTraceLine("");
Helpers.StringTraceLine(
"<<<<<<<< Generating Query View for Entity [" + entity.Name + "] OfType" + (includeSubtypes ? "" : "Only") + "("
+ type.Name + ") >>>>>>>");
}
if (containerMapping.GetEntitySetMapping(entity.Name).QueryView != null)
{
//Type-specific QV does not exist in the cache, but
// there is a EntitySet QV. So we can't generate the view (no mapping exists for this EntitySet)
// and we rely on Query to call us again to get the EntitySet View.
success = false;
return(null);
}
//Compute Cell Groups or get it from Memoizer
var args = new InputForComputingCellGroups(containerMapping, config);
var result = containerMapping.GetCellgroups(args);
success = result.Success;
if (!success)
{
return(null);
}
var foreignKeyConstraints = result.ForeignKeyConstraints;
// Get a Clone of cell groups from cache since cells are modified during viewgen, and we dont want the cached copy to change
var cellGroups = result.CellGroups.Select(setOfcells => new CellGroup(setOfcells.Select(cell => new Cell(cell)))).ToList();
var cells = result.Cells;
var identifiers = result.Identifiers;
var viewGenResults = new ViewGenResults();
var tmpLog = EnsureAllCSpaceContainerSetsAreMapped(cells, containerMapping);
if (tmpLog.Count > 0)
{
viewGenResults.AddErrors(tmpLog);
Helpers.StringTraceLine(viewGenResults.ErrorsToString());
success = true; //atleast we tried successfully
return(viewGenResults);
}
foreach (var cellGroup in cellGroups)
{
if (!DoesCellGroupContainEntitySet(cellGroup, entity))
{
continue;
}
ViewGenerator viewGenerator = null;
var groupErrorLog = new ErrorLog();
try
{
viewGenerator = new ViewGenerator(cellGroup, config, foreignKeyConstraints, containerMapping);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
groupErrorLog = exception.ErrorLog;
}
if (groupErrorLog.Count > 0)
{
break;
}
Debug.Assert(viewGenerator != null); //make sure there is no exception thrown that does not add error to log
var mode = includeSubtypes ? ViewGenMode.OfTypeViews : ViewGenMode.OfTypeOnlyViews;
groupErrorLog = viewGenerator.GenerateQueryViewForSingleExtent(viewGenResults.Views, identifiers, entity, type, mode);
if (groupErrorLog.Count != 0)
{
viewGenResults.AddErrors(groupErrorLog);
}
}
success = true;
return(viewGenResults);
}
/// <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>
public StorageAssociationSetMapping(AssociationSet extent, StorageEntityContainerMapping entityContainerMapping)
: base(extent, entityContainerMapping)
{
}
public void AddEntityContainerMapping(StorageEntityContainerMapping entityContainerMapping)
{
Check.NotNull(entityContainerMapping, "entityContainerMapping");
_entityContainerMappings.Add(entityContainerMapping);
}
// effects: Creates a cell creator object for an entity container's
// mappings (specified in "maps")
internal CellCreator(StorageEntityContainerMapping containerMapping)
{
m_containerMapping = containerMapping;
m_identifiers = new CqlIdentifiers();
}
public void WriteEntityContainerMappingElement_should_write_function_import_elements()
{
var typeUsage =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
var complexTypeProperty1 = new EdmProperty("CTProperty1", typeUsage);
var complexTypeProperty2 = new EdmProperty("CTProperty2", typeUsage);
var complexType = new ComplexType("CT", "Ns", DataSpace.CSpace);
complexType.AddMember(complexTypeProperty1);
complexType.AddMember(complexTypeProperty2);
var functionImport =
new EdmFunction(
"f_c", "Ns", DataSpace.CSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = true,
ReturnParameters =
new[]
{
new FunctionParameter(
"ReturnValue",
TypeUsage.CreateDefaultTypeUsage(complexType.GetCollectionType()),
ParameterMode.ReturnValue)
},
Parameters =
new[]
{
new FunctionParameter("param", typeUsage, ParameterMode.Out)
}
});
var rowTypeProperty1 = new EdmProperty("RTProperty1", typeUsage);
var rowTypeProperty2 = new EdmProperty("RTProperty2", typeUsage);
var rowType = new RowType(new[] { rowTypeProperty1, rowTypeProperty2 });
var storeFunction =
new EdmFunction(
"f_s", "Ns.Store", DataSpace.SSpace,
new EdmFunctionPayload
{
ReturnParameters =
new[]
{
new FunctionParameter(
"Return",
TypeUsage.CreateDefaultTypeUsage(rowType),
ParameterMode.ReturnValue)
},
Parameters =
new[]
{
new FunctionParameter("param", typeUsage, ParameterMode.Out)
}
});
var structuralTypeMapping =
new Tuple <StructuralType, List <StorageConditionPropertyMapping>, List <StoragePropertyMapping> >(
complexType, new List <StorageConditionPropertyMapping>(), new List <StoragePropertyMapping>());
structuralTypeMapping.Item3.Add(new StorageScalarPropertyMapping(complexTypeProperty1, rowTypeProperty1));
structuralTypeMapping.Item3.Add(new StorageScalarPropertyMapping(complexTypeProperty2, rowTypeProperty2));
var functionImportMapping = new FunctionImportMappingComposable(
functionImport,
storeFunction,
new List <Tuple <StructuralType, List <StorageConditionPropertyMapping>, List <StoragePropertyMapping> > >
{
structuralTypeMapping
});
var containerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.SSpace));
containerMapping.AddFunctionImportMapping(functionImportMapping);
var fixture = new Fixture();
fixture.Writer.WriteEntityContainerMappingElement(containerMapping);
Assert.Equal(
@"<EntityContainerMapping StorageEntityContainer="""" CdmEntityContainer=""C"">
<FunctionImportMapping FunctionName=""Ns.Store.f_s"" FunctionImportName=""f_c"">
<ResultMapping>
<ComplexTypeMapping TypeName=""Ns.CT"">
<ScalarProperty Name=""CTProperty1"" ColumnName=""RTProperty1"" />
<ScalarProperty Name=""CTProperty2"" ColumnName=""RTProperty2"" />
</ComplexTypeMapping>
</ResultMapping>
</FunctionImportMapping>
</EntityContainerMapping>",
fixture.ToString());
}
private ErrorLog GenerateQueryViewForExtentAndType(StorageEntityContainerMapping entityContainerMapping, CqlIdentifiers identifiers, ViewSet views, EntitySetBase entity, EntityTypeBase type, ViewGenMode mode)
{
Debug.Assert(mode != ViewGenMode.GenerateAllViews);
// Keep track of the mapping exceptions that we have generated
ErrorLog errorLog = new ErrorLog();
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("================= Generating {0} Query View for: {1} ===========================",
(mode == ViewGenMode.OfTypeViews) ? "OfType" : "OfTypeOnly",
entity.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
try
{
// (1) view generation (checks that extents are fully mapped)
ViewgenContext context = CreateViewgenContext(entity, ViewTarget.QueryView, identifiers);
QueryRewriter queryRewriter = GenerateViewsForExtentAndType(type, context, identifiers, views, mode);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
errorLog.Merge(exception.ErrorLog);
}
return errorLog;
}
private static bool HasQueryView(StorageEntityContainerMapping storageEntityContainerMapping)
{
foreach (EntitySetBase extent in storageEntityContainerMapping.EdmEntityContainer.BaseEntitySets)
{
if (storageEntityContainerMapping.HasQueryViewForSetMap(extent.Name))
{
return true;
}
}
return false;
}
/// <summary>
/// Creates a concrete DbMappingViewCache corresponding to the specified container mapping.
/// </summary>
/// <param name="mapping">A mapping between a container in the conceptual model and a container in
/// the store model.</param>
/// <returns>A concrete DbMappingViewCache, or null if a creator was not found.</returns>
internal DbMappingViewCache Create(StorageEntityContainerMapping mapping)
{
return(Create(mapping.EdmEntityContainer.Name, mapping.StorageEntityContainer.Name));
}
