// <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); } }
internal CollectionTypeElement(SchemaElement parentElement) : base(parentElement) { }
internal virtual SchemaElement Clone(SchemaElement parentElement) { throw Error.NotImplemented(); }
/// <summary> /// </summary> /// <param name="parentElement"> </param> internal SchemaElement(SchemaElement parentElement) { if (parentElement != null) { ParentElement = parentElement; for (var element = parentElement; element != null; element = element.ParentElement) { var schema = element as Schema; if (schema != null) { Schema = schema; break; } } if (Schema == null) { throw new InvalidOperationException(Strings.AllElementsMustBeInSchema); } } }
internal SchemaElement(SchemaElement parentElement, string name) : this(parentElement) { _name = name; }
internal override SchemaElement Clone(SchemaElement parentElement) { var parameter = new Parameter((Function)parentElement); parameter._collectionKind = _collectionKind; parameter._parameterDirection = _parameterDirection; parameter._type = _type; parameter.Name = Name; parameter._typeUsageBuilder = _typeUsageBuilder; return parameter; }
// <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)); } }
// <summary> // Initializes a new instance of the <see cref="SchemaEnumMember" /> class. // </summary> // <param name="parentElement"> Parent element. </param> public SchemaEnumMember(SchemaElement parentElement) : base(parentElement) { }
internal TypeRefElement(SchemaElement parentElement) : base(parentElement) { }
internal override SchemaElement Clone(SchemaElement parentElement) { throw Error.NotImplemented(); }
/// <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)); } } } }
internal RowTypePropertyElement(SchemaElement parentElement) : base(parentElement) { _typeUsageBuilder = new TypeUsageBuilder(this); }
internal ModelFunctionTypeElement(SchemaElement parentElement) : base(parentElement) { _typeUsageBuilder = new TypeUsageBuilder(this); }
internal override SchemaElement Clone(SchemaElement parentElement) { var entitySet = new EntityContainerEntitySet((EntityContainer)parentElement); entitySet._definingQueryElement = _definingQueryElement; entitySet._entityType = _entityType; entitySet._schema = _schema; entitySet._table = _table; entitySet.Name = Name; return entitySet; }
public DocumentationElement(SchemaElement parentElement) : base(parentElement, (IDbDependencyResolver)null) { }
/// <summary> /// See if a name is a member in a type or any of its base types /// </summary> /// <param name="name"> name to look for </param> /// <param name="definingType"> if defined, the type that defines it </param> /// <param name="definingMember"> if defined, the member that defines it </param> /// <returns> how name was defined </returns> private HowDefined DefinesMemberName(string name, out StructuredType definingType, out SchemaElement definingMember) { if (NamedMembers.ContainsKey(name)) { definingType = this; definingMember = NamedMembers[name]; return HowDefined.AsMember; } definingMember = NamedMembers.LookUpEquivalentKey(name); Debug.Assert(definingMember == null, "we allow the scenario that members can have same name but different cases"); if (IsTypeHierarchyRoot) { definingType = null; definingMember = null; return HowDefined.NotDefined; } return BaseType.DefinesMemberName(name, out definingType, out definingMember); }
internal FacetEnabledSchemaElement(SchemaElement parentElement) : base(parentElement) { }
/// <summary> /// </summary> /// <param name="parentElement"> </param> internal ReferenceTypeElement(SchemaElement parentElement) : base(parentElement) { }
// <summary> // See if a name is a member in a type or any of its base types // </summary> // <param name="name"> name to look for </param> // <param name="definingType"> if defined, the type that defines it </param> // <param name="definingMember"> if defined, the member that defines it </param> // <returns> how name was defined </returns> private HowDefined DefinesMemberName(string name, out StructuredType definingType, out SchemaElement definingMember) { if (NamedMembers.ContainsKey(name)) { definingType = this; definingMember = NamedMembers[name]; return(HowDefined.AsMember); } definingMember = NamedMembers.LookUpEquivalentKey(name); Debug.Assert(definingMember == null, "we allow the scenario that members can have same name but different cases"); if (IsTypeHierarchyRoot) { definingType = null; definingMember = null; return(HowDefined.NotDefined); } return(BaseType.DefinesMemberName(name, out definingType, out definingMember)); }
/// <summary> /// </summary> /// <param name="errorCode"> </param> /// <param name="severity"> </param> /// <param name="element"> </param> /// <param name="message"> </param> internal void AddError(ErrorCode errorCode, EdmSchemaErrorSeverity severity, SchemaElement element, object message) { AddError(errorCode, severity, element.Schema.Location, element.LineNumber, element.LinePosition, message); }
public TextElement(SchemaElement parentElement) : base(parentElement) { }
internal TypeUsageBuilder(SchemaElement element) { _element = element; _facetValues = new Dictionary<string, object>(); }
private bool InternalHandleAttribute(XmlReader reader) { if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.NullableFacetName)) { HandleNullableAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, XmlConstants.DefaultValueAttribute)) { HandleDefaultAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.PrecisionFacetName)) { HandlePrecisionAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.ScaleFacetName)) { HandleScaleAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, EdmProviderManifest.StoreGeneratedPatternFacetName)) { HandleStoreGeneratedPatternAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, EdmProviderManifest.ConcurrencyModeFacetName)) { HandleConcurrencyModeAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.MaxLengthFacetName)) { HandleMaxLengthAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.UnicodeFacetName)) { HandleUnicodeAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.CollationFacetName)) { HandleCollationAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.FixedLengthFacetName)) { HandleIsFixedLengthAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.NullableFacetName)) { HandleNullableAttribute(reader); return(true); } else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.SridFacetName)) { HandleSridAttribute(reader); return(true); } return(false); }
internal TypeUsageBuilder(SchemaElement element) { _element = element; _facetValues = new Dictionary <string, object>(); }
internal RowTypeElement(SchemaElement parentElement) : base(parentElement) { }
// <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)); } }
private static void AddOtherContent(SchemaElement element, MetadataItem item) { if (element.OtherContent.Count > 0) { item.AddMetadataProperties(element.OtherContent); } }
/// <summary> /// construct a KeyProperty object /// </summary> /// <param name="parentElement"> </param> public PropertyRefElement(SchemaElement parentElement) : base(parentElement) { }
internal override SchemaElement Clone(SchemaElement parentElement) { var setEnd = new EntityContainerAssociationSetEnd((EntityContainerAssociationSet)parentElement); setEnd._unresolvedRelationshipEndRole = _unresolvedRelationshipEndRole; setEnd.EntitySet = EntitySet; return setEnd; }
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)); } } }
internal override SchemaElement Clone(SchemaElement parentElement) { // We only support clone for FunctionImports. throw Error.NotImplemented(); }
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); }
/// <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); }
internal override SchemaElement Clone(SchemaElement parentElement) { var function = new FunctionImportElement((EntityContainer)parentElement); CloneSetFunctionFields(function); function._container = _container; function._entitySet = _entitySet; function._unresolvedEntitySet = _unresolvedEntitySet; function._entitySetPathDefined = _entitySetPathDefined; return function; }
internal override SchemaElement Clone(SchemaElement parentElement) { var parameter = new ReturnType((Function)parentElement); parameter._type = _type; parameter.Name = Name; parameter._typeUsageBuilder = _typeUsageBuilder; parameter._unresolvedType = _unresolvedType; parameter._unresolvedEntitySet = _unresolvedEntitySet; parameter._entitySetPathDefined = _entitySetPathDefined; parameter._entitySet = _entitySet; return parameter; }
internal void AddError(ErrorCode errorCode, EdmSchemaErrorSeverity severity, SchemaElement element, object message) { AddError(errorCode, severity, element.Schema.Location, element.LineNumber, element.LinePosition, message); }