protected override Expression VisitSelect(SqlSelectExpression select)
{
// Only consider aggregates in these locations
if (this.hasAggregate)
{
return select;
}
this.Visit(select.Where);
if (this.hasAggregate)
{
return select;
}
this.VisitExpressionList(select.OrderBy);
if (this.hasAggregate)
{
return select;
}
this.VisitColumnDeclarations(select.Columns);
return select;
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
if (selectExpression.Skip != null)
{
var rowNumber = new SqlFunctionCallExpression(typeof(int), "ROW_NUMBER");
var over = new SqlOverExpression(rowNumber, selectExpression.OrderBy ?? new ReadOnlyList<Expression>(new [] { new SqlOrderByExpression(OrderType.Ascending, selectExpression.Columns[0].Expression) }));
var additionalColumn = new SqlColumnDeclaration(RowColumnName, over);
var newAlias = selectExpression.Alias + "INNER";
var innerColumns = new ReadOnlyList<SqlColumnDeclaration>(selectExpression.Columns.Select(c => c).Concat(new[] { additionalColumn }));
var innerSelect = new SqlSelectExpression(selectExpression.Type, newAlias, innerColumns, selectExpression.From, selectExpression.Where, null, selectExpression.GroupBy, selectExpression.Distinct, null, null, selectExpression.ForUpdate);
var outerColumns = selectExpression.Columns.Select(c => new SqlColumnDeclaration(c.Name, new SqlColumnExpression(c.Expression.Type, newAlias, c.Name)));
Expression rowPredicate = Expression.GreaterThan(new SqlColumnExpression(typeof(int), newAlias, additionalColumn.Name), selectExpression.Skip);
if (selectExpression.Take != null && !(selectExpression.Take is SqlTakeAllValueExpression))
{
rowPredicate = Expression.And
(
rowPredicate,
Expression.LessThanOrEqual(new SqlColumnExpression(typeof(int), newAlias, additionalColumn.Name), Expression.Add(selectExpression.Skip, selectExpression.Take))
);
}
return new SqlSelectExpression(selectExpression.Type, selectExpression.Alias, outerColumns, innerSelect, rowPredicate, null, selectExpression.ForUpdate);
}
return base.VisitSelect(selectExpression);
}
internal static bool IsNameMapProjection(SqlSelectExpression select)
{
if (select.From is SqlTableExpression)
{
return false;
}
var fromSelect = select.From as SqlSelectExpression;
if (fromSelect == null || select.Columns.Count > fromSelect.Columns.Count)
{
return false;
}
var fromColumnNames = new HashSet<string>(fromSelect.Columns.Select(x => x.Name));
foreach (var t in @select.Columns)
{
var columnExpression = t.Expression as SqlColumnExpression;
if (columnExpression == null || !fromColumnNames.Contains(columnExpression.Name))
{
return false;
}
}
return true;
}
protected override void AppendLimit(SqlSelectExpression selectExpression)
{
if (selectExpression.Skip != null || selectExpression.Take != null)
{
if (selectExpression.Take != null)
{
this.Write(" LIMIT ");
Visit(selectExpression.Take);
this.Write(" ");
}
else
{
this.Write(" LIMIT -1 ");
}
if (selectExpression.Skip != null)
{
this.Write("OFFSET ");
Visit(selectExpression.Skip);
}
}
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
var from = selectExpression.From;
var where = Visit(selectExpression.Where);
var orderBy = selectExpression.OrderBy;
var groupBy = selectExpression.GroupBy;
var skip = selectExpression.Skip;
var take = selectExpression.Take;
var columns = selectExpression.Columns;
if (where != null)
{
if (where.NodeType == ExpressionType.Constant && where.Type == typeof(bool))
{
var value = (bool)((ConstantExpression)where).Value;
if (value)
{
where = null;
}
}
}
if (where != selectExpression.Where)
{
return new SqlSelectExpression(selectExpression.Type, selectExpression.Alias, columns, from, where, orderBy, groupBy, selectExpression.Distinct, skip, take, selectExpression.ForUpdate);
}
return base.VisitSelect(selectExpression);
}
protected override void AppendLimit(SqlSelectExpression selectExpression)
{
if (selectExpression.Skip != null && selectExpression.Take != null)
{
throw new InvalidOperationException("Skip/Take not supported");
}
}
internal static bool HasAggregates(SqlSelectExpression expression, bool ignoreInSubqueries)
{
var checker = new HasAggregateChecker(ignoreInSubqueries);
checker.Visit(expression);
return checker.hasAggregate;
}
protected override Expression VisitSelect(SqlSelectExpression expression)
{
this.hashCode ^= expression.Distinct ? 309065085 : 0;
this.hashCode ^= expression.ForUpdate ? -1548991485 : 0;
this.hashCode ^= expression.Reverse ? 1018104131 : 0;
this.hashCode ^= expression.Alias?.GetHashCode() ?? 0;
return base.VisitSelect(expression);
}
protected override Expression VisitSelect(SqlSelectExpression expression)
{
this.hashCode ^= expression.Distinct ? 309065085 : 0;
this.hashCode ^= expression.ForUpdate ? -1548991485 : 0;
this.hashCode ^= expression.Reverse ? 1018104131 : 0;
this.hashCode ^= expression.Alias?.GetHashCode() ?? 0;
return(base.VisitSelect(expression));
}
protected override Expression VisitUpdate(SqlUpdateExpression expression)
{
if (!expression.RequiresIdentityInsert)
{
return base.VisitUpdate(expression);
}
var tableName = ((SqlTableExpression)expression.Source).Name;
var typeDescriptor = this
.typeDescriptorProvider
.GetTypeDescriptors()
.Single(c => c.PersistedName == tableName);
var insertedColumns = expression
.Assignments
.OfType<SqlAssignExpression>()
.Select(c => new { name = ((SqlColumnExpression)c.Target).Name, value = c.Value, propertyDescriptor = typeDescriptor.GetPropertyDescriptorByColumnName(((SqlColumnExpression)c.Target).Name) })
.ToList();
var columnInfos = QueryBinder
.GetColumnInfos(this.typeDescriptorProvider, typeDescriptor.PersistedProperties.Where(c => insertedColumns.All(d => d.propertyDescriptor != c)))
.ToList();
var visitedUpdated = (SqlUpdateExpression)base.VisitUpdate(expression);
var selectIntoExpression = new SqlSelectExpression
(
typeof(void),
null,
columnInfos.Select
(
c => new SqlColumnDeclaration
(
null, new SqlColumnExpression(c.DefinitionProperty.PropertyType, null, c.GetColumnName())
)
)
.Concat(insertedColumns.Select(d => d.value.Type.GetUnwrappedNullableType() == typeof(bool) ? new SqlColumnDeclaration(d.name, new BitBooleanExpression(d.value)) : new SqlColumnDeclaration(d.name, d.value)))
.ToReadOnlyCollection(),
visitedUpdated.Source,
visitedUpdated.Where,
null, null, false, null, null, false, false, new SqlTableExpression("#TEMP")
);
var selectExpression = new SqlSelectExpression(typeof(void), null, null, selectIntoExpression.Into, null, null);
var insertExpression = new SqlInsertIntoExpression(visitedUpdated.Source, columnInfos.Select(c => c.GetColumnName()).Concat(insertedColumns.Select(c => c.name)).ToReadOnlyCollection(), null, selectExpression, null, true);
var deleteExpression = new SqlDeleteExpression(visitedUpdated.Source, visitedUpdated.Where);
var list = new List<Expression>
{
selectIntoExpression,
deleteExpression,
new SqlSetCommandExpression("IDENTITY_INSERT", visitedUpdated.Source, new SqlKeywordExpression("ON")),
insertExpression,
new SqlSetCommandExpression("IDENTITY_INSERT", visitedUpdated.Source, new SqlKeywordExpression("OFF")),
};
return new SqlStatementListExpression(list);
}
public SqlProjectionExpression(Type type, SqlSelectExpression select, Expression projector, LambdaExpression aggregator, bool isElementTableProjection, Expression defaultValue = null)
: base(type)
{
this.Select = select;
this.Projector = projector;
this.Aggregator = aggregator;
this.IsElementTableProjection = isElementTableProjection;
this.DefaultValue = defaultValue;
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
if (selectExpression.OrderBy != null)
{
return selectExpression.ChangeOrderBy(null);
}
return base.VisitSelect(selectExpression);
}
public SqlProjectionExpression(Type type, SqlSelectExpression select, Expression projector, LambdaExpression aggregator, bool isElementTableProjection, Expression defaultValue = null)
: base(type)
{
this.Select = select;
this.Projector = projector;
this.Aggregator = aggregator;
this.IsElementTableProjection = isElementTableProjection;
this.DefaultValue = defaultValue;
}
protected static SqlProjectionExpression UpdateProjection(SqlProjectionExpression projectionExpression, SqlSelectExpression select, Expression projector, LambdaExpression aggregator)
{
if (select != projectionExpression.Select || projector != projectionExpression.Projector || aggregator != projectionExpression.Aggregator)
{
return new SqlProjectionExpression(select, projector, aggregator, projectionExpression.IsElementTableProjection, projectionExpression.SelectFirstType, projectionExpression.DefaultValueExpression, projectionExpression.IsDefaultIfEmpty);
}
return projectionExpression;
}
protected override void AppendTop(SqlSelectExpression selectExpression)
{
if (selectExpression.Take != null && selectExpression.Skip == null)
{
this.Write("TOP(");
this.Visit(selectExpression.Take);
this.Write(") ");
}
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
selectNesting++;
var retval = base.VisitSelect(selectExpression);
selectNesting--;
return retval;
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
if (selectExpression.Columns.Count == 1
&& selectExpression.From.NodeType == (ExpressionType)SqlExpressionType.Select
&& selectExpression.Columns[0].Expression.NodeType == (ExpressionType)SqlExpressionType.Aggregate)
{
var from = (SqlSelectExpression)selectExpression.From;
var aggregateExpression = (SqlAggregateExpression)selectExpression.Columns[0].Expression;
if (from.Columns.Count > 1
|| aggregateExpression.IsDistinct
|| from.Distinct
|| from.Take != null
|| from.Skip != null
|| from.GroupBy != null
/* Don't fold a from with an orderby into the outer select if it has a count or other aggregate */
|| from.OrderBy != null && from.OrderBy.Count > 0 && SqlAggregateChecker.HasAggregates(selectExpression))
{
return base.VisitSelect(selectExpression);
}
var newColumns = new List<SqlColumnDeclaration>();
if (from.Columns.Count == 1)
{
foreach (var column in from.Columns)
{
if (column.Expression.NodeType != (ExpressionType)SqlExpressionType.Column)
{
return base.VisitSelect(selectExpression);
}
var newAggregate = new SqlAggregateExpression
(
aggregateExpression.Type,
aggregateExpression.AggregateType,
column.Expression,
aggregateExpression.IsDistinct
);
newColumns.Add(new SqlColumnDeclaration(column.Name, newAggregate));
}
}
else
{
newColumns.Add(selectExpression.Columns[0]);
}
var where = this.Visit(from.Where);
return from.ChangeWhereAndColumns(where, newColumns.ToReadOnlyList(), from.ForUpdate || selectExpression.ForUpdate);
}
return base.VisitSelect(selectExpression);
}
public SqlProjectionExpression(SqlSelectExpression select, Expression projector, LambdaExpression aggregator, bool isElementTableProjection, SelectFirstType selectFirstType, Expression defaultValueExpression, bool isDefaultIfEmpty)
: base(selectFirstType == SelectFirstType.None ? select.Type : select.Type.GetGenericArguments()[0])
{
this.Select = select;
this.Projector = projector;
this.Aggregator = aggregator;
this.SelectFirstType = selectFirstType;
this.DefaultValueExpression = defaultValueExpression;
this.IsElementTableProjection = isElementTableProjection;
this.IsDefaultIfEmpty = isDefaultIfEmpty;
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
if (this.selectsToRemove.Contains(select))
{
return this.Visit(select.From);
}
else
{
return base.VisitSelect(select);
}
}
private static bool IsRedudantSubquery(SqlSelectExpression select)
{
return (IsSimpleProjection(select) || IsNameMapProjection(select))
&& !select.Distinct
&& (select.Take == null)
&& (select.Skip == null)
&& select.Where == null
&& !select.Columns.Any(c => c.NoOptimise)
&& ((select.OrderBy?.Count ?? 0) == 0)
&& ((select.GroupBy?.Count ?? 0) == 0);
}
public SqlProjectionExpression(SqlSelectExpression select, Expression projector, LambdaExpression aggregator, bool isElementTableProjection, SelectFirstType selectFirstType, Expression defaultValueExpression, bool isDefaultIfEmpty)
: base(selectFirstType == SelectFirstType.None ? select.Type : select.Type.GetGenericArguments()[0])
{
this.Select = select;
this.Projector = projector;
this.Aggregator = aggregator;
this.SelectFirstType = selectFirstType;
this.DefaultValueExpression = defaultValueExpression;
this.IsElementTableProjection = isElementTableProjection;
this.IsDefaultIfEmpty = isDefaultIfEmpty;
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
if (selectExpression.GroupBy != null && selectExpression.GroupBy.Count == 1
&& selectExpression.GroupBy[0].NodeType == ExpressionType.New)
{
var groupBy = ((NewExpression)selectExpression.GroupBy[0]).Arguments;
return new SqlSelectExpression(selectExpression.Type, selectExpression.Alias, selectExpression.Columns.ToReadOnlyCollection(), selectExpression.From, selectExpression.Where, selectExpression.OrderBy.ToReadOnlyCollection(), groupBy.ToReadOnlyCollection(), selectExpression.Distinct, selectExpression.Skip, selectExpression.Take, selectExpression.ForUpdate);
}
return base.VisitSelect(selectExpression);
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
var columnRemoved = false;
select = (SqlSelectExpression)base.VisitSelect(select);
var columnsOrderedByName = select.Columns.OrderBy(c => c.Name).ToList();
var removedColumns = new BitArray(select.Columns.Count);
for (int i = 0, n = columnsOrderedByName.Count; i < n - 1; i++)
{
var icolumn = columnsOrderedByName[i];
var iNewColumnExpression = new SqlColumnExpression(icolumn.Expression.Type, select.Alias, icolumn.Name);
for (var j = i + 1; j < n; j++)
{
if (!removedColumns.Get(j))
{
var jcolumn = columnsOrderedByName[j];
if (IsSameExpression(icolumn.Expression, jcolumn.Expression))
{
// 'j' references should now be a reference to 'i'
var jNewColumnExpression = new SqlColumnExpression(jcolumn.Expression.Type, select.Alias, jcolumn.Name);
this.visitedColumns.Add(jNewColumnExpression, iNewColumnExpression);
removedColumns.Set(j, true);
columnRemoved = true;
}
}
}
}
if (columnRemoved)
{
var newColumnDeclarations = new List<SqlColumnDeclaration>();
for (int i = 0, n = columnsOrderedByName.Count; i < n; i++)
{
if (!removedColumns.Get(i))
{
newColumnDeclarations.Add(columnsOrderedByName[i]);
}
}
select = select.ChangeColumns(newColumnDeclarations);
}
return select;
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
var savedIsTopLevel = this.isTopLevel;
this.isTopLevel = false;
select = (SqlSelectExpression)base.VisitSelect(select);
// Attempt to merge subqueries that would have been removed by the above
// logic except for the existence of a where clause
while (CanMergeWithFrom(select))
{
var fromSelect = select.From.GetLeftMostSelect();
CanMergeWithFrom(select);
// remove the redundant subquery
select = SubqueryRemover.Remove(select, fromSelect);
// merge where expressions
var where = select.Where;
if (fromSelect.Where != null)
{
if (where != null)
{
where = Expression.And(fromSelect.Where, where);
}
else
{
where = fromSelect.Where;
}
}
var orderBy = select.OrderBy != null && select.OrderBy.Count > 0 ? select.OrderBy : fromSelect.OrderBy;
var groupBy = select.GroupBy != null && select.GroupBy.Count > 0 ? select.GroupBy : fromSelect.GroupBy;
var skip = select.Skip ?? fromSelect.Skip;
var take = select.Take ?? fromSelect.Take;
var isDistinct = select.Distinct || fromSelect.Distinct;
if (where != select.Where || orderBy != select.OrderBy || groupBy != select.GroupBy || isDistinct != select.Distinct || skip != select.Skip || take != select.Take)
{
select = new SqlSelectExpression(select.Type, select.Alias, select.Columns, select.From, where, orderBy, groupBy, isDistinct, skip, take, select.ForUpdate);
}
}
this.isTopLevel = savedIsTopLevel;
return select;
}
internal static bool IsSimpleProjection(SqlSelectExpression select)
{
foreach (var decl in select.Columns)
{
var col = decl.Expression as SqlColumnExpression;
if (col == null || decl.Name != col.Name)
{
return false;
}
}
return true;
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
select = (SqlSelectExpression)base.VisitSelect(select);
// Expand all purely redundant subqueries
var redundantQueries = RedundantSubqueryFinder.Find(select.From);
if (redundantQueries != null)
{
select = SubqueryRemover.Remove(select, redundantQueries);
}
return select;
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
var canHaveOrderBy = select.Take != null || select.Skip != null;
var hasGroupBy = select.GroupBy?.Count > 0;
var canReceiveOrderings = canHaveOrderBy && !hasGroupBy && !select.Distinct && !SqlAggregateChecker.HasAggregates(select);
this.outerCanReceiveOrderings &= canReceiveOrderings;
select = (SqlSelectExpression)base.VisitSelect(select);
var hasOrderBy = select.OrderBy?.Count > 0;
if (hasOrderBy)
{
this.PrependOrderings(select.OrderBy);
}
var columns = select.Columns;
var orderings = canReceiveOrderings ? this.gatheredOrderings : select.OrderBy;
var canPassOnOrderings = this.outerCanReceiveOrderings && !hasGroupBy && !select.Distinct;
if (this.gatheredOrderings != null)
{
if (canPassOnOrderings)
{
var producedAliases = SqlAliasesProduced.Gather(select.From);
var project = this.RebindOrderings(this.gatheredOrderings, select.Alias, producedAliases, select.Columns);
this.gatheredOrderings = null;
this.PrependOrderings(project.Orderings);
columns = project.Columns;
}
else
{
this.gatheredOrderings = null;
}
}
if (orderings != select.OrderBy || columns != select.Columns)
{
select = new SqlSelectExpression(select.Type, select.Alias, columns, select.From, select.Where, orderings, select.GroupBy, select.Distinct, select.Skip, select.Take, select.ForUpdate);
}
return select;
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
if (selectExpression.Skip != null)
{
var rowNumber = new SqlFunctionCallExpression(typeof(int), "ROW_NUMBER");
var oldAliases = (selectExpression.From as ISqlExposesAliases)?.Aliases;
var innerSelectWithRowAlias = selectExpression.Alias + "_ROW";
var cols = selectExpression.Columns.Select(c => new SqlColumnDeclaration(c.Name, new SqlColumnExpression(c.Expression.Type, selectExpression.Alias, c.Name))).ToList();
var over = new SqlOverExpression(rowNumber, selectExpression.OrderBy?.ToReadOnlyCollection() ?? cols.Select(c => new SqlOrderByExpression(OrderType.Ascending, c.Expression)).ToReadOnlyCollection());
if (oldAliases != null)
{
over = (SqlOverExpression)AliasReferenceReplacer.Replace(over, oldAliases.Contains, selectExpression.Alias);
}
var rowColumn = new SqlColumnDeclaration(RowColumnName, over);
cols.Add(rowColumn);
var innerSelectWithRowColumns = cols.ToReadOnlyCollection();
var innerSelectWithRow = new SqlSelectExpression(selectExpression.Type, innerSelectWithRowAlias, innerSelectWithRowColumns, this.Visit(selectExpression.ChangeOrderBy(null).ChangeSkipTake(null, null)), null, null, null, false, null, null, false);
var outerColumns = selectExpression.Columns.Select(c => new SqlColumnDeclaration(c.Name, new SqlColumnExpression(c.Expression.Type, innerSelectWithRowAlias, c.Name)));
Expression rowPredicate = Expression.GreaterThan(new SqlColumnExpression(typeof(int), innerSelectWithRowAlias, rowColumn.Name), selectExpression.Skip);
if (selectExpression.Take != null && !(selectExpression.Take is SqlTakeAllValueExpression))
{
rowPredicate = Expression.And
(
rowPredicate,
Expression.LessThanOrEqual(new SqlColumnExpression(typeof(int), innerSelectWithRowAlias, rowColumn.Name), Expression.Add(selectExpression.Skip, selectExpression.Take))
);
}
var retval = new SqlSelectExpression(selectExpression.Type, selectExpression.Alias, outerColumns.ToReadOnlyCollection(), innerSelectWithRow, rowPredicate, null, null, selectExpression.Distinct, null, null, selectExpression.ForUpdate, selectExpression.Reverse, selectExpression.Into);
return retval;
}
return base.VisitSelect(selectExpression);
}
protected virtual Expression VisitSelect(SqlSelectExpression selectExpression)
{
var from = VisitSource(selectExpression.From);
var where = Visit(selectExpression.Where);
var orderBy = this.VisitExpressionList(selectExpression.OrderBy);
var groupBy = this.VisitExpressionList(selectExpression.GroupBy);
var skip = this.Visit(selectExpression.Skip);
var take = this.Visit(selectExpression.Take);
var columns = VisitColumnDeclarations(selectExpression.Columns);
if (from != selectExpression.From || where != selectExpression.Where || columns != selectExpression.Columns || orderBy != selectExpression.OrderBy || groupBy != selectExpression.GroupBy || take != selectExpression.Take || skip != selectExpression.Skip)
{
return(new SqlSelectExpression(selectExpression.Type, selectExpression.Alias, columns, from, where, orderBy, groupBy, selectExpression.Distinct, skip, take, selectExpression.ForUpdate));
}
return(selectExpression);
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
var saveIsOuterMostSelect = this.isOuterMostSelect;
try
{
this.isOuterMostSelect = false;
if (!saveIsOuterMostSelect && selectExpression.OrderBy != null && selectExpression.Take == null)
{
return selectExpression.ChangeSkipTake(selectExpression.Skip, new SqlTakeAllValueExpression());
}
return base.VisitSelect(selectExpression);
}
finally
{
this.isOuterMostSelect = saveIsOuterMostSelect;
}
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
var savedWhere = this.currentWhere;
try
{
this.currentWhere = select.Where;
var result = (SqlSelectExpression)base.VisitSelect(select);
if (this.currentWhere != result.Where)
{
return result.ChangeWhere(this.currentWhere);
}
return result;
}
finally
{
this.currentWhere = savedWhere;
}
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
select = (SqlSelectExpression)base.VisitSelect(select);
if (this.aggregateSubqueriesBySelectAlias.Contains(select.Alias))
{
var columnsIncludingAggregates = new List<SqlColumnDeclaration>(select.Columns);
foreach (var aggregateSubqueryExpression in this.aggregateSubqueriesBySelectAlias[select.Alias])
{
var name = "__AGGR" + columnsIncludingAggregates.Count;
var columnDeclaration = new SqlColumnDeclaration(name, aggregateSubqueryExpression.AggregateInGroupSelect);
this.aggregateSubqueryInstances.Add(aggregateSubqueryExpression, new SqlColumnExpression(aggregateSubqueryExpression.Type, aggregateSubqueryExpression.GroupByAlias, name));
columnsIncludingAggregates.Add(columnDeclaration);
}
return new SqlSelectExpression(select.Type, select.Alias, columnsIncludingAggregates.ToReadOnlyCollection(), select.From, select.Where, select.OrderBy, select.GroupBy, select.Distinct, select.Skip, select.Take, select.ForUpdate);
}
return select;
}
protected static SqlProjectionExpression UpdateProjection(SqlProjectionExpression projectionExpression, SqlSelectExpression select, Expression projector, LambdaExpression aggregator)
{
if (select != projectionExpression.Select || projector != projectionExpression.Projector || aggregator != projectionExpression.Aggregator)
{
return(new SqlProjectionExpression(select, projector, aggregator, projectionExpression.IsElementTableProjection, projectionExpression.SelectFirstType, projectionExpression.DefaultValueExpression, projectionExpression.IsDefaultIfEmpty));
}
return(projectionExpression);
}
protected override Expression VisitSelect(SqlSelectExpression select)
{
this.aliases.Add(select.Alias);
return select;
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
if (this.currentProjection == null || this.currentProjection.Select != selectExpression)
{
return base.VisitSelect(selectExpression);
}
var objectType = selectExpression.Type.GetSequenceElementType();
if (!objectType.IsDataAccessObjectType())
{
return base.VisitSelect(selectExpression);
}
var aliasesAndTypes = SqlAliasTypeCollector.Collect(selectExpression)
.ToDictionary(c => c.Item1, c => typeDescriptorProvider.GetTypeDescriptor(c.Item2.GetSequenceElementType() ?? c.Item2));
List<SqlOrderByExpression> orderBys = null;
var includeJoins = selectExpression.From.GetIncludeJoins().ToList();
List<SqlColumnExpression> leftMostColumns = null;
foreach (var includeJoin in includeJoins)
{
var equalsExpression = (BinaryExpression)SqlExpressionFinder.FindFirst(includeJoin, c => c.NodeType == ExpressionType.Equal);
var left = (SqlColumnExpression)equalsExpression.Left;
var right = (SqlColumnExpression)equalsExpression.Right;
var leftType = aliasesAndTypes[left.SelectAlias];
var rightType = aliasesAndTypes[right.SelectAlias];
if (leftMostColumns == null)
{
var typeDescriptor = this.typeDescriptorProvider.GetTypeDescriptor(objectType);
var primaryKeyColumns = new HashSet<string>(QueryBinder.GetPrimaryKeyColumnInfos(this.typeDescriptorProvider, typeDescriptor).Select(c => c.ColumnName));
leftMostColumns = primaryKeyColumns
.Select(c => new SqlColumnExpression(objectType, left.SelectAlias, c))
.ToList();
}
var rightProperty = rightType.GetPropertyDescriptorByColumnName(right.Name);
var leftProperty = rightProperty.RelationshipInfo?.TargetProperty ?? leftType.GetPropertyDescriptorByColumnName(left.Name);
if (leftProperty.PropertyType.GetGenericTypeDefinitionOrNull() == typeof(RelatedDataAccessObjects<>))
{
var rightColumns = SqlExpressionFinder.FindAll(includeJoin, c => c.NodeType == (ExpressionType)SqlExpressionType.Column && ((SqlColumnExpression)c).SelectAlias == right.SelectAlias);
var leftColumns = SqlExpressionFinder.FindAll(includeJoin, c => c.NodeType == (ExpressionType)SqlExpressionType.Column && ((SqlColumnExpression)c).SelectAlias == left.SelectAlias);
if (orderBys == null)
{
orderBys = new List<SqlOrderByExpression>();
if (selectExpression.OrderBy?.Count > 0)
{
orderBys.AddRange(selectExpression.OrderBy);
orderBys.AddRange(leftMostColumns.Select(c => new SqlOrderByExpression(OrderType.Ascending, c)));
}
}
orderBys.AddRange(rightColumns.Select(c => new SqlOrderByExpression(OrderType.Ascending, c)));
orderBys.AddRange(leftColumns.Select(c => new SqlOrderByExpression(OrderType.Ascending, c)));
}
}
return selectExpression.ChangeOrderBy(orderBys?.Distinct(SqlExpressionEqualityComparer<SqlOrderByExpression>.Default) ?? selectExpression.OrderBy);
}
public SqlProjectionExpression(SqlSelectExpression select, Expression projector, LambdaExpression aggregator, bool isElementTableProjection)
: this(select, projector, aggregator, isElementTableProjection, SelectFirstType.None, null, false)
{
}
public SqlScalarExpression(Type type, SqlSelectExpression select)
: base(type, select)
{
}
public SqlProjectionExpression ChangeSelect(SqlSelectExpression select)
{
return(new SqlProjectionExpression(this.Type, select, this.Projector, this.Aggregator, this.IsElementTableProjection, this.DefaultValue));
}
public SqlProjectionExpression(SqlSelectExpression select, Expression projector, LambdaExpression aggregator)
: this(select, projector, aggregator, false)
{
}
public SqlProjectionExpression(SqlSelectExpression select, Expression projector, LambdaExpression aggregator, bool isElementTableProjection, Expression defaultValue = null)
: this(select.Type, select, projector, aggregator, isElementTableProjection, defaultValue)
{
}
public virtual SqlScalarExpression ChangeSelect(SqlSelectExpression select)
{
return(new SqlScalarExpression(this.Type, select));
}
public SqlProjectionExpression(SqlSelectExpression select, Expression projector, LambdaExpression aggregator, Expression defaultValue = null)
: this(select.Type, select, projector, aggregator, false, defaultValue)
{
}
public SqlProjectionExpression(SqlSelectExpression select, Expression projector)
: this(select, projector, null)
{
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
return(base.VisitSelect(selectExpression));
}
public SqlSubqueryExpression(Type type, SqlSelectExpression select)
: base(type)
{
this.Select = select;
}
protected override Expression VisitSelect(SqlSelectExpression selectExpression)
{
SqlSelectExpression current;
if (!TryGetCurrent(selectExpression, out current))
{
return(selectExpression);
}
result = result && (current.Alias == selectExpression.Alias &&
current.Distinct == selectExpression.Distinct &&
current.ForUpdate == selectExpression.ForUpdate);
if (result)
{
currentObject = current.Skip;
this.Visit(current.Skip);
}
if (result)
{
currentObject = current.Take;
this.Visit(current.Take);
}
if (!result)
{
return(selectExpression);
}
if (result)
{
currentObject = current.Columns;
VisitColumnDeclarations(selectExpression.Columns);
currentObject = current;
}
if (result)
{
currentObject = current.Where;
Visit(selectExpression.Where);
currentObject = current;
}
if (result)
{
currentObject = current.GroupBy;
VisitExpressionList(selectExpression.GroupBy);
currentObject = current;
}
if (result)
{
currentObject = current.OrderBy;
this.VisitExpressionList(selectExpression.OrderBy);
currentObject = current;
}
return(selectExpression);
}