protected override Expression VisitEntity(EntityExpression entity)
{
var save = this.includeScope;
this.includeScope = new ScopedDictionary<MemberInfo,bool>(this.includeScope);
try
{
if (this.mapper.HasIncludedMembers(entity))
{
entity = this.mapper.IncludeMembers(
entity,
m =>
{
if (this.includeScope.ContainsKey(m))
{
return false;
}
if (this.policy.IsIncluded(m))
{
this.includeScope.Add(m, true);
return true;
}
return false;
});
}
return base.VisitEntity(entity);
}
finally
{
this.includeScope = save;
}
}
protected EntityExpression UpdateEntity(EntityExpression entity, Expression expression)
{
if (expression != entity.Expression)
{
return new EntityExpression(entity.Entity, expression);
}
return entity;
}
protected override Expression VisitEntity(EntityExpression entity)
{
if (this.entity == null) {
this.entity = entity.Entity;
}
return entity;
}
protected override Expression VisitMemberAccess(MemberExpression expr)
{
expr = (MemberExpression)base.VisitMemberAccess(expr);
IClassMetadata metaData = GetMetaData(expr.Type);
if (metaData != null)
{
string associationPath = AssociationPathForEntity(expr);
return(new EntityExpression(associationPath, expr.Member.Name, expr.Type, metaData, expr.Expression));
}
string memberName;
IType nhibernateType;
EntityExpression parentExpression = GetParentExpression(expr, out memberName, out nhibernateType);
if (parentExpression != null)
{
if (nhibernateType.IsCollectionType)
{
CollectionType collectionType = (CollectionType)nhibernateType;
IType nhElementType = collectionType.GetElementType((ISessionFactoryImplementor)_sessionFactory);
System.Type elementType = nhElementType.ReturnedClass;
IClassMetadata elementMetaData = GetMetaData(elementType);
EntityExpression elementExpression = null;
if (elementMetaData != null)
{
elementExpression = new EntityExpression(null, memberName, elementType, elementMetaData, null);
}
return(new CollectionAccessExpression(memberName, expr.Type, nhibernateType, parentExpression, elementExpression));
}
return(new PropertyAccessExpression(memberName, expr.Type, nhibernateType, parentExpression));
}
return(expr);
}
/// <summary>
/// Recreate the type projection with the additional members included
/// </summary>
/// <param name="entity"></param>
/// <param name="fnIsIncluded"></param>
/// <returns></returns>
public override EntityExpression IncludeMembers(EntityExpression entity, Func <MemberInfo, bool> fnIsIncluded)
{
var assignments = this.GetAssignments(entity.Expression).ToDictionary(ma => ma.Member.Name);
bool anyAdded = false;
foreach (var mi in this.mapping.GetMappedMembers(entity.Entity))
{
EntityAssignment ea;
bool okayToInclude = !assignments.TryGetValue(mi.Name, out ea);
if (okayToInclude && fnIsIncluded(mi))
{
ea = new EntityAssignment(mi, this.GetMemberExpression(entity.Expression, entity.Entity, mi));
assignments[mi.Name] = ea;
anyAdded = true;
}
}
if (anyAdded)
{
return(new EntityExpression(entity.Entity, this.BuildEntityExpression(entity.Entity, assignments.Values.ToList())));
}
return(entity);
}
protected override Expression VisitEntityExpression(EntityExpression e)
{
if (TreatEntityAsKey)
{
var keyExpression = (KeyExpression)e.Fields.First(f => f.ExtendedType == ExtendedExpressionType.Key);
AddColumns(e, keyExpression.Mapping.GetItems());
if (KeepTypeId)
{
AddColumns(e, e.Fields.First(f => f.Name == WellKnown.TypeIdFieldName).Mapping.GetItems());
}
}
else
{
AddColumns(e,
e.Fields
.OfType <FieldExpression>()
.Where(f => f.ExtendedType == ExtendedExpressionType.Field)
.Where(f => !(OmitLazyLoad && f.Field.IsLazyLoad))
.Select(f => f.Mapping.Offset));
}
return(e);
}
EntityExpression IncludeMembers(EntityExpression entity, Func <IMemberMapping, bool> fnIsIncluded)
{
var assignments = this.dbExpressionBuilder.GetAssignments(entity.Expression).ToDictionary(ma => ma.Member.Name);
bool anyAdded = false;
foreach (var mi in entity.Entity.Members)
{
EntityAssignment ea;
bool okayToInclude = !assignments.TryGetValue(mi.Member.Name, out ea) || IsNullRelationshipAssignment(entity.Entity, ea);
if (okayToInclude && fnIsIncluded(mi))
{
ea = new EntityAssignment(mi, dbExpressionBuilder.GetMemberExpression(entity.Expression, entity.Entity, mi));
assignments[mi.Member.Name] = ea;
anyAdded = true;
}
}
if (anyAdded)
{
return(new EntityExpression(entity.Entity, dbExpressionBuilder.BuildEntityExpression(entity.Entity, assignments.Values.ToList())));
}
return(entity);
}
protected override Expression VisitEntity(EntityExpression entity)
{
if (entity.Expression is MemberInitExpression init)
{
var save = includeScope;
includeScope = new ScopedDictionary <IProperty, bool>(this.includeScope);
List <MemberBinding> newBindings = null;
foreach (var property in PropertyUnity.GetRelatedProperties(entity.Type))
{
PropertyInfo member;
if (property is IPropertyLazy && policy.IsIncluded(member = property.Info.ReflectionInfo))
{
if (includeScope.ContainsKey(property))
{
throw new NotSupportedException(string.Format("Cannot include '{0}.{1}' recursively.", property.Type, property.Name));
}
var me = QueryUtility.GetMemberExpression(init, property);
if (newBindings == null)
{
newBindings = new List <MemberBinding>(init.Bindings);
}
newBindings.Add(Expression.Bind(member, me));
}
}
if (newBindings != null)
{
entity = new EntityExpression(entity.Metadata, Expression.MemberInit(init.NewExpression, newBindings), entity.IsNoTracking);
}
includeScope = save;
}
return(base.VisitEntity(entity));
}
private ICriterion GetExistsCriteria(MethodCallExpression expr)
{
EntityExpression rootEntity = EntityExpressionVisitor.FirstEntity(expr);
string propertyName = MemberNameVisitor.GetMemberName(rootCriteria, expr);
var rootEntityType = rootEntity.Type;
if (rootEntity.MetaData.HasProxy)
{
rootEntityType = rootEntity.MetaData.GetMappedClass(EntityMode.Poco);
}
DetachedCriteria query = DetachedCriteria.For(rootEntityType)
.SetProjection(Projections.Id())
.Add(Restrictions.IsNotEmpty(propertyName));
if (expr.Arguments.Count > 1)
{
var arg = (LambdaExpression)LinqUtil.StripQuotes(expr.Arguments[1]);
string alias = arg.Parameters[0].Name;
DetachedCriteria subquery = query.CreateCriteria(propertyName, alias);
var temp = new WhereArgumentsVisitor(subquery.Adapt(session), session);
temp.Visit(arg.Body);
foreach (ICriterion c in temp.CurrentCriterions)
{
subquery.Add(c);
}
}
string identifierName = rootEntity.GetAliasedIdentifierPropertyName();
return(Subqueries.PropertyIn(identifierName, query));
}
internal Expression GetProjectorExpression(Alias tableAlias, QueryBinder binder)
{
Expression id = GetIdExpression(tableAlias);
if (IsView)
{
var bindings = this.Fields.Values.Select(ef => new FieldBinding(ef.FieldInfo, ef.Field.GetExpression(tableAlias, binder, id))).ToReadOnly();
var hasValue = id == null?Expression.Constant(true) : SmartEqualizer.NotEqualNullable(id, Expression.Constant(null, id.Type.Nullify()));
return(new EmbeddedEntityExpression(this.Type, hasValue, bindings, null, this));
}
else
{
Schema.Current.AssertAllowed(Type, inUserInterface: false);
var bindings = GenerateBindings(tableAlias, binder, id);
var mixins = GenerateMixins(tableAlias, binder, id);
var result = new EntityExpression(this.Type, (PrimaryKeyExpression)id, tableAlias, bindings, mixins, avoidExpandOnRetrieving: false);
return(result);
}
}
private static void ResolveExpressionToNode(IEnumerable <ScalarExpression> scalarExpressions, FromEntityContext context)
{
foreach (ScalarExpression expression in scalarExpressions)
{
EntityExpression entityExpression = expression as EntityExpression;
if (entityExpression != null)
{
if (!context.ReportExpressionMap.ContainsKey(expression.ExpressionId))
{
throw new ArgumentException(string.Format("Expression '{0}' for entity ID '{1}' not found in report expression map",
expression.ExpressionId, expression.EntityId),
"scalarExpressions");
}
if (!context.ReportNodeMap.ContainsKey(context.ReportExpressionMap[expression.ExpressionId]))
{
throw new ArgumentException(string.Format("Node '{0}' not found in report node map for expression '{1}' for entity ID '{2}'. This may be caused by duplicate GUIDs in legacy report XML.",
context.ReportExpressionMap[expression.ExpressionId], expression.ExpressionId, expression.EntityId),
"scalarExpressions");
}
entityExpression.NodeId = context.ReportNodeMap[context.ReportExpressionMap[expression.ExpressionId]];
}
}
}
protected internal override Expression VisitEntity(EntityExpression entityExpr)
{
Expression id = Visit(NullifyColumn(entityExpr.ExternalId));
if (entityExpr.TableAlias == null)
{
return(Expression.Call(retriever, miRequest.MakeGenericMethod(entityExpr.Type), id));
}
ParameterExpression e = Expression.Parameter(entityExpr.Type, entityExpr.Type.Name.ToLower().Substring(0, 1));
var bindings =
entityExpr.Bindings !
.Where(a => !ReflectionTools.FieldEquals(EntityExpression.IdField, a.FieldInfo))
.Select(b =>
{
var field = Expression.Field(e, b.FieldInfo);
var value = b.Binding is ChildProjectionExpression cpe ?
VisitMListChildProjection(cpe, field) :
Convert(Visit(b.Binding), b.FieldInfo.FieldType);
return((Expression)Expression.Assign(field, value));
}).ToList();
if (entityExpr.Mixins != null)
{
var blocks = entityExpr.Mixins.Select(m => AssignMixin(e, m)).ToList();
bindings.AddRange(blocks);
}
LambdaExpression lambda = Expression.Lambda(typeof(Action <>).MakeGenericType(entityExpr.Type), Expression.Block(bindings), e);
return(Expression.Call(retriever, miCached.MakeGenericMethod(entityExpr.Type), id.Nullify(), lambda));
}
public SqlDeleteCommand(ulong entityModelID)
{
T = new EntityExpression(entityModelID, this);
}
protected override Expression VisitEntity(EntityExpression expr)
{
Type = BinaryCriterionType.Property;
return(expr);
}
protected virtual bool CompareEntity(EntityExpression x, EntityExpression y)
{
return x.Entity == y.Entity && this.Compare(x.Expression, y.Expression);
}
public override bool HasIncludedMembers(EntityExpression entity)
{
var policy = this.translator.Police.Policy;
foreach (var mi in this.mapping.GetMappedMembers(entity.Entity))
{
if (policy.IsIncluded(mi))
return true;
}
return false;
}
protected virtual bool CompareEntity(EntityExpression x, EntityExpression y)
{
return(x.Metadata == y.Metadata && Compare(x.Expression, y.Expression));
}
private bool CompareEntity(EntityExpression x, EntityExpression y)
{
return x.Entity == y.Entity && this.Compare(x.Expression, y.Expression);
}
protected internal override Expression VisitEntity(EntityExpression entity)
{
var newID = (PrimaryKeyExpression)Visit(entity.ExternalId);
return(new EntityExpression(entity.Type, newID, null, null, null, null, null, entity.AvoidExpandOnRetrieving)); // remove bindings
}
private DbCommand _loadEntitySetCmd; //仅用于加载EntitySet，防止重复生成
#region ====Ctor====
/// <summary>
/// 新建根级
/// </summary>
internal SqlIncluder(EntityExpression root)
{
Debug.Assert(Expression.IsNull(root.Owner));
Expression = root;
}
/// <summary> /// Recreate the type projection with the additional members included /// </summary> /// <param name="entity"></param> /// <param name="fnIsIncluded"></param> /// <returns></returns> public abstract EntityExpression IncludeMembers(EntityExpression entity, Func <MemberInfo, bool> fnIsIncluded);
protected virtual Expression VisitEntity(EntityExpression entity)
{
var exp = this.Visit(entity.Expression);
return this.UpdateEntity(entity, exp);
}
protected override Expression VisitEntity(EntityExpression entity)
{
var mbrInitExp = entity.Expression as MemberInitExpression;
return(ConvertEntityExpression(mbrInitExp));
}
public SqlQuery(ulong entityModelID)
{
T = new EntityExpression(entityModelID, this);
}
protected virtual Expression VisitEntityExpression(EntityExpression expression)
{
return(expression);
}
protected override Expression VisitEntityExpression(EntityExpression expression)
{
var tupleExpression = GetTupleExpression(expression);
return(CreateEntity(expression, tupleExpression));
}
public abstract ICollection <T> FindAll(EntityExpression <T> entityExpression, Func <T, bool> func = null);
public abstract T Find(EntityExpression <T> entityExpression, Func <T, bool> func = null);
public EntityArithmenticEpxression(ArithmeticOperator op, EntityExpression lhs, EntityExpression rhs)
{
Operator = op;
Lhs = lhs;
Rhs = rhs;
}
public MainService()
{
this.entityManager = EntityManager <T, IdT> .Instance;
EntityExpressions = new EntityExpression <T>();
}
/// <summary> /// Recreate the type projection with the additional members included /// </summary> /// <param name="entity"></param> /// <param name="fnIsIncluded"></param> /// <returns></returns> public abstract EntityExpression IncludeMembers(EntityExpression entity, Func<MemberInfo, bool> fnIsIncluded);
protected override Expression VisitEntityExpression(EntityExpression expression)
{
return(expression);
}
private static EntityExpression CombineEntity(EntityExpression a, EntityExpression b, Type type, Func <Expression, Expression, Expression> combiner)
{
return(new EntityExpression(type, new PrimaryKeyExpression(combiner(a.ExternalId.Value, b.ExternalId.Value)), null, null, null, null, null, a.AvoidExpandOnRetrieving || b.AvoidExpandOnRetrieving));
}
public override EntityExpression IncludeMembers(EntityExpression entity, Func<MemberInfo, bool> fnIsIncluded)
{
var assignments = this.GetAssignments(entity.Expression).ToDictionary(ma => ma.Member.Name);
bool anyAdded = false;
foreach (var mi in this.mapping.GetMappedMembers(entity.Entity))
{
EntityAssignment ea;
bool okayToInclude = !assignments.TryGetValue(mi.Name, out ea) || IsNullRelationshipAssignment(entity.Entity, ea);
if (okayToInclude && fnIsIncluded(mi))
{
ea = new EntityAssignment(mi, this.GetMemberExpression(entity.Expression, entity.Entity, mi));
assignments[mi.Name] = ea;
anyAdded = true;
}
}
if (anyAdded)
{
return new EntityExpression(entity.Entity, this.BuildEntityExpression(entity.Entity, assignments.Values.ToList()));
}
return entity;
}
protected override Expression VisitEntity(EntityExpression entity)
{
entityType = entity.Type;
return(this.Visit(entity.Expression));
}
public SqlUpdateCommand(ulong entityModelID)
{
UpdateItems = new List <Expression>();
T = new EntityExpression(entityModelID, this);
}
/// <summary> /// </summary> /// <returns></returns> public abstract bool HasIncludedMembers(EntityExpression entity);
protected virtual Expression VisitEntity(EntityExpression entity)
{
this.Visit(entity.Expression);
return entity;
}
protected override Expression VisitEntity(EntityExpression expr)
{
Type = BinaryCriterionType.Property;
Name = MemberNameVisitor.GetMemberName(rootCriteria, expr);
return(expr);
}
/// <summary> /// </summary> /// <returns></returns> public abstract bool HasIncludedMembers(EntityExpression entity);
protected override System.Linq.Expressions.Expression VisitEntityExpression(EntityExpression expression)
{
translator.EnsureEntityFieldsAreJoined(expression, itemProjectorExpression);
return(base.VisitEntityExpression(expression));
}
