// Builds a map from foreign key instances to commands, with an entry for every command that may need to // precede some other operation. // // Predecessor commands must precede other commands using those values. There are two kinds of // predecessor: // // - Commands (updates or inserts) inserting FK "targets" (referenced by the foreign key) // - Commands (updates or deletes) deleting FK "sources" (referencing the foreign key) // // To avoid violating constraints, FK values must be created before they are referenced, and // cannot be deleted before their references private KeyToListMap <ForeignKeyValue, UpdateCommand> DetermineForeignKeyPredecessors() { var predecessors = new KeyToListMap <ForeignKeyValue, UpdateCommand>( _keyComparer); foreach (var command in Vertices.OfType <DynamicUpdateCommand>()) { if (ModificationOperator.Update == command.Operator || ModificationOperator.Insert == command.Operator) { foreach (var fkConstraint in _targetMap.EnumerateValues(command.Table)) { ForeignKeyValue fk; if (ForeignKeyValue.TryCreateTargetKey(fkConstraint, command.CurrentValues, true, out fk)) { // if this is an update and the target key is unchanged, there is no // need to add a dependency (from the perspective of the target, the update // is a no-op) ForeignKeyValue originalFK; if (ModificationOperator.Update != command.Operator || !ForeignKeyValue.TryCreateTargetKey(fkConstraint, command.OriginalValues, true, out originalFK) || !_keyComparer.Equals(originalFK, fk)) { predecessors.Add(fk, command); } } } } // register all source predecessors if (ModificationOperator.Update == command.Operator || ModificationOperator.Delete == command.Operator) { foreach (var fkConstraint in _sourceMap.EnumerateValues(command.Table)) { ForeignKeyValue fk; if (ForeignKeyValue.TryCreateSourceKey(fkConstraint, command.OriginalValues, false, out fk)) { // if this is an update and the source key is unchanged, there is no // need to add a dependency (from the perspective of the source, the update // is a no-op) ForeignKeyValue currentFK; if (ModificationOperator.Update != command.Operator || !ForeignKeyValue.TryCreateSourceKey(fkConstraint, command.CurrentValues, false, out currentFK) || !_keyComparer.Equals(currentFK, fk)) { predecessors.Add(fk, command); } } } } } return(predecessors); }
private QueryRewriter GenerateDirectionalViewsForExtent( ViewTarget viewTarget, EntitySetBase extent, CqlIdentifiers identifiers, KeyToListMap <EntitySetBase, GeneratedView> views) { ViewgenContext viewgenContext = this.CreateViewgenContext(extent, viewTarget, identifiers); QueryRewriter queryRewriter = (QueryRewriter)null; if (this.m_config.GenerateViewsForEachType) { foreach (EdmType generatedType in MetadataHelper.GetTypeAndSubtypesOf((EdmType)extent.ElementType, (ItemCollection)this.m_entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, false)) { if (this.m_config.IsViewTracing && !generatedType.Equals((object)extent.ElementType)) { Helpers.FormatTraceLine("CQL View for {0} and type {1}", (object)extent.Name, (object)generatedType.Name); } queryRewriter = this.GenerateViewsForExtentAndType(generatedType, viewgenContext, identifiers, views, ViewGenMode.OfTypeViews); } } else { queryRewriter = this.GenerateViewsForExtentAndType((EdmType)extent.ElementType, viewgenContext, identifiers, views, ViewGenMode.OfTypeViews); } if (viewTarget == ViewTarget.QueryView) { this.m_config.SetTimeForFinishedActivity(PerfType.QueryViews); } else { this.m_config.SetTimeForFinishedActivity(PerfType.UpdateViews); } this.m_queryRewriterCache[extent] = queryRewriter; return(queryRewriter); }
/// <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); } } }
private void CollectUnreachableTypes(Set <EntityType> reachableTypes, out KeyToListMap <EntityType, LineInfo> entityTypes, out KeyToListMap <EntityType, LineInfo> isTypeOfEntityTypes) { // Collect line infos for types in violation entityTypes = new KeyToListMap <EntityType, LineInfo>(EqualityComparer <EntityType> .Default); isTypeOfEntityTypes = new KeyToListMap <EntityType, LineInfo>(EqualityComparer <EntityType> .Default); if (reachableTypes.Count == this.MappedEntityTypes.Count) { // All types are reachable; nothing to check return; } // Find IsTypeOf mappings where no type in hierarchy can generate a row foreach (var isTypeOf in m_isTypeOfLineInfos.Keys) { if (!MetadataHelper.GetTypeAndSubtypesOf(isTypeOf, m_itemCollection, false) .Cast <EntityType>() .Intersect(reachableTypes) .Any()) { // no type in the hierarchy is reachable... isTypeOfEntityTypes.AddRange(isTypeOf, m_isTypeOfLineInfos.EnumerateValues(isTypeOf)); } } // Find explicit types not generating a value foreach (var entityType in m_entityTypeLineInfos.Keys) { if (!reachableTypes.Contains(entityType)) { entityTypes.AddRange(entityType, m_entityTypeLineInfos.EnumerateValues(entityType)); } } }
private ErrorLog GenerateQueryViewForExtentAndType( CqlIdentifiers identifiers, KeyToListMap <EntitySetBase, GeneratedView> views, EntitySetBase entity, EntityTypeBase type, ViewGenMode mode) { ErrorLog errorLog = new ErrorLog(); if (this.m_config.IsViewTracing) { Helpers.StringTraceLine(string.Empty); Helpers.StringTraceLine(string.Empty); Helpers.FormatTraceLine("================= Generating {0} Query View for: {1} ===========================", mode == ViewGenMode.OfTypeViews ? (object)"OfType" : (object)"OfTypeOnly", (object)entity.Name); Helpers.StringTraceLine(string.Empty); Helpers.StringTraceLine(string.Empty); } try { ViewgenContext viewgenContext = this.CreateViewgenContext(entity, ViewTarget.QueryView, identifiers); this.GenerateViewsForExtentAndType((EdmType)type, viewgenContext, identifiers, views, mode); } catch (InternalMappingException ex) { errorLog.Merge(ex.ErrorLog); } return(errorLog); }
// effects: Given a list of node, produces a new list in which all // leaf nodes of the same extent are adjacent to each other. Non-leaf // nodes are also adjacent to each other. CHANGE_ADYA_IMPROVE: Merge with GroupByRightExtent private static List <CellTreeNode> GroupLeafChildrenByExtent(List <CellTreeNode> nodes) { // Keep track of leaf cells for each extent var extentMap = new KeyToListMap <EntitySetBase, CellTreeNode>(EqualityComparer <EntitySetBase> .Default); var newNodes = new List <CellTreeNode>(); foreach (var node in nodes) { var leafNode = node as LeafCellTreeNode; // All non-leaf nodes are added to the result now // leaf nodes are added outside the loop if (leafNode != null) { extentMap.Add(leafNode.LeftCellWrapper.RightCellQuery.Extent, leafNode); } else { newNodes.Add(node); } } // Go through the map and add the leaf children newNodes.AddRange(extentMap.AllValues); return(newNodes); }
private void CheckImplication( SchemaConstraints <ViewKeyConstraint> cViewConstraints, SchemaConstraints <ViewKeyConstraint> sViewConstraints) { this.CheckImplicationKeyConstraints(cViewConstraints, sViewConstraints); KeyToListMap <CellGroupValidator.ExtentPair, ViewKeyConstraint> keyToListMap = new KeyToListMap <CellGroupValidator.ExtentPair, ViewKeyConstraint>((IEqualityComparer <CellGroupValidator.ExtentPair>)EqualityComparer <CellGroupValidator.ExtentPair> .Default); foreach (ViewKeyConstraint keyConstraint in cViewConstraints.KeyConstraints) { CellGroupValidator.ExtentPair key = new CellGroupValidator.ExtentPair(keyConstraint.Cell.CQuery.Extent, keyConstraint.Cell.SQuery.Extent); keyToListMap.Add(key, keyConstraint); } foreach (CellGroupValidator.ExtentPair key in keyToListMap.Keys) { ReadOnlyCollection <ViewKeyConstraint> readOnlyCollection = keyToListMap.ListForKey(key); bool flag = false; foreach (ViewKeyConstraint second in readOnlyCollection) { foreach (ViewKeyConstraint keyConstraint in sViewConstraints.KeyConstraints) { if (keyConstraint.Implies(second)) { flag = true; break; } } } if (!flag) { this.m_errorLog.AddEntry(ViewKeyConstraint.GetErrorRecord((IEnumerable <ViewKeyConstraint>)readOnlyCollection)); } } }
internal KeyToListMap <int, TVertex> GenerateConnectedComponents() { int compNum = 0; Dictionary <TVertex, UndirectedGraph <TVertex> .ComponentNum> dictionary = new Dictionary <TVertex, UndirectedGraph <TVertex> .ComponentNum>(this.m_comparer); foreach (TVertex vertex in this.Vertices) { dictionary.Add(vertex, new UndirectedGraph <TVertex> .ComponentNum(compNum)); ++compNum; } foreach (KeyValuePair <TVertex, TVertex> edge in this.Edges) { if (dictionary[edge.Key].componentNum != dictionary[edge.Value].componentNum) { int componentNum1 = dictionary[edge.Value].componentNum; int componentNum2 = dictionary[edge.Key].componentNum; dictionary[edge.Value].componentNum = componentNum2; foreach (TVertex key in dictionary.Keys) { if (dictionary[key].componentNum == componentNum1) { dictionary[key].componentNum = componentNum2; } } } } KeyToListMap <int, TVertex> keyToListMap = new KeyToListMap <int, TVertex>((IEqualityComparer <int>)EqualityComparer <int> .Default); foreach (TVertex vertex in this.Vertices) { int componentNum = dictionary[vertex].componentNum; keyToListMap.Add(componentNum, vertex); } return(keyToListMap); }
private KeyToListMap <UpdateCommandOrderer.ForeignKeyValue, UpdateCommand> DetermineForeignKeyPredecessors() { KeyToListMap <UpdateCommandOrderer.ForeignKeyValue, UpdateCommand> keyToListMap = new KeyToListMap <UpdateCommandOrderer.ForeignKeyValue, UpdateCommand>((IEqualityComparer <UpdateCommandOrderer.ForeignKeyValue>) this._keyComparer); foreach (DynamicUpdateCommand dynamicUpdateCommand in this.Vertices.OfType <DynamicUpdateCommand>()) { if (dynamicUpdateCommand.Operator == ModificationOperator.Update || ModificationOperator.Insert == dynamicUpdateCommand.Operator) { foreach (ReferentialConstraint enumerateValue in this._targetMap.EnumerateValues((EntitySetBase)dynamicUpdateCommand.Table)) { UpdateCommandOrderer.ForeignKeyValue key1; UpdateCommandOrderer.ForeignKeyValue key2; if (UpdateCommandOrderer.ForeignKeyValue.TryCreateTargetKey(enumerateValue, dynamicUpdateCommand.CurrentValues, true, out key1) && (dynamicUpdateCommand.Operator != ModificationOperator.Update || !UpdateCommandOrderer.ForeignKeyValue.TryCreateTargetKey(enumerateValue, dynamicUpdateCommand.OriginalValues, true, out key2) || !this._keyComparer.Equals(key2, key1))) { keyToListMap.Add(key1, (UpdateCommand)dynamicUpdateCommand); } } } if (dynamicUpdateCommand.Operator == ModificationOperator.Update || ModificationOperator.Delete == dynamicUpdateCommand.Operator) { foreach (ReferentialConstraint enumerateValue in this._sourceMap.EnumerateValues((EntitySetBase)dynamicUpdateCommand.Table)) { UpdateCommandOrderer.ForeignKeyValue key1; UpdateCommandOrderer.ForeignKeyValue key2; if (UpdateCommandOrderer.ForeignKeyValue.TryCreateSourceKey(enumerateValue, dynamicUpdateCommand.OriginalValues, false, out key1) && (dynamicUpdateCommand.Operator != ModificationOperator.Update || !UpdateCommandOrderer.ForeignKeyValue.TryCreateSourceKey(enumerateValue, dynamicUpdateCommand.CurrentValues, false, out key2) || !this._keyComparer.Equals(key2, key1))) { keyToListMap.Add(key1, (UpdateCommand)dynamicUpdateCommand); } } } } return(keyToListMap); }
private void CollectUnreachableTypes( Set <EntityType> reachableTypes, out KeyToListMap <EntityType, LineInfo> entityTypes, out KeyToListMap <EntityType, LineInfo> isTypeOfEntityTypes) { entityTypes = new KeyToListMap <EntityType, LineInfo>((IEqualityComparer <EntityType>)EqualityComparer <EntityType> .Default); isTypeOfEntityTypes = new KeyToListMap <EntityType, LineInfo>((IEqualityComparer <EntityType>)EqualityComparer <EntityType> .Default); if (reachableTypes.Count == this.MappedEntityTypes.Count) { return; } foreach (EntityType key in this.m_isTypeOfLineInfos.Keys) { if (!MetadataHelper.GetTypeAndSubtypesOf((EdmType)key, this.m_itemCollection, false).Cast <EntityType>().Intersect <EntityType>((IEnumerable <EntityType>)reachableTypes).Any <EntityType>()) { isTypeOfEntityTypes.AddRange(key, this.m_isTypeOfLineInfos.EnumerateValues(key)); } } foreach (EntityType key in this.m_entityTypeLineInfos.Keys) { if (!reachableTypes.Contains(key)) { entityTypes.AddRange(key, this.m_entityTypeLineInfos.EnumerateValues(key)); } } }
private void AddModelDependencies( KeyToListMap <EntityKey, UpdateCommand> producedMap, KeyToListMap <EntityKey, UpdateCommand> requiredMap) { foreach (var keyAndCommands in requiredMap.KeyValuePairs) { var key = keyAndCommands.Key; var commandsRequiringKey = keyAndCommands.Value; foreach (var commandProducingKey in producedMap.EnumerateValues(key)) { foreach (var commandRequiringKey in commandsRequiringKey) { // command cannot depend on itself and only function commands // need to worry about model dependencies (dynamic commands know about foreign keys) if (!ReferenceEquals(commandProducingKey, commandRequiringKey) && (commandProducingKey.Kind == UpdateCommandKind.Function || commandRequiringKey.Kind == UpdateCommandKind.Function)) { // add a dependency AddEdge(commandProducingKey, commandRequiringKey); } } } } }
/// <summary> /// Determines model level dependencies for the current command. Dependencies are based /// on the model operations performed by the command (adding or deleting entities or relationships). /// </summary> internal void GetRequiredAndProducedEntities(UpdateTranslator translator, KeyToListMap <EntityKey, UpdateCommand> addedEntities, KeyToListMap <EntityKey, UpdateCommand> deletedEntities, KeyToListMap <EntityKey, UpdateCommand> addedRelationships, KeyToListMap <EntityKey, UpdateCommand> deletedRelationships) { IList <IEntityStateEntry> stateEntries = GetStateEntries(translator); foreach (IEntityStateEntry stateEntry in stateEntries) { if (!stateEntry.IsRelationship) { if (stateEntry.State == EntityState.Added) { addedEntities.Add(stateEntry.EntityKey, this); } else if (stateEntry.State == EntityState.Deleted) { deletedEntities.Add(stateEntry.EntityKey, this); } } } // process foreign keys if (null != this.OriginalValues) { // if a foreign key being deleted, it 'frees' or 'produces' the referenced key AddReferencedEntities(translator, this.OriginalValues, deletedRelationships); } if (null != this.CurrentValues) { // if a foreign key is being added, if requires the referenced key AddReferencedEntities(translator, this.CurrentValues, addedRelationships); } // process relationships foreach (IEntityStateEntry stateEntry in stateEntries) { if (stateEntry.IsRelationship) { // only worry about the relationship if it is being added or deleted bool isAdded = stateEntry.State == EntityState.Added; if (isAdded || stateEntry.State == EntityState.Deleted) { DbDataRecord record = isAdded ? (DbDataRecord)stateEntry.CurrentValues : stateEntry.OriginalValues; Debug.Assert(2 == record.FieldCount, "non-binary relationship?"); EntityKey end1 = (EntityKey)record[0]; EntityKey end2 = (EntityKey)record[1]; // relationships require the entity when they're added and free the entity when they're deleted... KeyToListMap <EntityKey, UpdateCommand> affected = isAdded ? addedRelationships : deletedRelationships; // both ends are being modified by the relationship affected.Add(end1, this); affected.Add(end2, this); } } } }
private static void InitializeForeignKeyMaps(HashSet <EntityContainer> containers, HashSet <EntitySet> tables, out KeyToListMap <EntitySetBase, ReferentialConstraint> sourceMap, out KeyToListMap <EntitySetBase, ReferentialConstraint> targetMap) { sourceMap = new KeyToListMap <EntitySetBase, ReferentialConstraint>(EqualityComparer <EntitySetBase> .Default); targetMap = new KeyToListMap <EntitySetBase, ReferentialConstraint>(EqualityComparer <EntitySetBase> .Default); // Retrieve relationship ends from each container to populate edges in dependency // graph foreach (EntityContainer container in containers) { foreach (EntitySetBase extent in container.BaseEntitySets) { AssociationSet associationSet = extent as AssociationSet; if (null != associationSet) { AssociationSetEnd source = null; AssociationSetEnd target = null; var ends = associationSet.AssociationSetEnds; if (2 == ends.Count) { // source is equivalent to the "to" end of relationship, target is "from" AssociationType associationType = associationSet.ElementType; bool constraintFound = false; ReferentialConstraint fkConstraint = null; foreach (ReferentialConstraint constraint in associationType.ReferentialConstraints) { if (constraintFound) { Debug.Fail("relationship set should have at most one constraint"); } else { constraintFound = true; } source = associationSet.AssociationSetEnds[constraint.ToRole.Name]; target = associationSet.AssociationSetEnds[constraint.FromRole.Name]; fkConstraint = constraint; } Debug.Assert(constraintFound && null != target && null != source, "relationship set must have at least one constraint"); // only understand binary (foreign key) relationships between entity sets if (null != target && null != source) { if (tables.Contains(target.EntitySet) && tables.Contains(source.EntitySet)) { // Remember metadata sourceMap.Add(source.EntitySet, fkConstraint); targetMap.Add(target.EntitySet, fkConstraint); } } } } } } }
// requires: schema refers to C-side or S-side schema for the cells // inside this. if schema.IsQueryView is true, the left side of cells refers // to the C side (and vice-versa for the right side) // effects: Generates the relevant views for the schema side and // returns them. If allowMissingAttributes is true and attributes // are missing on the schema side, substitutes them with NULL // Modifies views to contain the generated views for different // extents specified by cells and the the schemaContext private ErrorLog GenerateDirectionalViews(ViewTarget viewTarget, CqlIdentifiers identifiers, ViewSet views) { bool isQueryView = viewTarget == ViewTarget.QueryView; // Partition cells by extent. KeyToListMap <EntitySetBase, Cell> extentCellMap = GroupCellsByExtent(m_cellGroup, viewTarget); // Keep track of the mapping exceptions that we have generated ErrorLog errorLog = new ErrorLog(); // Generate views for each extent foreach (EntitySetBase extent in extentCellMap.Keys) { if (m_config.IsViewTracing) { Helpers.StringTraceLine(String.Empty); Helpers.StringTraceLine(String.Empty); Helpers.FormatTraceLine("================= Generating {0} View for: {1} ===========================", isQueryView ? "Query" : "Update", extent.Name); Helpers.StringTraceLine(String.Empty); Helpers.StringTraceLine(String.Empty); } try { // (1) view generation (checks that extents are fully mapped) QueryRewriter queryRewriter = GenerateDirectionalViewsForExtent(viewTarget, extent, identifiers, views); // (2) validation for update views if (viewTarget == ViewTarget.UpdateView && m_config.IsValidationEnabled) { if (m_config.IsViewTracing) { Helpers.StringTraceLine(String.Empty); Helpers.StringTraceLine(String.Empty); Helpers.FormatTraceLine("----------------- Validation for generated update view for: {0} -----------------", extent.Name); Helpers.StringTraceLine(String.Empty); Helpers.StringTraceLine(String.Empty); } RewritingValidator validator = new RewritingValidator(queryRewriter.ViewgenContext, queryRewriter.BasicView); validator.Validate(); } } 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 void GetUnreachableTypes( bool validateAmbiguity, out KeyToListMap <EntityType, LineInfo> unreachableEntityTypes, out KeyToListMap <EntityType, LineInfo> unreachableIsTypeOfs) { DomainVariable <string, ValueCondition>[] variables = this.ConstructDomainVariables(); DomainConstraintConversionContext <string, ValueCondition> converter = new DomainConstraintConversionContext <string, ValueCondition>(); Vertex[] vertices = this.ConvertMappingConditionsToVertices((ConversionContext <DomainConstraint <string, ValueCondition> >)converter, variables); this.CollectUnreachableTypes(validateAmbiguity ? this.FindUnambiguouslyReachableTypes(converter, vertices) : this.FindReachableTypes(converter, vertices), out unreachableEntityTypes, out unreachableIsTypeOfs); }
private static KeyToListMap <EntitySetBase, Cell> GroupCellsByExtent( IEnumerable <Cell> cells, ViewTarget viewTarget) { KeyToListMap <EntitySetBase, Cell> keyToListMap = new KeyToListMap <EntitySetBase, Cell>((IEqualityComparer <EntitySetBase>)EqualityComparer <EntitySetBase> .Default); foreach (Cell cell in cells) { CellQuery leftQuery = cell.GetLeftQuery(viewTarget); keyToListMap.Add(leftQuery.Extent, cell); } return(keyToListMap); }
internal List <Set <Cell> > GroupRelatedCells() { UndirectedGraph <EntitySetBase> undirectedGraph = new UndirectedGraph <EntitySetBase>((IEqualityComparer <EntitySetBase>)EqualityComparer <EntitySetBase> .Default); Dictionary <EntitySetBase, Set <Cell> > extentToCell = new Dictionary <EntitySetBase, Set <Cell> >((IEqualityComparer <EntitySetBase>)EqualityComparer <EntitySetBase> .Default); foreach (Cell cell in this.m_cells) { EntitySetBase[] entitySetBaseArray = new EntitySetBase[2] { cell.CQuery.Extent, cell.SQuery.Extent }; foreach (EntitySetBase index in entitySetBaseArray) { Set <Cell> set; if (!extentToCell.TryGetValue(index, out set)) { extentToCell[index] = set = new Set <Cell>(); } set.Add(cell); undirectedGraph.AddVertex(index); } undirectedGraph.AddEdge(cell.CQuery.Extent, cell.SQuery.Extent); AssociationSet extent = cell.CQuery.Extent as AssociationSet; if (extent != null) { foreach (AssociationSetEnd associationSetEnd in extent.AssociationSetEnds) { undirectedGraph.AddEdge((EntitySetBase)associationSetEnd.EntitySet, (EntitySetBase)extent); } } } foreach (ForeignConstraint foreignKeyConstraint in this.m_foreignKeyConstraints) { undirectedGraph.AddEdge((EntitySetBase)foreignKeyConstraint.ChildTable, (EntitySetBase)foreignKeyConstraint.ParentTable); } KeyToListMap <int, EntitySetBase> connectedComponents = undirectedGraph.GenerateConnectedComponents(); List <Set <Cell> > setList = new List <Set <Cell> >(); foreach (int key in connectedComponents.Keys) { IEnumerable <Set <Cell> > sets = connectedComponents.ListForKey(key).Select <EntitySetBase, Set <Cell> >((Func <EntitySetBase, Set <Cell> >)(e => extentToCell[e])); Set <Cell> set1 = new Set <Cell>(); foreach (Set <Cell> set2 in sets) { set1.AddRange((IEnumerable <Cell>)set2); } setList.Add(set1); } return(setList); }
private void AddModelDependencies() { KeyToListMap <EntityKey, UpdateCommand> keyToListMap1 = new KeyToListMap <EntityKey, UpdateCommand>((IEqualityComparer <EntityKey>)EqualityComparer <EntityKey> .Default); KeyToListMap <EntityKey, UpdateCommand> keyToListMap2 = new KeyToListMap <EntityKey, UpdateCommand>((IEqualityComparer <EntityKey>)EqualityComparer <EntityKey> .Default); KeyToListMap <EntityKey, UpdateCommand> keyToListMap3 = new KeyToListMap <EntityKey, UpdateCommand>((IEqualityComparer <EntityKey>)EqualityComparer <EntityKey> .Default); KeyToListMap <EntityKey, UpdateCommand> keyToListMap4 = new KeyToListMap <EntityKey, UpdateCommand>((IEqualityComparer <EntityKey>)EqualityComparer <EntityKey> .Default); foreach (UpdateCommand vertex in this.Vertices) { vertex.GetRequiredAndProducedEntities(this._translator, keyToListMap1, keyToListMap2, keyToListMap3, keyToListMap4); } this.AddModelDependencies(keyToListMap1, keyToListMap3); this.AddModelDependencies(keyToListMap4, keyToListMap2); }
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] // referenced by System.Data.Entity.Design.dll internal Dictionary <EntitySetBase, string> GenerateEntitySetViews(out IList <EdmSchemaError> errors) { Dictionary <EntitySetBase, string> esqlViews = new Dictionary <EntitySetBase, string>(); errors = new List <EdmSchemaError>(); foreach (var mapping in GetItems <Map>()) { var entityContainerMapping = mapping as StorageEntityContainerMapping; if (entityContainerMapping != null) { // If there are no entity set maps, don't call the view generation process. if (!entityContainerMapping.HasViews) { return(esqlViews); } // If entityContainerMapping contains only query views, then add a warning to the errors and continue to next mapping. if (!entityContainerMapping.HasMappingFragments()) { Debug.Assert(2088 == (int)StorageMappingErrorCode.MappingAllQueryViewAtCompileTime, "Please change the ERRORCODE_MAPPINGALLQUERYVIEWATCOMPILETIME value as well"); errors.Add(new EdmSchemaError( Strings.Mapping_AllQueryViewAtCompileTime(entityContainerMapping.Identity), (int)StorageMappingErrorCode.MappingAllQueryViewAtCompileTime, EdmSchemaErrorSeverity.Warning)); } else { ViewGenResults viewGenResults = ViewgenGatekeeper.GenerateViewsFromMapping(entityContainerMapping, new ConfigViewGenerator() { GenerateEsql = true }); if (viewGenResults.HasErrors) { ((List <EdmSchemaError>)errors).AddRange(viewGenResults.Errors); } KeyToListMap <EntitySetBase, GeneratedView> extentMappingViews = viewGenResults.Views; foreach (KeyValuePair <EntitySetBase, List <GeneratedView> > extentViewPair in extentMappingViews.KeyValuePairs) { List <GeneratedView> generatedViews = extentViewPair.Value; // 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. esqlViews.Add(extentViewPair.Key, generatedViews[0].eSQL); } } } } return(esqlViews); }
// effects: Given a graph of cell groups, returns a list of cellgroup // such that each cellgroup contains all the cells that are in the // same connected component private static List <CellGroup> GenerateConnectedComponents(UndirectedGraph <Cell> graph) { KeyToListMap <int, Cell> groupMap = graph.GenerateConnectedComponents(); // Run through the list of groups and generate the merged groups List <CellGroup> result = new List <CellGroup>(); foreach (int setNum in groupMap.Keys) { ReadOnlyCollection <Cell> cellsInComponent = groupMap.ListForKey(setNum); CellGroup component = new CellGroup(cellsInComponent); result.Add(component); } return(result); }
// effects: Given all the cells for a container, groups the cells by // the left query's extent and returns a dictionary for it private static KeyToListMap <EntitySetBase, Cell> GroupCellsByExtent(IEnumerable <Cell> cells, ViewTarget viewTarget) { // Partition cells by extent -- extent is the top node in // the tree. Even for compositions for now? CHANGE_ADYA_FEATURE_COMPOSITION var extentCellMap = new KeyToListMap <EntitySetBase, Cell>(EqualityComparer <EntitySetBase> .Default); foreach (var cell in cells) { // Get the cell query and determine its extent var cellQuery = cell.GetLeftQuery(viewTarget); extentCellMap.Add(cellQuery.Extent, cell); } return(extentCellMap); }
internal void GetRequiredAndProducedEntities( UpdateTranslator translator, KeyToListMap <EntityKey, UpdateCommand> addedEntities, KeyToListMap <EntityKey, UpdateCommand> deletedEntities, KeyToListMap <EntityKey, UpdateCommand> addedRelationships, KeyToListMap <EntityKey, UpdateCommand> deletedRelationships) { IList <IEntityStateEntry> stateEntries = this.GetStateEntries(translator); foreach (IEntityStateEntry entityStateEntry in (IEnumerable <IEntityStateEntry>)stateEntries) { if (!entityStateEntry.IsRelationship) { if (entityStateEntry.State == EntityState.Added) { addedEntities.Add(entityStateEntry.EntityKey, this); } else if (entityStateEntry.State == EntityState.Deleted) { deletedEntities.Add(entityStateEntry.EntityKey, this); } } } if (this.OriginalValues != null) { this.AddReferencedEntities(translator, this.OriginalValues, deletedRelationships); } if (this.CurrentValues != null) { this.AddReferencedEntities(translator, this.CurrentValues, addedRelationships); } foreach (IEntityStateEntry entityStateEntry in (IEnumerable <IEntityStateEntry>)stateEntries) { if (entityStateEntry.IsRelationship) { bool flag = entityStateEntry.State == EntityState.Added; if (flag || entityStateEntry.State == EntityState.Deleted) { DbDataRecord dbDataRecord = flag ? (DbDataRecord)entityStateEntry.CurrentValues : entityStateEntry.OriginalValues; EntityKey key1 = (EntityKey)dbDataRecord[0]; EntityKey key2 = (EntityKey)dbDataRecord[1]; KeyToListMap <EntityKey, UpdateCommand> keyToListMap = flag ? addedRelationships : deletedRelationships; keyToListMap.Add(key1, this); keyToListMap.Add(key2, this); } } } }
private void InitializeFunctionMappingTranslators( EntitySetBase entitySetBase, EntityContainerMapping mapping) { KeyToListMap <AssociationSet, AssociationEndMember> keyToListMap = new KeyToListMap <AssociationSet, AssociationEndMember>((IEqualityComparer <AssociationSet>)EqualityComparer <AssociationSet> .Default); if (!this.m_functionMappingTranslators.ContainsKey(entitySetBase)) { foreach (EntitySetMapping entitySetMap in mapping.EntitySetMaps) { if (0 < entitySetMap.ModificationFunctionMappings.Count) { this.m_functionMappingTranslators.Add(entitySetMap.Set, ModificationFunctionMappingTranslator.CreateEntitySetTranslator(entitySetMap)); foreach (AssociationSetEnd associationSetEnd in entitySetMap.ImplicitlyMappedAssociationSetEnds) { AssociationSet parentAssociationSet = associationSetEnd.ParentAssociationSet; if (!this.m_functionMappingTranslators.ContainsKey((EntitySetBase)parentAssociationSet)) { this.m_functionMappingTranslators.Add((EntitySetBase)parentAssociationSet, ModificationFunctionMappingTranslator.CreateAssociationSetTranslator((AssociationSetMapping)null)); } AssociationSetEnd oppositeEnd = MetadataHelper.GetOppositeEnd(associationSetEnd); keyToListMap.Add(parentAssociationSet, oppositeEnd.CorrespondingAssociationEndMember); } } else { this.m_functionMappingTranslators.Add(entitySetMap.Set, (ModificationFunctionMappingTranslator)null); } } foreach (AssociationSetMapping relationshipSetMap in mapping.RelationshipSetMaps) { if (relationshipSetMap.ModificationFunctionMapping != null) { AssociationSet set = (AssociationSet)relationshipSetMap.Set; this.m_functionMappingTranslators.Add((EntitySetBase)set, ModificationFunctionMappingTranslator.CreateAssociationSetTranslator(relationshipSetMap)); keyToListMap.AddRange(set, Enumerable.Empty <AssociationEndMember>()); } else if (!this.m_functionMappingTranslators.ContainsKey(relationshipSetMap.Set)) { this.m_functionMappingTranslators.Add(relationshipSetMap.Set, (ModificationFunctionMappingTranslator)null); } } } foreach (AssociationSet key in keyToListMap.Keys) { this.m_associationSetMetadata.Add(key, new AssociationSetMetadata(keyToListMap.EnumerateValues(key))); } }
// effects: A restrictive version of GroupLeafChildrenByExtent -- // only for LASJ and LOJ nodes (works for LOJ only when A LOJ B LOJ C // s.t., B and C are subsets of A -- in our case that is how LOJs are constructed private static List <CellTreeNode> GroupNonAssociativeLeafChildren(List <CellTreeNode> nodes) { // Keep track of leaf cells for each extent ignoring the 0th child var extentMap = new KeyToListMap <EntitySetBase, CellTreeNode>(EqualityComparer <EntitySetBase> .Default); var newNodes = new List <CellTreeNode>(); var nonLeafNodes = new List <CellTreeNode>(); // Add the 0th child newNodes.Add(nodes[0]); for (var i = 1; i < nodes.Count; i++) { var node = nodes[i]; var leafNode = node as LeafCellTreeNode; // All non-leaf nodes are added to the result now // leaf nodes are added outside the loop if (leafNode != null) { extentMap.Add(leafNode.LeftCellWrapper.RightCellQuery.Extent, leafNode); } else { nonLeafNodes.Add(node); } } // Go through the map and add the leaf children // If a group of nodes exists for the 0th node's extent -- place // that group first var firstNode = nodes[0] as LeafCellTreeNode; if (firstNode != null) { var firstExtent = firstNode.LeftCellWrapper.RightCellQuery.Extent; if (extentMap.ContainsKey(firstExtent)) { newNodes.AddRange(extentMap.ListForKey(firstExtent)); // Remove this set from the map extentMap.RemoveKey(firstExtent); } } newNodes.AddRange(extentMap.AllValues); newNodes.AddRange(nonLeafNodes); return(newNodes); }
private ErrorLog GenerateDirectionalViews( ViewTarget viewTarget, CqlIdentifiers identifiers, KeyToListMap <EntitySetBase, GeneratedView> views) { bool flag = viewTarget == ViewTarget.QueryView; KeyToListMap <EntitySetBase, Cell> keyToListMap = ViewGenerator.GroupCellsByExtent((IEnumerable <Cell>) this.m_cellGroup, viewTarget); ErrorLog errorLog = new ErrorLog(); foreach (EntitySetBase key in keyToListMap.Keys) { if (this.m_config.IsViewTracing) { Helpers.StringTraceLine(string.Empty); Helpers.StringTraceLine(string.Empty); Helpers.FormatTraceLine("================= Generating {0} View for: {1} ===========================", flag ? (object)"Query" : (object)"Update", (object)key.Name); Helpers.StringTraceLine(string.Empty); Helpers.StringTraceLine(string.Empty); } try { QueryRewriter directionalViewsForExtent = this.GenerateDirectionalViewsForExtent(viewTarget, key, identifiers, views); if (viewTarget == ViewTarget.UpdateView) { if (this.m_config.IsValidationEnabled) { if (this.m_config.IsViewTracing) { Helpers.StringTraceLine(string.Empty); Helpers.StringTraceLine(string.Empty); Helpers.FormatTraceLine("----------------- Validation for generated update view for: {0} -----------------", (object)key.Name); Helpers.StringTraceLine(string.Empty); Helpers.StringTraceLine(string.Empty); } new RewritingValidator(directionalViewsForExtent.ViewgenContext, directionalViewsForExtent.BasicView).Validate(); } } } catch (InternalMappingException ex) { errorLog.Merge(ex.ErrorLog); } } return(errorLog); }
/// <summary> /// For function commands, we infer constraints based on relationships and entities. For instance, /// we always insert an entity before inserting a relationship referencing that entity. When dynamic /// and function UpdateCommands are mixed, we also fall back on this same interpretation. /// </summary> private void AddModelDependencies() { KeyToListMap<EntityKey, UpdateCommand> addedEntities = new KeyToListMap<EntityKey, UpdateCommand>(EqualityComparer<EntityKey>.Default); KeyToListMap<EntityKey, UpdateCommand> deletedEntities = new KeyToListMap<EntityKey, UpdateCommand>(EqualityComparer<EntityKey>.Default); KeyToListMap<EntityKey, UpdateCommand> addedRelationships = new KeyToListMap<EntityKey, UpdateCommand>(EqualityComparer<EntityKey>.Default); KeyToListMap<EntityKey, UpdateCommand> deletedRelationships = new KeyToListMap<EntityKey, UpdateCommand>(EqualityComparer<EntityKey>.Default); foreach (UpdateCommand command in this.Vertices) { command.GetRequiredAndProducedEntities(_translator, addedEntities, deletedEntities, addedRelationships, deletedRelationships); } // Add entities before adding dependent relationships AddModelDependencies(producedMap: addedEntities, requiredMap: addedRelationships); // Delete dependent relationships before deleting entities AddModelDependencies(producedMap: deletedRelationships, requiredMap: deletedEntities); }
// effects: Given a graph of T, returns a map such that nodes in the // same connected component are in the same list in the KeyToListMap internal KeyToListMap <int, TVertex> GenerateConnectedComponents() { var count = 0; // Set the "component number" for each node var componentMap = new Dictionary <TVertex, ComponentNum>(m_comparer); foreach (var vertex in Vertices) { componentMap.Add(vertex, new ComponentNum(count)); count++; } // Run the connected components algorithm (Page 441 of the CLR -- Cormen, Rivest, Lieserson) foreach (var edge in Edges) { if (componentMap[edge.Key].componentNum != componentMap[edge.Value].componentNum) { // Set the component numbers of both of the nodes to be the same var oldValue = componentMap[edge.Value].componentNum; var newValue = componentMap[edge.Key].componentNum; componentMap[edge.Value].componentNum = newValue; // Since we are resetting edge.Value's component number, find all components whose value // is oldValue and reset it to the new value foreach (var vertex in componentMap.Keys) { if (componentMap[vertex].componentNum == oldValue) { componentMap[vertex].componentNum = newValue; } } } } // Now just grab the vertices which have the same set numbers var result = new KeyToListMap <int, TVertex>(EqualityComparer <int> .Default); foreach (var vertex in Vertices) { var componentNum = componentMap[vertex].componentNum; result.Add(componentNum, vertex); } return(result); }
private QueryRewriter GenerateViewsForExtentAndType( EdmType generatedType, ViewgenContext context, CqlIdentifiers identifiers, KeyToListMap <EntitySetBase, GeneratedView> views, ViewGenMode mode) { QueryRewriter queryRewriter = new QueryRewriter(generatedType, context, mode); queryRewriter.GenerateViewComponents(); CellTreeNode basicView = queryRewriter.BasicView; if (this.m_config.IsNormalTracing) { Helpers.StringTrace("Basic View: "); Helpers.StringTraceLine(basicView.ToString()); } CellTreeNode simplifiedView = ViewGenerator.GenerateSimplifiedView(basicView, queryRewriter.UsedCells); if (this.m_config.IsNormalTracing) { Helpers.StringTraceLine(string.Empty); Helpers.StringTrace("Simplified View: "); Helpers.StringTraceLine(simplifiedView.ToString()); } CqlGenerator cqlGenerator = new CqlGenerator(simplifiedView, queryRewriter.CaseStatements, identifiers, context.MemberMaps.ProjectedSlotMap, queryRewriter.UsedCells.Count, queryRewriter.TopLevelWhereClause, this.m_entityContainerMapping.StorageMappingItemCollection); string eSQL; DbQueryCommandTree commandTree; if (this.m_config.GenerateEsql) { eSQL = cqlGenerator.GenerateEsql(); commandTree = (DbQueryCommandTree)null; } else { eSQL = (string)null; commandTree = cqlGenerator.GenerateCqt(); } GeneratedView generatedView = GeneratedView.CreateGeneratedView(context.Extent, generatedType, commandTree, eSQL, this.m_entityContainerMapping.StorageMappingItemCollection, this.m_config); views.Add(context.Extent, generatedView); return(queryRewriter); }
// effects: Checks if all sViewConstraints are implied by the // constraints in cViewConstraints. If some S-level constraints are // not implied, adds errors/warnings to m_errorLog private void CheckImplication(ViewSchemaConstraints cViewConstraints, ViewSchemaConstraints sViewConstraints) { // Check key constraints // i.e., if S has a key <k1, k2>, C must have a key that is a subset of this CheckImplicationKeyConstraints(cViewConstraints, sViewConstraints); // For updates, we need to ensure the following: for every // extent E, table T pair, some key of E is implied by T's key // Get all key constraints for each extent and each table var extentPairConstraints = new KeyToListMap <ExtentPair, ViewKeyConstraint>(EqualityComparer <ExtentPair> .Default); foreach (var cKeyConstraint in cViewConstraints.KeyConstraints) { var pair = new ExtentPair(cKeyConstraint.Cell.CQuery.Extent, cKeyConstraint.Cell.SQuery.Extent); extentPairConstraints.Add(pair, cKeyConstraint); } // Now check that we guarantee at least one constraint per // extent/table pair foreach (var extentPair in extentPairConstraints.Keys) { var cKeyConstraints = extentPairConstraints.ListForKey(extentPair); var sImpliesSomeC = false; // Go through all key constraints for the extent/table pair, and find one that S implies foreach (var cKeyConstraint in cKeyConstraints) { foreach (var sKeyConstraint in sViewConstraints.KeyConstraints) { if (sKeyConstraint.Implies(cKeyConstraint)) { sImpliesSomeC = true; break; // The implication holds - so no problem } } } if (sImpliesSomeC == false) { // Indicate that at least one key must be ensured on the S-side m_errorLog.AddEntry(ViewKeyConstraint.GetErrorRecord(cKeyConstraints)); } } }
internal ErrorLog.Record CheckForDuplicateFields(CellQuery cQuery, Cell sourceCell) { KeyToListMap <MemberProjectedSlot, int> keyToListMap = new KeyToListMap <MemberProjectedSlot, int>((IEqualityComparer <MemberProjectedSlot>)ProjectedSlot.EqualityComparer); for (int index = 0; index < this.m_projectedSlots.Length; ++index) { MemberProjectedSlot projectedSlot = this.m_projectedSlots[index] as MemberProjectedSlot; keyToListMap.Add(projectedSlot, index); } StringBuilder stringBuilder1 = (StringBuilder)null; bool flag = false; foreach (MemberProjectedSlot key in keyToListMap.Keys) { ReadOnlyCollection <int> cSideSlotIndexes = keyToListMap.ListForKey(key); if (cSideSlotIndexes.Count > 1 && !cQuery.AreSlotsEquivalentViaRefConstraints(cSideSlotIndexes)) { flag = true; if (stringBuilder1 == null) { stringBuilder1 = new StringBuilder(Strings.ViewGen_Duplicate_CProperties((object)this.Extent.Name)); stringBuilder1.AppendLine(); } StringBuilder stringBuilder2 = new StringBuilder(); for (int index1 = 0; index1 < cSideSlotIndexes.Count; ++index1) { int index2 = cSideSlotIndexes[index1]; if (index1 != 0) { stringBuilder2.Append(", "); } MemberProjectedSlot projectedSlot = (MemberProjectedSlot)cQuery.m_projectedSlots[index2]; stringBuilder2.Append(projectedSlot.ToUserString()); } stringBuilder1.AppendLine(Strings.ViewGen_Duplicate_CProperties_IsMapped((object)key.ToUserString(), (object)stringBuilder2.ToString())); } } if (!flag) { return((ErrorLog.Record)null); } return(new ErrorLog.Record(ViewGenErrorCode.DuplicateCPropertiesMapped, stringBuilder1.ToString(), sourceCell, string.Empty)); }
/// <summary> /// Determines which explicitly mapped types in the function import mapping cannot be generated. /// For IsTypeOf declarations, reports if no type in hierarchy can be produced. /// Works by: /// - Converting type mapping conditions into vertices /// - Checking that some assignment satisfies /// </summary> private void GetUnreachableTypes( bool validateAmbiguity, out KeyToListMap<EntityType, LineInfo> unreachableEntityTypes, out KeyToListMap<EntityType, LineInfo> unreachableIsTypeOfs) { // Contains, for each DiscriminatorColumn, a domain variable where the domain values are // integers representing the ordinal within discriminatorDomains. var variables = ConstructDomainVariables(); // Convert type mapping conditions to decision diagram vertices. var converter = new DomainConstraintConversionContext<string, ValueCondition>(); var mappingConditions = ConvertMappingConditionsToVertices(converter, variables); // Find reachable types. var reachableTypes = validateAmbiguity ? FindUnambiguouslyReachableTypes(converter, mappingConditions) : FindReachableTypes(converter, mappingConditions); CollectUnreachableTypes(reachableTypes, out unreachableEntityTypes, out unreachableIsTypeOfs); }
internal FunctionImportStructuralTypeMappingKB( IEnumerable<FunctionImportStructuralTypeMapping> structuralTypeMappings, ItemCollection itemCollection) { DebugCheck.NotNull(structuralTypeMappings); DebugCheck.NotNull(itemCollection); m_itemCollection = itemCollection; // If no specific type mapping. if (structuralTypeMappings.Count() == 0) { // Initialize with defaults. ReturnTypeColumnsRenameMapping = new Dictionary<string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping>(); NormalizedEntityTypeMappings = new ReadOnlyCollection<FunctionImportNormalizedEntityTypeMapping>( new List<FunctionImportNormalizedEntityTypeMapping>()); DiscriminatorColumns = new ReadOnlyCollection<string>(new List<string>()); MappedEntityTypes = new ReadOnlyCollection<EntityType>(new List<EntityType>()); return; } var entityTypeMappings = structuralTypeMappings.OfType<FunctionImportEntityTypeMapping>(); // FunctionImportEntityTypeMapping if (null != entityTypeMappings && null != entityTypeMappings.FirstOrDefault()) { var isOfTypeEntityTypeColumnsRenameMapping = new Dictionary<EntityType, Collection<FunctionImportReturnTypePropertyMapping>>(); var entityTypeColumnsRenameMapping = new Dictionary<EntityType, Collection<FunctionImportReturnTypePropertyMapping>>(); var normalizedEntityTypeMappings = new List<FunctionImportNormalizedEntityTypeMapping>(); // Collect all mapped entity types. MappedEntityTypes = entityTypeMappings .SelectMany(mapping => mapping.GetMappedEntityTypes(m_itemCollection)) .Distinct() .ToList() .AsReadOnly(); // Collect all discriminator columns. DiscriminatorColumns = entityTypeMappings .SelectMany(mapping => mapping.GetDiscriminatorColumns()) .Distinct() .ToList() .AsReadOnly(); m_entityTypeLineInfos = new KeyToListMap<EntityType, LineInfo>(EqualityComparer<EntityType>.Default); m_isTypeOfLineInfos = new KeyToListMap<EntityType, LineInfo>(EqualityComparer<EntityType>.Default); foreach (var entityTypeMapping in entityTypeMappings) { // Remember LineInfos for error reporting. foreach (var entityType in entityTypeMapping.EntityTypes) { m_entityTypeLineInfos.Add(entityType, entityTypeMapping.LineInfo); } foreach (var isTypeOf in entityTypeMapping.IsOfTypeEntityTypes) { m_isTypeOfLineInfos.Add(isTypeOf, entityTypeMapping.LineInfo); } // Create map from column name to condition. var columnMap = entityTypeMapping.Conditions.ToDictionary( condition => condition.ColumnName, condition => condition); // Align conditions with discriminator columns. var columnMappings = new List<FunctionImportEntityTypeMappingCondition>(DiscriminatorColumns.Count); for (var i = 0; i < DiscriminatorColumns.Count; i++) { var discriminatorColumn = DiscriminatorColumns[i]; FunctionImportEntityTypeMappingCondition mappingCondition; if (columnMap.TryGetValue(discriminatorColumn, out mappingCondition)) { columnMappings.Add(mappingCondition); } else { // Null indicates the value for this discriminator doesn't matter. columnMappings.Add(null); } } // Create bit map for implied entity types. var impliedEntityTypesBitMap = new bool[MappedEntityTypes.Count]; var impliedEntityTypesSet = new Set<EntityType>(entityTypeMapping.GetMappedEntityTypes(m_itemCollection)); for (var i = 0; i < MappedEntityTypes.Count; i++) { impliedEntityTypesBitMap[i] = impliedEntityTypesSet.Contains(MappedEntityTypes[i]); } // Construct normalized mapping. normalizedEntityTypeMappings.Add( new FunctionImportNormalizedEntityTypeMapping(this, columnMappings, new BitArray(impliedEntityTypesBitMap))); // Construct the rename mappings by adding isTypeOf types and specific entity types to the corresponding lists. foreach (var isOfType in entityTypeMapping.IsOfTypeEntityTypes) { if (!isOfTypeEntityTypeColumnsRenameMapping.Keys.Contains(isOfType)) { isOfTypeEntityTypeColumnsRenameMapping.Add( isOfType, new Collection<FunctionImportReturnTypePropertyMapping>()); } foreach (var rename in entityTypeMapping.ColumnsRenameList) { isOfTypeEntityTypeColumnsRenameMapping[isOfType].Add(rename); } } foreach (var entityType in entityTypeMapping.EntityTypes) { if (!entityTypeColumnsRenameMapping.Keys.Contains(entityType)) { entityTypeColumnsRenameMapping.Add(entityType, new Collection<FunctionImportReturnTypePropertyMapping>()); } foreach (var rename in entityTypeMapping.ColumnsRenameList) { entityTypeColumnsRenameMapping[entityType].Add(rename); } } } ReturnTypeColumnsRenameMapping = new FunctionImportReturnTypeEntityTypeColumnsRenameBuilder( isOfTypeEntityTypeColumnsRenameMapping, entityTypeColumnsRenameMapping) .ColumnRenameMapping; NormalizedEntityTypeMappings = new ReadOnlyCollection<FunctionImportNormalizedEntityTypeMapping>( normalizedEntityTypeMappings); } else { // FunctionImportComplexTypeMapping Debug.Assert( structuralTypeMappings.First() is FunctionImportComplexTypeMapping, "only two types can have renames, complexType and entityType"); var complexTypeMappings = structuralTypeMappings.Cast<FunctionImportComplexTypeMapping>(); Debug.Assert( complexTypeMappings.Count() == 1, "how come there are more than 1, complex type cannot derive from other complex type"); ReturnTypeColumnsRenameMapping = new Dictionary<string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping>(); foreach (var rename in complexTypeMappings.First().ColumnsRenameList) { var columnRenameMapping = new FunctionImportReturnTypeStructuralTypeColumnRenameMapping(rename.CMember); columnRenameMapping.AddRename( new FunctionImportReturnTypeStructuralTypeColumn( rename.SColumn, complexTypeMappings.First().ReturnType, false, rename.LineInfo)); ReturnTypeColumnsRenameMapping.Add(rename.CMember, columnRenameMapping); } // Initialize the entity mapping data as empty. NormalizedEntityTypeMappings = new ReadOnlyCollection<FunctionImportNormalizedEntityTypeMapping>( new List<FunctionImportNormalizedEntityTypeMapping>()); DiscriminatorColumns = new ReadOnlyCollection<string>( new List<string> { }); MappedEntityTypes = new ReadOnlyCollection<EntityType>( new List<EntityType> { }); } }
// effects: Given all the cells for a container, groups the cells by // the left query's extent and returns a dictionary for it private static KeyToListMap<EntitySetBase, Cell> GroupCellsByExtent(IEnumerable<Cell> cells, ViewTarget viewTarget) { // Partition cells by extent -- extent is the top node in // the tree. Even for compositions for now? CHANGE_ADYA_FEATURE_COMPOSITION var extentCellMap = new KeyToListMap<EntitySetBase, Cell>(EqualityComparer<EntitySetBase>.Default); foreach (var cell in cells) { // Get the cell query and determine its extent var cellQuery = cell.GetLeftQuery(viewTarget); extentCellMap.Add(cellQuery.Extent, cell); } return extentCellMap; }
private CellTreeNode ConvertUnionsToNormalizedLOJs(CellTreeNode rootNode) { // Recursively, transform the subtrees rooted at rootNode's children. for (var i = 0; i < rootNode.Children.Count; i++) { // Method modifies input as well. rootNode.Children[i] = ConvertUnionsToNormalizedLOJs(rootNode.Children[i]); } // We rewrite only LOJs. if (rootNode.OpType != CellTreeOpType.LOJ || rootNode.Children.Count < 2) { return rootNode; } // Create the resulting LOJ node. var result = new OpCellTreeNode(m_viewgenContext, rootNode.OpType); // Create working collection for the LOJ children. var children = new List<CellTreeNode>(); // If rootNode looks something like ((V0 IJ V1) LOJ V2 LOJ V3), // and it turns out that there are FK associations from V2 or V3 pointing, let's say at V0, // then we want to rewrite the result as (V1 IJ (V0 LOJ V2 LOJ V3)). // If we don't do this, then plan compiler won't have a chance to eliminate LOJ V2 LOJ V3. // Hence, flatten the first child or rootNode if it's IJ, but remember that its parts are driving nodes for the LOJ, // so that we don't accidentally nest them. OpCellTreeNode resultIJDriver = null; HashSet<CellTreeNode> resultIJDriverChildren = null; if (rootNode.Children[0].OpType == CellTreeOpType.IJ) { // Create empty resultIJDriver node and add it as the first child (driving) into the LOJ result. resultIJDriver = new OpCellTreeNode(m_viewgenContext, rootNode.Children[0].OpType); result.Add(resultIJDriver); children.AddRange(rootNode.Children[0].Children); resultIJDriverChildren = new HashSet<CellTreeNode>(rootNode.Children[0].Children); } else { result.Add(rootNode.Children[0]); } // Flatten unions in non-driving nodes: (V0 LOJ (V1 Union V2 Union V3)) -> (V0 LOJ V1 LOJ V2 LOJ V3) foreach (var child in rootNode.Children.Skip(1)) { var opNode = child as OpCellTreeNode; if (opNode != null && opNode.OpType == CellTreeOpType.Union) { children.AddRange(opNode.Children); } else { children.Add(child); } } // A dictionary that maps an extent to the nodes that are from that extent. // We want a ref comparer here. var extentMap = new KeyToListMap<EntitySet, LeafCellTreeNode>(EqualityComparer<EntitySet>.Default); // Note that we skip non-leaf nodes (non-leaf nodes don't have FKs) and attach them directly to the result. foreach (var child in children) { var leaf = child as LeafCellTreeNode; if (leaf != null) { EntitySetBase extent = GetLeafNodeTable(leaf); if (extent != null) { extentMap.Add((EntitySet)extent, leaf); } } else { if (resultIJDriverChildren != null && resultIJDriverChildren.Contains(child)) { resultIJDriver.Add(child); } else { result.Add(child); } } } // We only deal with simple cases - one node per extent, remove the rest from children and attach directly to result. var nonTrivial = extentMap.KeyValuePairs.Where(m => m.Value.Count > 1).ToArray(); foreach (var m in nonTrivial) { extentMap.RemoveKey(m.Key); foreach (var n in m.Value) { if (resultIJDriverChildren != null && resultIJDriverChildren.Contains(n)) { resultIJDriver.Add(n); } else { result.Add(n); } } } Debug.Assert(extentMap.KeyValuePairs.All(m => m.Value.Count == 1), "extentMap must map to single nodes only."); // Walk the extents in extentMap and for each extent build PK -> FK1(PK1), FK2(PK2), ... map // where PK is the primary key of the left extent, and FKn(PKn) is an FK of a right extent that // points to the PK of the left extent and is based on the PK columns of the right extent. // Example: // table tBaseType(Id int, c1 int), PK = (tBaseType.Id) // table tDerivedType1(Id int, c2 int), PK1 = (tDerivedType1.Id), FK1 = (tDerivedType1.Id -> tBaseType.Id) // table tDerivedType2(Id int, c3 int), PK2 = (tDerivedType2.Id), FK2 = (tDerivedType2.Id -> tBaseType.Id) // Will produce: // (tBaseType) -> (tDerivedType1, tDerivedType2) var pkFkMap = new KeyToListMap<EntitySet, EntitySet>(EqualityComparer<EntitySet>.Default); // Also for each extent in extentMap, build another map (extent) -> (LOJ node). // It will be used to construct the nesting in the next step. var extentLOJs = new Dictionary<EntitySet, OpCellTreeNode>(EqualityComparer<EntitySet>.Default); foreach (var extentInfo in extentMap.KeyValuePairs) { var principalExtent = extentInfo.Key; foreach (var fkExtent in GetFKOverPKDependents(principalExtent)) { // Only track fkExtents that are in extentMap. ReadOnlyCollection<LeafCellTreeNode> nodes; if (extentMap.TryGetListForKey(fkExtent, out nodes)) { // Make sure that we are not adding resultIJDriverChildren as FK dependents - we do not want them to get nested. if (resultIJDriverChildren == null || !resultIJDriverChildren.Contains(nodes.Single())) { pkFkMap.Add(principalExtent, fkExtent); } } } var extentLojNode = new OpCellTreeNode(m_viewgenContext, CellTreeOpType.LOJ); extentLojNode.Add(extentInfo.Value.Single()); extentLOJs.Add(principalExtent, extentLojNode); } // Construct LOJ nesting inside extentLOJs based on the information in pkFkMap. // Also, track nested extents using nestedExtents. // Example: // We start with nestedExtents empty extentLOJs as such: // tBaseType -> LOJ(BaseTypeNode) // tDerivedType1 -> LOJ(DerivedType1Node)* // tDerivedType2 -> LOJ(DerivedType2Node)** // Note that * and ** represent object references. So each time something is nested, // we don't clone, but nest the original LOJ. When we get to processing the extent of that LOJ, // we might add other children to that nested LOJ. // As we walk pkFkMap, we end up with this: // tBaseType -> LOJ(BaseTypeNode, LOJ(DerivedType1Node)*, LOJ(DerivedType2Node)**) // tDerivedType1 -> LOJ(DerivedType1Node)* // tDerivedType2 -> LOJ(DerivedType2Node)** // nestedExtens = (tDerivedType1, tDerivedType2) var nestedExtents = new Dictionary<EntitySet, EntitySet>(EqualityComparer<EntitySet>.Default); foreach (var m in pkFkMap.KeyValuePairs) { var principalExtent = m.Key; foreach (var fkExtent in m.Value) { OpCellTreeNode fkExtentLOJ; if (extentLOJs.TryGetValue(fkExtent, out fkExtentLOJ) && // make sure we don't nest twice and we don't create a cycle. !nestedExtents.ContainsKey(fkExtent) && !CheckLOJCycle(fkExtent, principalExtent, nestedExtents)) { extentLOJs[m.Key].Add(fkExtentLOJ); nestedExtents.Add(fkExtent, principalExtent); } } } // Now we need to grab the LOJs that have not been nested and add them to the result. // All LOJs that have been nested must be somewhere inside the LOJs that have not been nested, // so they as well end up in the result as part of the unnested ones. foreach (var m in extentLOJs) { if (!nestedExtents.ContainsKey(m.Key)) { // extentLOJ represents (Vx LOJ Vy LOJ(Vm LOJ Vn)) where Vx is the original node from rootNode.Children or resultIJDriverChildren. var extentLOJ = m.Value; if (resultIJDriverChildren != null && resultIJDriverChildren.Contains(extentLOJ.Children[0])) { resultIJDriver.Add(extentLOJ); } else { result.Add(extentLOJ); } } } return result.Flatten(); }
// requires: The tree rooted at cellTreeNode is an FOJ tree of // LeafCellTreeNodes only, i.e., there is an FOJ node with the // children being LeafCellTreeNodes // // effects: Given a tree rooted at rootNode, ensures that cells // of the same right extent are placed in their own subtree below // cellTreeNode. That is, if there are 3 cells of extent A and 2 of // extent B (i.e., 5 cells with an FOJ on it), the resulting tree has // an FOJ node with two children -- FOJ nodes. These FOJ nodes have 2 // and 3 children internal CellTreeNode GroupByRightExtent(CellTreeNode rootNode) { // A dictionary that maps an extent to the nodes are from that extent // We want a ref comparer here var extentMap = new KeyToListMap<EntitySetBase, LeafCellTreeNode>(EqualityComparer<EntitySetBase>.Default); // CR_Meek_Low: method can be simplified (Map<Extent, OpCellTreeNode>, populate as you go) // (becomes self-documenting) // For each leaf child, find the extent of the child and place it // in extentMap foreach (LeafCellTreeNode childNode in rootNode.Children) { // A cell may contain P, P.PA -- we return P // CHANGE_ADYA_FEATURE_COMPOSITION Need to fix for composition!! var extent = childNode.LeftCellWrapper.RightCellQuery.Extent; // relation or extent to group by Debug.Assert(extent != null, "Each cell must have a right extent"); // Add the childNode as a child of the FOJ tree for "extent" extentMap.Add(extent, childNode); } // Now go through the extent map and create FOJ nodes for each extent // Place the nodes for that extent in the newly-created FOJ subtree // Also add the op node for every node as a child of the final result var result = new OpCellTreeNode(m_viewgenContext, CellTreeOpType.FOJ); foreach (var extent in extentMap.Keys) { var extentFojNode = new OpCellTreeNode(m_viewgenContext, CellTreeOpType.FOJ); foreach (var childNode in extentMap.ListForKey(extent)) { extentFojNode.Add(childNode); } result.Add(extentFojNode); } // We call Flatten to remove any unnecessary nestings // where an OpNode has only 1 child. return result.Flatten(); }
// requires: All slots in this are join tree slots // This method is called for an S-side query // cQuery is the corresponding C-side query in the cell // sourceCell is the original cell for "this" and cQuery // effects: Checks if any of the columns in "this" are mapped to multiple properties in cQuery. If so, // returns an error record about the duplicated slots internal ErrorLog.Record CheckForDuplicateFields(CellQuery cQuery, Cell sourceCell) { // slotMap stores the slots on the S-side and the // C-side properties that it maps to var slotMap = new KeyToListMap<MemberProjectedSlot, int>(ProjectedSlot.EqualityComparer); // Note that this does work for self-association. In the manager // employee example, ManagerId and EmployeeId from the SEmployee // table map to the two ends -- Manager.ManagerId and // Employee.EmployeeId in the C Space for (var i = 0; i < m_projectedSlots.Length; i++) { var projectedSlot = m_projectedSlots[i]; var slot = projectedSlot as MemberProjectedSlot; Debug.Assert(slot != null, "All slots for this method must be JoinTreeSlots"); slotMap.Add(slot, i); } StringBuilder builder = null; // Now determine the entries that have more than one integer per slot var isErrorSituation = false; foreach (var slot in slotMap.Keys) { var indexes = slotMap.ListForKey(slot); Debug.Assert(indexes.Count >= 1, "Each slot must have one index at least"); if (indexes.Count > 1 && cQuery.AreSlotsEquivalentViaRefConstraints(indexes) == false) { // The column is mapped to more than one property and it // failed the "association corresponds to referential // constraints" check isErrorSituation = true; if (builder == null) { builder = new StringBuilder(Strings.ViewGen_Duplicate_CProperties(Extent.Name)); builder.AppendLine(); } var tmpBuilder = new StringBuilder(); for (var i = 0; i < indexes.Count; i++) { var index = indexes[i]; if (i != 0) { tmpBuilder.Append(", "); } // The slot must be a JoinTreeSlot. If it isn't it is an internal error var cSlot = (MemberProjectedSlot)cQuery.m_projectedSlots[index]; tmpBuilder.Append(cSlot.ToUserString()); } builder.AppendLine(Strings.ViewGen_Duplicate_CProperties_IsMapped(slot.ToUserString(), tmpBuilder.ToString())); } } if (false == isErrorSituation) { return null; } var record = new ErrorLog.Record(ViewGenErrorCode.DuplicateCPropertiesMapped, builder.ToString(), sourceCell, String.Empty); return record; }
// effects: Given a list of node, produces a new list in which all // leaf nodes of the same extent are adjacent to each other. Non-leaf // nodes are also adjacent to each other. CHANGE_[....]_IMPROVE: Merge with GroupByRightExtent private static List<CellTreeNode> GroupLeafChildrenByExtent(List<CellTreeNode> nodes) { // Keep track of leaf cells for each extent KeyToListMap<EntitySetBase, CellTreeNode> extentMap = new KeyToListMap<EntitySetBase, CellTreeNode>(EqualityComparer<EntitySetBase>.Default); List<CellTreeNode> newNodes = new List<CellTreeNode>(); foreach (CellTreeNode node in nodes) { LeafCellTreeNode leafNode = node as LeafCellTreeNode; // All non-leaf nodes are added to the result now // leaf nodes are added outside the loop if (leafNode != null) { extentMap.Add(leafNode.LeftCellWrapper.RightCellQuery.Extent, leafNode); } else { newNodes.Add(node); } } // Go through the map and add the leaf children newNodes.AddRange(extentMap.AllValues); return newNodes; }
// effects: A restrictive version of GroupLeafChildrenByExtent -- // only for LASJ and LOJ nodes (works for LOJ only when A LOJ B LOJ C // s.t., B and C are subsets of A -- in our case that is how LOJs are constructed private static List<CellTreeNode> GroupNonAssociativeLeafChildren(List<CellTreeNode> nodes) { // Keep track of leaf cells for each extent ignoring the 0th child KeyToListMap<EntitySetBase, CellTreeNode> extentMap = new KeyToListMap<EntitySetBase, CellTreeNode>(EqualityComparer<EntitySetBase>.Default); List<CellTreeNode> newNodes = new List<CellTreeNode>(); List<CellTreeNode> nonLeafNodes = new List<CellTreeNode>(); // Add the 0th child newNodes.Add(nodes[0]); for (int i = 1; i < nodes.Count; i++) { CellTreeNode node = nodes[i]; LeafCellTreeNode leafNode = node as LeafCellTreeNode; // All non-leaf nodes are added to the result now // leaf nodes are added outside the loop if (leafNode != null) { extentMap.Add(leafNode.LeftCellWrapper.RightCellQuery.Extent, leafNode); } else { nonLeafNodes.Add(node); } } // Go through the map and add the leaf children // If a group of nodes exists for the 0th node's extent -- place // that group first LeafCellTreeNode firstNode = nodes[0] as LeafCellTreeNode; if (firstNode != null) { EntitySetBase firstExtent = firstNode.LeftCellWrapper.RightCellQuery.Extent; if (extentMap.ContainsKey(firstExtent)) { newNodes.AddRange(extentMap.ListForKey(firstExtent)); // Remove this set from the map extentMap.RemoveKey(firstExtent); } } newNodes.AddRange(extentMap.AllValues); newNodes.AddRange(nonLeafNodes); return newNodes; }
private void CollectUnreachableTypes( Set<EntityType> reachableTypes, out KeyToListMap<EntityType, LineInfo> entityTypes, out KeyToListMap<EntityType, LineInfo> isTypeOfEntityTypes) { // Collect line infos for types in violation entityTypes = new KeyToListMap<EntityType, LineInfo>(EqualityComparer<EntityType>.Default); isTypeOfEntityTypes = new KeyToListMap<EntityType, LineInfo>(EqualityComparer<EntityType>.Default); if (reachableTypes.Count == MappedEntityTypes.Count) { // All types are reachable; nothing to check return; } // Find IsTypeOf mappings where no type in hierarchy can generate a row foreach (var isTypeOf in m_isTypeOfLineInfos.Keys) { if (!MetadataHelper.GetTypeAndSubtypesOf(isTypeOf, m_itemCollection, false) .Cast<EntityType>() .Intersect(reachableTypes) .Any()) { // no type in the hierarchy is reachable... isTypeOfEntityTypes.AddRange(isTypeOf, m_isTypeOfLineInfos.EnumerateValues(isTypeOf)); } } // Find explicit types not generating a value foreach (var entityType in m_entityTypeLineInfos.Keys) { if (!reachableTypes.Contains(entityType)) { entityTypes.AddRange(entityType, m_entityTypeLineInfos.EnumerateValues(entityType)); } } }
internal ViewGenResults() { m_views = new KeyToListMap<EntitySetBase, GeneratedView>(EqualityComparer<EntitySetBase>.Default); m_errorLog = new ErrorLog(); }
// effects: Checks if all sViewConstraints are implied by the // constraints in cViewConstraints. If some S-level constraints are // not implied, adds errors/warnings to m_errorLog private void CheckImplication(ViewSchemaConstraints cViewConstraints, ViewSchemaConstraints sViewConstraints) { // Check key constraints // i.e., if S has a key <k1, k2>, C must have a key that is a subset of this CheckImplicationKeyConstraints(cViewConstraints, sViewConstraints); // For updates, we need to ensure the following: for every // extent E, table T pair, some key of E is implied by T's key // Get all key constraints for each extent and each table var extentPairConstraints = new KeyToListMap<ExtentPair, ViewKeyConstraint>(EqualityComparer<ExtentPair>.Default); foreach (var cKeyConstraint in cViewConstraints.KeyConstraints) { var pair = new ExtentPair(cKeyConstraint.Cell.CQuery.Extent, cKeyConstraint.Cell.SQuery.Extent); extentPairConstraints.Add(pair, cKeyConstraint); } // Now check that we guarantee at least one constraint per // extent/table pair foreach (var extentPair in extentPairConstraints.Keys) { var cKeyConstraints = extentPairConstraints.ListForKey(extentPair); var sImpliesSomeC = false; // Go through all key constraints for the extent/table pair, and find one that S implies foreach (var cKeyConstraint in cKeyConstraints) { foreach (var sKeyConstraint in sViewConstraints.KeyConstraints) { if (sKeyConstraint.Implies(cKeyConstraint)) { sImpliesSomeC = true; break; // The implication holds - so no problem } } } if (sImpliesSomeC == false) { // Indicate that at least one key must be ensured on the S-side m_errorLog.AddEntry(ViewKeyConstraint.GetErrorRecord(cKeyConstraints)); } } }