public override Expression Remap(int offset, Dictionary <Expression, Expression> processedExpressions) { if (!CanRemap) { return(this); } Expression result; if (processedExpressions.TryGetValue(this, out result)) { return(result); } var fields = Fields .Select(f => f.Remap(offset, processedExpressions)) .Cast <PersistentFieldExpression>() .ToList(); var keyExpression = (KeyExpression)Key.Remap(offset, processedExpressions); var entity = Entity != null ? (EntityExpression)Entity.Remap(offset, processedExpressions) : null; result = new EntityFieldExpression(PersistentType, Field, fields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty); if (Owner == null) { return(result); } processedExpressions.Add(this, result); Owner.Remap(offset, processedExpressions); return(result); }
public override Expression BindParameter(ParameterExpression parameter, Dictionary <Expression, Expression> processedExpressions) { Expression result; if (processedExpressions.TryGetValue(this, out result)) { return(result); } var fields = Fields .Select(f => f.BindParameter(parameter, processedExpressions)) .Cast <PersistentFieldExpression>() .ToList(); var keyExpression = (KeyExpression)Key.BindParameter(parameter, processedExpressions); var entity = Entity != null ? (EntityExpression)Entity.BindParameter(parameter, processedExpressions) : null; result = new EntityFieldExpression(PersistentType, Field, fields, Mapping, keyExpression, entity, parameter, DefaultIfEmpty); if (Owner == null) { return(result); } processedExpressions.Add(this, result); Owner.BindParameter(parameter, processedExpressions); return(result); }
public override Expression Remap(int offset, Dictionary <Expression, Expression> processedExpressions) { if (!CanRemap) { return(this); } if (processedExpressions.TryGetValue(this, out var result)) { return(result); } var newFields = new List <PersistentFieldExpression>(fields.Count); foreach (var field in fields) { // Do not convert to LINQ. We want to avoid a closure creation here. newFields.Add((PersistentFieldExpression)field.Remap(offset, processedExpressions)); } var keyExpression = (KeyExpression)Key.Remap(offset, processedExpressions); var entity = (EntityExpression)Entity?.Remap(offset, processedExpressions); result = new EntityFieldExpression( PersistentType, Field, newFields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty); if (Owner == null) { return(result); } processedExpressions.Add(this, result); Owner.Remap(offset, processedExpressions); return(result); }
public override Expression Remap(int[] map, Dictionary <Expression, Expression> processedExpressions) { if (!CanRemap) { return(this); } if (processedExpressions.TryGetValue(this, out var result)) { return(result); } var newFields = new List <PersistentFieldExpression>(fields.Count); using (new SkipOwnerCheckScope()) { foreach (var field in fields) { // Do not convert to LINQ. We want to avoid a closure creation here. var mappedField = (PersistentFieldExpression)field.Remap(map, processedExpressions); if (mappedField == null) { continue; } newFields.Add(mappedField); } } if (newFields.Count != Fields.Count) { processedExpressions.Add(this, null); return(null); } var keyExpression = (KeyExpression)Key.Remap(map, processedExpressions); EntityExpression entity; using (new SkipOwnerCheckScope()) { entity = (EntityExpression)Entity?.Remap(map, processedExpressions); } result = new EntityFieldExpression( PersistentType, Field, newFields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty); if (Owner == null) { return(result); } processedExpressions.Add(this, result); Owner.Remap(map, processedExpressions); return(result); }
// ReSharper disable RedundantNameQualifier private static PersistentFieldExpression BuildNestedFieldExpression(FieldInfo nestedField, int offset) { if (nestedField.IsPrimitive) { return(FieldExpression.CreateField(nestedField, offset)); } if (nestedField.IsStructure) { return(StructureFieldExpression.CreateStructure(nestedField, offset)); } if (nestedField.IsEntity) { return(EntityFieldExpression.CreateEntityField(nestedField, offset)); } throw new NotSupportedException(string.Format(Strings.ExNestedFieldXIsNotSupported, nestedField.Attributes)); }
public override Expression Remap(int[] map, Dictionary <Expression, Expression> processedExpressions) { if (!CanRemap) { return(this); } Expression result; if (processedExpressions.TryGetValue(this, out result)) { return(result); } List <PersistentFieldExpression> fields; using (new SkipOwnerCheckScope()) { fields = Fields .Select(f => f.Remap(map, processedExpressions)) .Where(f => f != null) .Cast <PersistentFieldExpression>() .ToList(); } if (fields.Count != Fields.Count) { processedExpressions.Add(this, null); return(null); } var keyExpression = (KeyExpression)Key.Remap(map, processedExpressions); EntityExpression entity; using (new SkipOwnerCheckScope()) entity = Entity != null ? (EntityExpression)Entity.Remap(map, processedExpressions) : null; result = new EntityFieldExpression(PersistentType, Field, fields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty); if (Owner == null) { return(result); } processedExpressions.Add(this, result); Owner.Remap(map, processedExpressions); 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>())); }