public static void VerifyEdmTypesEquivalent(LegacyMetadata.EdmType legacyEdmType, EdmType edmType)
{
Assert.Equal(legacyEdmType.FullName, edmType.FullName);
Assert.True(
(legacyEdmType.BaseType == null && edmType.BaseType == null) ||
legacyEdmType.BaseType.FullName == edmType.BaseType.FullName);
Assert.Equal(legacyEdmType.BuiltInTypeKind.ToString(), edmType.BuiltInTypeKind.ToString());
Assert.Equal(
((LegacyMetadata.DataSpace)typeof(LegacyMetadata.EdmType)
.GetProperty("DataSpace", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(legacyEdmType)).ToString(),
((DataSpace)typeof(EdmType)
.GetProperty("DataSpace", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(edmType)).ToString());
if (edmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveTypeKind)
{
var prmitiveEdmType = (PrimitiveType)edmType;
var legacyPrmitiveEdmType = (LegacyMetadata.PrimitiveType)legacyEdmType;
// EF5 geospatial types should be converted to EF6 spatial types
var expectedClrEquivalentType =
legacyPrmitiveEdmType.ClrEquivalentType == typeof(LegacySpatial.DbGeography)
? typeof(DbGeography)
: legacyPrmitiveEdmType.ClrEquivalentType == typeof(LegacySpatial.DbGeometry)
? typeof(DbGeometry)
: legacyPrmitiveEdmType.ClrEquivalentType;
Assert.Equal(expectedClrEquivalentType, prmitiveEdmType.ClrEquivalentType);
Assert.Equal(legacyPrmitiveEdmType.GetEdmPrimitiveType().FullName, prmitiveEdmType.GetEdmPrimitiveType().FullName);
}
}
protected override PrepareMappingRes PrepareMapping(string typeFullName, EdmType edmItem)
{
// find existing parent storageEntitySet
// thp derived types does not have storageEntitySet
EntitySet storageEntitySet;
EdmType baseEdmType = edmItem;
while (!EntityContainer.TryGetEntitySetByName(baseEdmType.Name, false, out storageEntitySet))
{
if (baseEdmType.BaseType == null)
{
break;
}
baseEdmType = baseEdmType.BaseType;
}
if (storageEntitySet == null)
{
return null;
}
var isRoot = baseEdmType == edmItem;
if (!isRoot)
{
var parent = _entityMaps.Values.FirstOrDefault(x => x.EdmType == baseEdmType);
// parent table has not been mapped yet
if (parent == null)
{
throw new ParentNotMappedYetException();
}
}
string tableName = GetTableName(storageEntitySet);
return new PrepareMappingRes { TableName = tableName, StorageEntitySet = storageEntitySet, IsRoot = isRoot, BaseEdmType = baseEdmType };
}
/// <summary>
/// Returns all the FacetDescriptions for a particular type
/// </summary>
/// <param name="type"> the type to return FacetDescriptions for. </param>
/// <returns> The FacetDescriptions for the type given. </returns>
public override ReadOnlyCollection<FacetDescription> GetFacetDescriptions(EdmType type)
{
Debug.Assert(type is PrimitiveType, "EdmProviderManifest.GetFacetDescriptions(): Argument is not a PrimitiveType");
InitializeFacetDescriptions();
// Some types may not have facets, so just try to get them, if there aren't any, just return an empty list
ReadOnlyCollection<FacetDescription> collection = null;
if (_facetDescriptions.TryGetValue(type as PrimitiveType, out collection))
{
return collection;
}
return Helper.EmptyFacetDescriptionEnumerable;
}
private void DataTypeTestHelper(object value, EdmType edmType, string formattedValue)
{
var dict = new Dictionary<string, object>
{
{ "Foo", value }
};
XElement xml = DataServicesHelper.CreateDataElement(dict);
var prop = xml.Element(null, "content").Element("m", "properties").Element("d", "Foo");
Assert.That(prop.Attribute("m", "type").ValueOrDefault(), Is.EqualTo(edmType.ToString()));
Assert.That(xml.Element(null, "content").Element("m", "properties").Element("d", "Foo").Value, Is.EqualTo(formattedValue));
}
/// <summary>
/// Gets a function providing a transformation from the specified <paramref name="type"/> to the hashed value represented as <see cref="ulong"/>.
/// </summary>
public static Func<object, ulong> GetHashingTransformer(EdmType type)
{
switch (type)
{
case EdmType.String:
return TransformString;
case EdmType.Binary:
return TransformBytes;
case EdmType.DateTime:
return TransformDateTime;
case EdmType.Double:
return TransformDouble;
case EdmType.Guid:
return TransformGuid;
case EdmType.Int32:
return TransformInt;
case EdmType.Int64:
return TransformLong;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Initializes a new instance of the EntityProperty class given the
/// EdmType of the property (the value must be set by a public
/// constructor).
/// </summary>
private EntityProperty(EdmType propertyType)
{
this.PropertyType = propertyType;
}
/// <summary>
/// Is the given type an Enity Type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static bool IsEntityType(EdmType type)
{
return(BuiltInTypeKind.EntityType == type.BuiltInTypeKind);
}
public override ReadOnlyCollection<FacetDescription> GetFacetDescriptions(EdmType edmType)
{
Debug.Assert(edmType != null, "edmType != null");
Debug.Assert(edmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType, "Primitive type expected.");
Debug.Assert(
(DataSpace)typeof(EdmType)
.GetProperty("DataSpace", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(edmType) == DataSpace.SSpace,
"Expected SSpace type.");
try
{
var legacyStoreType = _legacyStoreTypes.Single(t => t.FullName == edmType.FullName);
return new ReadOnlyCollection<FacetDescription>(
_wrappedProviderManifest
.GetFacetDescriptions(legacyStoreType)
.Select(
legacyFacetDescription =>
(FacetDescription)FacetDescriptionConstructor.Invoke(
BindingFlags.CreateInstance,
null,
new[]
{
legacyFacetDescription.FacetName,
FromLegacyPrimitiveType((LegacyMetadata.PrimitiveType)legacyFacetDescription.FacetType),
legacyFacetDescription.MinValue,
legacyFacetDescription.MaxValue,
legacyFacetDescription.DefaultValue == TypeUsageHelper.LegacyVariableValue
? TypeUsageHelper.VariableValue
: legacyFacetDescription.DefaultValue,
legacyFacetDescription.IsConstant,
legacyStoreType.FullName
},
CultureInfo.InvariantCulture))
.ToList());
}
catch (SystemData.ProviderIncompatibleException exception)
{
throw new ProviderIncompatibleException(exception.Message, exception.InnerException);
}
}
private void AddDbQueryKeys()
{
EdmType.AddKeys(EdmType.StructuralProperties());
}
protected override void Visit(EdmType edmType)
{
base.Visit(edmType);
}
/// <summary>
/// Generates a property filter condition string for the <see cref="EdmType"/> value, formatted as the specified <see cref="EdmType"/>.
/// </summary>
/// <param name="propertyName">A string containing the name of the property to compare.</param>
/// <param name="operation">A string containing the comparison operator to use.</param>
/// <param name="givenValue">A string containing the value to compare with the property.</param>
/// <param name="edmType">The <see cref="EdmType"/> to format the value as.</param>
/// <returns>A string containing the formatted filter condition.</returns>
private static string GenerateFilterCondition(string propertyName, string operation, string givenValue, EdmType edmType)
{
string valueOperand = null;
if (edmType == EdmType.Boolean || edmType == EdmType.Double || edmType == EdmType.Int32)
{
valueOperand = givenValue;
}
else if (edmType == EdmType.Int64)
{
valueOperand = string.Format("{0}L", givenValue);
}
else if (edmType == EdmType.DateTime)
{
valueOperand = string.Format("datetime'{0}'", givenValue);
}
else if (edmType == EdmType.Guid)
{
valueOperand = string.Format("guid'{0}'", givenValue);
}
else if (edmType == EdmType.Binary)
{
valueOperand = string.Format("X'{0}'", givenValue);
}
else
{
valueOperand = string.Format("'{0}'", givenValue);
}
return string.Format("{0} {1} {2}", propertyName, operation, valueOperand);
}
private static T ReadAndResolveWithEdmTypeResolver <T>(Dictionary <string, string> entityAttributes, Func <string, string, DateTimeOffset, IDictionary <string, EntityProperty>, string, T> resolver, Func <string, string, string, string, EdmType> propertyResolver, string etag, Type type, OperationContext ctx, bool disablePropertyResolverCache)
{
string pk = null;
string rk = null;
DateTimeOffset ts = new DateTimeOffset();
Dictionary <string, EntityProperty> properties = new Dictionary <string, EntityProperty>();
Dictionary <string, EdmType> propertyResolverDictionary = null;
if (type != null)
{
#if WINDOWS_DESKTOP && !WINDOWS_PHONE
if (!disablePropertyResolverCache)
{
propertyResolverDictionary = TableEntity.PropertyResolverCache.GetOrAdd(type, TableOperationHttpResponseParsers.CreatePropertyResolverDictionary);
}
else
{
propertyResolverDictionary = TableOperationHttpResponseParsers.CreatePropertyResolverDictionary(type);
}
#else
propertyResolverDictionary = TableOperationHttpResponseParsers.CreatePropertyResolverDictionary(type);
#endif
}
foreach (KeyValuePair <string, string> prop in entityAttributes)
{
if (prop.Key == TableConstants.PartitionKey)
{
pk = (string)prop.Value;
}
else if (prop.Key == TableConstants.RowKey)
{
rk = (string)prop.Value;
}
else if (prop.Key == TableConstants.Timestamp)
{
ts = DateTimeOffset.Parse(prop.Value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
if (etag == null)
{
etag = GetETagFromTimestamp(prop.Value);
}
}
else
{
if (propertyResolver != null)
{
Logger.LogVerbose(ctx, SR.UsingUserProvidedPropertyResolver);
try
{
EdmType edmType = propertyResolver(pk, rk, prop.Key, prop.Value);
Logger.LogVerbose(ctx, SR.AttemptedEdmTypeForTheProperty, prop.Key, edmType);
try
{
properties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, edmType));
}
catch (FormatException ex)
{
throw new StorageException(string.Format(CultureInfo.InvariantCulture, SR.FailParseProperty, prop.Key, prop.Value, edmType), ex)
{
IsRetryable = false
};
}
}
catch (StorageException)
{
throw;
}
catch (Exception ex)
{
throw new StorageException(SR.PropertyResolverThrewError, ex)
{
IsRetryable = false
};
}
}
else if (type != null)
{
Logger.LogVerbose(ctx, SR.UsingDefaultPropertyResolver);
EdmType edmType;
if (propertyResolverDictionary != null)
{
propertyResolverDictionary.TryGetValue(prop.Key, out edmType);
Logger.LogVerbose(ctx, SR.AttemptedEdmTypeForTheProperty, prop.Key, edmType);
properties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, edmType));
}
}
else
{
Logger.LogVerbose(ctx, SR.NoPropertyResolverAvailable);
properties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, typeof(string)));
}
}
}
return(resolver(pk, rk, ts, properties, etag));
}
/// <summary>
///
/// </summary>
/// <param name="typeFullName"></param>
/// <param name="edmItem"></param>
public EntityMap MapEntity(string typeFullName, EdmType edmItem)
{
var identity = edmItem.FullName;
if (!TphData.ContainsKey(identity))
{
return(null);
}
var temp = PrepareMapping(typeFullName, edmItem);
if (temp == null)
{
return(null);
}
var storageEntitySet = temp.StorageEntitySet;
var tableName = temp.TableName;
var isRoot = temp.IsRoot;
var baseEdmType = temp.BaseEdmType;
string schema = (string)storageEntitySet.MetadataProperties["Schema"].Value;
var entityMap = RegEntity(typeFullName, tableName, schema);
entityMap.IsRoot = isRoot;
entityMap.EdmType = edmItem;
entityMap.ParentEdmType = entityMap.IsRoot ? null : baseEdmType;
_pks[tableName] = storageEntitySet.ElementType.KeyMembers.Select(x => x.Name).ToArray();
entityMap.IsTph = TphData[identity].Discriminators.Count > 0;
string prefix = null;
int i = 0;
var propertiesToMap = GetPropertiesToMap(entityMap, storageEntitySet.ElementType.Properties);
foreach (var edmProperty in propertiesToMap)
{
MapProperty(entityMap, edmProperty, ref i, ref prefix);
}
// create navigation properties
foreach (var navigationProperty in TphData[identity].NavProperties)
{
var associationType = navigationProperty.RelationshipType as AssociationType;
if (associationType == null || associationType.ReferentialConstraints.Count == 0)
{
continue;
}
var to = associationType.ReferentialConstraints[0].ToProperties[0];
var propertyMap = entityMap.Properties.Cast <PropertyMap>()
.FirstOrDefault(x => x.EdmMember == to);
if (propertyMap != null)
{
propertyMap.NavigationPropertyName = navigationProperty.Name;
if (entityMap.Prop(navigationProperty.Name) == null)
{
var navigationPropertyMap = entityMap.MapProperty(navigationProperty.Name, propertyMap.ColumnName);
navigationPropertyMap.IsNavigationProperty = true;
navigationPropertyMap.ForeignKeyPropertyName = propertyMap.PropertyName;
navigationPropertyMap.ForeignKey = propertyMap;
propertyMap.NavigationProperty = navigationPropertyMap;
}
}
}
// create discriminators
foreach (var discriminator in TphData[identity].Discriminators)
{
var propertyMap = entityMap.MapDiscriminator(discriminator.Key, discriminator.Value);
entityMap.AddDiscriminator(propertyMap);
}
return(entityMap);
}
// requires: workspace
// Determines CSpace EntityType associated with the type argument T
internal static bool TryDetermineCSpaceModelType <T>(MetadataWorkspace workspace, out EdmType modelEdmType)
{
return(TryDetermineCSpaceModelType(typeof(T), workspace, out modelEdmType));
}
private static bool TryMatchType(EntityProperty rhs, EdmType edmType, out object matchedValue, out string error)
{
error = null;
switch (edmType)
{
case EdmType.String:
if (rhs.PropertyType == EdmType.String)
{
matchedValue = rhs.StringValue;
return(true);
}
break;
case EdmType.Binary:
if (rhs.PropertyType == EdmType.Binary)
{
matchedValue = rhs.BinaryValue;
return(true);
}
break;
case EdmType.Boolean:
if (rhs.PropertyType == EdmType.Boolean)
{
matchedValue = rhs.BooleanValue;
return(true);
}
break;
case EdmType.DateTime:
if (rhs.PropertyType == EdmType.DateTime)
{
matchedValue = rhs.DateTime;
return(true);
}
break;
case EdmType.Double:
if (rhs.PropertyType == EdmType.Double)
{
matchedValue = rhs.DoubleValue;
return(true);
}
if (rhs.PropertyType == EdmType.Int32)
{
matchedValue = (double?)rhs.Int32Value;
return(true);
}
if (rhs.PropertyType == EdmType.Int64)
{
matchedValue = (double?)rhs.Int64Value;
return(true);
}
break;
case EdmType.Guid:
if (rhs.PropertyType == EdmType.Guid)
{
matchedValue = rhs.GuidValue;
return(true);
}
break;
case EdmType.Int32:
if (rhs.PropertyType == EdmType.Int32)
{
matchedValue = rhs.Int32Value;
return(true);
}
break;
case EdmType.Int64:
if (rhs.PropertyType == EdmType.Int64)
{
matchedValue = rhs.Int64Value;
return(true);
}
if (rhs.PropertyType == EdmType.Int32)
{
matchedValue = (long?)rhs.Int32Value;
return(true);
}
break;
default:
error = "Unknown type conversion.";
matchedValue = null;
return(false);
}
error = $"Cannot convert {rhs.PropertyType} to {edmType}";
matchedValue = null;
return(false);
}
protected abstract PrepareMappingRes PrepareMapping(string typeFullName, EdmType edmitem);
internal void RemoveIsOfType(EdmType type)
{
DebugCheck.NotNull(type);
m_isOfEntityTypes.Remove(type.FullName);
}
/// <summary>
/// Add a Type to the list of Is-Of types that this mapping is valid for
/// </summary>
internal void AddIsOfType(EdmType type)
{
DebugCheck.NotNull(type);
m_isOfEntityTypes.Add(type.FullName, type);
}
/// <summary>
/// Add a Type to the list of types that this mapping is valid for
/// </summary>
public void AddType(EdmType type)
{
Check.NotNull(type, "type");
m_entityTypes.Add(type.FullName, type);
}
private static void WriteTestHelper(object value, EdmType edmType, string formattedValue)
{
var be = BaseTestElement();
EdmHelper.Write(be, new KeyValuePair<string, object>("Test", value));
var element = be.Element("d", "Test");
Assert.That(element, Is.Not.Null);
Assert.That(element.Attribute("m", "type").Value, Is.EqualTo(edmType.ToString()));
Assert.That(element.Value, Is.EqualTo(formattedValue));
}
internal static bool TryDetermineCSpaceModelType(Type type, MetadataWorkspace workspace, out EdmType modelEdmType)
{
Debug.Assert(null != workspace);
Type nonNullabelType = TypeSystem.GetNonNullableType(type);
// make sure the workspace knows about T
workspace.ImplicitLoadAssemblyForType(nonNullabelType, System.Reflection.Assembly.GetCallingAssembly());
ObjectItemCollection objectItemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace);
EdmType objectEdmType;
if (objectItemCollection.TryGetItem <EdmType>(nonNullabelType.FullName, out objectEdmType))
{
Map map;
if (workspace.TryGetMap(objectEdmType, DataSpace.OCSpace, out map))
{
ObjectTypeMapping objectMapping = (ObjectTypeMapping)map;
modelEdmType = objectMapping.EdmType;
return(true);
}
}
modelEdmType = null;
return(false);
}
/// <summary>
/// Initialises a new instance of the <see cref="ConstantNode" /> class.
/// </summary>
/// <param name="edmType">The <see cref="EdmType"/> of the value.</param>
/// <param name="literalText">The literal text.</param>
protected ConstantNode(EdmType edmType, string literalText)
{
EdmType = edmType;
LiteralText = literalText;
}
// effects: Returns true if member's type has a discrete domain (i.e. is bolean type)
// Note: enums don't have discrete domains as we allow domain of the underlying type.
internal static bool HasDiscreteDomain(EdmType edmType)
{
var primitiveType = edmType as PrimitiveType;
return(primitiveType != null && primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Boolean);
}
/// <summary>
/// Is the given type a primitive type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static bool IsPrimitiveType(EdmType type)
{
return(BuiltInTypeKind.PrimitiveType == type.BuiltInTypeKind);
}
// effects: Returns this type and its sub types - for refs, gets the
// type and subtypes of the entity type
internal static IEnumerable <EdmType> GetTypeAndSubtypesOf(EdmType type, MetadataWorkspace workspace, bool includeAbstractTypes)
{
return(GetTypeAndSubtypesOf(type, workspace.GetItemCollection(DataSpace.CSpace), includeAbstractTypes));
}
internal static void ReadAndUpdateTableEntityWithEdmTypeResolver(ITableEntity entity, Dictionary <string, string> entityAttributes, EntityReadFlags flags, Func <string, string, string, string, EdmType> propertyResolver, OperationContext ctx)
{
Dictionary <string, EntityProperty> entityProperties = (flags & EntityReadFlags.Properties) > 0 ? new Dictionary <string, EntityProperty>() : null;
Dictionary <string, EdmType> propertyResolverDictionary = null;
// Try to add the dictionary to the cache only if it is not a DynamicTableEntity. If DisablePropertyResolverCache is true, then just use reflection and generate dictionaries for each entity.
if (entity.GetType() != typeof(DynamicTableEntity))
{
#if WINDOWS_DESKTOP && !WINDOWS_PHONE
if (!TableEntity.DisablePropertyResolverCache)
{
propertyResolverDictionary = TableEntity.PropertyResolverCache.GetOrAdd(entity.GetType(), TableOperationHttpResponseParsers.CreatePropertyResolverDictionary);
}
else
{
Logger.LogVerbose(ctx, SR.PropertyResolverCacheDisabled);
propertyResolverDictionary = TableOperationHttpResponseParsers.CreatePropertyResolverDictionary(entity.GetType());
}
#else
propertyResolverDictionary = TableOperationHttpResponseParsers.CreatePropertyResolverDictionary(entity.GetType());
#endif
}
if (flags > 0)
{
foreach (KeyValuePair <string, string> prop in entityAttributes)
{
if (prop.Key == TableConstants.PartitionKey)
{
entity.PartitionKey = (string)prop.Value;
}
else if (prop.Key == TableConstants.RowKey)
{
entity.RowKey = (string)prop.Value;
}
else if (prop.Key == TableConstants.Timestamp)
{
if ((flags & EntityReadFlags.Timestamp) == 0)
{
continue;
}
entity.Timestamp = DateTime.Parse(prop.Value, CultureInfo.InvariantCulture);
}
else if ((flags & EntityReadFlags.Properties) > 0)
{
if (propertyResolver != null)
{
Logger.LogVerbose(ctx, SR.UsingUserProvidedPropertyResolver);
try
{
EdmType type = propertyResolver(entity.PartitionKey, entity.RowKey, prop.Key, prop.Value);
Logger.LogVerbose(ctx, SR.AttemptedEdmTypeForTheProperty, prop.Key, type.GetType().ToString());
try
{
entityProperties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, type.GetType()));
}
catch (FormatException ex)
{
throw new StorageException(string.Format(CultureInfo.InvariantCulture, SR.FailParseProperty, prop.Key, prop.Value, type.ToString()), ex)
{
IsRetryable = false
};
}
}
catch (StorageException)
{
throw;
}
catch (Exception ex)
{
throw new StorageException(SR.PropertyResolverThrewError, ex)
{
IsRetryable = false
};
}
}
else if (entity.GetType() != typeof(DynamicTableEntity))
{
EdmType edmType;
Logger.LogVerbose(ctx, SR.UsingDefaultPropertyResolver);
if (propertyResolverDictionary != null)
{
propertyResolverDictionary.TryGetValue(prop.Key, out edmType);
Logger.LogVerbose(ctx, SR.AttemptedEdmTypeForTheProperty, prop.Key, edmType);
entityProperties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, edmType));
}
}
else
{
Logger.LogVerbose(ctx, SR.NoPropertyResolverAvailable);
entityProperties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, typeof(string)));
}
}
}
if ((flags & EntityReadFlags.Properties) > 0)
{
entity.ReadEntity(entityProperties, ctx);
}
}
}
// Metadata 'Visitor' methods
protected virtual EdmType VisitType(EdmType type)
{
return(type);
}
internal void ValidateAndSetTypeUsage(EdmType edmType)
{
_typeUsageBuilder.ValidateAndSetTypeUsage(edmType, false);
}
/// <summary>
/// Initializes a new instance of the EntityProperty class given the
/// EdmType of the property (the value must be set by a public
/// constructor).
/// </summary>
private EntityProperty(EdmType propertyType)
{
this.PropertyType = propertyType;
}
/// <summary>
/// Returns the list of facet descriptions for the specified Entity Data Model (EDM) type.
/// </summary>
/// <param name="edmType">An <see cref="T:System:Data.Metadata.Edm.EdmType"/> for which the facet descriptions are to be retrieved.</param>
/// <returns>
/// A collection of type <see cref="T:System.Collections.ObjectModel.ReadOnlyCollection`1"/> that contains the list of facet descriptions for the specified Entity Data Model (EDM) type.
/// </returns>
public override ReadOnlyCollection<FacetDescription> GetFacetDescriptions(EdmType edmType)
{
return this.wrappedProviderManifest.GetFacetDescriptions(edmType);
}
/// <summary>
/// Is the given type a collection type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static bool IsCollectionType(EdmType type)
{
return(type.BuiltInTypeKind == BuiltInTypeKind.CollectionType);
}
/// <summary>
/// Is the given type a row type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static bool IsRowType(EdmType type)
{
return(BuiltInTypeKind.RowType == type.BuiltInTypeKind);
}
/// <summary>
/// Get the edm type, if the type is not a edm type throw a exception.
/// </summary>
private Type GetType(EdmType edmType)
{
switch (edmType)
{
case EdmType.Binary :
return typeof(byte[]);
case EdmType.Boolean :
return typeof(bool);
case EdmType.DateTime :
return typeof(DateTime);
case EdmType.Double :
return typeof(double);
case EdmType.Guid :
return typeof(Guid);
case EdmType.Int32 :
return typeof(int);
case EdmType.Int64 :
return typeof(long);
case EdmType.String :
return typeof(string);
default: throw new TypeLoadException(string.Format("not supported edmType:{0}" ,edmType));
}
}
/// <summary>
/// Gets the C# type equivalent of an entity data model (Edm) type.
/// </summary>
/// <param name="type">The Edm type.</param>
/// <returns>The C# type.</returns>
private static string GetType(EdmType type)
{
switch (type)
{
case EdmType.Binary:
return "byte[]";
case EdmType.Boolean:
return "bool?";
case EdmType.DateTime:
return "DateTime?";
case EdmType.Double:
return "double?";
case EdmType.Guid:
return "Guid?";
case EdmType.Int32:
return "int?";
case EdmType.Int64:
return "long?";
case EdmType.String:
return "string";
default:
throw new NotSupportedException(string.Format(Exceptions.TypeNotSupported, type));
}
}
protected abstract PrepareMappingRes PrepareMapping(string typeFullName, EdmType edmitem);
/// <summary>
/// Ensures that the given type matches the type of this entity
/// property; throws an exception if the types do not match.
/// </summary>
private void EnforceType(EdmType requestedType)
{
if (this.PropertyType != requestedType)
{
throw new InvalidOperationException(string.Format(
"Cannot return {0} type for a {1} typed property.",
requestedType,
this.PropertyType));
}
}
/// <summary>
/// Generates a property filter condition string for the <see cref="EdmType"/> value, formatted as the specified <see cref="EdmType"/>.
/// </summary>
/// <param name="propertyName">A string containing the name of the property to compare.</param>
/// <param name="operation">A string containing the comparison operator to use.</param>
/// <param name="givenValue">A string containing the value to compare with the property.</param>
/// <param name="edmType">The <see cref="EdmType"/> to format the value as.</param>
/// <returns>A string containing the formatted filter condition.</returns>
private static string GenerateFilterCondition(string propertyName, string operation, string givenValue, EdmType edmType)
{
string valueOperand = null;
if (edmType == EdmType.Boolean || edmType == EdmType.Double || edmType == EdmType.Int32)
{
valueOperand = givenValue;
}
else if (edmType == EdmType.Int64)
{
valueOperand = string.Format(CultureInfo.InvariantCulture, "{0}L", givenValue);
}
else if (edmType == EdmType.DateTime)
{
valueOperand = string.Format(CultureInfo.InvariantCulture, "datetime'{0}'", givenValue);
}
else if (edmType == EdmType.Guid)
{
valueOperand = string.Format(CultureInfo.InvariantCulture, "guid'{0}'", givenValue);
}
else if (edmType == EdmType.Binary)
{
valueOperand = string.Format(CultureInfo.InvariantCulture, "X'{0}'", givenValue);
}
else
{
// OData readers expect single quote to be escaped in a param value.
valueOperand = string.Format(CultureInfo.InvariantCulture, "'{0}'", givenValue.Replace("'", "''"));
}
return string.Format(CultureInfo.InvariantCulture, "{0} {1} {2}", propertyName, operation, valueOperand);
}
/// <summary>
/// Generates a property filter condition string for the <see cref="EdmType"/> value, formatted as the specified <see cref="EdmType"/>.
/// </summary>
/// <param name="propertyName">A string containing the name of the property to compare.</param>
/// <param name="operation">A string containing the comparison operator to use.</param>
/// <param name="value">A string containing the value to compare with the property.</param>
/// <param name="edmType">The <see cref="EdmType"/> to format the value as.</param>
/// <returns>A string containing the formatted filter condition.</returns>
private static string GenerateFilterCondition(string propertyName, string operation, string value, EdmType edmType)
{
string valueOperand = null;
if (edmType == EdmType.Boolean || edmType == EdmType.Double || edmType == EdmType.Int32 ||
edmType == EdmType.Int64)
{
valueOperand = value;
}
else if (edmType == EdmType.DateTime)
{
valueOperand = string.Format("datetime'{0}'", value);
}
else if (edmType == EdmType.Guid)
{
valueOperand = string.Format("guid'{0}'", value);
}
else if (edmType == EdmType.Binary)
{
valueOperand = string.Format("X'{0}'", value);
}
else
{
valueOperand = string.Format("'{0}'", value);
}
return(string.Format("{0} {1} {2}", propertyName, operation, valueOperand));
}
/// <summary> /// Gets a ConstantNode which represents a type in the entity data model. /// </summary> /// <param name="literalText">The literal text.</param> /// <param name="edmType">The type in the entity data model.</param> /// <returns>A ConstantNode representing a duration value.</returns> internal static ConstantNode <EdmType> EdmTypeNode(string literalText, EdmType edmType) => new ConstantNode <EdmType>(edmType, literalText, edmType);
/// <summary>
/// Gets the CLR type for given EDM type.
/// </summary>
/// <param name="edmType">Type of the EDM.</param>
/// <returns></returns>
private static Type UnderlyingClrType(EdmType edmType) {
var primitiveType = edmType as PrimitiveType;
if (primitiveType != null)
return primitiveType.ClrEquivalentType;
return typeof(object);
}
private void EnsureConfigurationIsFullyMapped(
MemberPath currentPath,
BoolExpression currentWhereClause,
HashSet <FragmentQuery> outputUsedViews,
ErrorLog errorLog)
{
foreach (Constant domainValue in this.GetDomain(currentPath))
{
if (domainValue != Constant.Undefined)
{
BoolExpression memberCondition = this.CreateMemberCondition(currentPath, domainValue);
BoolExpression and = BoolExpression.CreateAnd(currentWhereClause, memberCondition);
Tile <FragmentQuery> rewriting;
if (!this.FindRewritingAndUsedViews((IEnumerable <MemberPath>) this._keyAttributes, and, outputUsedViews, out rewriting))
{
if (!ErrorPatternMatcher.FindMappingErrors(this._context, this._domainMap, this._errorLog))
{
StringBuilder builder = new StringBuilder();
string str = StringUtil.FormatInvariant("{0}", (object)this._extentPath);
BoolExpression condition = rewriting.Query.Condition;
condition.ExpensiveSimplify();
if (condition.RepresentsAllTypeConditions)
{
string viewGenExtent = Strings.ViewGen_Extent;
builder.AppendLine(Strings.ViewGen_Cannot_Recover_Types((object)viewGenExtent, (object)str));
}
else
{
string viewGenEntities = Strings.ViewGen_Entities;
builder.AppendLine(Strings.ViewGen_Cannot_Disambiguate_MultiConstant((object)viewGenEntities, (object)str));
}
RewritingValidator.EntityConfigurationToUserString(condition, builder);
ErrorLog.Record record = new ErrorLog.Record(ViewGenErrorCode.AmbiguousMultiConstants, builder.ToString(), (IEnumerable <LeftCellWrapper>) this._context.AllWrappersForExtent, string.Empty);
errorLog.AddEntry(record);
}
}
else
{
TypeConstant typeConstant = domainValue as TypeConstant;
if (typeConstant != null)
{
EdmType edmType = typeConstant.EdmType;
List <MemberPath> list = QueryRewriter.GetNonConditionalScalarMembers(edmType, currentPath, this._domainMap).Union <MemberPath>(QueryRewriter.GetNonConditionalComplexMembers(edmType, currentPath, this._domainMap)).ToList <MemberPath>();
IEnumerable <MemberPath> notCoveredAttributes;
if (list.Count > 0 && !this.FindRewritingAndUsedViews((IEnumerable <MemberPath>)list, and, outputUsedViews, out rewriting, out notCoveredAttributes))
{
List <MemberPath> memberPathList = new List <MemberPath>(list.Where <MemberPath>((Func <MemberPath, bool>)(a => !a.IsPartOfKey)));
this.AddUnrecoverableAttributesError(notCoveredAttributes, memberCondition, errorLog);
}
else
{
foreach (MemberPath conditionalComplexMember in QueryRewriter.GetConditionalComplexMembers(edmType, currentPath, this._domainMap))
{
this.EnsureConfigurationIsFullyMapped(conditionalComplexMember, and, outputUsedViews, errorLog);
}
foreach (MemberPath conditionalScalarMember in QueryRewriter.GetConditionalScalarMembers(edmType, currentPath, this._domainMap))
{
this.EnsureConfigurationIsFullyMapped(conditionalScalarMember, and, outputUsedViews, errorLog);
}
}
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="typeFullName"></param>
/// <param name="edmItem"></param>
public EntityMap MapEntity(string typeFullName, EdmType edmItem)
{
var identity = edmItem.FullName;
if (!TphData.ContainsKey(identity))
{
return null;
}
var temp = PrepareMapping(typeFullName, edmItem);
if (temp == null)
{
return null;
}
var storageEntitySet = temp.StorageEntitySet;
var tableName = temp.TableName;
var isRoot = temp.IsRoot;
var baseEdmType = temp.BaseEdmType;
string schema = (string)storageEntitySet.MetadataProperties["Schema"].Value;
var entityMap = RegEntity(typeFullName, tableName, schema);
entityMap.IsRoot = isRoot;
entityMap.EdmType = edmItem;
entityMap.ParentEdmType = entityMap.IsRoot ? null : baseEdmType;
_pks[tableName] = storageEntitySet.ElementType.KeyMembers.Select(x => x.Name).ToArray();
entityMap.IsTph = TphData[identity].Discriminators.Count > 0;
string prefix = null;
int i = 0;
var propertiesToMap = GetPropertiesToMap(entityMap, storageEntitySet.ElementType.Properties);
foreach (var edmProperty in propertiesToMap)
{
MapProperty(entityMap, edmProperty, ref i, ref prefix);
}
// create navigation properties
foreach (var navigationProperty in TphData[identity].NavProperties)
{
var associationType = navigationProperty.RelationshipType as AssociationType;
if (associationType == null || associationType.ReferentialConstraints.Count == 0)
{
continue;
}
var to = associationType.ReferentialConstraints[0].ToProperties[0];
var propertyMap = entityMap.Properties.Cast<PropertyMap>()
.FirstOrDefault(x => x.EdmMember == to);
if (propertyMap != null)
{
propertyMap.NavigationPropertyName = navigationProperty.Name;
if (entityMap.Prop(navigationProperty.Name) == null)
{
var navigationPropertyMap = entityMap.MapProperty(navigationProperty.Name, propertyMap.ColumnName);
navigationPropertyMap.IsNavigationProperty = true;
navigationPropertyMap.ForeignKeyPropertyName = propertyMap.PropertyName;
navigationPropertyMap.ForeignKey = propertyMap;
propertyMap.NavigationProperty = navigationPropertyMap;
}
}
}
// create discriminators
foreach (var discriminator in TphData[identity].Discriminators)
{
var propertyMap = entityMap.MapDiscriminator(discriminator.Key, discriminator.Value);
entityMap.AddDiscriminator(propertyMap);
}
return entityMap;
}
internal static IEnumerable <ComplexType> ToHierarchy(this ComplexType edmType)
{
return(EdmType.SafeTraverseHierarchy(edmType));
}
/// <summary>
/// Initialises a new instance of the <see cref="ConstantNode" /> class.
/// </summary>
/// <param name="edmType">The <see cref="EdmType"/> of the value.</param>
/// <param name="literalText">The literal text.</param>
/// <param name="value">The value.</param>
private ConstantNode(EdmType edmType, string literalText, object value)
{
this.EdmType = edmType;
this.LiteralText = literalText;
this.Value = value;
}
internal static bool Equals(EdmType x, EdmType y)
{
return(x.Identity.Equals(y.Identity));
}
private MappingBase GetOCMapForTransientType(EdmType edmType, DataSpace typeSpace)
{
Debug.Assert(
typeSpace == DataSpace.CSpace || typeSpace == DataSpace.OSpace || Helper.IsRowType(edmType) ||
Helper.IsCollectionType(edmType));
EdmType clrType = null;
EdmType cdmType = null;
var index = -1;
if (typeSpace != DataSpace.OSpace)
{
if (_edmTypeIndexes.TryGetValue(edmType.Identity, out index))
{
return((MappingBase)this[index]);
}
else
{
cdmType = edmType;
clrType = ConvertCSpaceToOSpaceType(edmType);
}
}
else if (typeSpace == DataSpace.OSpace)
{
if (_clrTypeIndexes.TryGetValue(edmType.Identity, out index))
{
return((MappingBase)this[index]);
}
else
{
clrType = edmType;
cdmType = ConvertOSpaceToCSpaceType(clrType);
}
}
var typeMapping = new ObjectTypeMapping(clrType, cdmType);
if (BuiltInTypeKind.RowType
== edmType.BuiltInTypeKind)
{
var clrRowType = (RowType)clrType;
var edmRowType = (RowType)cdmType;
Debug.Assert(clrRowType.Properties.Count == edmRowType.Properties.Count, "Property count mismatch");
for (var idx = 0; idx < clrRowType.Properties.Count; idx++)
{
typeMapping.AddMemberMap(new ObjectPropertyMapping(edmRowType.Properties[idx], clrRowType.Properties[idx]));
}
}
if ((!_edmTypeIndexes.ContainsKey(cdmType.Identity)) &&
(!_clrTypeIndexes.ContainsKey(clrType.Identity)))
{
lock (_lock)
{
var clrTypeIndexes = new Dictionary <string, int>(_clrTypeIndexes);
var edmTypeIndexes = new Dictionary <string, int>(_edmTypeIndexes);
typeMapping = AddInternalMapping(typeMapping, clrTypeIndexes, edmTypeIndexes);
_clrTypeIndexes = clrTypeIndexes;
_edmTypeIndexes = edmTypeIndexes;
}
}
return(typeMapping);
}
// <summary>
// Search for a Mapping metadata with the specified type key.
// </summary>
// <param name="identity"> identity of the type </param>
// <param name="typeSpace"> The dataspace that the type for which map needs to be returned belongs to </param>
// <param name="ignoreCase"> true for case-insensitive lookup </param>
// <returns> Returns false if no match found. </returns>
internal override bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out MappingBase map)
{
EdmType cdmType = null;
EdmType clrType = null;
if (typeSpace == DataSpace.CSpace)
{
if (ignoreCase)
{
// Get the correct casing of the identity first if we are asked to do ignore case
if (!_edmCollection.TryGetItem(identity, true, out cdmType))
{
map = null;
return(false);
}
identity = cdmType.Identity;
}
int index;
if (_edmTypeIndexes.TryGetValue(identity, out index))
{
map = (MappingBase)this[index];
return(true);
}
if (cdmType != null
||
_edmCollection.TryGetItem(identity, ignoreCase, out cdmType))
{
// If the mapping is not already loaded, then get the mapping ospace type
_objectCollection.TryGetOSpaceType(cdmType, out clrType);
}
}
else if (typeSpace == DataSpace.OSpace)
{
if (ignoreCase)
{
// Get the correct casing of the identity first if we are asked to do ignore case
if (!_objectCollection.TryGetItem(identity, true, out clrType))
{
map = null;
return(false);
}
identity = clrType.Identity;
}
int index;
if (_clrTypeIndexes.TryGetValue(identity, out index))
{
map = (MappingBase)this[index];
return(true);
}
if (clrType != null
||
_objectCollection.TryGetItem(identity, ignoreCase, out clrType))
{
// If the mapping is not already loaded, get the mapping cspace type
var cspaceTypeName = ObjectItemCollection.TryGetMappingCSpaceTypeIdentity(clrType);
_edmCollection.TryGetItem(cspaceTypeName, out cdmType);
}
}
if ((clrType == null) ||
(cdmType == null))
{
map = null;
return(false);
}
else
{
map = GetDefaultMapping(cdmType, clrType);
return(true);
}
}
// <summary>
// Returns all the FacetDescriptions for a particular type
// </summary>
// <param name="type"> the type to return FacetDescriptions for. </param>
// <returns> The FacetDescriptions for the type given. </returns>
public override ReadOnlyCollection<FacetDescription> GetFacetDescriptions(EdmType type)
{
if (Helper.IsPrimitiveType(type)
&& (type).DataSpace == DataSpace.OSpace)
{
// we don't have our own facets, just defer to the edm primitive type facets
var basePrimitive = (PrimitiveType)type.BaseType;
return basePrimitive.ProviderManifest.GetFacetDescriptions(basePrimitive);
}
return Helper.EmptyFacetDescriptionEnumerable;
}
/// <summary>
/// Dumps the specified EDM type metadata instance with the specified decoration
/// </summary>
/// <param name="type"> The type metadata to dump </param>
/// <param name="name"> The decorating block name </param>
internal void Dump(EdmType type, string name)
{
Begin(name);
Dump(type);
End(name);
}
