private static Expression GetUpdateExpressionByParameter(TranslateContext transContext, ParameterExpression parExp, LambdaExpression predicate, bool isAsync) { var metadata = EntityMetadataUnity.GetEntityMetadata(parExp.Type); var table = new TableExpression(new TableAlias(), metadata.TableName, parExp.Type); return(new UpdateCommandExpression(table, predicate.Body, GetUpdateArguments(transContext, table, parExp), isAsync)); }
internal static Expression GetUpdateExpression(TranslateContext transContext, Expression instance, LambdaExpression predicate, bool isAsync) { if (instance is ParameterExpression) { return(GetUpdateExpressionByParameter(transContext, (ParameterExpression)instance, predicate, isAsync)); } else if (instance is ConstantExpression) { return(GetUpdateExpressionByEntity(transContext, (ConstantExpression)instance, predicate, isAsync)); } var lambda = instance as LambdaExpression; if (lambda == null && instance.NodeType == ExpressionType.Quote) { lambda = ((UnaryExpression)instance).Operand as LambdaExpression; } if (lambda != null) { return(GetUpdateExpressionByCalculator(transContext, lambda, predicate, isAsync)); } return(null); }
internal static Expression GetInsertExpression(TranslateContext transContext, Expression instance, bool isAsync) { var entityType = instance.Type; Func <TableExpression, Expression, IEnumerable <ColumnAssignment> > func; if (instance is ParameterExpression) { func = new Func <TableExpression, Expression, IEnumerable <ColumnAssignment> >((t, exp) => GetInsertArguments(transContext, t, exp.As <ParameterExpression>())); } else if (instance is ConstantExpression) { func = new Func <TableExpression, Expression, IEnumerable <ColumnAssignment> >((t, exp) => GetInsertArguments(transContext, t, exp.As <ConstantExpression>().Value as IEntity)); } else { throw new ArgumentException("instance"); } var metadata = EntityMetadataUnity.GetEntityMetadata(entityType); var table = new TableExpression(new TableAlias(), metadata.TableName, entityType); return(new InsertCommandExpression(table, func(table, instance), isAsync) { WithAutoIncrement = !string.IsNullOrEmpty(transContext.SyntaxProvider.IdentitySelect) && HasAutoIncrement(instance.Type), WithGenerateValue = HasGenerateValue(instance.Type) }); }
private static IEnumerable <ColumnAssignment> GetUpdateArguments(TranslateContext transContext, TableExpression table, IEnumerable <MemberAssignment> bindings) { return(from m in bindings let property = PropertyUnity.GetProperty(table.Type, m.Member.Name) where property != null select new ColumnAssignment( (ColumnExpression)GetMemberExpression(transContext, table, property), m.Expression)); }
private static IEnumerable <ColumnAssignment> GetUpdateArguments(TranslateContext transContext, TableExpression table, IEntity entity) { var properties = GetModifiedProperties(entity).ToArray(); return(properties .Select(p => new ColumnAssignment( (ColumnExpression)GetMemberExpression(transContext, table, p), Expression.Constant(GetConvertableValue(entity, p)) )).ToList()); }
internal static Expression GetMemberExpression(TranslateContext transContext, Expression root, IProperty property) { if (property is RelationProperty relationProprety) { //所关联的实体类型 var relMetadata = EntityMetadataUnity.GetEntityMetadata(relationProprety.RelationalType); var projection = GetTableQuery(transContext, relMetadata, false, false); Expression parentExp = null, childExp = null; var ship = RelationshipUnity.GetRelationship(relationProprety); if (ship.ThisType != relationProprety.EntityType) { parentExp = projection.Projector; childExp = root; } else { parentExp = root; childExp = projection.Projector; } var where = ship.Keys.Select(r => GetMemberExpression(transContext, parentExp, r.ThisProperty).Equal(GetMemberExpression(transContext, childExp, r.OtherProperty))) .Aggregate(Expression.And); var newAlias = new TableAlias(); var pc = ColumnProjector.ProjectColumns(CanBeColumnExpression, projection.Projector, null, newAlias, projection.Select.Alias); var aggregator = GetAggregator(property.Type, typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type)); var result = new ProjectionExpression( new SelectExpression(newAlias, pc.Columns, projection.Select, where), pc.Projector, aggregator, projection.IsAsync, projection.IsNoTracking ); return(transContext.QueryPolicy.ApplyPolicy(result, property.Info.ReflectionInfo, ex => QueryBinder.Bind(transContext, ex))); } if (root is TableExpression table) { if (property is SubqueryProperty sqProperty) { return(new SubqueryColumnExpression(property.Type, table.Alias, property.Info.FieldName, sqProperty.Subquery)); } else if (property is ISavedProperty) { return(new ColumnExpression(property.Type, table.Alias, property.Name, property.Info)); } } return(QueryBinder.BindMember(root, property.Info.ReflectionInfo)); }
internal static Expression GetTypeProjection(TranslateContext transContext, Expression root, EntityMetadata entity) { var entityType = entity.EntityType; //获取实体中定义的所有依赖属性 var properties = PropertyUnity.GetLoadedProperties(entityType); var bindings = from p in properties let mbrExp = GetMemberExpression(transContext, root, p) where mbrExp != null select Expression.Bind(p.Info.ReflectionInfo, mbrExp); return(new EntityExpression(entity, Expression.MemberInit(Expression.New(entityType), bindings))); }
private static IEnumerable <ColumnAssignment> GetUpdateArguments(TranslateContext transContext, TableExpression table, ParameterExpression parExp) { IEnumerable <IProperty> properties = null; if (transContext.TemporaryBag != null) { properties = GetModifiedProperties(table.Type, transContext.TemporaryBag); } return(from p in properties select new ColumnAssignment( (ColumnExpression)GetMemberExpression(transContext, table, p), Expression.MakeMemberAccess(parExp, p.Info.ReflectionInfo))); }
/// <summary> /// 返回插入具体实体时的 <see cref="ColumnAssignment"/> 集合。 /// </summary> /// <param name="syntax"></param> /// <param name="table"></param> /// <param name="entity">具体的实体。</param> /// <returns></returns> private static IEnumerable <ColumnAssignment> GetInsertArguments(TranslateContext transContext, TableExpression table, IEntity entity) { var properties = GetModifiedProperties(entity); var assignments = properties .Select(p => new ColumnAssignment( (ColumnExpression)GetMemberExpression(transContext, table, p), Expression.Constant(GetConvertableValue(entity, p)) )).ToList(); assignments.AddRange(GetAssignmentsForPrimaryKeys(transContext, table, null, entity)); return(assignments); }
private static Expression GetUpdateExpressionByEntity(TranslateContext transContext, ConstantExpression constant, LambdaExpression predicate, bool isAsync) { var entity = constant.Value as IEntity; var metadata = EntityMetadataUnity.GetEntityMetadata(entity.EntityType); var table = new TableExpression(new TableAlias(), metadata.TableName, metadata.EntityType); Expression where = null; if (predicate != null) { var row = GetTypeProjection(transContext, table, metadata); where = DbExpressionReplacer.Replace(predicate.Body, predicate.Parameters[0], row); } return(new UpdateCommandExpression(table, where, GetUpdateArguments(transContext, table, entity), isAsync)); }
internal static ProjectionExpression GetTableQuery(TranslateContext transContext, EntityMetadata entity, bool isNoTracking, bool isAsync) { var tableAlias = new TableAlias(); var selectAlias = new TableAlias(); var entityType = entity.EntityType; var table = new TableExpression(tableAlias, entity.TableName, entityType); var projector = GetTypeProjection(transContext, table, entity); var pc = ColumnProjector.ProjectColumns(CanBeColumnExpression, projector, null, selectAlias, tableAlias); var proj = new ProjectionExpression( new SelectExpression(selectAlias, pc.Columns, table, null), pc.Projector, isAsync, isNoTracking ); return((ProjectionExpression)transContext.QueryPolicy.ApplyPolicy(proj, entityType, ex => QueryBinder.Bind(transContext, ex))); }
internal static LambdaExpression GetPrimaryKeyExpression(TranslateContext transContext, ParameterExpression parExp) { var metadata = EntityMetadataUnity.GetEntityMetadata(parExp.Type); var table = new TableExpression(new TableAlias(), metadata.TableName, parExp.Type); var primaryKeys = PropertyUnity.GetPrimaryProperties(parExp.Type); if (!primaryKeys.Any()) { throw new NotSupportedException(SR.GetString(SRKind.NotDefinedPrimaryKey)); } var where = primaryKeys.Select(p => GetMemberExpression(transContext, table, p).Equal(Expression.MakeMemberAccess(parExp, p.Info.ReflectionInfo))) .Aggregate(Expression.Add); return(Expression.Lambda(where, parExp)); }
private static IEnumerable <ColumnAssignment> GetAssignmentsForPrimaryKeys(TranslateContext transContext, TableExpression table, ParameterExpression parExp, IEntity entity) { var entityType = parExp != null ? parExp.Type : entity.EntityType; var assignments = new List <ColumnAssignment>(); foreach (var p in PropertyUnity.GetPrimaryProperties(entityType)) { var pvExp = GetPrimaryValueExpression(transContext.SyntaxProvider, table, parExp, entity, p); if (pvExp != null) { var columnExp = (ColumnExpression)GetMemberExpression(transContext, table, p); assignments.Add(new ColumnAssignment(columnExp, pvExp)); } } return(assignments); }
/// <summary> /// 返回插入具体实体时的 <see cref="ColumnAssignment"/> 集合。 /// </summary> /// <param name="syntax"></param> /// <param name="table"></param> /// <param name="parExp"></param> /// <returns></returns> private static IEnumerable <ColumnAssignment> GetInsertArguments(TranslateContext transContext, TableExpression table, ParameterExpression parExp) { IEnumerable <IProperty> properties = null; if (transContext.TemporaryBag != null) { properties = GetModifiedProperties(table.Type, transContext.TemporaryBag); } var assignments = properties .Select(p => new ColumnAssignment( (ColumnExpression)GetMemberExpression(transContext, table, p), Expression.MakeMemberAccess(parExp, p.Info.ReflectionInfo) )).ToList(); assignments.AddRange(GetAssignmentsForPrimaryKeys(transContext, table, parExp, null)); return(assignments); }
internal static Expression GetLogicalDeleteExpression(TranslateContext transContext, EntityMetadata metadata, LambdaExpression predicate, bool isAsync) { var table = new TableExpression(new TableAlias(), metadata.TableName, metadata.EntityType); Expression where = null; var delflag = (ColumnExpression)GetMemberExpression(transContext, table, metadata.DeleteProperty); var assignments = new List <ColumnAssignment> { new ColumnAssignment(delflag, Expression.Constant(true)) }; if (predicate != null) { var row = GetTypeProjection(transContext, table, metadata); where = DbExpressionReplacer.Replace(predicate.Body, predicate.Parameters[0], row); } return(new UpdateCommandExpression(table, where, assignments, isAsync)); }
internal static Expression GetDeleteExpression(TranslateContext transContext, EntityMetadata metadata, LambdaExpression predicate, bool replace, bool isAsync) { var table = new TableExpression(new TableAlias(), metadata.TableName, metadata.EntityType); Expression where = null; if (predicate != null) { if (replace) { var row = GetTypeProjection(transContext, table, metadata); where = DbExpressionReplacer.Replace(predicate.Body, predicate.Parameters[0], row); } else { where = predicate.Body; } } return(new DeleteCommandExpression(table, where, isAsync)); }
private static Expression GetUpdateExpressionByCalculator(TranslateContext transContext, LambdaExpression lambda, LambdaExpression predicate, bool isAsync) { var initExp = lambda.Body as MemberInitExpression; var newExp = initExp.NewExpression; var entityType = newExp.Type; var metadata = EntityMetadataUnity.GetEntityMetadata(entityType); var table = new TableExpression(new TableAlias(), metadata.TableName, metadata.EntityType); Expression where = null; var row = GetTypeProjection(transContext, table, metadata); if (predicate != null) { where = DbExpressionReplacer.Replace(predicate.Body, predicate.Parameters[0], row); } var bindings = initExp.Bindings.Cast <MemberAssignment>().Select(m => Expression.Bind(m.Member, DbExpressionReplacer.Replace(m.Expression, lambda.Parameters[0], row))); return(new UpdateCommandExpression(table, where, GetUpdateArguments(transContext, table, bindings), isAsync)); }
public override TranslatorBase CreateTranslator(TranslateContext transContext) { return(new PostgreSqlTranslator(transContext)); }
private Expression TranslateInternal(TranslateContext transContext, Expression expression) { var translation = QueryBinder.Bind(transContext, expression); translation = LogicalDeleteFlagRewriter.Rewrite(translation); translation = GlobalQueryPolicyRewriter.Rewrite(translation); translation = AggregateRewriter.Rewrite(translation); translation = UnusedColumnRemover.Remove(translation); translation = RedundantColumnRemover.Remove(translation); translation = RedundantSubqueryRemover.Remove(translation); translation = RedundantJoinRemover.Remove(translation); var bound = RelationshipBinder.Bind(transContext, translation); if (bound != translation) { translation = bound; translation = RedundantColumnRemover.Remove(translation); translation = RedundantJoinRemover.Remove(translation); } translation = ComparisonRewriter.Rewrite(translation); Expression rewritten; if (transContext.QueryPolicy != null) { rewritten = RelationshipIncluder.Include(transContext, translation); if (rewritten != translation) { translation = rewritten; translation = UnusedColumnRemover.Remove(translation); translation = RedundantColumnRemover.Remove(translation); translation = RedundantSubqueryRemover.Remove(translation); translation = RedundantJoinRemover.Remove(translation); } } rewritten = SingletonProjectionRewriter.Rewrite(translation); if (rewritten != translation) { translation = rewritten; translation = UnusedColumnRemover.Remove(translation); translation = RedundantColumnRemover.Remove(translation); translation = RedundantSubqueryRemover.Remove(translation); translation = RedundantJoinRemover.Remove(translation); } rewritten = ClientJoinedProjectionRewriter.Rewrite(translation); if (rewritten != translation) { translation = rewritten; translation = UnusedColumnRemover.Remove(translation); translation = RedundantColumnRemover.Remove(translation); translation = RedundantSubqueryRemover.Remove(translation); translation = RedundantJoinRemover.Remove(translation); } translation = BuildExpression(translation); return(translation); }
public override TranslatorBase CreateTranslator(TranslateContext transContext) { return(new FirebirdTranslator(transContext)); }
public static Expression Bind(TranslateContext transContext, Expression expression) { return(new RelationshipBinder { _transContext = transContext }.Visit(expression)); }
public SQLiteTranslator(TranslateContext transContext) : base(transContext) { }
public AccessTranslator(TranslateContext transContext) : base(transContext) { }
public FirebirdTranslator(TranslateContext transContext) : base(transContext) { }
public static Expression Include(TranslateContext transContext, Expression expression) { return(new RelationshipIncluder { _transContext = transContext, _policy = transContext.QueryPolicy }.Visit(expression)); }
public override TranslatorBase CreateTranslator(TranslateContext transContext) { return(new OracleTranslator(transContext)); }
public MySqlTranslator(TranslateContext transContext) : base(transContext) { }
/// <summary> /// 对 ELinq 表达式进行翻译,并返回翻译的结果。 /// </summary> /// <param name="transContext"></param> /// <param name="expression">一个 ELinq 表达式。</param> /// <returns></returns> public virtual Expression Translate(TranslateContext transContext, Expression expression) { expression = PartialEvaluator.Eval(expression, CanBeEvaluatedLocally); return(TranslateInternal(transContext, expression)); }
public OracleTranslator(TranslateContext transContext) : base(transContext) { }
/// <summary> /// 获取一个 ELinq 翻译器。 /// </summary> /// <param name="transContext"></param> /// <returns></returns> public abstract TranslatorBase CreateTranslator(TranslateContext transContext);