private static Condition CreateConditionUsingEntity( CommandProcessorContext cpc, EntityType conceptualEntityType, Property tableColumn, bool?isNull, string conditionValue) { // first see if we have a Default ETM var mappingFragment = ModelHelper.FindMappingFragment( cpc, conceptualEntityType, tableColumn.EntityType, EntityTypeMappingKind.Default, false); if (mappingFragment == null) { // if we don't have a default, then find or create an IsTypeOf ETM to put this in mappingFragment = ModelHelper.FindMappingFragment( cpc, conceptualEntityType, tableColumn.EntityType, EntityTypeMappingKind.IsTypeOf, true); } Debug.Assert(mappingFragment != null, "Failed to create the MappingFragment to house this Condition"); if (mappingFragment == null) { throw new ParentItemCreationFailureException(); } // create the condition var cond = CreateConditionUsingFragment(mappingFragment, tableColumn, isNull, conditionValue); // see if any conditions need to move now EnforceEntitySetMappingRules.AddRule(cpc, cond); return(cond); }
protected override void PostInvoke(CommandProcessorContext cpc) { // in the conceptual model, changing key states will impact MSL generated any // inferred ref constraints if (Property.EntityModel.IsCSDL) { EnforceEntitySetMappingRules.AddRule(cpc, Property.EntityType); InferReferentialConstraints.AddRule(cpc, Property.EntityType); // Add the integrity check to propagate the StoreGeneratedPattern value to the // S-side (may be altered by property being/not being a key) unless we are part // of an Update Model txn in which case there is no need as the whole artifact has // this integrity check applied by UpdateModelFromDatabaseCommand if (EfiTransactionOriginator.UpdateModelFromDatabaseId != cpc.OriginatorId) { var cProp = Property as ConceptualProperty; Debug.Assert( cProp != null, "expected _property of type ConceptualProperty, instead got type " + Property.GetType().FullName); if (cProp != null) { PropagateStoreGeneratedPatternToStorageModel.AddRule(cpc, cProp, true); } } } base.PostInvoke(cpc); }
protected override void PreInvoke(CommandProcessorContext cpc) { // save off the deleted entity type name SaveDeletedInformation(); EnforceEntitySetMappingRules.AddRule(cpc, EntityTypeMapping.EntitySetMapping); base.PreInvoke(cpc); }
private static ScalarProperty CreateScalarPropertyUsingEntity( CommandProcessorContext cpc, EntityType conceptualEntityType, Property entityProperty, Property tableColumn) { // the S-Side entity var storageEntityType = tableColumn.Parent as EntityType; Debug.Assert(storageEntityType != null, "tableColumn.Parent should be an EntityType"); // get the fragment to use var mappingFragment = ModelHelper.FindMappingFragment(cpc, conceptualEntityType, tableColumn.EntityType, true); Debug.Assert(mappingFragment != null, "Failed to create the MappingFragment to house this ScalarProperty"); if (mappingFragment == null) { throw new ParentItemCreationFailureException(); } // now go do the real work var sp = CreateScalarPropertyUsingFragment(mappingFragment, entityProperty, tableColumn); // enforce our mapping rules EnforceEntitySetMappingRules.AddRule(cpc, sp); return(sp); }
protected override void PreInvoke(CommandProcessorContext cpc) { if (ScalarProperty.MappingFragment != null) { EnforceEntitySetMappingRules.AddRule(cpc, ScalarProperty); MFConceptualEntityTypeName = ScalarProperty.FirstBoundConceptualEntityType != null ? ScalarProperty.FirstBoundConceptualEntityType.Name.Value : null; MFConceptualPropertyName = ScalarProperty.Name.Target != null ? ScalarProperty.Name.Target.Name.Value : null; MFStorageEntitySetName = ScalarProperty.BoundStorageEntityType != null ? ScalarProperty.BoundStorageEntityType.Name.Value : null; MFStorageColumnName = ScalarProperty.ColumnName.Target != null ? ScalarProperty.ColumnName.Target.Name.Value : null; MFConceptualEntityTypeOwnerName = ScalarProperty.FirstBoundConceptualEntityType != null ? ScalarProperty.FirstBoundConceptualEntityType.Name.Value : null; MFComplexParentList = ScalarProperty.GetParentComplexProperties(true) .Where(cp => cp.Name.Target != null) .Select(cp => cp.Name.Target.Name.Value); } else if (ScalarProperty.EndProperty != null) { var asm = ScalarProperty.EndProperty.Parent as AssociationSetMapping; Debug.Assert(asm != null, "this.ScalarProperty.EndProperty.Parent should be an AssociationSetMapping"); if (asm != null) { EnforceAssociationSetMappingRules.AddRule(cpc, asm); var assoc = asm.TypeName.Target; Debug.Assert(assoc != null, "the association set mapping does not have an Association"); if (assoc != null) { InferReferentialConstraints.AddRule(cpc, assoc); } } } // Also add the integrity check to propagate the StoreGeneratedPattern value to the // S-side (may be altered by property mapping being deleted) unless we are part // of an Update Model txn in which case there is no need as the whole artifact has // this integrity check applied by UpdateModelFromDatabaseCommand if (EfiTransactionOriginator.UpdateModelFromDatabaseId != cpc.OriginatorId && ScalarProperty.Name != null && ScalarProperty.Name.Target != null) { var cProp = ScalarProperty.Name.Target as ConceptualProperty; Debug.Assert( cProp != null, "ScalarProperty should have Name target with type " + typeof(ConceptualProperty).Name + ", instead got type " + ScalarProperty.Name.Target.GetType().FullName); if (cProp != null) { PropagateStoreGeneratedPatternToStorageModel.AddRule(cpc, cProp, true); } } base.PreInvoke(cpc); }
protected override void PostInvoke(CommandProcessorContext cpc) { // changing abstractness will impact the MSL generated if (EntityType != null) { EnforceEntitySetMappingRules.AddRule(cpc, EntityType.EntitySet); } }
protected override void PreInvoke(CommandProcessorContext cpc) { Debug.Assert(_derivedType.BaseType.Target != null, "The derivedType passed does not derive from any type"); SaveDeletedInformation(); base.PreInvoke(cpc); // register to enforce MSL rules on the existing entity set, which won't include the derived type any more // after this command completes EnforceEntitySetMappingRules.AddRule(cpc, _derivedType.EntitySet); }
protected override void InvokeInternal(CommandProcessorContext cpc) { // don't do anything if we are trying to set the same thing if (string.Compare(Condition.ColumnName.RefName, NewStorageProperty.LocalName.Value, StringComparison.CurrentCulture) != 0) { Condition.ColumnName.SetRefName(NewStorageProperty); XmlModelHelper.NormalizeAndResolve(Condition); EnforceEntitySetMappingRules.AddRule(cpc, Condition); } }
protected override void PreInvoke(CommandProcessorContext cpc) { if (MappingFragment.EntityTypeMapping != null && MappingFragment.EntityTypeMapping.EntitySetMapping != null) { ConceptualEntityTypeName = MappingFragment.EntityTypeMapping.FirstBoundConceptualEntityType != null ? MappingFragment.EntityTypeMapping.FirstBoundConceptualEntityType.Name.Value : null; StorageEntitySetName = MappingFragment.StoreEntitySet.Target != null ? MappingFragment.StoreEntitySet.Target.Name.Value : null; EnforceEntitySetMappingRules.AddRule(cpc, MappingFragment.EntityTypeMapping.EntitySetMapping); } base.PreInvoke(cpc); }
protected override void PostInvoke(CommandProcessorContext cpc) { // now that we have a new entity set, make sure that it and any derived types use correct MSL EnforceEntitySetMappingRules.AddRule(cpc, _derivedType.EntitySet); // see if this type is used by association ends; since we deleted the inheritance, this entity got // a new EntitySet so we need to change any EntitySet references for corresponding AssociationSetEnds to the new one Association association = null; foreach (var end in _derivedType.GetAntiDependenciesOfType <AssociationEnd>()) { foreach (var setEnd in end.GetAntiDependenciesOfType <AssociationSetEnd>()) { setEnd.EntitySet.SetRefName(_derivedType.EntitySet); XmlModelHelper.NormalizeAndResolve(setEnd); } association = end.Parent as Association; } // try to recreate the AssociationSetMapping if one exists if (association != null && association.AssociationSet != null && association.AssociationSet.AssociationSetMapping != null && association.AssociationSet.AssociationSetMapping.XObject != null) { // store off the entity set for later var storeEntitySet = association.AssociationSet.AssociationSetMapping.StoreEntitySet.Target; // delete it DeleteEFElementCommand.DeleteInTransaction(cpc, association.AssociationSet.AssociationSetMapping); // create a new one (if we can) if (storeEntitySet != null && storeEntitySet.EntityType.Target != null) { var set = storeEntitySet.EntityType.Target as StorageEntityType; Debug.Assert(storeEntitySet.EntityType.Target == null || set != null, "EntityType is not StorageEntityType"); CreateAssociationSetMappingCommand.CreateAssociationSetMappingAndIntellimatch(cpc, association, set); } } base.PostInvoke(cpc); }
/// <summary> /// We override this method because we need to do some extra things before /// the normal PreInvoke gets called and our antiDeps are removed /// </summary> /// <param name="cpc"></param> protected override void PreInvoke(CommandProcessorContext cpc) { // save off the deleted entity type name SaveDeletedInformation(); // enforce our mapping rules for C-side entities if (EntityType.EntityModel.IsCSDL) { EnforceEntitySetMappingRules.AddRule(cpc, EntityType); // remove base type for all derived EntityTypes var cet = EntityType as ConceptualEntityType; Debug.Assert(cet != null, "EntityType is not a ConceptualEntityType"); foreach (var derivedType in cet.ResolvableDirectDerivedTypes) { var cmd = new DeleteInheritanceCommand(derivedType); CommandProcessor.InvokeSingleCommand(cpc, cmd); } } base.PreInvoke(cpc); }
protected override void InvokeInternal(CommandProcessorContext cpc) { // see if we have the ETM we need, if not create it if (_entityTypeMapping == null) { _entityTypeMapping = ModelHelper.FindEntityTypeMapping(cpc, ConceptualEntityType, _entityTypeMappingKind, true); } // make sure it was created Debug.Assert(_entityTypeMapping != null, "We should have created an EntityTypeMapping if needed, it is still null."); if (_entityTypeMapping == null) { throw new CannotLocateParentItemException(); } _createdMappingFragment = new MappingFragment(_entityTypeMapping, null); _createdMappingFragment.StoreEntitySet.SetRefName(StorageEntitySet); _entityTypeMapping.AddMappingFragment(_createdMappingFragment); XmlModelHelper.NormalizeAndResolve(_createdMappingFragment); EnforceEntitySetMappingRules.AddRule(cpc, _entityTypeMapping.EntitySetMapping); }
protected override void PreInvoke(CommandProcessorContext cpc) { var fragment = Condition.MappingFragment; if (fragment != null) { EnforceEntitySetMappingRules.AddRule(cpc, Condition); } // Save off the conceptual and storage entity names var conceptualEntityType = Condition.FirstBoundConceptualEntityType; var storageEntityType = Condition.BoundStorageEntityType; if (conceptualEntityType != null && storageEntityType != null && Condition.ColumnName.Target != null) { OriginalConceptualEntityName = conceptualEntityType.Name.Value; OriginalStorageEntityName = storageEntityType.Name.Value; OriginalStoragePropertyName = Condition.ColumnName.Target.Name.Value; } base.PreInvoke(cpc); }
protected override void PreInvoke(CommandProcessorContext cpc) { base.PreInvoke(cpc); // you cannot use this command with a type that already has a base class; throwing here // because its not a good idea to throw an exception in a c'tor if (EntityToBeDerived == null || EntityToBeDerived.BaseType.Target != null) { throw new InvalidOperationException(); } EnforceEntitySetMappingRules.AddRule(cpc, BaseType.EntitySet); // see if this type is used by association ends; since we are creating an inheritance // we need to change any AssociationSetEnd references from the current EntitySet to the // new baseType's EntitySet (the derived type's EntitySet will be deleted) var associationsToUpdate = new HashSet <Association>(); if (EntityToBeDerived.EntitySet != null) { var associationSetEndsToUpdate = EntityToBeDerived.EntitySet.GetAntiDependenciesOfType <AssociationSetEnd>(); foreach (var setEnd in associationSetEndsToUpdate) { setEnd.EntitySet.SetRefName(BaseType.EntitySet); XmlModelHelper.NormalizeAndResolve(setEnd); var aSet = setEnd.Parent as AssociationSet; if (aSet != null) { if (aSet.Association.Target != null) { associationsToUpdate.Add(aSet.Association.Target); } } } } foreach (var association in associationsToUpdate) { // try to recreate the AssociationSetMapping if one exists if (association != null && association.AssociationSet != null && association.AssociationSet.AssociationSetMapping != null && association.AssociationSet.AssociationSetMapping.XObject != null) { // store off the entity set for later var storeEntitySet = association.AssociationSet.AssociationSetMapping.StoreEntitySet.Target; // delete it DeleteEFElementCommand.DeleteInTransaction(cpc, association.AssociationSet.AssociationSetMapping); // create a new one (if we can) if (storeEntitySet != null && storeEntitySet.EntityType.Target != null) { var set = storeEntitySet.EntityType.Target as StorageEntityType; Debug.Assert(set != null, "EntityType is not StorageEntityType"); CreateAssociationSetMappingCommand.CreateAssociationSetMappingAndIntellimatch(cpc, association, set); } } } }
protected override void InvokeInternal(CommandProcessorContext cpc) { var service = cpc.EditingContext.GetEFArtifactService(); var artifact = service.Artifact; Debug.Assert(artifact != null, "Null Artifact"); if (null == artifact) { return; } // construct a mapping of the existing model's C-side objects // and their S-side identities before anything is updated var existingModel = new ExistingModelSummary(artifact); // replace the old SSDL with the new and fixup any references // in the MSL that broke because of the replacement of the SSDL // (i.e. the S-side Alias and S-side EntityContainer name) var replaceSsdlCommand = new ReplaceSsdlCommand(_newArtifactFromDB.StorageModel()); CommandProcessor.InvokeSingleCommand(cpc, replaceSsdlCommand); // remove any mappings with references which no longer work // with the new SSDL var deleteUnboundMappingsCommand = new DeleteUnboundMappingsCommand(); CommandProcessor.InvokeSingleCommand(cpc, deleteUnboundMappingsCommand); // remove any mappings which should no longer be mapped with the new SSDL // but actually are because a new S-side object with identical name // but different identity has been added var deleteChangedIdentityMappingsCommand = new DeleteChangedIdentityMappingsCommand(existingModel); CommandProcessor.InvokeSingleCommand(cpc, deleteChangedIdentityMappingsCommand); // from the temp model for the updated database determine which // C-side objects need to be added/updated and then update the // C- and M- side models appropriately var modelFromUpdatedDatabase = new UpdatedModelSummary(_newArtifactFromDB); var updateCsdlAndMslCommand = new UpdateConceptualAndMappingModelsCommand(existingModel, modelFromUpdatedDatabase); CommandProcessor.InvokeSingleCommand(cpc, updateCsdlAndMslCommand); // fix up Function Import parameters and add integrity checks if (artifact.MappingModel() != null && artifact.MappingModel().FirstEntityContainerMapping != null) { // Function Import parameters are now out-of-date compared to the updated Function ones. // We need to update them as otherwise there is no way to do so using Escher. foreach (var fim in artifact.MappingModel().FirstEntityContainerMapping.FunctionImportMappings()) { if (null != fim.FunctionImportName && null != fim.FunctionImportName.Target && null != fim.FunctionName && null != fim.FunctionName.Target) { CreateFunctionImportCommand.UpdateFunctionImportParameters( cpc, fim.FunctionImportName.Target, fim.FunctionName.Target); } } // Add integrity checks to enforce mapping rules foreach (var esm in artifact.MappingModel().FirstEntityContainerMapping.EntitySetMappings()) { EnforceEntitySetMappingRules.AddRule(cpc, esm); } // add the integrity check to propagate all appropriate StoreGeneratedPattern values to the S-side // Note: should not propagate "None"/defaulted values to prevent those C-side values overwriting // correctly updated S-side StoreGeneratedPattern values which were just received from the runtime PropagateStoreGeneratedPatternToStorageModel.AddRule(cpc, artifact, false); // Add integrity check to enforce synchronizing C-side Property facets to S-side values var shouldSynchronizePropertyFacets = ModelHelper.GetDesignerPropertyValueFromArtifactAsBool( OptionsDesignerInfo.ElementName, OptionsDesignerInfo.AttributeSynchronizePropertyFacets, OptionsDesignerInfo.SynchronizePropertyFacetsDefault(artifact), artifact); if (shouldSynchronizePropertyFacets) { PropagateStoragePropertyFacetsToConceptualModel.AddRule(cpc, artifact); } } }