public virtual Expression Remap(int[] map, Dictionary <Expression, Expression> processedExpressions)
{
// Don't check CanRemap - Remap always.
// Save Subquery parameter
var remapContext = RemapScope.CurrentContext;
bool isTopSubquery = remapContext.SubqueryParameterExpression == null;
if (isTopSubquery)
{
remapContext.SubqueryParameterExpression = OuterParameter;
}
// Remap recordset parameters
var visitor = new ApplyParameterAccessVisitor(ApplyParameter, (mc, index) => Call(mc.Object, mc.Method, Constant(map.IndexOf(index))));
var providerVisitor = new CompilableProviderVisitor((provider, expression) => visitor.Visit(expression));
var newDataSource = providerVisitor.VisitCompilable(ProjectionExpression.ItemProjector.DataSource);
// Remap Field parametrized parameters
var item = GenericExpressionVisitor <IMappedExpression> .Process(ProjectionExpression.ItemProjector.Item, mapped => {
var parametrizedExpression = mapped as ParameterizedExpression;
if (parametrizedExpression != null && parametrizedExpression.OuterParameter == OuterParameter)
{
return(mapped.Remap(map, new Dictionary <Expression, Expression>()));
}
return((Expression)mapped);
});
var newItemProjector = new ItemProjectorExpression(item, newDataSource, ProjectionExpression.ItemProjector.Context);
var newProjectionExpression = new ProjectionExpression(ProjectionExpression.Type, newItemProjector, ProjectionExpression.TupleParameterBindings);
var result = new SubQueryExpression(Type, OuterParameter, DefaultIfEmpty, newProjectionExpression, ApplyParameter, ExtendedType);
processedExpressions.Add(this, result);
// Restore subquery parameter
if (isTopSubquery)
{
remapContext.SubqueryParameterExpression = null;
}
return(result);
}
/// <inheritdoc/>
protected override SqlProvider VisitApply(ApplyProvider provider)
{
bool processViaCrossApply;
switch (provider.SequenceType)
{
case ApplySequenceType.All:
// apply is required
if (!providerInfo.Supports(ProviderFeatures.Apply))
{
throw new NotSupportedException();
}
processViaCrossApply = true;
break;
case ApplySequenceType.First:
case ApplySequenceType.FirstOrDefault:
// apply is prefered but is not required
processViaCrossApply = providerInfo.Supports(ProviderFeatures.Apply);
break;
case ApplySequenceType.Single:
case ApplySequenceType.SingleOrDefault:
// apply is not allowed
processViaCrossApply = false;
break;
default:
throw new ArgumentOutOfRangeException();
}
var left = Compile(provider.Left);
bool shouldUseQueryReference;
var sourceSelect = left.Request.Statement;
if (processViaCrossApply)
{
shouldUseQueryReference = ShouldUseQueryReference(provider, left);
}
else
{
var calculatedColumnIndexes = sourceSelect.Columns
.Select((c, i) => IsCalculatedColumn(c) ? i : -1)
.Where(i => i >= 0)
.ToList();
var groupByIsUsed = sourceSelect.GroupBy.Count > 0;
var usedOuterColumns = new List <int>();
var visitor = new ApplyParameterAccessVisitor(provider.ApplyParameter, (mc, index) => {
usedOuterColumns.Add(index);
return(mc);
});
var providerVisitor = new CompilableProviderVisitor((p, e) => visitor.Visit(e));
providerVisitor.VisitCompilable(provider.Right);
shouldUseQueryReference = usedOuterColumns.Any(calculatedColumnIndexes.Contains) ||
groupByIsUsed ||
provider.Left.Type.In(ProviderType.Store, ProviderType.Include) ||
left.Header.Columns.Count != left.Request.Statement.Columns.Count;
}
var binding = OuterReferences.Add(
provider.ApplyParameter, new Pair <SqlProvider, bool>(left, shouldUseQueryReference));
using (binding) {
var right = Compile(provider.Right);
var query = processViaCrossApply
? ProcessApplyViaCrossApply(provider, left, right)
: ProcessApplyViaSubqueries(provider, left, right, shouldUseQueryReference);
return(CreateProvider(query, provider, left, right));
}
}