protected override Expression VisitStructureExpression(StructureExpression expression)
{
var tupleExpression = GetTupleExpression(expression);
var typeInfo = expression.PersistentType;
var tuplePrototype = typeInfo.TuplePrototype;
var mappingInfo = expression.Fields
.OfType <FieldExpression>()
.Where(f => f.ExtendedType == ExtendedExpressionType.Field)
.OrderBy(f => f.Field.MappingInfo.Offset)
.Select(f => new Pair <int>(f.Field.MappingInfo.Offset, f.Mapping.Offset))
.Distinct()
.ToArray();
int[] columnMap = MaterializationHelper.CreateSingleSourceMap(tuplePrototype.Count, mappingInfo);
var persistentTupleExpression = (Expression)Expression.Call(
BuildPersistentTupleMethod,
tupleExpression,
Expression.Constant(tuplePrototype),
Expression.Constant(columnMap));
return(Expression.Convert(
Expression.Call(
WellKnownMembers.CreateStructure,
Expression.Field(itemMaterializationContextParameter, ItemMaterializationContext.SessionFieldInfo),
Expression.Constant(expression.Type),
persistentTupleExpression),
expression.Type));
}
public void StructureTestWithChild()
{
var expr = new StructureExpression("foo", new StructureExpression("bar"));
var result = expr.Run();
Assert.Collection(result,
item =>
{
Assert.IsType <StructureResultTree>(item);
Assert.Equal("foo", (item as StructureResultTree).Name);
Assert.Collection((item as StructureResultTree).FirstChild,
item => {
Assert.IsType <StructureResultTree>(item);
Assert.Equal("bar", (item as StructureResultTree).Name);
Assert.Collection((item as StructureResultTree).FirstChild,
item => Assert.Null(item)
);
Assert.Collection((item as StructureResultTree).NextSibling,
item => Assert.Null(item)
);
}
);
Assert.Collection((item as StructureResultTree).NextSibling,
item => Assert.Null(item)
);
}
);
}
protected override Expression VisitStructureExpression(StructureExpression expression)
{
AddColumns(expression,
expression.Fields
.Where(fieldExpression => fieldExpression.ExtendedType == ExtendedExpressionType.Field)
.Select(fieldExpression => fieldExpression.Mapping.Offset));
return(expression);
}
private IMappedExpression BuildField(Type type, ref int index, ref IEnumerable <Type> types)
{
// if (type.IsOfGenericType(typeof (Ref<>))) {
// var entityType = type.GetGenericType(typeof (Ref<>)).GetGenericArguments()[0];
// TypeInfo typeInfo = model.Types[entityType];
// KeyInfo keyProviderInfo = typeInfo.KeyInfo;
// TupleDescriptor keyTupleDescriptor = keyProviderInfo.TupleDescriptor;
// KeyExpression entityExpression = KeyExpression.Create(typeInfo, index);
// index += keyTupleDescriptor.Count;
// types = types.Concat(keyTupleDescriptor);
// return Expression.Convert(entityExpression, type);
// }
if (type.IsSubclassOf(typeof(Entity)))
{
TypeInfo typeInfo = model.Types[type];
KeyInfo keyInfo = typeInfo.Key;
TupleDescriptor keyTupleDescriptor = keyInfo.TupleDescriptor;
IMappedExpression expression;
if (isKeyConverter)
{
expression = KeyExpression.Create(typeInfo, index);
}
else
{
var entityExpression = EntityExpression.Create(typeInfo, index, true);
entityExpression.IsNullable = true;
expression = entityExpression;
}
index += keyTupleDescriptor.Count;
types = types.Concat(keyTupleDescriptor);
return(expression);
}
if (type.IsSubclassOf(typeof(Structure)))
{
TypeInfo typeInfo = model.Types[type];
TupleDescriptor tupleDescriptor = typeInfo.TupleDescriptor;
var tupleSegment = new Segment <int>(index, tupleDescriptor.Count);
StructureExpression structureExpression = StructureExpression.CreateLocalCollectionStructure(typeInfo, tupleSegment);
index += tupleDescriptor.Count;
types = types.Concat(tupleDescriptor);
return(structureExpression);
}
if (TypeIsStorageMappable(type))
{
ColumnExpression columnExpression = ColumnExpression.Create(type, index);
types = types.AddOne(type);
index++;
return(columnExpression);
}
throw new NotSupportedException();
}
protected virtual Expression VisitStructureExpression(StructureExpression expression)
{
return(expression);
}
