public void GetFacetDescriptions_returns_correct_facets_for_all_primitive_types() { var storeTypes = ProviderManifestWrapper .GetStoreTypes() .OrderBy(t => t.Name) .ToArray(); var legacyStoreTypes = LegacyProviderManifest .GetStoreTypes() .OrderBy(t => t.Name) .ToArray(); for (var i = 0; i < storeTypes.Length; i++) { var facetDescriptions = ProviderManifestWrapper.GetFacetDescriptions(storeTypes[i]).OrderBy(f => f.FacetName).ToArray(); var legacyFacetDescriptions = LegacyProviderManifest.GetFacetDescriptions(legacyStoreTypes[i]).OrderBy(f => f.FacetName).ToArray(); Assert.Equal(facetDescriptions.Length, legacyFacetDescriptions.Length); for (var j = 0; j < facetDescriptions.Count(); j++) { TypeUsageVerificationHelper.VerifyFacetDescriptionsEquivalent(facetDescriptions[j], legacyFacetDescriptions[j]); } } }
public PrimitiveSchema(SchemaManager schemaManager) : base(schemaManager) { Schema = this; DbProviderManifest providerManifest = ProviderManifest; if (providerManifest == null) { AddError(new EdmSchemaError(System.Data.Entity.Strings.FailedToRetrieveProviderManifest, (int)ErrorCode.FailedToRetrieveProviderManifest, EdmSchemaErrorSeverity.Error)); } else { IList <PrimitiveType> primitiveTypes = providerManifest.GetStoreTypes(); // EDM Spatial types are only available to V3 and above CSDL. if (schemaManager.DataModel == SchemaDataModelOption.EntityDataModel && schemaManager.SchemaVersion < XmlConstants.EdmVersionForV3) { primitiveTypes = primitiveTypes.Where(t => !Helper.IsSpatialType(t)) .ToList(); } foreach (PrimitiveType entry in primitiveTypes) { TryAddType(new ScalarType(this, entry.Name, entry), false /*doNotAddErrorForEmptyName*/); } } }
protected virtual void ConfigureColumn(EdmProperty column, EntityType table, DbProviderManifest providerManifest) { ConfigureColumnName(column, table); ConfigureAnnotations(column); if (!string.IsNullOrWhiteSpace(ColumnType)) { column.PrimitiveType = providerManifest.GetStoreTypeFromName(ColumnType); } if (ColumnOrder != null) { column.SetOrder(ColumnOrder.Value); } var storeType = providerManifest.GetStoreTypes() .SingleOrDefault(t => t.Name.Equals(column.TypeName, StringComparison.OrdinalIgnoreCase)); if (storeType != null) { storeType.FacetDescriptions.Each(f => Configure(column, f)); } column.SetConfiguration(this); }
public static PrimitiveType GetStoreTypeFromName(this DbProviderManifest providerManifest, string name) { DebugCheck.NotNull(providerManifest); DebugCheck.NotEmpty(name); return(providerManifest.GetStoreTypes() .Single(p => string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase))); }
internal virtual void Configure( EdmProperty column, EntityType table, DbProviderManifest providerManifest, bool allowOverride = false, bool fillFromExistingConfiguration = false) { DebugCheck.NotNull(column); DebugCheck.NotNull(table); DebugCheck.NotNull(providerManifest); var existingConfiguration = column.GetConfiguration() as PrimitivePropertyConfiguration; if (existingConfiguration != null) { var overridable = column.GetAllowOverride(); string errorMessage; if ((existingConfiguration.OverridableConfigurationParts & OverridableConfigurationParts.OverridableInSSpace) != OverridableConfigurationParts.OverridableInSSpace && !overridable && !allowOverride && !fillFromExistingConfiguration && !existingConfiguration.IsCompatible(this, inCSpace: false, errorMessage: out errorMessage)) { throw Error.ConflictingColumnConfiguration(column.Name, table.Name, errorMessage); } FillFrom(existingConfiguration, inCSpace: false); } ConfigureColumnName(column, table); if (!string.IsNullOrWhiteSpace(ColumnType)) { column.PrimitiveType = providerManifest.GetStoreTypeFromName(ColumnType); } if (ColumnOrder != null) { column.SetOrder(ColumnOrder.Value); } var storeType = providerManifest.GetStoreTypes() .SingleOrDefault(t => t.Name.Equals(column.TypeName, StringComparison.OrdinalIgnoreCase)); if (storeType != null) { storeType.FacetDescriptions.Each(f => Configure(column, f)); } column.SetConfiguration(this); column.SetAllowOverride(allowOverride); }
private void LoadProviderManifest(DbProviderManifest storeManifest) { foreach (PrimitiveType storeType in storeManifest.GetStoreTypes()) { this.AddInternal((GlobalItem)storeType); this._primitiveTypeMaps.Add(storeType); } foreach (GlobalItem storeFunction in storeManifest.GetStoreFunctions()) { this.AddInternal(storeFunction); } }
public void CreateTransientMetadataWorkspace_creates_workspace_with_provided_store_entity_sets() { var property = EdmProperty.CreatePrimitive( "Id", ProviderManifest.GetStoreTypes().Single(t => t.PrimitiveTypeKind == PrimitiveTypeKind.Int32)); property.Nullable = false; var entityType = EntityType.Create("EntityType", "MyModel", DataSpace.SSpace, new[] { "Id" }, new[] { property }, null); var entitySet = EntitySet.Create("EntityTypeSet", "dbo", "EntityTypes", null, entityType, null); var workspace = EntitySetDefiningQueryConverter.CreateTransientMetadataWorkspace( new List <EntitySet> { entitySet }, EntityFrameworkVersion.Version3, "System.Data.SqlClient", "2008", ProviderManifest); Assert.NotNull(workspace); var storeItemCollection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace); Assert.NotNull(storeItemCollection); Assert.Equal(1, storeItemCollection.GetEntityContainer("StoreModelContainer").EntitySets.Count); Assert.Equal( "EntityTypeSet", storeItemCollection.GetEntityContainer("StoreModelContainer").EntitySets.Single().Name); Assert.Equal(1, storeItemCollection.GetItems <EntityType>().Count); Assert.Equal("EntityType", storeItemCollection.GetItems <EntityType>().Single().Name); Assert.NotNull(workspace.GetItemCollection(DataSpace.CSpace)); Assert.NotNull(workspace.GetItemCollection(DataSpace.CSSpace)); }
// <summary> // checks if the schemaKey refers to the provider manifest schema key // and if true, loads the provider manifest // </summary> // <param name="storeManifest"> The store manifest </param> private void LoadProviderManifest(DbProviderManifest storeManifest) { foreach (var primitiveType in storeManifest.GetStoreTypes()) { //Add it to the collection and the primitive type maps AddInternal(primitiveType); _primitiveTypeMaps.Add(primitiveType); } foreach (var function in storeManifest.GetStoreFunctions()) { AddInternal(function); } }
public static PrimitiveType GetStoreTypeFromName(this DbProviderManifest providerManifest, string name) { DebugCheck.NotNull(providerManifest); DebugCheck.NotEmpty(name); var primitiveType = providerManifest.GetStoreTypes() .SingleOrDefault(p => string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase)); if (primitiveType == null) { throw Error.StoreTypeNotFound(name, providerManifest.NamespaceName); } return(primitiveType); }
/// <summary> /// checks if the schemaKey refers to the provider manifest schema key /// and if true, loads the provider manifest /// </summary> /// <param name="connection">The connection where the store manifest is loaded from</param> /// <param name="checkForSystemNamespace">Check for System namespace</param> /// <returns>The provider manifest object that was loaded</returns> private void LoadProviderManifest(DbProviderManifest storeManifest, bool checkForSystemNamespace) { foreach (PrimitiveType primitiveType in storeManifest.GetStoreTypes()) { //Add it to the collection and the primitive type maps this.AddInternal(primitiveType); _primitiveTypeMaps.Add(primitiveType); } foreach (EdmFunction function in storeManifest.GetStoreFunctions()) { AddInternal(function); } }
private static PrimitiveType GetPrimitiveType( ScalarType scalarType, DbProviderManifest providerManifest) { PrimitiveType primitiveType = (PrimitiveType)null; string name = scalarType.Name; foreach (PrimitiveType storeType in providerManifest.GetStoreTypes()) { if (storeType.Name == name) { primitiveType = storeType; break; } } return(primitiveType); }
public PrimitiveSchema(SchemaManager schemaManager) : base(schemaManager) { this.Schema = (Schema)this; DbProviderManifest providerManifest = this.ProviderManifest; if (providerManifest == null) { this.AddError(new EdmSchemaError(Strings.FailedToRetrieveProviderManifest, 168, EdmSchemaErrorSeverity.Error)); } else { IList <PrimitiveType> source = (IList <PrimitiveType>)providerManifest.GetStoreTypes(); if (schemaManager.DataModel == SchemaDataModelOption.EntityDataModel && schemaManager.SchemaVersion < 3.0) { source = (IList <PrimitiveType>)source.Where <PrimitiveType>((Func <PrimitiveType, bool>)(t => !Helper.IsSpatialType(t))).ToList <PrimitiveType>(); } foreach (PrimitiveType primitiveType in (IEnumerable <PrimitiveType>)source) { this.TryAddType((SchemaType) new ScalarType((Schema)this, primitiveType.Name, primitiveType), false); } } }
protected virtual void ConfigureColumn( EdmProperty column, EntityType table, DbProviderManifest providerManifest) { this.ConfigureColumnName(column, table); this.ConfigureAnnotations(column); if (!string.IsNullOrWhiteSpace(this.ColumnType)) { column.PrimitiveType = providerManifest.GetStoreTypeFromName(this.ColumnType); } if (this.ColumnOrder.HasValue) { column.SetOrder(this.ColumnOrder.Value); } PrimitiveType primitiveType = providerManifest.GetStoreTypes().SingleOrDefault <PrimitiveType>((Func <PrimitiveType, bool>)(t => t.Name.Equals(column.TypeName, StringComparison.OrdinalIgnoreCase))); if (primitiveType != null) { primitiveType.FacetDescriptions.Each <FacetDescription>((Action <FacetDescription>)(f => this.Configure(column, f))); } column.SetConfiguration((object)this); }
/// <summary> /// checks if the schemaKey refers to the provider manifest schema key /// and if true, loads the provider manifest /// </summary> /// <param name="connection"> The connection where the store manifest is loaded from </param> /// <returns> The provider manifest object that was loaded </returns> private void LoadProviderManifest(DbProviderManifest storeManifest) { foreach (var primitiveType in storeManifest.GetStoreTypes()) { //Add it to the collection and the primitive type maps AddInternal(primitiveType); _primitiveTypeMaps.Add(primitiveType); } foreach (var function in storeManifest.GetStoreFunctions()) { AddInternal(function); } }
private static EdmProperty CreateStoreProperty(string name, string typeName) { return(EdmProperty.CreatePrimitive( name, ProviderManifest.GetStoreTypes().Single(t => t.Name == typeName))); }
public static PrimitiveType GetStoreTypeFromName( this DbProviderManifest providerManifest, string name) { return(providerManifest.GetStoreTypes().Single <PrimitiveType>((Func <PrimitiveType, bool>)(p => string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase)))); }