private SimplePolymorphicColumnMap CreatePolymorphicColumnMap(
TypeInfo typeInfo,
string name)
{
Dictionary <object, TypedColumnMap> dictionary = new Dictionary <object, TypedColumnMap>(typeInfo.RootType.DiscriminatorMap == null ? (IEqualityComparer <object>)null : (IEqualityComparer <object>)TrailingSpaceComparer.Instance);
List <TypedColumnMap> allMaps = new List <TypedColumnMap>();
TypeInfo rootType = (TypeInfo)typeInfo.RootType;
SimpleColumnMap typeIdColumnMap = this.CreateTypeIdColumnMap(rootType.TypeIdProperty);
if (TypeSemantics.IsComplexType(typeInfo.Type))
{
this.CreateComplexTypeColumnMap(rootType, name, (ComplexTypeColumnMap)null, dictionary, allMaps);
}
else
{
this.CreateEntityColumnMap(rootType, name, (EntityColumnMap)null, dictionary, allMaps, true);
}
TypedColumnMap typedColumnMap1 = (TypedColumnMap)null;
foreach (TypedColumnMap typedColumnMap2 in allMaps)
{
if (TypeSemantics.IsStructurallyEqual(typedColumnMap2.Type, typeInfo.Type))
{
typedColumnMap1 = typedColumnMap2;
break;
}
}
System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(null != typedColumnMap1, "Didn't find requested type in polymorphic type hierarchy?");
return(new SimplePolymorphicColumnMap(typeInfo.Type, name, typedColumnMap1.Properties, typeIdColumnMap, dictionary));
}
private static bool UntypedNullAwareIsStructurallyEqual(TypeUsage fromType, TypeUsage toType)
{
if (fromType == null)
{
return(SemanticResolver.UntypedNullAwareIsPromotableTo(fromType, toType));
}
return(TypeSemantics.IsStructurallyEqual(fromType, toType));
}
internal override bool IsEquivalent(Op other)
{
if (other.OpType == this.OpType)
{
return(TypeSemantics.IsStructurallyEqual(this.Type, other.Type));
}
return(false);
}
/// <summary>
/// Resolves <paramref name="argTypes"/> against the list of function signatures.
/// </summary>
/// <returns>Funciton metadata</returns>
internal static EdmFunction ResolveFunctionOverloads(IList <EdmFunction> functionsMetadata,
IList <TypeUsage> argTypes,
bool isGroupAggregateFunction,
out bool isAmbiguous)
{
return(ResolveFunctionOverloads(
functionsMetadata,
argTypes,
(edmFunction) => edmFunction.Parameters,
(functionParameter) => functionParameter.TypeUsage,
(functionParameter) => functionParameter.Mode,
(argType) => TypeSemantics.FlattenType(argType),
(paramType, argType) => TypeSemantics.FlattenType(paramType),
(fromType, toType) => TypeSemantics.IsPromotableTo(fromType, toType),
(fromType, toType) => TypeSemantics.IsStructurallyEqual(fromType, toType),
isGroupAggregateFunction,
out isAmbiguous));
}
internal static EdmFunction ResolveFunctionOverloads(
IList <EdmFunction> functionsMetadata,
IList <TypeUsage> argTypes,
bool isGroupAggregateFunction,
out bool isAmbiguous)
{
return(FunctionOverloadResolver.ResolveFunctionOverloads <EdmFunction, FunctionParameter>(functionsMetadata, argTypes, (Func <EdmFunction, IList <FunctionParameter> >)(edmFunction => (IList <FunctionParameter>)edmFunction.Parameters), (Func <FunctionParameter, TypeUsage>)(functionParameter => functionParameter.TypeUsage), (Func <FunctionParameter, ParameterMode>)(functionParameter => functionParameter.Mode), (Func <TypeUsage, IEnumerable <TypeUsage> >)(argType => TypeSemantics.FlattenType(argType)), (Func <TypeUsage, TypeUsage, IEnumerable <TypeUsage> >)((paramType, argType) => TypeSemantics.FlattenType(paramType)), (Func <TypeUsage, TypeUsage, bool>)((fromType, toType) => TypeSemantics.IsPromotableTo(fromType, toType)), (Func <TypeUsage, TypeUsage, bool>)((fromType, toType) => TypeSemantics.IsStructurallyEqual(fromType, toType)), isGroupAggregateFunction, out isAmbiguous));
}
public bool Equals(TypeUsage x, TypeUsage y)
{
return(TypeSemantics.IsStructurallyEqual(x, y));
}
/// <summary>
/// Two scalarOps are equivalent (usually) if their OpTypes and types are the
/// same. Obviously, their arguments need to be equivalent as well - but that's
/// checked elsewhere
/// </summary>
/// <param name="other"> The other Op to compare against </param>
/// <returns> true, if the Ops are indeed equivalent </returns>
internal override bool IsEquivalent(Op other)
{
return(other.OpType == OpType && TypeSemantics.IsStructurallyEqual(Type, other.Type));
}