internal UpdatedModelSummary(EFArtifact artifact)
{
_artifact = artifact;
Debug.Assert(artifact != null, "Null artifact");
if (artifact != null)
{
if (null != artifact.MappingModel() &&
null != artifact.MappingModel().FirstEntityContainerMapping)
{
RecordEntityTypeIdentities(
artifact.MappingModel().FirstEntityContainerMapping);
// build the association summary
_associationSummary = AssociationSummary.ConstructAssociationSummary(artifact);
}
if (null != artifact.StorageModel() &&
null != artifact.StorageModel().FirstEntityContainer)
{
var sec = artifact.StorageModel().FirstEntityContainer as StorageEntityContainer;
if (sec != null)
{
RecordStorageProperties(sec);
}
}
}
}
public static AssociationEnd GetFreshAssociationEnd(this EFArtifact artifact, string associationTypeName, int index)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(associationTypeName), "!string.IsNullOrWhiteSpace(associationTypeName)");
return(GetFreshAssociation(artifact, associationTypeName).AssociationEnds()[index]);
}
public static FunctionImport GetFreshFunctionImport(this EFArtifact artifact, string functionImportName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(functionImportName), "!string.IsNullOrWhiteSpace(functionImportName)");
return((FunctionImport)artifact.ConceptualModel().EntityContainers().Single().GetFirstNamedChildByLocalName(functionImportName));
}
public static ConceptualEntityType GetFreshConceptualEntity(this EFArtifact artifact, string entityTypeName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(entityTypeName), "!string.IsNullOrWhiteSpace(entityTypeName)");
return(artifact.GetConceptualChildByName <ConceptualEntityType>(entityTypeName));
}
public static Association GetFreshAssociation(this EFArtifact artifact, string associationTypeName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(associationTypeName), "!string.IsNullOrWhiteSpace(associationTypeName)");
return(artifact.GetConceptualChildByName <Association>(associationTypeName));
}
public static Function GetFreshStorageFunction(this EFArtifact artifact, string functionName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(functionName), "!string.IsNullOrWhiteSpace(functionName)");
return(artifact.GetStorageChildByName <Function>(functionName));
}
public static StorageEntityType GetFreshStorageEntity(this EFArtifact artifact, string entityTypeName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(entityTypeName), "!string.IsNullOrWhiteSpace(entityTypeName)");
return(artifact.GetStorageChildByName <StorageEntityType>(entityTypeName));
}
internal UpdatedModelSummary(EFArtifact artifact)
{
_artifact = artifact;
Debug.Assert(artifact != null, "Null artifact");
if (artifact != null)
{
if (null != artifact.MappingModel()
&& null != artifact.MappingModel().FirstEntityContainerMapping)
{
RecordEntityTypeIdentities(
artifact.MappingModel().FirstEntityContainerMapping);
// build the association summary
_associationSummary = AssociationSummary.ConstructAssociationSummary(artifact);
}
if (null != artifact.StorageModel()
&& null != artifact.StorageModel().FirstEntityContainer)
{
var sec = artifact.StorageModel().FirstEntityContainer as StorageEntityContainer;
if (sec != null)
{
RecordStorageProperties(sec);
}
}
}
}
internal static void ProcessStoredProcedureReturnTypeInformation(
EFArtifact artifact,
Dictionary <EntityStoreSchemaFilterEntry, IDataSchemaProcedure> newFunctionSchemaProceduresMap, IList <Command> commands,
bool shouldCreateComposableFunctionImports)
{
if (null == artifact)
{
Debug.Fail("null artifact");
return;
}
if (null == newFunctionSchemaProceduresMap)
{
Debug.Fail("Null newFunctionSchemaProceduresMap for artifact " + artifact.Uri);
return;
}
var sem = artifact.StorageModel();
if (null == sem)
{
Debug.Fail("Null StorageEntityModel for artifact " + artifact.Uri);
return;
}
var storageEntityContainerName = sem.FirstEntityContainer.LocalName.Value;
if (string.IsNullOrWhiteSpace(storageEntityContainerName))
{
Debug.Fail("Null or whitespace StorageEntityContainerName for artifact " + artifact.Uri);
return;
}
foreach (var entry in newFunctionSchemaProceduresMap.Keys)
{
var schemaProcedure = newFunctionSchemaProceduresMap[entry];
Command cmd = null;
if (null == schemaProcedure)
{
// schemaProcedure information was not collected - so delete the Function
var dbObj = DatabaseObject.CreateFromEntityStoreSchemaFilterEntry(entry, storageEntityContainerName);
var func = ModelHelper.FindFunction(sem, dbObj);
Debug.Assert(func != null, "Could not find Function to delete matching Database Object " + dbObj.ToString());
if (null != func)
{
cmd = func.GetDeleteCommand();
}
}
else
{
cmd = new CreateMatchingFunctionImportCommand(schemaProcedure, shouldCreateComposableFunctionImports);
}
if (null != cmd)
{
commands.Add(cmd);
}
}
}
internal static void AddRule(CommandProcessorContext cpc, EFArtifact artifact, bool propagateNoneSGP)
{
if (null != artifact)
{
IIntegrityCheck check = new PropagateStoreGeneratedPatternToStorageModel(cpc, artifact, propagateNoneSGP);
cpc.AddIntegrityCheck(check);
}
}
private static string GetReturnType(IRawDataSchemaProcedure procedure, EFArtifact artifact)
{
if (procedure.RawReturnValue != null)
{
return(GetParameterType(procedure.RawReturnValue, artifact));
}
return(null);
}
internal static void AddRule(CommandProcessorContext cpc, EFArtifact artifact)
{
if (artifact != null)
{
IIntegrityCheck check = new PropagateStoragePropertyFacetsToConceptualModel(cpc, artifact);
cpc.AddIntegrityCheck(check);
}
}
private EfiTransaction(EFArtifact artifact, string originatorId, bool createdXmlTxn, EfiTransactionContext context)
{
_artifact = artifact;
_changes = new EfiChangeGroup(this);
_createdXmlTxn = createdXmlTxn;
_originatorId = originatorId;
_efiTransactionContext = context != null ? context : new EfiTransactionContext();
}
private static void UpdateMappingModel(EFArtifact existingArtifact, string oldStorageEntityContainerName)
{
// replaces the possible reference to the old S-side EntityContainer name
ReplaceMappingContainerRef(existingArtifact, oldStorageEntityContainerName);
// normalize and resolve the changes we just made above
XmlModelHelper.NormalizeAndResolve(existingArtifact.MappingModel());
}
private void LoadDesignerInfoAndDescriptors(EditingContext editingContext, EFArtifact artifact)
{
if (artifact != null &&
artifact.DesignerInfo() != null)
{
DesignerInfo connectionDesignerInfo = null;
DesignerInfo optionsDesignerInfo = null;
var foundConnectionDesignerInfo = artifact.DesignerInfo()
.TryGetDesignerInfo(ConnectionDesignerInfo.ElementName, out connectionDesignerInfo);
if (foundConnectionDesignerInfo)
{
var connectionDesigner = connectionDesignerInfo as ConnectionDesignerInfo;
Debug.Assert(connectionDesigner != null, "DesignerInfo with element name 'Connection' must be a ConnectionDesignerInfo");
if (connectionDesigner != null)
{
// if the owner of the edmx file is a website, then we can
// only have one possible value (EmbedInOutputAssembly) for metadata artifact processing
// however the item template just adds CopyToOutputDirectory, so we need to fix it
var project = VSHelpers.GetProjectForDocument(artifact.Uri.LocalPath, PackageManager.Package);
if (project != null)
{
var appType = VsUtils.GetApplicationType(Services.ServiceProvider, project);
if (appType == VisualStudioProjectSystem.Website)
{
var mapDefault = ConnectionManager.GetMetadataArtifactProcessingDefault();
if (connectionDesigner.MetadataArtifactProcessingProperty != null &&
connectionDesigner.MetadataArtifactProcessingProperty.ValueAttr.Value != mapDefault)
{
var cpc = new CommandProcessorContext(
editingContext, EfiTransactionOriginator.PropertyWindowOriginatorId,
Resources.Tx_ChangeMetadataArtifactProcessing);
var cmd =
new UpdateDefaultableValueCommand <string>(
connectionDesigner.MetadataArtifactProcessingProperty.ValueAttr, mapDefault);
CommandProcessor.InvokeSingleCommand(cpc, cmd);
}
}
}
_EFConnectionDesignerInfoDescriptor = new EFConnectionDesignerInfoDescriptor();
_EFConnectionDesignerInfoDescriptor.Initialize(connectionDesigner, editingContext);
}
}
var foundOptionsDesignerInfo = artifact.DesignerInfo()
.TryGetDesignerInfo(OptionsDesignerInfo.ElementName, out optionsDesignerInfo);
if (foundOptionsDesignerInfo)
{
_EFOptionsDesignerInfoDescriptor = new EFOptionsDesignerInfoDescriptor();
_EFOptionsDesignerInfoDescriptor.Initialize(optionsDesignerInfo as OptionsDesignerInfo, editingContext);
}
}
}
public static T GetStorageChildByName <T>(this EFArtifact artifact, string childName)
where T : EFNameableItem
{
Debug.Assert(artifact != null, "artifact != null");
var storageModel = artifact.StorageModel();
return((T)storageModel.GetFirstNamedChildByLocalName(childName));
}
public static ConceptualEntityContainer GetFreshConceptualEntityContainer(this EFArtifact artifact, string entityContainerName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(entityContainerName), "!string.IsNullOrWhiteSpace(entityContainerName)");
return
((ConceptualEntityContainer)
artifact.ConceptualModel().EntityContainers().SingleOrDefault(e => e.Name.Value == entityContainerName));
}
internal static string GetMslFromArtifact(EFArtifact artifact)
{
Debug.Assert(artifact != null, "Artifact is null ");
if (artifact != null)
{
return(GetSchemaFromRuntimeModelRoot(artifact.MappingModel()));
}
return(String.Empty);
}
public static EntitySetMapping GetFreshEntitySetMapping(this EFArtifact artifact, string entitySetName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(entitySetName), "!string.IsNullOrWhiteSpace(entitySetName)");
return
(artifact.MappingModel()
.EntityContainerMappings().Single()
.EntitySetMappings().SingleOrDefault(m => m.Name.RefName == entitySetName));
}
public static AssociationSetMapping GetFreshAssociationSetMapping(this EFArtifact artifact, string associationSetMappingName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(associationSetMappingName), "!string.IsNullOrWhiteSpace(associationSetName)");
return(artifact
.MappingModel()
.EntityContainerMappings().Single()
.AssociationSetMappings().SingleOrDefault(asm => asm.Name.Target.LocalName.Value == associationSetMappingName));
}
public static FunctionImportMapping GetFreshFunctionMapping(this EFArtifact artifact, string functionImportName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(functionImportName), "!string.IsNullOrWhiteSpace(functionImportName)");
return
(artifact.MappingModel()
.EntityContainerMappings().Single()
.FunctionImportMappings().SingleOrDefault(m => m.FunctionImportName.RefName == functionImportName));
}
internal DispatchToExtensionsCommand(ModelBuilderSettings settings)
{
_settings = settings;
_artifact = settings.Artifact;
_fromDbDocument = ((EdmxModelBuilderEngine)settings.ModelBuilderEngine).Edmx;
_projectItem = VsUtils.GetProjectItemForDocument(_artifact.Uri.LocalPath, PackageManager.Package);
// make a copy of the artifact before any chagnes are done to it. This is the "original document" that will be passed to extensions
_originalDocument = XDocument.Parse(_artifact.XDocument.ToString(), LoadOptions.PreserveWhitespace);
}
public static EditingContext GetEditingContext(this EFArtifact artifact)
{
Debug.Assert(artifact != null, "artifact != null");
var service = new EFArtifactService(artifact);
var editingContext = new EditingContext();
editingContext.SetEFArtifactService(service);
return(editingContext);
}
private void PropagateAllStoragePropertyFacets(EFArtifact artifact)
{
var sModel = artifact.StorageModel();
if (null == sModel)
{
Debug.Fail("null StorageEntityModel");
return;
}
var cModel = artifact.ConceptualModel();
if (null == cModel)
{
Debug.Fail("null ConceptualEntityModel");
return;
}
// loop over every S-side Property
foreach (var sSideEntityType in sModel.EntityTypes())
{
foreach (var sSideProperty in sSideEntityType.Properties())
{
// add every mapped C-side Property whose parent is a C-side EntityType (as opposed to a ComplexType)
var cSideProperties = new HashSet <Property>();
foreach (var scalarProp in sSideProperty.GetAntiDependenciesOfType <ScalarProperty>())
{
// only count mappings through EntitySetMapping and EntityTypeMapping (MappingFragment only
// appears as a child in these kinds of mappings). Mappings through e.g.
// AssociationSetMapping do not identify the C-side properties to be updated.
if (scalarProp.GetParentOfType(typeof(MappingFragment)) != null)
{
var cSideProperty = scalarProp.Name.Target;
if (null != cSideProperty &&
null != cSideProperty.GetParentOfType(typeof(EntityType)) &&
false == cSideProperties.Contains(cSideProperty))
{
cSideProperties.Add(cSideProperty);
}
}
}
// propagate the facets for this S-side Property to all the C-side Properties that are mapped to it
foreach (var mappedCSideProperty in cSideProperties)
{
// for each mapped C-side Property, loop over all the facet-synchronizers invoking them
foreach (var facetSynchronizer in _facetSynchronizers)
{
facetSynchronizer.Invoke(sSideProperty, mappedCSideProperty);
}
}
}
}
}
private static bool IsArtifactDesignerSafe(EFArtifact artifact)
{
// if the artifact needs to be reloaded, treat it as designer-unsafe for our purposes.
// this should only be the case when editing in the xml editor, and our selection container
// gets invoked.
if (artifact.RequireDelayedReload)
{
return(false);
}
return(artifact.IsDesignerSafe);
}
public static EntityTypeMapping GetFreshEntityTypeMapping(this EFArtifact artifact, string entitySetName, string entityTypeName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(entityTypeName), "!string.IsNullOrWhiteSpace(entityTypeName)");
var entitySetMapping = GetFreshEntitySetMapping(artifact, entitySetName);
return(entitySetMapping != null
? entitySetMapping.EntityTypeMappings().SingleOrDefault(m => m.TypeName.RefName == entityTypeName)
: null);
}
internal static AssociationSummary ConstructAssociationSummary(EFArtifact artifact)
{
var ecm = artifact.MappingModel().FirstEntityContainerMapping;
var summary = new AssociationSummary();
if (!EdmFeatureManager.GetForeignKeysInModelFeatureState(artifact.SchemaVersion).IsEnabled())
{
if (ecm != null)
{
// Foreign keys in the model are not supported for this EDMX version.
foreach (var asm in ecm.AssociationSetMappings())
{
var cSideAssociation = asm.TypeName.Target;
if (null != cSideAssociation)
{
var assocId = AssociationIdentityForAssociationSetMapping.CreateAssociationIdentity(asm);
if (null != assocId)
{
summary.Add(cSideAssociation, assocId);
}
}
}
}
}
else
{
// Foreign keys in the model are supported for this EDMX version.
foreach (var a in artifact.ConceptualModel().Associations())
{
AssociationIdentity assocId = null;
if (a.IsManyToMany == false &&
a.ReferentialConstraint != null)
{
assocId = AssociationIdentityForReferentialConstraint.CreateAssociationIdentity(a.ReferentialConstraint);
}
else
{
var asm = ModelHelper.FindAssociationSetMappingForConceptualAssociation(a);
if (asm != null)
{
assocId = AssociationIdentityForAssociationSetMapping.CreateAssociationIdentity(asm);
}
}
if (null != assocId)
{
summary.Add(a, assocId);
}
}
}
return(summary);
}
public static ScalarProperty GetFreshScalarProperty(
this EFArtifact artifact, string entitySetName, string entityTypeName, string propertyName)
{
var entityTypeMapping = GetFreshEntityTypeMapping(artifact, entitySetName, entityTypeName);
return(entityTypeMapping != null
? entityTypeMapping
.MappingFragments()
.SelectMany(m => m.ScalarProperties())
.SingleOrDefault(p => p.Name.Target.LocalName.Value == propertyName)
: null);
}
public static Condition GetFreshCondition(this EFArtifact artifact, string entitySetName, string columnName)
{
Debug.Assert(artifact != null, "artifact != null");
Debug.Assert(!string.IsNullOrWhiteSpace(entitySetName), "!string.IsNullOrWhiteSpace(entitySetName)");
Debug.Assert(!string.IsNullOrWhiteSpace(columnName), "!string.IsNullOrWhiteSpace(columnName)");
return(artifact.MappingModel()
.EntityContainerMappings()
.Single()
.EntitySetMappings().Single(m => m.Name.RefName == entitySetName)
.EntityTypeMappings().SelectMany(t => t.MappingFragments())
.SelectMany(f => f.Conditions()).SingleOrDefault(c => c.ColumnName.RefName == columnName));
}
private static void ValidateArtifact(EntityDesignModelManager modelManager, EFArtifact artifact, WizardKind kind)
{
var errorsFound = false;
Exception caughtException = null;
try
{
VsUtils.EnsureProvider(artifact);
var artifactSet = (EntityDesignArtifactSet)modelManager.GetArtifactSet(artifact.Uri);
modelManager.ValidateAndCompileMappings(artifactSet, false); // just run the runtime's validation
var errors = artifactSet.GetAllErrorsForArtifact(artifact);
if (errors != null &&
errors.Count > 0)
{
foreach (var error in errors)
{
if (error.IsError())
{
errorsFound = true;
break;
}
}
}
}
catch (Exception e)
{
caughtException = e;
}
if (errorsFound || caughtException != null)
{
var message = string.Empty;
if (kind == WizardKind.Generate)
{
message = Resources.Extensibility_ExtensionMadeBadModel;
}
else if (kind == WizardKind.UpdateModel)
{
message = Resources.Extensibility_ExtensionMadeBadModel_Update;
}
if (caughtException == null)
{
throw new InvalidOperationException(message);
}
else
{
throw new InvalidOperationException(message, caughtException);
}
}
}
internal static string GetDatabaseSchemaNameFromArtifact(EFArtifact artifact)
{
var databaseSchemaName = ModelHelper.GetDesignerPropertyValueFromArtifact(
OptionsDesignerInfo.ElementName, OptionsDesignerInfo.AttributeDatabaseSchemaName, artifact);
if (String.IsNullOrEmpty(databaseSchemaName))
{
// There is probably not a DesignerProperty under the DesignerInfoPropertySet or there may not even
// be a DesignerInfoPropertySet under the DesignerInfo. In this case, we will just use the default value
// of the database schema name
databaseSchemaName = DefaultDatabaseSchemaName;
}
return(databaseSchemaName);
}
internal CreateEntityContainerMappingCommand(EFArtifact artifact)
{
Debug.Assert(artifact != null, "artifact should not be null");
Debug.Assert(
artifact.ConceptualModel().EntityContainerCount == 1,
"conceptual model EntityContainer count (" + artifact.ConceptualModel().EntityContainerCount + ") should be 1");
Debug.Assert(
artifact.StorageModel().EntityContainerCount == 1,
"storage model EntityContainer count (" + artifact.StorageModel().EntityContainerCount + ") should be 1");
Debug.Assert(
artifact.MappingModel().FirstEntityContainerMapping == null, "mapping model FirstEntityContainer should not be null");
_artifact = artifact;
}
/// <summary>
/// Note: If createTransactionImmediately is set to true, the caller is responsible for calling CommandProcessor's FinalizeTransaction(). This is a bit wonky. User can spin up a CommandProcessor
/// with this context, and then invoke that method on that command processor.
/// </summary>
/// <param name="editingContext"></param>
/// <param name="originatorId"></param>
/// <param name="transactionName"></param>
/// <param name="artifact"></param>
/// <param name="transactionContext"></param>
/// <param name="createTransactionImmediately"></param>
internal CommandProcessorContext(
EditingContext editingContext, string originatorId, string transactionName, EFArtifact artifact,
EfiTransactionContext transactionContext, bool createTransactionImmediately)
{
_editingContext = editingContext;
_originatorId = originatorId;
_transactionName = transactionName;
_artifact = artifact;
_transactionContext = transactionContext;
if (createTransactionImmediately)
{
_transaction = CreateTransaction();
}
}
internal static bool IsStorageModelEmpty(EFArtifact artifact)
{
var result = false;
var storageModel = artifact.StorageModel();
if (storageModel != null)
{
var container = storageModel.FirstEntityContainer as StorageEntityContainer;
if (container != null)
{
var element = container.Children.OfType<EFElement>().FirstOrDefault<EFElement>();
if (element == null)
{
result = true;
}
}
}
return result;
}
private void FindNewStorageEntitySetsWithSameName(
EFArtifact artifact, out HashSet<StorageEntitySet> storageEntitySetsWithSameNameButDifferentIdentity)
{
storageEntitySetsWithSameNameButDifferentIdentity = new HashSet<StorageEntitySet>();
if (null != artifact
&& null != artifact.StorageModel()
&& null != artifact.StorageModel().FirstEntityContainer)
{
// set up Dictionary of EntitySetName to EntitySet for new (DB-based) artifact
var newEntitySetMap = new Dictionary<string, EntitySet>();
foreach (var newEntitySet in artifact.StorageModel().FirstEntityContainer.EntitySets())
{
newEntitySetMap.Add(newEntitySet.LocalName.Value, newEntitySet);
}
// now compare all names - if we find a local name match compare identities
// if they have the same name but different identities then add to returned HashSet
foreach (var existingEntitySet in _preExistingModel.AllTablesAndViewsDictionary)
{
var existingEntitySetLocalName = existingEntitySet.Value;
EntitySet newEntitySet;
if (newEntitySetMap.TryGetValue(existingEntitySetLocalName, out newEntitySet))
{
var newStorageEntitySet = newEntitySet as StorageEntitySet;
if (null != newStorageEntitySet)
{
// we have a StorageEntitySet in the DB-based artifact which is the
// same as one in the pre-existing artifact. Now compare identities.
var newEntitySetIdentity = DatabaseObject.CreateFromEntitySet(newStorageEntitySet);
var existingEntitySetIdentity = existingEntitySet.Key;
if (!newEntitySetIdentity.Equals(existingEntitySetIdentity))
{
storageEntitySetsWithSameNameButDifferentIdentity.Add(newStorageEntitySet);
}
}
}
}
}
}
internal ExistingModelSummary(EFArtifact artifact)
{
_artifact = artifact;
if (null == artifact)
{
Debug.Fail("Null artifact");
}
else
{
if (null != artifact.MappingModel()
&& null != artifact.MappingModel().FirstEntityContainerMapping)
{
RecordEntityTypeIdentities(
artifact.MappingModel().FirstEntityContainerMapping);
// build the association summary.
_associationSummary = AssociationSummary.ConstructAssociationSummary(artifact);
}
if (null != artifact.ConceptualModel())
{
RecordInheritanceAndEntityTypeMappings(artifact.ConceptualModel());
}
if (null != artifact.StorageModel())
{
RecordFunctions(artifact.StorageModel());
if (null != artifact.StorageModel().FirstEntityContainer)
{
var sec = artifact.StorageModel().FirstEntityContainer as StorageEntityContainer;
if (sec != null)
{
RecordStorageEntitySetsAndProperties(sec);
}
}
}
}
}
internal PropagateStoreGeneratedPatternToStorageModel(CommandProcessorContext cpc, EFArtifact artifact, bool propagateNoneSGP)
{
_cpc = cpc;
_artifact = artifact;
_propagateNoneSGP = propagateNoneSGP;
}
internal static CreateFunctionCommand GetCreateFunctionCommandFromDataSchemaProcedure(
IRawDataSchemaProcedure procedure, EFArtifact artifact, Func<Command, CommandProcessorContext, bool> bindingAction = null)
{
CreateFunctionCommand createFunctionCommand = null;
if (procedure.IsFunction)
{
createFunctionCommand = new CreateFunctionCommand
(
name: ModelHelper.CreateValidSimpleIdentifier(procedure.Name),
schemaName: procedure.Schema,
isNiladic: !procedure.RawParameters.Any(),
isAggregate: false, // figure out if there's some way to determine this from IDataSchemaProcedure
isBuiltIn: false,
isComposable: true, // figure out if there's some way to determine this from IDataSchemaProcedure
commandText: null,
returnType: GetReturnType(procedure, artifact),
storeFunctionName: procedure.Name,
parameterInfos: GetParameterInfos(procedure, artifact),
dataSchemaProcedure: procedure,
bindingAction: bindingAction
);
}
else
{
createFunctionCommand = new CreateFunctionCommand
(
name: ModelHelper.CreateValidSimpleIdentifier(procedure.Name),
storeFunctionName: procedure.Name,
schemaName: procedure.Schema,
commandText: null,
parameterInfos: GetParameterInfos(procedure, artifact),
dataSchemaProcedure: procedure,
bindingAction: bindingAction
);
}
return createFunctionCommand;
}
internal static bool SynchronizePropertyFacetsDefault(EFArtifact artifact)
{
return artifact != null && artifact.IsSqlFamilyProvider();
}
internal static AssociationSummary ConstructAssociationSummary(EFArtifact artifact)
{
var ecm = artifact.MappingModel().FirstEntityContainerMapping;
var summary = new AssociationSummary();
if (!EdmFeatureManager.GetForeignKeysInModelFeatureState(artifact.SchemaVersion).IsEnabled())
{
if (ecm != null)
{
// Foreign keys in the model are not supported for this EDMX version.
foreach (var asm in ecm.AssociationSetMappings())
{
var cSideAssociation = asm.TypeName.Target;
if (null != cSideAssociation)
{
var assocId = AssociationIdentityForAssociationSetMapping.CreateAssociationIdentity(asm);
if (null != assocId)
{
summary.Add(cSideAssociation, assocId);
}
}
}
}
}
else
{
// Foreign keys in the model are supported for this EDMX version.
foreach (var a in artifact.ConceptualModel().Associations())
{
AssociationIdentity assocId = null;
if (a.IsManyToMany == false
&& a.ReferentialConstraint != null)
{
assocId = AssociationIdentityForReferentialConstraint.CreateAssociationIdentity(a.ReferentialConstraint);
}
else
{
var asm = ModelHelper.FindAssociationSetMappingForConceptualAssociation(a);
if (asm != null)
{
assocId = AssociationIdentityForAssociationSetMapping.CreateAssociationIdentity(asm);
}
}
if (null != assocId)
{
summary.Add(a, assocId);
}
}
}
return summary;
}
private static IEnumerable<ParameterDefinition> GetParameterInfos(IRawDataSchemaProcedure procedure, EFArtifact artifact)
{
var parameterInfos = new List<ParameterDefinition>();
foreach (var dataSchemaParam in procedure.RawParameters.Where(p => p != null && p.Direction != ParameterDirection.ReturnValue))
{
// -1 means that the type is unknown
if (dataSchemaParam.ProviderDataType != -1)
{
var info = new ParameterDefinition();
parameterInfos.Add(info);
info.Name = ModelHelper.CreateValidSimpleIdentifier(dataSchemaParam.Name);
switch (dataSchemaParam.Direction)
{
case ParameterDirection.Input:
info.Mode = Parameter.InOutMode.In.ToString();
break;
case ParameterDirection.InputOutput:
info.Mode = Parameter.InOutMode.InOut.ToString();
break;
case ParameterDirection.Output:
info.Mode = Parameter.InOutMode.Out.ToString();
break;
case ParameterDirection.ReturnValue:
default:
Debug.Fail("Could not determine parameter mode");
info.Mode = Parameter.InOutMode.Unknown.ToString();
break;
}
info.Type = GetParameterType(dataSchemaParam, artifact);
}
}
return parameterInfos;
}
internal CommandProcessorContext(
EditingContext editingContext, string originatorId, string transactionName, EFArtifact artifact,
EfiTransactionContext transactionContext)
: this(editingContext, originatorId, transactionName, artifact, transactionContext, false)
{
}
private void FindNewStorageFunctionsWithSameName(
EFArtifact artifact, out HashSet<Function> storageFunctionsWithSameNameButDifferentIdentity)
{
storageFunctionsWithSameNameButDifferentIdentity = new HashSet<Function>();
if (null != artifact
&& null != artifact.StorageModel())
{
// set up Dictionary of EntitySetName to EntitySet for new (DB-based) artifact
var newFunctionMap = new Dictionary<string, Function>();
foreach (var newFunction in artifact.StorageModel().Functions())
{
newFunctionMap.Add(newFunction.LocalName.Value, newFunction);
}
// now compare all names - if we find a local name match compare identities
// if they have the same name but different identities then add to returned HashSet
foreach (var existingFunction in _preExistingModel.AllFunctionsDictionary)
{
var existingFunctionLocalName = existingFunction.Value;
Function newFunction;
if (newFunctionMap.TryGetValue(existingFunctionLocalName, out newFunction))
{
if (null != newFunction)
{
// we have a Function in the DB-based artifact which is the
// same as one in the pre-existing artifact. Now compare identities.
var newFunctionIdentity = DatabaseObject.CreateFromFunction(newFunction);
var existingFunctionIdentity = existingFunction.Key;
if (!newFunctionIdentity.Equals(existingFunctionIdentity))
{
storageFunctionsWithSameNameButDifferentIdentity.Add(newFunction);
}
}
}
}
}
}
private static string GetParameterType(IRawDataSchemaParameter parameter, EFArtifact artifact)
{
var type = ModelHelper.GetPrimitiveType(artifact.StorageModel(), parameter.NativeDataType, parameter.ProviderDataType);
if (type != null)
{
return type.Name;
}
Debug.Fail(
"Unable to find EDM primitive type for DB type:" + parameter.NativeDataType + ", provider data type:"
+ parameter.ProviderDataType);
return null;
}
public EFArtifactService(EFArtifact artifact)
{
_artifact = artifact;
}
private static string GetReturnType(IRawDataSchemaProcedure procedure, EFArtifact artifact)
{
if (procedure.RawReturnValue != null)
{
return GetParameterType(procedure.RawReturnValue, artifact);
}
return null;
}
public EFArtifactSet CreateArtifactSet(EFArtifact artifact)
{
return new EntityDesignArtifactSet(artifact);
}
private EFObject EdmSchemaError2EFObject(EdmSchemaError error, EFArtifact defaultArtifactForError)
{
EFArtifact a = null;
if (error.SchemaLocation != null)
{
a = _modelManager.GetArtifact(Utils.FileName2Uri(error.SchemaLocation));
}
if (a == null)
{
a = defaultArtifactForError;
}
return a.FindEFObjectForLineAndColumn(error.Line, error.Column);
}
/// <summary>
/// This method returns true if the passed-in error code is one that requires the document to be opened in the XML editor,
/// with no designer.
/// </summary>
internal static bool IsOpenInEditorError(ErrorInfo errorInfo, EFArtifact artifact)
{
if ((errorInfo.ErrorClass & ErrorClass.Runtime_All) == 0)
{
return false;
}
var o = artifact.FindEFObjectForLineAndColumn(errorInfo.GetLineNumber(), errorInfo.GetColumnNumber());
if (errorInfo.ErrorCode == (int)MappingErrorCode.XmlSchemaValidationError
&& o is ModificationFunctionMapping)
{
// we don't trigger safe-mode for XSD errors on ModificationFunctionMapping, since these can be fixed in the designer
return false;
}
if (errorInfo.ErrorCode == (int)ErrorCode.XmlError
&& o is ReferentialConstraintRole)
{
// we don't trigger safe-mode for XSD errors on referential constraint roles. This is so we can leave the RC
// and the Role, even if it has no properties.
return false;
}
if (errorInfo.ErrorCode == (int)MappingErrorCode.ConditionError
&& o is Condition)
{
// don't trigger safe-mode for errors based around condition validation
return false;
}
if (errorInfo.ErrorCode == (int)ErrorCode.InvalidPropertyInRelationshipConstraint
&& o is ReferentialConstraint)
{
// don't trigger safe-mode for error about Principal not being exactly identical to the EntityType key,
// since we can run into this problem just by adding new key Property to the EntityType that is Principal Role for some Referential Constraint
return false;
}
if (errorInfo.ErrorCode == ErrorCodes.ESCHER_VALIDATOR_UNDEFINED_COMPLEX_PROPERTY_TYPE
|| (errorInfo.ErrorCode == (int)ErrorCode.NotInNamespace && o is ComplexConceptualProperty))
{
// don't trigger safe-mode for underfined/deleted complex property types, the user should be able to fix the problem in the designer.
return false;
}
if (errorInfo.ErrorCode == (int)ErrorCode.XmlError)
{
var navigationProperty = o as NavigationProperty;
if (navigationProperty != null)
{
// we allow the user to have navigation properties not bound to any association via an AssociationEnd if the Name property is defined as it's still required.
return
string.IsNullOrEmpty(navigationProperty.LocalName.Value) /* invalid name */||
navigationProperty.Relationship.Status != BindingStatus.Undefined ||
navigationProperty.ToRole.Status != BindingStatus.Undefined ||
navigationProperty.FromRole.Status != BindingStatus.Undefined;
}
}
return
UnrecoverableRuntimeErrors.SchemaObjectModelErrorCodes.Any(c => c == (ErrorCode)errorInfo.ErrorCode) ||
UnrecoverableRuntimeErrors.StorageMappingErrorCodes.Any(c => c == (MappingErrorCode)errorInfo.ErrorCode);
}
private static XmlReader CreateXmlReader(EFArtifact artifact, XElement xobject)
{
var baseReader = xobject.CreateReader();
var lineNumberService = new XNodeReaderLineNumberService(artifact.XmlModelProvider, baseReader, artifact.Uri);
return new XmlReaderProxy(baseReader, artifact.Uri, lineNumberService);
}
internal UpdateModelFromDatabaseCommand(EFArtifact newArtifactFromDB)
{
_newArtifactFromDB = newArtifactFromDB;
}
AddAssociationSetMappingForConceptualAssociation(
CommandProcessorContext cpc, EFArtifact existingArtifact,
Association assocInTempArtifact, Association assocInExistingArtifact,
Dictionary<EntityType, EntityType> tempArtifactCEntityTypeToNewCEntityTypeInExistingArtifact)
{
// first find the AssociationSetMapping in the tempArtifact for this association
var asmInTempArtifact =
ModelHelper.FindAssociationSetMappingForConceptualAssociation(assocInTempArtifact);
if (asmInTempArtifact == null)
{
if (!EdmFeatureManager.GetForeignKeysInModelFeatureState(existingArtifact.SchemaVersion).IsEnabled()
|| assocInTempArtifact.IsManyToMany)
{
// this is an error condition - we should have an association set mapping in this case, so assert and throw an exception
throw new UpdateModelFromDatabaseException(
string.Format(
CultureInfo.CurrentCulture,
Resources.UpdateFromDatabaseAssociationSetMappingCannotFind,
assocInTempArtifact.ToPrettyString()));
}
else
{
// we don't expect an association set mapping here
return;
}
}
// next find the S-side EntitySet in the tempArtifact for this AssociationSetMapping
var storeEntitySetInTempArtifact = asmInTempArtifact.StoreEntitySet.Target;
if (storeEntitySetInTempArtifact == null)
{
throw new UpdateModelFromDatabaseException(
string.Format(
CultureInfo.CurrentCulture,
Resources.UpdateFromDatabaseAssociationSetMappingCannotFindTempSSideEntitySet,
asmInTempArtifact.ToPrettyString()));
}
// now find the S-side EntitySet in the existingArtifact which matches this
// Note: LocalName's will be the same as the SSDL has been replaced
StorageEntitySet storeEntitySetInExistingArtifact = null;
foreach (var es in existingArtifact.StorageModel().FirstEntityContainer.EntitySets())
{
if (es.LocalName.Value == storeEntitySetInTempArtifact.LocalName.Value)
{
storeEntitySetInExistingArtifact = es as StorageEntitySet;
break;
}
}
if (storeEntitySetInExistingArtifact == null)
{
throw new UpdateModelFromDatabaseException(
string.Format(
CultureInfo.CurrentCulture,
Resources.UpdateFromDatabaseAssociationSetMappingCannotFindMatchingSSideEntitySet,
storeEntitySetInTempArtifact.LocalName.Value));
}
// now create a new AssociationSetMapping in the existingArtifact using the data
// accumulated above
CloneAssociationSetMapping(
cpc,
asmInTempArtifact,
existingArtifact.MappingModel().FirstEntityContainerMapping,
assocInExistingArtifact.AssociationSet,
assocInExistingArtifact,
storeEntitySetInExistingArtifact,
tempArtifactCEntityTypeToNewCEntityTypeInExistingArtifact
);
}
/// <summary>
/// Clone the Association with its ReferentialConstraint (if available), AssociationSet
/// and AssociationSetMapping. If the ReferentialConstraint is available in the temp artifact
/// but we cannot find matching properties in the existing artifact then the whole Association
/// (and AssociationSet and AssociationSetMapping) will not be cloned, a warning message will
/// be issued but otherwise the process is not stopped.
/// But if the Association cannot be created for any other reason that's an error and an
/// UpdateModelFromDatabaseException will be thrown.
/// </summary>
/// <param name="cpc">CommandProcessorContext for the commands to be issued</param>
/// <param name="existingArtifact">the existing artifact in which to make these changes</param>
/// <param name="assocInTempArtifact">the Association in the temp artifact to be cloned</param>
/// <param name="end1InTempArtifact">the end of the Association in the temp artifact to be cloned to be treated as End1</param>
/// <param name="end2InTempArtifact">the end of the Association in the temp artifact to be cloned to be treated as End2</param>
/// <param name="navProp1InTempArtifact">the NavigationProperty for End1 in the temp artifact to be cloned</param>
/// <param name="navProp2InTempArtifact">the NavigationProperty for End2 in the temp artifact to be cloned</param>
/// <param name="end1EntityTypeInExistingArtifact">the EntityType in the existing artifact matching the End1 target in the temp artifact</param>
/// <param name="end2EntityTypeInExistingArtifact">the EntityType in the existing artifact matching the End2 target in the temp artifact</param>
/// <param name="tempArtifactCEntityTypeToNewCEntityTypeInExistingArtifact">
/// a Dictionary mapping temp artifact EntityTypes which have
/// been identified as new to their equivalent in the existing artifact
/// </param>
private void CloneAssociation(
CommandProcessorContext cpc, EFArtifact existingArtifact, Association assocInTempArtifact,
AssociationEnd end1InTempArtifact, AssociationEnd end2InTempArtifact,
NavigationProperty navProp1InTempArtifact, NavigationProperty navProp2InTempArtifact,
ConceptualEntityType end1EntityTypeInExistingArtifact, ConceptualEntityType end2EntityTypeInExistingArtifact,
Dictionary<EntityType, EntityType> tempArtifactCEntityTypeToNewCEntityTypeInExistingArtifact)
{
Association newAssocInExistingArtifact = null;
AssociationEnd newAssocEnd1 = null;
AssociationEnd newAssocEnd2 = null;
if (assocInTempArtifact.ReferentialConstraint == null)
{
// if there is no ReferentialConstraint to clone then just try to
// create the Association and AssociationSet
var cmd = new CreateConceptualAssociationCommand(
assocInTempArtifact.LocalName.Value,
end1EntityTypeInExistingArtifact, end1InTempArtifact.Multiplicity.Value, navProp1InTempArtifact.LocalName.Value,
end2EntityTypeInExistingArtifact, end2InTempArtifact.Multiplicity.Value, navProp2InTempArtifact.LocalName.Value,
true, false);
CommandProcessor.InvokeSingleCommand(cpc, cmd);
newAssocInExistingArtifact = cmd.CreatedAssociation;
newAssocEnd1 = cmd.End1;
newAssocEnd2 = cmd.End2;
}
else
{
// There is a ReferentialConstraint - so we need to check whether we can find matching properties
// for the Principal and Dependent roles of the ReferentialConstraint. If we can't find
// matching properties then log a warning message and return. Otherwise attempt to create
// the Association (and its AssociationSet) followed by a matching ReferentialConstraint.
//
// Note: ShouldCreateAssociationGivenReferentialConstraint() produces 2 sets of information:
// (1) the sets of matching properties to use if we can find matching properties for the Principal
// and Dependent roles, and (2) the sets of property names to include in the error message if
// we cannot find matching properties for the Principal and Dependent roles.
// If ShouldCreateAssociationGivenReferentialConstraint() returns true we use the first set of
// information to create the ReferentialConstraint after having created the Association and
// AssociationSet. If it returns false we use the second set of information to construct the
// warning message.
var refConstraintInTempArtifact = assocInTempArtifact.ReferentialConstraint;
bool end1IsPrincipalEnd;
List<Property> principalPropertiesInExistingArtifact;
List<Property> dependentPropertiesInExistingArtifact;
List<string> unfoundPrincipalProperties;
List<string> unfoundDependentProperties;
if (ShouldCreateAssociationGivenReferentialConstraint(
refConstraintInTempArtifact, end1InTempArtifact,
end2InTempArtifact, end1EntityTypeInExistingArtifact, end2EntityTypeInExistingArtifact, out end1IsPrincipalEnd,
out principalPropertiesInExistingArtifact, out dependentPropertiesInExistingArtifact,
out unfoundPrincipalProperties, out unfoundDependentProperties))
{
// create the new Association and AssociationSet
var cmd = new CreateConceptualAssociationCommand(
assocInTempArtifact.LocalName.Value,
end1EntityTypeInExistingArtifact, end1InTempArtifact.Multiplicity.Value, navProp1InTempArtifact.LocalName.Value,
end2EntityTypeInExistingArtifact, end2InTempArtifact.Multiplicity.Value, navProp2InTempArtifact.LocalName.Value,
true, false);
CommandProcessor.InvokeSingleCommand(cpc, cmd);
newAssocInExistingArtifact = cmd.CreatedAssociation;
newAssocEnd1 = cmd.End1;
newAssocEnd2 = cmd.End2;
// Add in the ReferentialConstraint for the new Association
if (null != newAssocInExistingArtifact)
{
AddReferentialConstraintForAssociation(
cpc, cmd, end1IsPrincipalEnd, principalPropertiesInExistingArtifact, dependentPropertiesInExistingArtifact);
}
}
else
{
// Unable to find matching properties for the Principal and Dependent roles of
// the ReferentialConstraint. So log a warning message.
newAssocInExistingArtifact = null;
EntityType principalEndEntityType = end1IsPrincipalEnd
? end1EntityTypeInExistingArtifact
: end2EntityTypeInExistingArtifact;
EntityType dependentEndEntityType = end1IsPrincipalEnd
? end2EntityTypeInExistingArtifact
: end1EntityTypeInExistingArtifact;
LogWarningMessageForReferentialConstraintProperties(
assocInTempArtifact.LocalName.Value,
principalEndEntityType, dependentEndEntityType, unfoundPrincipalProperties, unfoundDependentProperties);
// having logged the warning message we do not need to attempt to create
// the AssociationSetMapping nor throw an exception due to the lack of the
// created Association - so just return
return;
}
}
// if we have failed to create an Association at this stage that's a serious error
// so throw an exception to indicate the failure
if (null == newAssocInExistingArtifact)
{
throw new UpdateModelFromDatabaseException(
string.Format(
CultureInfo.CurrentCulture,
Resources.UpdateFromDatabaseCannotCreateAssociation,
assocInTempArtifact.ToPrettyString()));
}
// update OnDeleteActions to match temp artifact
UpdateOnDeleteAction(cpc, newAssocEnd1, end1InTempArtifact);
UpdateOnDeleteAction(cpc, newAssocEnd2, end2InTempArtifact);
// add a new AssociationSetMapping for the new Association
AddAssociationSetMappingForConceptualAssociation(
cpc, existingArtifact, assocInTempArtifact,
newAssocInExistingArtifact, tempArtifactCEntityTypeToNewCEntityTypeInExistingArtifact);
}
internal static void AddRule(CommandProcessorContext cpc, EFArtifact artifact, bool propagateNoneSGP)
{
if (null != artifact)
{
IIntegrityCheck check = new PropagateStoreGeneratedPatternToStorageModel(cpc, artifact, propagateNoneSGP);
cpc.AddIntegrityCheck(check);
}
}