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); }