private static AssociationSet ConvertToAssociationSet(
EntityContainerRelationshipSet relationshipSet,
DbProviderManifest providerManifest,
Converter.ConversionCache convertedItemCache,
EntityContainer container,
Dictionary <SchemaElement, GlobalItem> newGlobalItems)
{
AssociationType associationType = (AssociationType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)relationshipSet.Relationship, providerManifest, convertedItemCache, newGlobalItems);
AssociationSet parentSet = new AssociationSet(relationshipSet.Name, associationType);
foreach (EntityContainerRelationshipSetEnd end in relationshipSet.Ends)
{
EntityType entityType = (EntityType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)end.EntitySet.EntityType, providerManifest, convertedItemCache, newGlobalItems);
AssociationEndMember member = (AssociationEndMember)associationType.Members[end.Name];
AssociationSetEnd associationSetEnd = new AssociationSetEnd(Converter.GetEntitySet(end.EntitySet, container), parentSet, member);
Converter.AddOtherContent((SchemaElement)end, (MetadataItem)associationSetEnd);
parentSet.AddAssociationSetEnd(associationSetEnd);
if (end.Documentation != null)
{
associationSetEnd.Documentation = Converter.ConvertToDocumentation(end.Documentation);
}
}
if (relationshipSet.Documentation != null)
{
parentSet.Documentation = Converter.ConvertToDocumentation(relationshipSet.Documentation);
}
Converter.AddOtherContent((SchemaElement)relationshipSet, (MetadataItem)parentSet);
return(parentSet);
}
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);
}