/// <summary>
/// Overrides the default equality function. Two NestedPropertyRefs are
/// equal if the have the same property name, and the types are the same
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
NestedPropertyRef other = obj as NestedPropertyRef;
return(other != null &&
m_inner.Equals(other.m_inner) &&
m_outer.Equals(other.m_outer));
}
/// <summary>
/// Get the datatype for a propertyRef. The only concrete classes that we
/// handle are TypeIdPropertyRef, and BasicPropertyRef.
/// AllPropertyRef is illegal here.
/// For BasicPropertyRef, we simply pick up the type from the corresponding
/// property. For TypeIdPropertyRef, we use "string" as the default type
/// or the discriminator property type where one is available.
/// </summary>
/// <param name="typeInfo">typeinfo of the current type</param>
/// <param name="p">current property ref</param>
/// <returns>the datatype of the property</returns>
private md.TypeUsage GetPropertyType(RootTypeInfo typeInfo, PropertyRef p)
{
md.TypeUsage result = null;
PropertyRef innerProperty = null;
// Get the "leaf" property first
while (p is NestedPropertyRef)
{
NestedPropertyRef npr = (NestedPropertyRef)p;
p = npr.OuterProperty;
innerProperty = npr.InnerProperty;
}
if (p is TypeIdPropertyRef)
{
//
// Get to the innermost type that specifies this typeid (the entity type),
// get the datatype for the typeid column from that type
//
if (innerProperty != null && innerProperty is SimplePropertyRef)
{
md.TypeUsage innerType = ((SimplePropertyRef)innerProperty).Property.TypeUsage;
TypeInfo innerTypeInfo = GetTypeInfo(innerType);
result = innerTypeInfo.RootType.TypeIdType;
}
else
{
result = typeInfo.TypeIdType;
}
}
else if (p is EntitySetIdPropertyRef || p is NullSentinelPropertyRef)
{
result = m_intType;
}
else if (p is RelPropertyRef)
{
result = (p as RelPropertyRef).Property.ToEnd.TypeUsage;
}
else
{
SimplePropertyRef simpleP = p as SimplePropertyRef;
if (simpleP != null)
{
result = md.Helper.GetModelTypeUsage(simpleP.Property);
}
}
result = GetNewType(result);
PlanCompiler.Assert(null != result, "unrecognized property type?");
return(result);
}
/// <summary>
/// Determines the offset for structured types in Flattened type. For instance, if the original type is of the form:
///
/// { int X, ComplexType Y }
///
/// and the flattened type is of the form:
///
/// { int X, Y_ComplexType_Prop1, Y_ComplexType_Prop2 }
///
/// GetNestedStructureOffset(Y) returns 1
/// </summary>
/// <param name="property">Complex property.</param>
/// <returns>Offset.</returns>
internal int GetNestedStructureOffset(PropertyRef property)
{
// m_propertyRefList contains every element of the flattened type
for (int i = 0; i < m_propertyRefList.Count; i++)
{
NestedPropertyRef nestedPropertyRef = m_propertyRefList[i] as NestedPropertyRef;
// match offset of the first element of the complex type property
if (null != nestedPropertyRef && nestedPropertyRef.InnerProperty.Equals(property))
{
return(i);
}
}
PlanCompiler.Assert(false, "no complex structure " + property + " found in TypeInfo");
// return something so that the compiler doesn't complain
return(default(int));
}
