public static EntityExpression Create(TypeInfo typeInfo, int offset, bool keyFieldsOnly)
{
if (!typeInfo.IsEntity && !typeInfo.IsInterface)
{
throw new ArgumentException(string.Format(Strings.ExPersistentTypeXIsNotEntityOrPersistentInterface, typeInfo.Name), "typeInfo");
}
var fields = new List <PersistentFieldExpression>();
var keyExpression = KeyExpression.Create(typeInfo, offset);
fields.Add(keyExpression);
var result = new EntityExpression(typeInfo, keyExpression, null, false);
if (keyFieldsOnly)
{
// Add key fields to field collection
var keyFieldClones = keyExpression
.KeyFields
.Select(kf => FieldExpression.CreateField(kf.Field, offset))
.Cast <PersistentFieldExpression>();
fields.AddRange(keyFieldClones);
}
else
{
foreach (var nestedField in typeInfo.Fields)
{
fields.Add(BuildNestedFieldExpression(nestedField, offset));
}
}
result.Fields = fields;
return(result);
}
public static EntityFieldExpression CreateEntityField(FieldInfo entityField, int offset)
{
if (!entityField.IsEntity)
{
throw new ArgumentException(string.Format(Strings.ExFieldXIsNotEntity, entityField.Name), nameof(entityField));
}
var entityType = entityField.ValueType;
var persistentType = entityField.ReflectedType.Model.Types[entityType];
var mappingInfo = entityField.MappingInfo;
var mapping = new Segment <int>(mappingInfo.Offset + offset, mappingInfo.Length);
var keyFields = persistentType.Key.Fields;
var keyExpression = KeyExpression.Create(persistentType, offset + mappingInfo.Offset);
var fields = new List <PersistentFieldExpression>(keyFields.Count + 1)
{
keyExpression
};
foreach (var field in keyFields)
{
// Do not convert to LINQ. We want to avoid a closure creation here.
fields.Add(BuildNestedFieldExpression(field, offset + mappingInfo.Offset));
}
return(new EntityFieldExpression(persistentType, entityField, fields, mapping, keyExpression, null, null, false));
}
// Constructors
private EntityExpression(
TypeInfo entityType,
KeyExpression key,
ParameterExpression parameterExpression,
bool defaultIfEmpty)
: base(ExtendedExpressionType.Entity, entityType.UnderlyingType, parameterExpression, defaultIfEmpty)
{
PersistentType = entityType;
Key = key;
}
// Having this code as a separate method helps to avoid closure allocation during RemoveOuterParameter call
// in case processedExpressions dictionary already contains a result.
private Expression RemoveOuterParameterWithNoCheck(Dictionary <Expression, Expression> processedExpressions)
{
FieldExpression RemoveOuterParameter(FieldExpression f)
=> (FieldExpression)f.RemoveOuterParameter(processedExpressions);
var fields = KeyFields.Select(RemoveOuterParameter).ToArray(KeyFields.Count);
var result = new KeyExpression(EntityType, fields, Mapping, UnderlyingProperty, null, DefaultIfEmpty);
processedExpressions.Add(this, result);
return(result);
}
// Having this code as a separate method helps to avoid closure allocation during Remap call
// in case processedExpressions dictionary already contains a result.
private Expression RemapWithNoCheck(int offset, Dictionary <Expression, Expression> processedExpressions)
{
var newMapping = new Segment <int>(Mapping.Offset + offset, Mapping.Length);
FieldExpression Remap(FieldExpression f) => (FieldExpression)f.Remap(offset, processedExpressions);
var fields = KeyFields.Select(Remap).ToArray(KeyFields.Count);
var result = new KeyExpression(EntityType, fields, newMapping, UnderlyingProperty, OuterParameter, DefaultIfEmpty);
processedExpressions.Add(this, result);
return(result);
}
// Constructors
private EntityFieldExpression(
TypeInfo persistentType,
FieldInfo field,
List <PersistentFieldExpression> fields,
Segment <int> mapping,
KeyExpression key,
EntityExpression entity,
ParameterExpression parameterExpression,
bool defaultIfEmpty)
: base(ExtendedExpressionType.EntityField, field, mapping, parameterExpression, defaultIfEmpty)
{
PersistentType = persistentType;
Fields = fields;
Key = key;
Entity = entity;
}
public override Expression BindParameter(ParameterExpression parameter, Dictionary <Expression, Expression> processedExpressions)
{
Expression value;
if (processedExpressions.TryGetValue(this, out value))
{
return(value);
}
var fields = KeyFields
.Select(f => (FieldExpression)f.BindParameter(parameter, processedExpressions))
.ToList()
.AsReadOnly();
var result = new KeyExpression(EntityType, fields, Mapping, UnderlyingProperty, parameter, DefaultIfEmpty);
processedExpressions.Add(this, result);
return(result);
}
public static EntityFieldExpression CreateEntityField(FieldInfo entityField, int offset)
{
if (!entityField.IsEntity)
{
throw new ArgumentException(string.Format(Strings.ExFieldXIsNotEntity, entityField.Name), "entityField");
}
var entityType = entityField.ValueType;
var persistentType = entityField.ReflectedType.Model.Types[entityType];
var mapping = new Segment <int>(entityField.MappingInfo.Offset + offset, entityField.MappingInfo.Length);
var fields = new List <PersistentFieldExpression>();
var keyExpression = KeyExpression.Create(persistentType, offset + entityField.MappingInfo.Offset);
fields.Add(keyExpression);
foreach (var keyField in persistentType.Fields.Where(f => f.IsPrimaryKey))
{
fields.Add(BuildNestedFieldExpression(keyField, offset + entityField.MappingInfo.Offset));
}
return(new EntityFieldExpression(persistentType, entityField, fields, mapping, keyExpression, null, null, false));
}
public override Expression Remap(int[] map, Dictionary <Expression, Expression> processedExpressions)
{
if (!CanRemap)
{
return(this);
}
Expression value;
if (processedExpressions.TryGetValue(this, out value))
{
return(value);
}
var segment = new Segment <int>(map.IndexOf(Mapping.Offset), Mapping.Length);
System.Collections.ObjectModel.ReadOnlyCollection <FieldExpression> fields;
using (new SkipOwnerCheckScope()) {
fields = KeyFields
.Select(f => f.Remap(map, processedExpressions))
.Where(f => f != null)
.Cast <FieldExpression>()
.ToList()
.AsReadOnly();
}
if (fields.Count != KeyFields.Count)
{
if (SkipOwnerCheckScope.IsActive)
{
processedExpressions.Add(this, null);
return(null);
}
throw Exceptions.InternalError(Strings.ExUnableToRemapKeyExpression, OrmLog.Instance);
}
var result = new KeyExpression(EntityType, fields, segment, UnderlyingProperty, OuterParameter, DefaultIfEmpty);
processedExpressions.Add(this, result);
return(result);
}
public static EntityExpression Create(EntityFieldExpression entityFieldExpression, int offset)
{
var typeInfo = entityFieldExpression.PersistentType;
var fields = new List <PersistentFieldExpression>();
var keyExpression = KeyExpression.Create(typeInfo, offset);
fields.Add(keyExpression);
foreach (var nestedField in typeInfo.Fields)
{
fields.Add(BuildNestedFieldExpression(nestedField, offset));
}
var result = new EntityExpression(typeInfo, keyExpression, null, entityFieldExpression.DefaultIfEmpty)
{
Fields = fields
};
if (entityFieldExpression.OuterParameter == null)
{
return(result);
}
return((EntityExpression)result.BindParameter(entityFieldExpression.OuterParameter, new Dictionary <Expression, Expression>()));
}
public override Expression Remap(int[] map, Dictionary <Expression, Expression> processedExpressions)
{
if (!CanRemap)
{
return(this);
}
if (processedExpressions.TryGetValue(this, out var value))
{
return(value);
}
var segment = new Segment <int>(map.IndexOf(Mapping.Offset), Mapping.Length);
var fields = new FieldExpression[KeyFields.Count];
using (new SkipOwnerCheckScope()) {
for (var index = 0; index < fields.Length; index++)
{
var field = (FieldExpression)KeyFields[index].Remap(map, processedExpressions);
if (field == null)
{
if (SkipOwnerCheckScope.IsActive)
{
processedExpressions.Add(this, null);
return(null);
}
throw Exceptions.InternalError(Strings.ExUnableToRemapKeyExpression, OrmLog.Instance);
}
fields[index] = field;
}
}
var result = new KeyExpression(EntityType, fields, segment, UnderlyingProperty, OuterParameter, DefaultIfEmpty);
processedExpressions.Add(this, result);
return(result);
}
public override Expression Remap(int offset, Dictionary <Expression, Expression> processedExpressions)
{
if (!CanRemap)
{
return(this);
}
Expression value;
if (processedExpressions.TryGetValue(this, out value))
{
return(value);
}
var mapping = new Segment <int>(Mapping.Offset + offset, Mapping.Length);
var fields = KeyFields
.Select(f => (FieldExpression)f.Remap(offset, processedExpressions))
.ToList()
.AsReadOnly();
var result = new KeyExpression(EntityType, fields, mapping, UnderlyingProperty, OuterParameter, DefaultIfEmpty);
processedExpressions.Add(this, result);
return(result);
}
