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))));
}
