/// <summary>
/// Initializes a new instance of AssociationEndMember
/// </summary>
/// <param name="name">name of the association end member</param>
/// <param name="endRefType">Ref type that this end refers to </param>
/// <param name="multiplicity">multiplicity of the end</param>
internal AssociationEndMember(
string name,
RefType endRefType,
RelationshipMultiplicity multiplicity)
: base(name, endRefType, multiplicity)
{
}
/// <summary>
/// Initializes a new instance of RelationshipEndMember
/// </summary>
/// <param name="name">name of the relationship end member</param>
/// <param name="endRefType">Ref type that this end refers to </param>
/// <param name="multiplicity">The multiplicity of this relationship end</param>
/// <exception cref="System.ArgumentNullException">Thrown if name or endRefType arguments is null</exception>
/// <exception cref="System.ArgumentException">Thrown if name argument is empty string</exception>
internal RelationshipEndMember(string name,
RefType endRefType,
RelationshipMultiplicity multiplicity)
: base(name,
TypeUsage.Create(endRefType, new FacetValues{ Nullable = false }))
{
_relationshipMultiplicity = multiplicity;
_deleteBehavior = OperationAction.None;
}
/// <summary>
/// The type needs an entitysetidproperty, if it is either an entity type
/// or a reference type, AND we cannot determine that there is only entityset
/// in the query that could be producing instances of this entity
/// </summary>
/// <param name="typeInfo"></param>
/// <returns></returns>
private bool NeedsEntitySetIdProperty(TypeInfo typeInfo)
{
md.EntityType entityType;
md.RefType refType = typeInfo.Type.EdmType as md.RefType;
if (refType != null)
{
entityType = refType.ElementType as md.EntityType;
}
else
{
entityType = typeInfo.Type.EdmType as md.EntityType;
}
bool result = ((entityType != null) && (GetEntitySet(entityType) == null));
return(result);
}
internal override bool ResolveNameAndSetTypeUsage(Converter.ConversionCache convertedItemCache, Dictionary<Som.SchemaElement, GlobalItem> newGlobalItems)
{
if (_typeUsage == null)
{
Debug.Assert(!(_type is ScalarType));
EdmType edmType = (EdmType)Converter.LoadSchemaElement(_type, _type.Schema.ProviderManifest, convertedItemCache, newGlobalItems);
EntityType entityType = edmType as EntityType;
Debug.Assert(entityType != null);
RefType refType = new RefType(entityType);
refType.AddMetadataProperties(this.OtherContent);
_typeUsage = TypeUsage.Create(refType);
}
return true;
}
/// <summary>
/// Get the list of "key" properties (in the flattened type)
/// </summary>
/// <returns>the key property equivalents in the flattened type</returns>
internal IEnumerable <PropertyRef> GetKeyPropertyRefs()
{
md.EntityTypeBase entityType = null;
md.RefType refType = null;
if (TypeHelpers.TryGetEdmType <md.RefType>(m_type, out refType))
{
entityType = refType.ElementType;
}
else
{
entityType = TypeHelpers.GetEdmType <md.EntityTypeBase>(m_type);
}
// Walk through the list of keys of the entity type, and find their analogs in the
// "flattened" type
foreach (md.EdmMember p in entityType.KeyMembers)
{
// Eventually this could be RelationshipEndMember, but currently only properties are suppported as key members
PlanCompiler.Assert(p is md.EdmProperty, "Non-EdmProperty key members are not supported");
SimplePropertyRef spr = new SimplePropertyRef(p);
yield return(spr);
}
}
private static bool TryGetCommonType(RefType refType1, RefType reftype2, out EdmType commonType)
{
Debug.Assert(refType1.ElementType != null && reftype2.ElementType != null);
if (!TryGetCommonType(refType1.ElementType, reftype2.ElementType, out commonType))
{
return false;
}
commonType = new RefType((EntityType)commonType);
return true;
}
protected override void Visit(RefType refType)
{
int index;
if (!this.AddObjectToSeenListAndHashBuilder(refType, out index))
{
return;
}
this.AddObjectStartDumpToHashBuilder(refType, index);
#region Inner data visit
this.AddObjectContentToHashBuilder(refType.Identity);
// Identity contains Name, NamespaceName and FullName
base.Visit(refType);
#endregion
this.AddObjectEndDumpToHashBuilder();
}
protected virtual void Visit(RefType refType)
{
Visit(refType.BaseType);
Visit(refType.ElementType);
}
/// <summary>Convert CSpace TypeMetadata into OSpace TypeMetadata</summary>
/// <param name="clrType"></param>
/// <returns>OSpace type metadata</returns>
private EdmType ConvertOSpaceToCSpaceType(EdmType clrType)
{
EdmType cdmType = null;
if (Helper.IsCollectionType(clrType))
{
EdmType elemType = ConvertOSpaceToCSpaceType(((CollectionType)clrType).TypeUsage.EdmType);
cdmType = new CollectionType(elemType);
}
else if (Helper.IsRowType(clrType))
{
List<EdmProperty> cdmProperties = new List<EdmProperty>();
foreach (EdmProperty column in ((RowType)clrType).Properties)
{
EdmType cdmPropertyType = ConvertOSpaceToCSpaceType(column.TypeUsage.EdmType);
EdmProperty cdmPorperty = new EdmProperty(column.Name, TypeUsage.Create(cdmPropertyType));
cdmProperties.Add(cdmPorperty);
}
cdmType = new RowType(cdmProperties, ((RowType)clrType).InitializerMetadata);
}
else if (Helper.IsRefType(clrType))
{
cdmType = new RefType((EntityType)(ConvertOSpaceToCSpaceType(((RefType)clrType).ElementType)));
}
else
{
cdmType = ((ObjectTypeMapping)GetMap(clrType)).EdmType;
}
Debug.Assert((null != cdmType), "null converted clr type");
return cdmType;
}
/// <summary>Convert CSpace TypeMetadata into OSpace TypeMetadata</summary>
/// <param name="cdmType"></param>
/// <returns>OSpace type metadata</returns>
private EdmType ConvertCSpaceToOSpaceType(EdmType cdmType)
{
EdmType clrType = null;
if (Helper.IsCollectionType(cdmType))
{
var elemType = ConvertCSpaceToOSpaceType(((CollectionType)cdmType).TypeUsage.EdmType);
clrType = new CollectionType(elemType);
}
else if (Helper.IsRowType(cdmType))
{
var clrProperties = new List<EdmProperty>();
var rowType = (RowType)cdmType;
foreach (var column in rowType.Properties)
{
var clrPropertyType = ConvertCSpaceToOSpaceType(column.TypeUsage.EdmType);
var clrProperty = new EdmProperty(column.Name, TypeUsage.Create(clrPropertyType));
clrProperties.Add(clrProperty);
}
clrType = new RowType(clrProperties, rowType.InitializerMetadata);
}
else if (Helper.IsRefType(cdmType))
{
clrType = new RefType((EntityType)ConvertCSpaceToOSpaceType(((RefType)cdmType).ElementType));
}
else if (Helper.IsPrimitiveType(cdmType))
{
clrType = m_objectCollection.GetMappedPrimitiveType(((PrimitiveType)cdmType).PrimitiveTypeKind);
}
else
{
clrType = ((ObjectTypeMapping)GetMap(cdmType)).ClrType;
}
Debug.Assert((null != clrType), "null converted clr type");
return clrType;
}
/// <summary>
/// Initializes a new instance of AssociationEndMember
/// </summary>
/// <param name="name">name of the association end member</param>
/// <param name="endRefType">Ref type that this end refers to </param>
/// <param name="multiplicity">multiplicity of the end</param>
internal AssociationEndMember(string name,
RefType endRefType,
RelationshipMultiplicity multiplicity)
: base(name, endRefType, multiplicity)
{
}
