private InnerJoinExpression( TableExpressionBase table, SqlExpression joinPredicate, IEnumerable <IAnnotation>?annotations) : base(table, joinPredicate, annotations) { }
private Expression BuildColumnExpression( IReadOnlyCollection <Expression> projections, TableExpressionBase tableExpression, IProperty property) { Check.NotNull(property, nameof(property)); if (projections.Count == 0) { return(new ColumnExpression( _queryCompilationContext.GetColumnName(property), property, tableExpression)); } var matchingColumnExpression = projections .OfType <AliasExpression>() .Last(p => p.TryGetColumnExpression()?.Property == property); return(new ColumnExpression( matchingColumnExpression.Alias ?? matchingColumnExpression.TryGetColumnExpression().Name, property, tableExpression)); }
internal ColumnExpression(ProjectionExpression subqueryProjection, TableExpressionBase table) : this( subqueryProjection.Alias, table, subqueryProjection.Type, subqueryProjection.Expression.TypeMapping, IsNullableProjection(subqueryProjection)) { }
private static void LiftOrderBy( SelectExpression innerJoinSelectExpression, SelectExpression targetSelectExpression, TableExpressionBase innerJoinExpression) { var needOrderingChanges = innerJoinSelectExpression.OrderBy .Any(x => x.Expression is SelectExpression || x.Expression.IsAliasWithColumnExpression() || x.Expression.IsAliasWithSelectExpression()); var orderings = innerJoinSelectExpression.OrderBy.ToList(); if (needOrderingChanges) { innerJoinSelectExpression.ClearOrderBy(); } foreach (var ordering in orderings) { var orderingExpression = ordering.Expression; var aliasExpression = ordering.Expression as AliasExpression; if (aliasExpression?.Alias != null) { var columnExpression = aliasExpression.TryGetColumnExpression(); if (columnExpression != null) { orderingExpression = new ColumnExpression( aliasExpression.Alias, columnExpression.Property, columnExpression.Table); } } var index = orderingExpression is SelectExpression ? innerJoinSelectExpression.AddAliasToProjection(innerJoinSelectExpression.Alias + "_" + innerJoinSelectExpression.Projection.Count, orderingExpression) : innerJoinSelectExpression.AddToProjection(orderingExpression); var expression = innerJoinSelectExpression.Projection[index]; if (needOrderingChanges) { innerJoinSelectExpression.AddToOrderBy(new Ordering(expression.TryGetColumnExpression() ?? expression, ordering.OrderingDirection)); } var newExpression = targetSelectExpression.UpdateColumnExpression(expression, innerJoinExpression); targetSelectExpression.AddToOrderBy(new Ordering(newExpression, ordering.OrderingDirection)); } if ((innerJoinSelectExpression.Limit == null) && (innerJoinSelectExpression.Offset == null)) { innerJoinSelectExpression.ClearOrderBy(); } }
private Expression TryParseExpression(TableExpressionBase table, IEntityType entityType, ICollection <Expression> expressions) { var expression = expressions.First(); var visitor = new PrivateParseExpressionVisitor(table, entityType); return(visitor.Visit(expression)); }
private Expression BuildColumnExpression( IReadOnlyCollection <Expression> projections, TableExpressionBase tableExpression, IProperty property, IQuerySource querySource) { Check.NotNull(property, nameof(property)); if (projections.Count == 0) { return(new ColumnExpression( _relationalAnnotationProvider.For(property).ColumnName, property, tableExpression)); } var aliasExpressions = projections .OfType <AliasExpression>() .Where(p => p.TryGetColumnExpression()?.Property == property) .ToList(); var aliasExpression = aliasExpressions.Count == 1 ? aliasExpressions[0] : aliasExpressions.Last(ae => ae.TryGetColumnExpression().Table.QuerySource == querySource); return(new ColumnExpression( aliasExpression.Alias ?? aliasExpression.TryGetColumnExpression().Name, property, tableExpression)); }
/// <summary> /// Creates a new instance of the <see cref="PredicateJoinExpressionBase" /> class. /// </summary> /// <param name="table">A table source to join with.</param> /// <param name="joinPredicate">A predicate to use for the join.</param> /// <param name="annotations">A collection of annotations associated with this expression.</param> protected PredicateJoinExpressionBase( TableExpressionBase table, SqlExpression joinPredicate, IEnumerable <IAnnotation>?annotations) : base(table, annotations) { JoinPredicate = joinPredicate; }
public EntityProjectionExpression([NotNull] IEntityType entityType, [NotNull] TableExpressionBase innerTable, bool nullable) { Check.NotNull(entityType, nameof(entityType)); Check.NotNull(innerTable, nameof(innerTable)); EntityType = entityType; _innerTable = innerTable; _nullable = nullable; }
protected override TableExpressionBase Visit(TableExpressionBase tableExpressionBase) { if (tableExpressionBase is TemporalTableExpression) { return(tableExpressionBase); } return(base.Visit(tableExpressionBase)); }
protected override TableExpressionBase Visit([NotNull] TableExpressionBase tableExpressionBase) { switch (tableExpressionBase) { case SingleRowTableExpression singleRowTableExpression: return(singleRowTableExpression); default: return(base.Visit(tableExpressionBase)); } }
private Expression BuildJoinEqualityExpression( INavigation navigation, TableExpressionBase targetTableExpression, TableExpressionBase joinExpression, IQuerySource querySource) { Expression joinPredicateExpression = null; var targetTableProjections = ExtractProjections(targetTableExpression).ToList(); var joinTableProjections = ExtractProjections(joinExpression).ToList(); for (var i = 0; i < navigation.ForeignKey.Properties.Count; i++) { var principalKeyProperty = navigation.ForeignKey.PrincipalKey.Properties[i]; var foreignKeyProperty = navigation.ForeignKey.Properties[i]; var foreignKeyColumnExpression = BuildColumnExpression( targetTableProjections, targetTableExpression, foreignKeyProperty, querySource); var primaryKeyColumnExpression = BuildColumnExpression( joinTableProjections, joinExpression, principalKeyProperty, querySource); var primaryKeyExpression = primaryKeyColumnExpression; if (foreignKeyColumnExpression.Type != primaryKeyExpression.Type) { if (foreignKeyColumnExpression.Type.IsNullableType() && !primaryKeyExpression.Type.IsNullableType()) { primaryKeyExpression = Expression.Convert(primaryKeyExpression, foreignKeyColumnExpression.Type); } else if (primaryKeyExpression.Type.IsNullableType() && !foreignKeyColumnExpression.Type.IsNullableType()) { foreignKeyColumnExpression = Expression.Convert(foreignKeyColumnExpression, primaryKeyColumnExpression.Type); } } var equalExpression = Expression.Equal(foreignKeyColumnExpression, primaryKeyExpression); joinPredicateExpression = joinPredicateExpression == null ? equalExpression : Expression.AndAlso(joinPredicateExpression, equalExpression); } return(joinPredicateExpression); }
private static IEnumerable <Expression> ExtractProjections(TableExpressionBase tableExpression) { var selectExpression = tableExpression as SelectExpression; if (selectExpression != null) { return(selectExpression.Projection.ToList()); } var joinExpression = tableExpression as JoinExpressionBase; return(joinExpression != null ? ExtractProjections(joinExpression.TableExpression) : Enumerable.Empty <Expression>()); }
public override void AddTable(TableExpressionBase tableExpression) { if (UseAsOf && tableExpression is TableExpression te) { base.AddTable(new AsOfTableExpression(AsOf, te.Table, te.Schema, te.Alias, te.QuerySource)); } else if (UseBetween && tableExpression is TableExpression tableExpr) { base.AddTable(new BetweenTableExpression(StartTime, EndTime, tableExpr.Table, tableExpr.Schema, tableExpr.Alias, tableExpr.QuerySource)); } else { base.AddTable(tableExpression); } }
private Expression BuildJoinEqualityExpression( INavigation navigation, IReadOnlyList <IProperty> primaryKeyProperties, TableExpressionBase targetTableExpression, TableExpressionBase joinExpression) { Expression joinPredicateExpression = null; for (var i = 0; i < navigation.ForeignKey.Properties.Count; i++) { var primaryKeyProperty = primaryKeyProperties[i]; var foreignKeyProperty = navigation.ForeignKey.Properties[i]; var foreignKeyColumnExpression = new ColumnExpression( QueryCompilationContext.GetColumnName(foreignKeyProperty), foreignKeyProperty, targetTableExpression); Expression primaryKeyColumnExpression = new ColumnExpression( QueryCompilationContext.GetColumnName(primaryKeyProperty), primaryKeyProperty, joinExpression); if (foreignKeyColumnExpression.Type != primaryKeyColumnExpression.Type) { if (foreignKeyColumnExpression.Type.IsNullableType() && !primaryKeyColumnExpression.Type.IsNullableType()) { primaryKeyColumnExpression = Expression.Convert(primaryKeyColumnExpression, foreignKeyColumnExpression.Type); } } var equalExpression = Expression.Equal(foreignKeyColumnExpression, primaryKeyColumnExpression); joinPredicateExpression = joinPredicateExpression == null ? equalExpression : Expression.AndAlso(joinPredicateExpression, equalExpression); } return(joinPredicateExpression); }
private static void LiftOrderBy( SelectExpression innerJoinSelectExpression, SelectExpression targetSelectExpression, TableExpressionBase innerJoinExpression) { foreach (var ordering in innerJoinSelectExpression.OrderBy) { var orderingExpression = ordering.Expression; var aliasExpression = ordering.Expression as AliasExpression; if (aliasExpression?.Alias != null) { var columnExpression = aliasExpression.TryGetColumnExpression(); if (columnExpression != null) { orderingExpression = new ColumnExpression( aliasExpression.Alias, columnExpression.Property, columnExpression.Table); } } var index = innerJoinSelectExpression.AddToProjection(orderingExpression); var expression = innerJoinSelectExpression.Projection[index]; var newExpression = targetSelectExpression.UpdateColumnExpression(expression, innerJoinExpression); targetSelectExpression.AddToOrderBy(new Ordering(newExpression, ordering.OrderingDirection)); } if (innerJoinSelectExpression.Limit == null && innerJoinSelectExpression.Offset == null) { innerJoinSelectExpression.ClearOrderBy(); } }
//from ef core private static bool IsNonComposedSetOperation(SelectExpression selectExpression) { if (selectExpression.Offset == null && selectExpression.Limit == null && !selectExpression.IsDistinct && selectExpression.Predicate == null && selectExpression.Having == null && selectExpression.Orderings.Count == 0 && selectExpression.GroupBy.Count == 0 && selectExpression.Tables.Count == 1) { TableExpressionBase tableExpressionBase = selectExpression.Tables[0]; SetOperationBase setOperation = tableExpressionBase as SetOperationBase; if (setOperation != null && selectExpression.Projection.Count == setOperation.Source1.Projection.Count) { return(selectExpression.Projection.Select(delegate(ProjectionExpression pe, int index) { ColumnExpression columnExpression = pe.Expression as ColumnExpression; if (columnExpression != null && string.Equals(columnExpression.Table.Alias, setOperation.Alias, StringComparison.OrdinalIgnoreCase)) { return string.Equals(columnExpression.Name, setOperation.Source1.Projection[index].Alias, StringComparison.OrdinalIgnoreCase); } return false; }).All((bool e) => e)); } } return(false); }
private Expression BuildColumnExpression( IReadOnlyCollection <ColumnExpression> projections, TableExpressionBase tableExpression, IProperty property) { if (projections.Count == 0) { return(new ColumnExpression( _queryCompilationContext.GetColumnName(property), property, tableExpression)); } var matchingColumnExpression = projections.Single(p => p.Property == property); return(new ColumnExpression( matchingColumnExpression.Alias ?? matchingColumnExpression.Name, property, tableExpression)); }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> // Issue#11266 This method is being used by provider code. Do not break. public static ColumnReferenceExpression LiftExpressionFromSubquery( [NotNull] this Expression expression, [NotNull] TableExpressionBase table) { Check.NotNull(expression, nameof(expression)); Check.NotNull(table, nameof(table)); switch (expression) { case ColumnExpression columnExpression: return(new ColumnReferenceExpression(columnExpression, table)); case AliasExpression aliasExpression: return(new ColumnReferenceExpression(aliasExpression, table)); case ColumnReferenceExpression columnReferenceExpression: return(new ColumnReferenceExpression(columnReferenceExpression, table)); } Debug.Fail("LiftExpressionFromSubquery was called on incorrect expression type."); return(null); }
private List <TableExpressionBase> ExtractTableExpressions(TableExpressionBase tableExpressionBase) { if (tableExpressionBase is JoinExpressionBase joinExpression) { tableExpressionBase = joinExpression.Table; } if (tableExpressionBase is TableExpression tableExpression) { return(new List <TableExpressionBase> { tableExpression }); } if (tableExpressionBase is SelectExpression selectExpression) { var result = new List <TableExpressionBase>(); foreach (var table in selectExpression.Tables) { result.AddRange(ExtractTableExpressions(table)); } return(result); } if (tableExpressionBase is SetOperationBase setOperationBase) { var result = new List <TableExpressionBase>(); result.AddRange(ExtractTableExpressions(setOperationBase.Source1)); result.AddRange(ExtractTableExpressions(setOperationBase.Source2)); return(result); } throw new InvalidOperationException("Unsupported table expression base type."); }
protected JoinExpressionBase(TableExpressionBase table) : base("") { Table = table; }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> protected override TableExpressionBase Visit(TableExpressionBase tableExpressionBase) { return(tableExpressionBase is TemporalTableExpression temporalTableExpression ? temporalTableExpression : base.Visit(tableExpressionBase)); }
/// <summary> /// Creates a new expression that is like this one, but using the supplied children. If all of the children are the same, it will /// return this expression. /// </summary> /// <param name="table">The <see cref="JoinExpressionBase.Table" /> property of the result.</param> /// <param name="joinPredicate">The <see cref="PredicateJoinExpressionBase.JoinPredicate" /> property of the result.</param> /// <returns>This expression if no children changed, or an expression with the updated children.</returns> public virtual InnerJoinExpression Update(TableExpressionBase table, SqlExpression joinPredicate) => table != Table || joinPredicate != JoinPredicate ? new InnerJoinExpression(table, joinPredicate, GetAnnotations()) : this;
public EntityProjectionExpression(IEntityType entityType, TableExpressionBase innerTable, bool nullable) { EntityType = entityType; _innerTable = innerTable; _nullable = nullable; }
/// <summary> /// Creates a new expression that is like this one, but using the supplied children. If all of the children are the same, it will /// return this expression. /// </summary> /// <param name="table">The <see cref="JoinExpressionBase.Table" /> property of the result.</param> /// <returns>This expression if no children changed, or an expression with the updated children.</returns> public virtual OuterApplyExpression Update(TableExpressionBase table) => table != Table ? new OuterApplyExpression(table, GetAnnotations()) : this;
/// <summary> /// Creates a new instance of the <see cref="OuterApplyExpression" /> class. /// </summary> /// <param name="table">A table source to OUTER APPLY with.</param> public OuterApplyExpression(TableExpressionBase table) : this(table, annotations : null) { }
/// <summary> /// Creates a new expression that is like this one, but using the supplied children. If all of the children are the same, it will /// return this expression. /// </summary> /// <param name="table">The <see cref="JoinExpressionBase.Table" /> property of the result.</param> /// <returns>This expression if no children changed, or an expression with the updated children.</returns> public virtual CrossApplyExpression Update(TableExpressionBase table) => table != Table ? new CrossApplyExpression(table) : this;
/// <summary> /// Creates a new instance of the <see cref="CrossApplyExpression" /> class. /// </summary> /// <param name="table">A table source to CROSS APPLY with.</param> public CrossApplyExpression(TableExpressionBase table) : base(table) { }
private OuterApplyExpression(TableExpressionBase table, IEnumerable <IAnnotation>?annotations) : base(table, annotations) { }
/// <summary> /// Creates a new instance of the <see cref="CrossJoinExpression" /> class. /// </summary> /// <param name="table">A table source to CROSS JOIN with.</param> public CrossJoinExpression(TableExpressionBase table) : base(table) { }
public EntityProjectionExpression([NotNull] IEntityType entityType, [NotNull] TableExpressionBase innerTable, bool nullable) { throw new NotSupportedException(); }