/// <summary>
/// Validates whether facets are declared correctly.
/// </summary>
/// <param name="element"> Schema element being validated. Must not be null. </param>
/// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
/// <param name="typeUsageBuilder"> TypeUsageBuilder for the current element. Must not be null. </param>
internal static void ValidateFacets(SchemaElement element, SchemaType type, TypeUsageBuilder typeUsageBuilder)
{
Debug.Assert(element != null);
Debug.Assert(typeUsageBuilder != null);
if (type != null)
{
var schemaEnumType = type as SchemaEnumType;
if (schemaEnumType != null)
{
typeUsageBuilder.ValidateEnumFacets(schemaEnumType);
}
else if (!(type is ScalarType)
&& typeUsageBuilder.HasUserDefinedFacets)
{
Debug.Assert(!(type is SchemaEnumType), "Note that enums should have already been handled.");
// Non-scalar type should not have Facets.
element.AddError(
ErrorCode.FacetOnNonScalarType, EdmSchemaErrorSeverity.Error, Strings.FacetsOnNonScalarType(type.FQName));
}
}
else
{
if (typeUsageBuilder.HasUserDefinedFacets)
{
// Type attribute not specified but facets exist.
element.AddError(
ErrorCode.IncorrectlyPlacedFacet, EdmSchemaErrorSeverity.Error, Strings.FacetDeclarationRequiresTypeAttribute);
}
}
}
/// <summary>
/// Validates whether facets are declared correctly.
/// </summary>
/// <param name="element"> Schema element being validated. Must not be null. </param>
/// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
/// <param name="typeUsageBuilder"> TypeUsageBuilder for the current element. Must not be null. </param>
internal static void ValidateFacets(SchemaElement element, SchemaType type, TypeUsageBuilder typeUsageBuilder)
{
DebugCheck.NotNull(element);
DebugCheck.NotNull(typeUsageBuilder);
if (type != null)
{
var schemaEnumType = type as SchemaEnumType;
if (schemaEnumType != null)
{
typeUsageBuilder.ValidateEnumFacets(schemaEnumType);
}
else if (!(type is ScalarType) &&
typeUsageBuilder.HasUserDefinedFacets)
{
Debug.Assert(!(type is SchemaEnumType), "Note that enums should have already been handled.");
// Non-scalar type should not have Facets.
element.AddError(
ErrorCode.FacetOnNonScalarType, EdmSchemaErrorSeverity.Error, Strings.FacetsOnNonScalarType(type.FQName));
}
}
else
{
if (typeUsageBuilder.HasUserDefinedFacets)
{
// Type attribute not specified but facets exist.
element.AddError(
ErrorCode.IncorrectlyPlacedFacet, EdmSchemaErrorSeverity.Error, Strings.FacetDeclarationRequiresTypeAttribute);
}
}
}
/// <summary>
/// Validated whether a type is declared correctly.
/// </summary>
/// <param name="element"> Schema element being validated. Must not be null. </param>
/// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
/// <param name="typeSubElement"> Child schema element. Possibly null. </param>
/// <remarks>
/// For some elements (e.g. ReturnType) we allow the type to be defined inline in an attribute on the element itself or
/// by using nested elements. These definitions are mutually exclusive.
/// </remarks>
internal static void ValidateTypeDeclaration(SchemaElement element, SchemaType type, SchemaElement typeSubElement)
{
DebugCheck.NotNull(element);
if (type == null &&
typeSubElement == null)
{
//Type not declared as either attribute or subelement
element.AddError(ErrorCode.TypeNotDeclared, EdmSchemaErrorSeverity.Error, Strings.TypeMustBeDeclared);
}
if (type != null &&
typeSubElement != null)
{
//Both attribute and sub-element declarations exist
element.AddError(
ErrorCode.TypeDeclaredAsAttributeAndElement, EdmSchemaErrorSeverity.Error, Strings.TypeDeclaredAsAttributeAndElement);
}
}
/// <summary>
/// Validated whether a type is declared correctly.
/// </summary>
/// <param name="element"> Schema element being validated. Must not be null. </param>
/// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
/// <param name="typeSubElement"> Child schema element. Possibly null. </param>
/// <remarks>
/// For some elements (e.g. ReturnType) we allow the type to be defined inline in an attribute on the element itself or
/// by using nested elements. These definitions are mutually exclusive.
/// </remarks>
internal static void ValidateTypeDeclaration(SchemaElement element, SchemaType type, SchemaElement typeSubElement)
{
Debug.Assert(element != null);
if (type == null
&& typeSubElement == null)
{
//Type not declared as either attribute or subelement
element.AddError(ErrorCode.TypeNotDeclared, EdmSchemaErrorSeverity.Error, Strings.TypeMustBeDeclared);
}
if (type != null
&& typeSubElement != null)
{
//Both attribute and sub-element declarations exist
element.AddError(
ErrorCode.TypeDeclaredAsAttributeAndElement, EdmSchemaErrorSeverity.Error, Strings.TypeDeclaredAsAttributeAndElement);
}
}
/// <summary>
/// Validate that reference type is an entity type.
/// </summary>
/// <param name="element"> Schema element being validated. Must not be null. </param>
/// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
internal static void ValidateRefType(SchemaElement element, SchemaType type)
{
DebugCheck.NotNull(element);
if (type != null &&
!(type is SchemaEntityType))
{
// Ref type refers to non entity type.
element.AddError(
ErrorCode.ReferenceToNonEntityType, EdmSchemaErrorSeverity.Error, Strings.ReferenceToNonEntityType(type.FQName));
}
}
/// <summary>
/// </summary>
/// <param name="end"> </param>
/// <param name="name"> </param>
/// <returns> </returns>
private bool ValidateUniqueName(SchemaElement end, string name)
{
if (EndLookup.ContainsKey(name))
{
end.AddError(
ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
Strings.EndNameAlreadyDefinedDuplicate(name));
return(false);
}
return(true);
}
private void ValidateFunctionImportReturnType(
SchemaElement owner, SchemaType returnType, CollectionKind returnTypeCollectionKind, EntityContainerEntitySet entitySet,
bool entitySetPathDefined)
{
if (returnType != null &&
!ReturnTypeMeetsFunctionImportBasicRequirements(returnType, returnTypeCollectionKind))
{
owner.AddError(
ErrorCode.FunctionImportUnsupportedReturnType,
EdmSchemaErrorSeverity.Error,
owner,
GetReturnTypeErrorMessage(Name)
);
}
ValidateFunctionImportReturnType(owner, returnType, entitySet, entitySetPathDefined);
}
private void DuplicateOrEquivalentMemberNameWhileExtendingEntityContainer(
SchemaElement schemaElement,
AddErrorKind error)
{
Debug.Assert(
error != AddErrorKind.MissingNameError, "Since entity container members are already resolved, name must never be empty");
Debug.Assert(ExtendingEntityContainer != null, "ExtendingEntityContainer must not be null");
if (error != AddErrorKind.Succeeded)
{
Debug.Assert(error == AddErrorKind.DuplicateNameError, "Error must be duplicate name error");
schemaElement.AddError(
ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
Strings.DuplicateMemberNameInExtendedEntityContainer(
schemaElement.Name, ExtendingEntityContainer.Name, Name));
}
}
internal void ResolveEntitySet(SchemaElement owner, string unresolvedEntitySet, ref EntityContainerEntitySet entitySet)
{
Debug.Assert(IsFunctionImport, "Only FunctionImport elkements specify EntitySets");
Debug.Assert(null != _container, "function imports must know container");
// resolve entity set
if (null == entitySet &&
null != unresolvedEntitySet)
{
entitySet = _container.FindEntitySet(unresolvedEntitySet);
if (null == entitySet)
{
owner.AddError(
ErrorCode.FunctionImportUnknownEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportUnknownEntitySet(unresolvedEntitySet, FQName));
}
}
}
/// <summary>
/// Add a member to the type
/// </summary>
/// <param name="newMember"> the member being added </param>
protected void AddMember(SchemaElement newMember)
{
DebugCheck.NotNull(newMember);
if (string.IsNullOrEmpty(newMember.Name))
{
// this is an error condition that has already been reported.
return;
}
if (Schema.DataModel != SchemaDataModelOption.ProviderDataModel
&&
Utils.CompareNames(newMember.Name, Name) == 0)
{
newMember.AddError(
ErrorCode.BadProperty, EdmSchemaErrorSeverity.Error,
Strings.InvalidMemberNameMatchesTypeName(newMember.Name, FQName));
}
NamedMembers.Add(newMember, true, Strings.PropertyNameAlreadyDefinedDuplicate);
}
/// <summary>
/// Look up a fully qualified type name reference.
/// </summary>
/// <param name="usingElement"> element containing the reference </param>
/// <param name="typeName"> the fully qualified type name </param>
/// <param name="type"> the referenced schema type </param>
/// <returns> false if there was an error </returns>
internal bool ResolveTypeName(SchemaElement usingElement, string typeName, out SchemaType type)
{
DebugCheck.NotNull(usingElement);
DebugCheck.NotNull(typeName);
type = null;
// get the schema(s) that match the namespace/alias
string actualQualification;
string unqualifiedTypeName;
Utils.ExtractNamespaceAndName(typeName, out actualQualification, out unqualifiedTypeName);
var definingQualification = actualQualification;
if (definingQualification == null)
{
definingQualification = ProviderManifest == null ? _namespaceName : ProviderManifest.NamespaceName;
}
string namespaceName;
// First check if there is an alias defined by this name. For primitive type namespace, we do not need to resolve
// any alias, since that's a reserved keyword and we don't allow alias with that name
if (actualQualification == null ||
!AliasResolver.TryResolveAlias(definingQualification, out namespaceName))
{
namespaceName = definingQualification;
}
// Resolve the type name
if (!SchemaManager.TryResolveType(namespaceName, unqualifiedTypeName, out type))
{
// it must be an undefined type.
if (actualQualification == null)
{
// Every type except the primitive type must be qualified
usingElement.AddError(ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error, Strings.NotNamespaceQualified(typeName));
}
else if (!SchemaManager.IsValidNamespaceName(namespaceName))
{
usingElement.AddError(
ErrorCode.BadNamespace, EdmSchemaErrorSeverity.Error, Strings.BadNamespaceOrAlias(actualQualification));
}
else
{
// if the type name was alias qualified
if (namespaceName != definingQualification)
{
usingElement.AddError(
ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error,
Strings.NotInNamespaceAlias(unqualifiedTypeName, namespaceName, definingQualification));
}
else
{
usingElement.AddError(
ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error,
Strings.NotInNamespaceNoAlias(unqualifiedTypeName, namespaceName));
}
}
return(false);
}
// For ssdl and provider manifest, make sure that the type is present in this schema or primitive schema
else if (DataModel != SchemaDataModelOption.EntityDataModel &&
type.Schema != this &&
type.Schema != SchemaManager.PrimitiveSchema)
{
Debug.Assert(type.Namespace != Namespace, "Using element is not allowed in the schema of ssdl and provider manifest");
usingElement.AddError(
ErrorCode.InvalidNamespaceOrAliasSpecified, EdmSchemaErrorSeverity.Error,
Strings.InvalidNamespaceOrAliasSpecified(actualQualification));
return(false);
}
return(true);
}
private void DuplicateOrEquivalentMemberNameWhileExtendingEntityContainer(
SchemaElement schemaElement,
AddErrorKind error)
{
Debug.Assert(
error != AddErrorKind.MissingNameError, "Since entity container members are already resolved, name must never be empty");
Debug.Assert(ExtendingEntityContainer != null, "ExtendingEntityContainer must not be null");
if (error != AddErrorKind.Succeeded)
{
Debug.Assert(error == AddErrorKind.DuplicateNameError, "Error must be duplicate name error");
schemaElement.AddError(
ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
Strings.DuplicateMemberNameInExtendedEntityContainer(
schemaElement.Name, ExtendingEntityContainer.Name, Name));
}
}
private bool TryGetFacets(EdmType edmType, bool complainOnMissingFacet, out Dictionary <string, Facet> calculatedFacets)
{
var noErrors = true;
var defaultFacets = edmType.GetAssociatedFacetDescriptions().ToDictionary(f => f.FacetName, f => f.DefaultValueFacet);
calculatedFacets = new Dictionary <string, Facet>();
foreach (var defaultFacet in defaultFacets.Values)
{
object value;
if (_facetValues.TryGetValue(defaultFacet.Name, out value))
{
// If the facet is a constant facet, then the facet must not be specified in the schema
if (defaultFacet.Description.IsConstant)
{
_element.AddError(
ErrorCode.ConstantFacetSpecifiedInSchema,
EdmSchemaErrorSeverity.Error,
_element,
Strings.ConstantFacetSpecifiedInSchema(defaultFacet.Name, edmType.Name));
noErrors = false;
}
else
{
calculatedFacets.Add(defaultFacet.Name, Facet.Create(defaultFacet.Description, value));
}
// remove the used facet
// so we know which ones we need to add below
_facetValues.Remove(defaultFacet.Name);
}
else if (complainOnMissingFacet && defaultFacet.Description.IsRequired)
{
// Throw missing facet exception
_element.AddError(
ErrorCode.RequiredFacetMissing, EdmSchemaErrorSeverity.Error, Strings.RequiredFacetMissing(
defaultFacet.Name,
edmType.Name));
noErrors = false;
}
else
{
calculatedFacets.Add(defaultFacet.Name, defaultFacet);
}
}
foreach (var value in _facetValues)
{
if (value.Key
== EdmProviderManifest.StoreGeneratedPatternFacetName)
{
var facet = Facet.Create(Converter.StoreGeneratedPatternFacet, value.Value);
calculatedFacets.Add(facet.Name, facet);
}
else if (value.Key
== EdmProviderManifest.ConcurrencyModeFacetName)
{
var facet = Facet.Create(Converter.ConcurrencyModeFacet, value.Value);
calculatedFacets.Add(facet.Name, facet);
}
else if (edmType is PrimitiveType &&
((PrimitiveType)edmType).PrimitiveTypeKind == PrimitiveTypeKind.String
&&
value.Key == DbProviderManifest.CollationFacetName)
{
var facet = Facet.Create(Converter.CollationFacet, value.Value);
calculatedFacets.Add(facet.Name, facet);
}
else
{
_element.AddError(
ErrorCode.FacetNotAllowedByType,
EdmSchemaErrorSeverity.Error,
Strings.FacetNotAllowed(value.Key, edmType.Name));
}
}
return(noErrors);
}
/// <summary>
/// Add a member to the type
/// </summary>
/// <param name="newMember"> the member being added </param>
protected void AddMember(SchemaElement newMember)
{
Debug.Assert(newMember != null, "newMember parameter is null");
if (string.IsNullOrEmpty(newMember.Name))
{
// this is an error condition that has already been reported.
return;
}
if (Schema.DataModel != SchemaDataModelOption.ProviderDataModel
&&
Utils.CompareNames(newMember.Name, Name) == 0)
{
newMember.AddError(
ErrorCode.BadProperty, EdmSchemaErrorSeverity.Error,
Strings.InvalidMemberNameMatchesTypeName(newMember.Name, FQName));
}
NamedMembers.Add(newMember, true, Strings.PropertyNameAlreadyDefinedDuplicate);
}
/// <summary>
/// Validate that reference type is an entity type.
/// </summary>
/// <param name="element"> Schema element being validated. Must not be null. </param>
/// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
internal static void ValidateRefType(SchemaElement element, SchemaType type)
{
Debug.Assert(element != null);
if (type != null
&& !(type is SchemaEntityType))
{
// Ref type refers to non entity type.
element.AddError(
ErrorCode.ReferenceToNonEntityType, EdmSchemaErrorSeverity.Error, Strings.ReferenceToNonEntityType(type.FQName));
}
}
internal void ResolveEntitySet(SchemaElement owner, string unresolvedEntitySet, ref EntityContainerEntitySet entitySet)
{
Debug.Assert(IsFunctionImport, "Only FunctionImport elkements specify EntitySets");
Debug.Assert(null != _container, "function imports must know container");
// resolve entity set
if (null == entitySet
&& null != unresolvedEntitySet)
{
entitySet = _container.FindEntitySet(unresolvedEntitySet);
if (null == entitySet)
{
owner.AddError(
ErrorCode.FunctionImportUnknownEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportUnknownEntitySet(unresolvedEntitySet, FQName));
}
}
}
/// <summary>
/// validate the following negative scenarios:
/// ReturnType="Collection(EntityTypeA)"
/// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
/// EntitySet="A"
/// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
/// ReturnType="Collection(ComplexTypeA)", but the ComplexTypeA has a nested complexType property, this scenario will be handle in the runtime
/// </summary>
private void ValidateFunctionImportReturnType(
SchemaElement owner, SchemaType returnType, EntityContainerEntitySet entitySet, bool entitySetPathDefined)
{
// If entity type, verify specification of entity set and that the type is appropriate for the entity set
var entityType = returnType as SchemaEntityType;
if (entitySet != null && entitySetPathDefined)
{
owner.AddError(
ErrorCode.FunctionImportEntitySetAndEntitySetPathDeclared,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntitySetAndEntitySetPathDeclared(FQName));
}
if (null != entityType)
{
// entity type
if (null == entitySet)
{
// ReturnType="Collection(EntityTypeA)"
owner.AddError(
ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet(FQName));
}
else if (null != entitySet.EntityType &&
!entityType.IsOfType(entitySet.EntityType))
{
// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
owner.AddError(
ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntityTypeDoesNotMatchEntitySet(
FQName, entitySet.EntityType.FQName, entitySet.Name));
}
}
else
{
// complex type
var complexType = returnType as SchemaComplexType;
if (complexType != null)
{
if (entitySet != null || entitySetPathDefined)
{
// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
owner.AddError(
ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet,
EdmSchemaErrorSeverity.Error,
owner.LineNumber,
owner.LinePosition,
Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet(FQName, complexType.Name));
}
}
else
{
Debug.Assert(
returnType == null || returnType is ScalarType || returnType is SchemaEnumType || returnType is Relationship,
"null return type, scalar return type, enum return type or relationship expected here.");
// scalar type or no return type
if (entitySet != null || entitySetPathDefined)
{
// EntitySet="A"
owner.AddError(
ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportSpecifiesEntitySetButNotEntityType(FQName));
}
}
}
}
/// <summary>
/// Look up a fully qualified type name reference.
/// </summary>
/// <param name="usingElement">element containing the reference</param>
/// <param name="typeName">the fully qualified type name</param>
/// <param name="type">the referenced schema type</param>
/// <returns>false if there was an error</returns>
internal bool ResolveTypeName(SchemaElement usingElement, string typeName, out SchemaType type)
{
Debug.Assert(usingElement != null);
Debug.Assert(typeName != null);
type = null;
// get the schema(s) that match the namespace/alias
string actualQualification;
string unqualifiedTypeName;
Utils.ExtractNamespaceAndName(typeName, out actualQualification, out unqualifiedTypeName);
var definingQualification = actualQualification;
if (definingQualification == null)
{
definingQualification = ProviderManifest == null ? _namespaceName : ProviderManifest.NamespaceName;
}
string namespaceName;
// First check if there is an alias defined by this name. For primitive type namespace, we do not need to resolve
// any alias, since that's a reserved keyword and we don't allow alias with that name
if (actualQualification == null
|| !AliasResolver.TryResolveAlias(definingQualification, out namespaceName))
{
namespaceName = definingQualification;
}
// Resolve the type name
if (!SchemaManager.TryResolveType(namespaceName, unqualifiedTypeName, out type))
{
// it must be an undefined type.
if (actualQualification == null)
{
// Every type except the primitive type must be qualified
usingElement.AddError(ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error, Strings.NotNamespaceQualified(typeName));
}
else if (!SchemaManager.IsValidNamespaceName(namespaceName))
{
usingElement.AddError(
ErrorCode.BadNamespace, EdmSchemaErrorSeverity.Error, Strings.BadNamespaceOrAlias(actualQualification));
}
else
{
// if the type name was alias qualified
if (namespaceName != definingQualification)
{
usingElement.AddError(
ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error,
Strings.NotInNamespaceAlias(unqualifiedTypeName, namespaceName, definingQualification));
}
else
{
usingElement.AddError(
ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error,
Strings.NotInNamespaceNoAlias(unqualifiedTypeName, namespaceName));
}
}
return false;
}
// For ssdl and provider manifest, make sure that the type is present in this schema or primitive schema
else if (DataModel != SchemaDataModelOption.EntityDataModel && type.Schema != this
&& type.Schema != SchemaManager.PrimitiveSchema)
{
Debug.Assert(type.Namespace != Namespace, "Using element is not allowed in the schema of ssdl and provider manifest");
usingElement.AddError(
ErrorCode.InvalidNamespaceOrAliasSpecified, EdmSchemaErrorSeverity.Error,
Strings.InvalidNamespaceOrAliasSpecified(actualQualification));
return false;
}
return true;
}
/// <summary>
/// validate the following negative scenarios:
/// ReturnType="Collection(EntityTypeA)"
/// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
/// EntitySet="A"
/// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
/// ReturnType="Collection(ComplexTypeA)", but the ComplexTypeA has a nested complexType property, this scenario will be handle in the runtime
/// </summary>
private void ValidateFunctionImportReturnType(
SchemaElement owner, SchemaType returnType, EntityContainerEntitySet entitySet, bool entitySetPathDefined)
{
// If entity type, verify specification of entity set and that the type is appropriate for the entity set
var entityType = returnType as SchemaEntityType;
if (entitySet != null && entitySetPathDefined)
{
owner.AddError(
ErrorCode.FunctionImportEntitySetAndEntitySetPathDeclared,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntitySetAndEntitySetPathDeclared(FQName));
}
if (null != entityType)
{
// entity type
if (null == entitySet)
{
// ReturnType="Collection(EntityTypeA)"
owner.AddError(
ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet(FQName));
}
else if (null != entitySet.EntityType
&& !entityType.IsOfType(entitySet.EntityType))
{
// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
owner.AddError(
ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntityTypeDoesNotMatchEntitySet(
FQName, entitySet.EntityType.FQName, entitySet.Name));
}
}
else
{
// complex type
var complexType = returnType as SchemaComplexType;
if (complexType != null)
{
if (entitySet != null || entitySetPathDefined)
{
// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
owner.AddError(
ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet,
EdmSchemaErrorSeverity.Error,
owner.LineNumber,
owner.LinePosition,
Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet(FQName, complexType.Name));
}
}
else
{
Debug.Assert(
returnType == null || returnType is ScalarType || returnType is SchemaEnumType || returnType is Relationship,
"null return type, scalar return type, enum return type or relationship expected here.");
// scalar type or no return type
if (entitySet != null || entitySetPathDefined)
{
// EntitySet="A"
owner.AddError(
ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportSpecifiesEntitySetButNotEntityType(FQName));
}
}
}
}
private void ValidateFunctionImportReturnType(
SchemaElement owner, SchemaType returnType, CollectionKind returnTypeCollectionKind, EntityContainerEntitySet entitySet,
bool entitySetPathDefined)
{
if (returnType != null
&& !ReturnTypeMeetsFunctionImportBasicRequirements(returnType, returnTypeCollectionKind))
{
owner.AddError(
ErrorCode.FunctionImportUnsupportedReturnType,
EdmSchemaErrorSeverity.Error,
owner,
GetReturnTypeErrorMessage(Name)
);
}
ValidateFunctionImportReturnType(owner, returnType, entitySet, entitySetPathDefined);
}