private void HandlePropertyElement(XmlReader reader) { StructuredProperty structuredProperty = new StructuredProperty(this); structuredProperty.Parse(reader); this.AddMember((SchemaElement)structuredProperty); }
/// <summary> /// </summary> /// <param name="reader"> </param> private void HandlePropertyElement(XmlReader reader) { var property = new StructuredProperty(this); property.Parse(reader); AddMember(property); }
internal bool ResolveNames(SchemaEntityType entityType) { if (string.IsNullOrEmpty(this.Name)) { return(true); } this._property = entityType.FindProperty(this.Name); return(this._property != null); }
/// <summary> /// Since this method can be used in different context, this method does not add any errors /// Please make sure that the caller of this methods handles the error case and add errors /// appropriately /// </summary> internal bool ResolveNames(SchemaEntityType entityType) { if (string.IsNullOrEmpty(Name)) { // Don't flag this error. This must already must have flaged as error, while handling name attribute return(true); } // Make sure there is a property by this name _property = entityType.FindProperty(Name); return(_property != null); }
/// <summary> /// Since this method can be used in different context, this method does not add any errors /// Please make sure that the caller of this methods handles the error case and add errors /// appropriately /// </summary> /// <param name="entityType"> </param> /// <returns> </returns> internal bool ResolveNames(SchemaEntityType entityType) { if (string.IsNullOrEmpty(Name)) { // Don't flag this error. This must already must have flaged as error, while handling name attribute return true; } // Make sure there is a property by this name _property = entityType.FindProperty(Name); return (_property != null); }
public StructuredProperty FindProperty(string name) { StructuredProperty structuredProperty = this.Properties.LookUpEquivalentKey(name); if (structuredProperty != null) { return(structuredProperty); } if (this.IsTypeHierarchyRoot) { return((StructuredProperty)null); } return(this.BaseType.FindProperty(name)); }
internal override void Validate() { Dictionary <string, PropertyRefElement> dictionary = new Dictionary <string, PropertyRefElement>((IEqualityComparer <string>)StringComparer.Ordinal); foreach (PropertyRefElement keyProperty in this._keyProperties) { StructuredProperty property = keyProperty.Property; if (dictionary.ContainsKey(property.Name)) { this.AddError(ErrorCode.DuplicatePropertySpecifiedInEntityKey, EdmSchemaErrorSeverity.Error, (object)Strings.DuplicatePropertyNameSpecifiedInEntityKey((object)this.ParentElement.FQName, (object)property.Name)); } else { dictionary.Add(property.Name, keyProperty); if (property.Nullable) { this.AddError(ErrorCode.InvalidKey, EdmSchemaErrorSeverity.Error, (object)Strings.InvalidKeyNullablePart((object)property.Name, (object)this.ParentElement.Name)); } if (!(property.Type is ScalarType) && !(property.Type is SchemaEnumType) || property.CollectionKind != CollectionKind.None) { this.AddError(ErrorCode.EntityKeyMustBeScalar, EdmSchemaErrorSeverity.Error, (object)Strings.EntityKeyMustBeScalar((object)property.Name, (object)this.ParentElement.Name)); } else if (!(property.Type is SchemaEnumType)) { PrimitiveType edmType = (PrimitiveType)property.TypeUsage.EdmType; if (this.Schema.DataModel == SchemaDataModelOption.EntityDataModel) { if (edmType.PrimitiveTypeKind == PrimitiveTypeKind.Binary && this.Schema.SchemaVersion < 2.0 || Helper.IsSpatialType(edmType)) { this.AddError(ErrorCode.EntityKeyTypeCurrentlyNotSupported, EdmSchemaErrorSeverity.Error, (object)Strings.EntityKeyTypeCurrentlyNotSupported((object)property.Name, (object)this.ParentElement.FQName, (object)edmType.PrimitiveTypeKind)); } } else if (edmType.PrimitiveTypeKind == PrimitiveTypeKind.Binary && this.Schema.SchemaVersion < 2.0 || Helper.IsSpatialType(edmType)) { this.AddError(ErrorCode.EntityKeyTypeCurrentlyNotSupported, EdmSchemaErrorSeverity.Error, (object)Strings.EntityKeyTypeCurrentlyNotSupportedInSSDL((object)property.Name, (object)this.ParentElement.FQName, (object)property.TypeUsage.EdmType.Name, (object)property.TypeUsage.EdmType.BaseType.FullName, (object)edmType.PrimitiveTypeKind)); } } } } }
/// <summary> /// </summary> /// <param name="reader"> </param> private void HandlePropertyElement(XmlReader reader) { var property = new StructuredProperty(this); property.Parse(reader); AddMember(property); }
/// <summary> /// Converts a property from SOM to metadata /// </summary> /// <param name="somProperty"> The SOM element to process </param> /// <param name="providerManifest"> The provider manifest to be used for conversion </param> /// <param name="convertedItemCache"> The item collection for currently existing metadata objects </param> /// <param name="newGlobalItems"> The new GlobalItem objects that are created as a result of this conversion </param> /// <returns> The property object resulting from the convert </returns> private static EdmProperty ConvertToProperty( StructuredProperty somProperty, DbProviderManifest providerManifest, ConversionCache convertedItemCache, Dictionary<SchemaElement, GlobalItem> newGlobalItems) { EdmProperty property; // Get the appropriate type object for this type, for primitive and enum types, get the facet values for the type // property as a type usage object as well TypeUsage typeUsage = null; var scalarType = somProperty.Type as ScalarType; if (scalarType != null && somProperty.Schema.DataModel != SchemaDataModelOption.EntityDataModel) { // parsing ssdl typeUsage = somProperty.TypeUsage; UpdateSentinelValuesInFacets(ref typeUsage); } else { EdmType propertyType; if (scalarType != null) { Debug.Assert(somProperty.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); // try to get the instance of the primitive type from the item collection so that it back pointer is set. propertyType = convertedItemCache.ItemCollection.GetItem<PrimitiveType>(somProperty.TypeUsage.EdmType.FullName); } else { propertyType = (EdmType)LoadSchemaElement(somProperty.Type, providerManifest, convertedItemCache, newGlobalItems); } if (somProperty.CollectionKind != CollectionKind.None) { typeUsage = TypeUsage.Create(new CollectionType(propertyType)); } else { var enumType = scalarType == null ? somProperty.Type as SchemaEnumType : null; typeUsage = TypeUsage.Create(propertyType); if (enumType != null) { somProperty.EnsureEnumTypeFacets(convertedItemCache, newGlobalItems); } if (somProperty.TypeUsage != null) { ApplyTypePropertyFacets(somProperty.TypeUsage, ref typeUsage); } } } PopulateGeneralFacets(somProperty, ref typeUsage); property = new EdmProperty(somProperty.Name, typeUsage); // Extract the optional Documentation if (somProperty.Documentation != null) { property.Documentation = ConvertToDocumentation(somProperty.Documentation); } AddOtherContent(somProperty, property); return property; }
/// <summary> /// Populate the facets on the TypeUsage object for a property /// </summary> /// <param name="somProperty"> The property containing the information </param> /// <param name="propertyTypeUsage"> The type usage object where to populate facet </param> private static void PopulateGeneralFacets( StructuredProperty somProperty, ref TypeUsage propertyTypeUsage) { var madeChanges = false; var facets = propertyTypeUsage.Facets.ToDictionary(f => f.Name); if (!somProperty.Nullable) { facets[DbProviderManifest.NullableFacetName] = Facet.Create(MetadataItem.NullableFacetDescription, false); madeChanges = true; } if (somProperty.Default != null) { facets[DbProviderManifest.DefaultValueFacetName] = Facet.Create( MetadataItem.DefaultValueFacetDescription, somProperty.DefaultAsObject); madeChanges = true; } //This is not really a general facet //If we are dealing with a 1.1 Schema, Add a facet for CollectionKind if (somProperty.Schema.SchemaVersion == XmlConstants.EdmVersionForV1_1) { var newFacet = Facet.Create(MetadataItem.CollectionKindFacetDescription, somProperty.CollectionKind); facets.Add(newFacet.Name, newFacet); madeChanges = true; } if (madeChanges) { propertyTypeUsage = TypeUsage.Create(propertyTypeUsage.EdmType, facets.Values); } }