protected override Provider VisitPredicateJoin(PredicateJoinProvider provider)
{
List <int> leftMapping;
List <int> rightMapping;
SplitMappings(provider, out leftMapping, out rightMapping);
leftMapping.AddRange(mappingsGatherer.Gather(provider.Predicate,
provider.Predicate.Parameters[0]));
rightMapping.AddRange(mappingsGatherer.Gather(provider.Predicate,
provider.Predicate.Parameters[1]));
var newLeftProvider = provider.Left;
var newRightProvider = provider.Right;
VisitJoin(ref leftMapping, ref newLeftProvider, ref rightMapping, ref newRightProvider);
mappings[provider] = MergeMappings(provider.Left, leftMapping, rightMapping);
var predicate = TranslateJoinPredicate(leftMapping, rightMapping, provider.Predicate);
if (newLeftProvider == provider.Left && newRightProvider == provider.Right &&
provider.Predicate == predicate)
{
return(provider);
}
return(new PredicateJoinProvider(newLeftProvider, newRightProvider, (Expression <Func <Tuple, Tuple, bool> >)predicate, provider.JoinType));
}
/// <inheritdoc/>
protected override SqlProvider VisitPredicateJoin(PredicateJoinProvider provider)
{
var left = Compile(provider.Left);
var right = Compile(provider.Right);
var leftShouldUseReference = ShouldUseQueryReference(provider, left);
var leftTable = leftShouldUseReference
? left.PermanentReference
: left.Request.Statement.From;
var leftColumns = leftShouldUseReference
? leftTable.Columns.Cast <SqlColumn>()
: left.Request.Statement.Columns;
var leftExpressions = leftShouldUseReference
? leftTable.Columns.Cast <SqlExpression>().ToList()
: ExtractColumnExpressions(left.Request.Statement);
var rightShouldUseReference = ShouldUseQueryReference(provider, right);
var rightTable = rightShouldUseReference
? right.PermanentReference
: right.Request.Statement.From;
var rightColumns = rightShouldUseReference
? rightTable.Columns.Cast <SqlColumn>()
: right.Request.Statement.Columns;
var rightExpressions = rightShouldUseReference
? rightTable.Columns.Cast <SqlExpression>().ToList()
: ExtractColumnExpressions(right.Request.Statement);
var joinType = provider.JoinType == JoinType.LeftOuter ? SqlJoinType.LeftOuterJoin : SqlJoinType.InnerJoin;
var result = ProcessExpression(provider.Predicate, leftExpressions, rightExpressions);
var joinExpression = result.First;
var bindings = result.Second;
var joinedTable = SqlDml.Join(
joinType,
leftTable,
rightTable,
leftColumns.ToList(),
rightColumns.ToList(),
joinExpression);
var query = SqlDml.Select(joinedTable);
if (!leftShouldUseReference)
{
query.Where &= left.Request.Statement.Where;
}
if (!rightShouldUseReference)
{
query.Where &= right.Request.Statement.Where;
}
query.Columns.AddRange(joinedTable.AliasedColumns);
return(CreateProvider(query, bindings, provider, left, right));
}
protected override Provider VisitPredicateJoin(PredicateJoinProvider provider)
{
var left = VisitCompilable(provider.Left);
var leftOrder = sortOrder;
var right = VisitCompilable(provider.Right);
var rightOrder = sortOrder;
var result = left == provider.Left && right == provider.Right
? provider
: new PredicateJoinProvider(left, right, provider.Predicate, provider.JoinType);
sortOrder = ComputeBinaryOrder(provider, leftOrder, rightOrder);
return(result);
}
protected override Provider VisitPredicateJoin(PredicateJoinProvider provider)
{
CompilableProvider left;
CompilableProvider right;
VisitBinaryProvider(provider, out left, out right);
if (provider.JoinType == JoinType.LeftOuter)
{
EnsureAbsenceOfApplyProviderRequiringConversion();
}
if (left != provider.Left || right != provider.Right)
{
return(new PredicateJoinProvider(left, right, provider.Predicate, provider.JoinType));
}
return(provider);
}
/// <summary> /// Compiles <see cref="PredicateJoinProvider"/>. /// </summary> /// <param name="provider">Join provider.</param> protected abstract TResult VisitPredicateJoin(PredicateJoinProvider provider);
