private static EntityContainer ConvertToEntityContainer( System.Data.Entity.Core.SchemaObjectModel.EntityContainer element, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { EntityContainer entityContainer = new EntityContainer(element.Name, Converter.GetDataSpace(providerManifest)); newGlobalItems.Add((SchemaElement)element, (GlobalItem)entityContainer); foreach (EntityContainerEntitySet entitySet in element.EntitySets) { entityContainer.AddEntitySetBase((EntitySetBase)Converter.ConvertToEntitySet(entitySet, providerManifest, convertedItemCache, newGlobalItems)); } foreach (EntityContainerRelationshipSet relationshipSet in element.RelationshipSets) { entityContainer.AddEntitySetBase((EntitySetBase)Converter.ConvertToAssociationSet(relationshipSet, providerManifest, convertedItemCache, entityContainer, newGlobalItems)); } foreach (System.Data.Entity.Core.SchemaObjectModel.Function functionImport in element.FunctionImports) { entityContainer.AddFunctionImport(Converter.ConvertToFunction(functionImport, providerManifest, convertedItemCache, entityContainer, newGlobalItems)); } if (element.Documentation != null) { entityContainer.Documentation = Converter.ConvertToDocumentation(element.Documentation); } Converter.AddOtherContent((SchemaElement)element, (MetadataItem)entityContainer); return(entityContainer); }
private static EntityType ConvertToEntityType( SchemaEntityType element, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { string[] strArray = (string[])null; if (element.DeclaredKeyProperties.Count != 0) { strArray = new string[element.DeclaredKeyProperties.Count]; for (int index = 0; index < strArray.Length; ++index) { strArray[index] = element.DeclaredKeyProperties[index].Property.Name; } } EdmProperty[] edmPropertyArray = new EdmProperty[element.Properties.Count]; int num = 0; foreach (StructuredProperty property in element.Properties) { edmPropertyArray[num++] = Converter.ConvertToProperty(property, providerManifest, convertedItemCache, newGlobalItems); } EntityType entityType = new EntityType(element.Name, element.Namespace, Converter.GetDataSpace(providerManifest), (IEnumerable <string>)strArray, (IEnumerable <EdmMember>)edmPropertyArray); if (element.BaseType != null) { entityType.BaseType = (EdmType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)element.BaseType, providerManifest, convertedItemCache, newGlobalItems); } entityType.Abstract = element.IsAbstract; if (element.Documentation != null) { entityType.Documentation = Converter.ConvertToDocumentation(element.Documentation); } Converter.AddOtherContent((SchemaElement)element, (MetadataItem)entityType); newGlobalItems.Add((SchemaElement)element, (GlobalItem)entityType); return(entityType); }
private static EdmFunction ConvertToFunction( System.Data.Entity.Core.SchemaObjectModel.Function somFunction, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, EntityContainer functionImportEntityContainer, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { GlobalItem globalItem = (GlobalItem)null; if (!somFunction.IsFunctionImport && newGlobalItems.TryGetValue((SchemaElement)somFunction, out globalItem)) { return((EdmFunction)globalItem); } bool areConvertingForProviderManifest = somFunction.Schema.DataModel == SchemaDataModelOption.ProviderManifestModel; List <FunctionParameter> functionParameterList1 = new List <FunctionParameter>(); if (somFunction.ReturnTypeList != null) { int num = 0; foreach (ReturnType returnType in (IEnumerable <ReturnType>)somFunction.ReturnTypeList) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)returnType, providerManifest, areConvertingForProviderManifest, returnType.Type, returnType.CollectionKind, returnType.IsRefType, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } string str = num == 0 ? string.Empty : num.ToString((IFormatProvider)CultureInfo.InvariantCulture); ++num; FunctionParameter functionParameter = new FunctionParameter("ReturnType" + str, functionTypeUsage, ParameterMode.ReturnValue); Converter.AddOtherContent((SchemaElement)returnType, (MetadataItem)functionParameter); functionParameterList1.Add(functionParameter); } } else if (somFunction.Type != null) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)null, providerManifest, areConvertingForProviderManifest, somFunction.Type, somFunction.CollectionKind, somFunction.IsReturnAttributeReftype, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } functionParameterList1.Add(new FunctionParameter("ReturnType", functionTypeUsage, ParameterMode.ReturnValue)); } EntitySet[] entitySetArray = (EntitySet[])null; string name; if (somFunction.IsFunctionImport) { FunctionImportElement functionImportElement = (FunctionImportElement)somFunction; name = functionImportElement.Container.Name; if (functionImportElement.EntitySet != null) { EntityContainer container = functionImportEntityContainer; entitySetArray = new EntitySet[1] { Converter.GetEntitySet(functionImportElement.EntitySet, container) }; } else if (functionImportElement.ReturnTypeList != null) { EntityContainer entityContainer = functionImportEntityContainer; entitySetArray = functionImportElement.ReturnTypeList.Select <ReturnType, EntitySet>((Func <ReturnType, EntitySet>)(returnType => { if (returnType.EntitySet == null) { return((EntitySet)null); } return(Converter.GetEntitySet(returnType.EntitySet, functionImportEntityContainer)); })).ToArray <EntitySet>(); } } else { name = somFunction.Namespace; } List <FunctionParameter> functionParameterList2 = new List <FunctionParameter>(); foreach (Parameter parameter in somFunction.Parameters) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)parameter, providerManifest, areConvertingForProviderManifest, parameter.Type, parameter.CollectionKind, parameter.IsRefType, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } FunctionParameter functionParameter = new FunctionParameter(parameter.Name, functionTypeUsage, Converter.GetParameterMode(parameter.ParameterDirection)); Converter.AddOtherContent((SchemaElement)parameter, (MetadataItem)functionParameter); if (parameter.Documentation != null) { functionParameter.Documentation = Converter.ConvertToDocumentation(parameter.Documentation); } functionParameterList2.Add(functionParameter); } EdmFunction edmFunction = new EdmFunction(somFunction.Name, name, Converter.GetDataSpace(providerManifest), new EdmFunctionPayload() { Schema = somFunction.DbSchema, StoreFunctionName = somFunction.StoreFunctionName, CommandText = somFunction.CommandText, EntitySets = (IList <EntitySet>)entitySetArray, IsAggregate = new bool?(somFunction.IsAggregate), IsBuiltIn = new bool?(somFunction.IsBuiltIn), IsNiladic = new bool?(somFunction.IsNiladicFunction), IsComposable = new bool?(somFunction.IsComposable), IsFromProviderManifest = new bool?(areConvertingForProviderManifest), IsFunctionImport = new bool?(somFunction.IsFunctionImport), ReturnParameters = (IList <FunctionParameter>)functionParameterList1.ToArray(), Parameters = (IList <FunctionParameter>)functionParameterList2.ToArray(), ParameterTypeSemantics = new ParameterTypeSemantics?(somFunction.ParameterTypeSemantics) }); if (!somFunction.IsFunctionImport) { newGlobalItems.Add((SchemaElement)somFunction, (GlobalItem)edmFunction); } if (somFunction.Documentation != null) { edmFunction.Documentation = Converter.ConvertToDocumentation(somFunction.Documentation); } Converter.AddOtherContent((SchemaElement)somFunction, (MetadataItem)edmFunction); return(edmFunction); }
private static AssociationType ConvertToAssociationType( Relationship element, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { AssociationType associationType = new AssociationType(element.Name, element.Namespace, element.IsForeignKey, Converter.GetDataSpace(providerManifest)); newGlobalItems.Add((SchemaElement)element, (GlobalItem)associationType); foreach (RelationshipEnd end in (IEnumerable <IRelationshipEnd>)element.Ends) { EntityType endMemberType = (EntityType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)end.Type, providerManifest, convertedItemCache, newGlobalItems); AssociationEndMember associationEndMember = Converter.InitializeAssociationEndMember(associationType, (IRelationshipEnd)end, endMemberType); Converter.AddOtherContent((SchemaElement)end, (MetadataItem)associationEndMember); foreach (OnOperation operation in (IEnumerable <OnOperation>)end.Operations) { if (operation.Operation == Operation.Delete) { OperationAction operationAction = OperationAction.None; switch (operation.Action) { case System.Data.Entity.Core.SchemaObjectModel.Action.None: operationAction = OperationAction.None; break; case System.Data.Entity.Core.SchemaObjectModel.Action.Cascade: operationAction = OperationAction.Cascade; break; } associationEndMember.DeleteBehavior = operationAction; } } if (end.Documentation != null) { associationEndMember.Documentation = Converter.ConvertToDocumentation(end.Documentation); } } for (int index = 0; index < element.Constraints.Count; ++index) { System.Data.Entity.Core.SchemaObjectModel.ReferentialConstraint constraint = element.Constraints[index]; AssociationEndMember member1 = (AssociationEndMember)associationType.Members[constraint.PrincipalRole.Name]; AssociationEndMember member2 = (AssociationEndMember)associationType.Members[constraint.DependentRole.Name]; EntityTypeBase elementType1 = ((RefType)member1.TypeUsage.EdmType).ElementType; EntityTypeBase elementType2 = ((RefType)member2.TypeUsage.EdmType).ElementType; ReferentialConstraint referentialConstraint = new ReferentialConstraint((RelationshipEndMember)member1, (RelationshipEndMember)member2, (IEnumerable <EdmProperty>)Converter.GetProperties(elementType1, constraint.PrincipalRole.RoleProperties), (IEnumerable <EdmProperty>)Converter.GetProperties(elementType2, constraint.DependentRole.RoleProperties)); if (constraint.Documentation != null) { referentialConstraint.Documentation = Converter.ConvertToDocumentation(constraint.Documentation); } if (constraint.PrincipalRole.Documentation != null) { referentialConstraint.FromRole.Documentation = Converter.ConvertToDocumentation(constraint.PrincipalRole.Documentation); } if (constraint.DependentRole.Documentation != null) { referentialConstraint.ToRole.Documentation = Converter.ConvertToDocumentation(constraint.DependentRole.Documentation); } associationType.AddReferentialConstraint(referentialConstraint); Converter.AddOtherContent((SchemaElement)element.Constraints[index], (MetadataItem)referentialConstraint); } if (element.Documentation != null) { associationType.Documentation = Converter.ConvertToDocumentation(element.Documentation); } Converter.AddOtherContent((SchemaElement)element, (MetadataItem)associationType); return(associationType); }
private static ComplexType ConvertToComplexType( SchemaComplexType element, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { ComplexType complexType = new ComplexType(element.Name, element.Namespace, Converter.GetDataSpace(providerManifest)); newGlobalItems.Add((SchemaElement)element, (GlobalItem)complexType); foreach (StructuredProperty property in element.Properties) { complexType.AddMember((EdmMember)Converter.ConvertToProperty(property, providerManifest, convertedItemCache, newGlobalItems)); } complexType.Abstract = element.IsAbstract; if (element.BaseType != null) { complexType.BaseType = (EdmType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)element.BaseType, providerManifest, convertedItemCache, newGlobalItems); } if (element.Documentation != null) { complexType.Documentation = Converter.ConvertToDocumentation(element.Documentation); } Converter.AddOtherContent((SchemaElement)element, (MetadataItem)complexType); return(complexType); }