public override void WrapPartitionedStream <TLeftKey, TRightKey>(
PartitionedStream <TLeftInput, TLeftKey> leftStream, PartitionedStream <TRightInput, TRightKey> rightStream,
IPartitionedStreamRecipient <TOutput> outputRecipient, bool preferStriping, QuerySettings settings)
{
Debug.Assert(rightStream.PartitionCount == leftStream.PartitionCount);
if (LeftChild.OutputOrdered)
{
if (ExchangeUtilities.IsWorseThan(LeftChild.OrdinalIndexState, OrdinalIndexState.Increasing))
{
PartitionedStream <TLeftInput, int> leftStreamInt =
QueryOperator <TLeftInput> .ExecuteAndCollectResults(leftStream, leftStream.PartitionCount, OutputOrdered, preferStriping, settings)
.GetPartitionedStream();
WrapPartitionedStreamHelper <int, TRightKey>(
ExchangeUtilities.HashRepartitionOrdered(leftStreamInt, _leftKeySelector, _keyComparer, null, settings.CancellationState.MergedCancellationToken),
rightStream, outputRecipient, settings.CancellationState.MergedCancellationToken);
}
else
{
WrapPartitionedStreamHelper <TLeftKey, TRightKey>(
ExchangeUtilities.HashRepartitionOrdered(leftStream, _leftKeySelector, _keyComparer, null, settings.CancellationState.MergedCancellationToken),
rightStream, outputRecipient, settings.CancellationState.MergedCancellationToken);
}
}
else
{
WrapPartitionedStreamHelper <int, TRightKey>(
ExchangeUtilities.HashRepartition(leftStream, _leftKeySelector, _keyComparer, null, settings.CancellationState.MergedCancellationToken),
rightStream, outputRecipient, settings.CancellationState.MergedCancellationToken);
}
}
private void InitOrderIndex()
{
OrdinalIndexState childIndexState = Child.OrdinalIndexState;
if (_indexedRightChildSelector != null)
{
// If this is an indexed SelectMany, we need the order keys to be Correct, so that we can pass them
// into the user delegate.
_prematureMerge = ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct);
_limitsParallelism = _prematureMerge && childIndexState != OrdinalIndexState.Shuffled;
}
else
{
if (OutputOrdered)
{
// If the output of this SelectMany is ordered, the input keys must be at least increasing. The
// SelectMany algorithm assumes that there will be no duplicate order keys, so if the order keys
// are Shuffled, we need to merge prematurely.
_prematureMerge = ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Increasing);
}
}
SetOrdinalIndexState(OrdinalIndexState.Increasing);
}
private void InitOrdinalIndexState()
{
if (ExchangeUtilities.IsWorseThan(Child.OrdinalIndexState, OrdinalIndexState.Correct))
{
m_prematureMerge = true;
}
SetOrdinalIndexState(OrdinalIndexState.Increasing);
}
private void InitOrdinalIndexState()
{
OrdinalIndexState childIndexState = Child.OrdinalIndexState;
if (ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct))
{
_prematureMerge = true;
_limitsParallelism = childIndexState != OrdinalIndexState.Shuffled;
}
SetOrdinalIndexState(OrdinalIndexState.Increasing);
}
private bool m_prematureMerge = false; // Whether to prematurely merge the input of this operator.
//---------------------------------------------------------------------------------------
// Constructs a new instance of the contains search operator.
//
// Arguments:
// child - the child tree to enumerate.
// index - index we are searching for.
//
internal ElementAtQueryOperator(IEnumerable <TSource> child, int index)
: base(child)
{
Contract.Assert(child != null, "child data source cannot be null");
Contract.Assert(index >= 0, "index can't be less than 0");
m_index = index;
if (ExchangeUtilities.IsWorseThan(Child.OrdinalIndexState, OrdinalIndexState.Correct))
{
m_prematureMerge = true;
}
}
private void InitOrdinalIndexState()
{
OrdinalIndexState indexState = Child.OrdinalIndexState;
if (ExchangeUtilities.IsWorseThan(Child.OrdinalIndexState, OrdinalIndexState.Correct))
{
m_prematureMerge = true;
indexState = OrdinalIndexState.Correct;
}
Contract.Assert(!ExchangeUtilities.IsWorseThan(indexState, OrdinalIndexState.Correct));
SetOrdinalIndexState(indexState);
}
public override void WrapPartitionedStream <TLeftKey, TRightKey>(
PartitionedStream <TSource, TLeftKey> leftStream, PartitionedStream <TSource, TRightKey> rightStream,
IPartitionedStreamRecipient <TSource> outputRecipient, bool preferStriping, QuerySettings settings)
{
OrdinalIndexState leftChildIndexState = leftStream.OrdinalIndexState;
int partitionCount = leftStream.PartitionCount;
PartitionedStream <TSource, int> leftStreamInc;
PartitionedStream <TSource, int> rightStreamInc;
// Prematurely merge the left results, if necessary
if (m_prematureMergeLeft)
{
ListQueryResults <TSource> leftStreamResults =
ExecuteAndCollectResults(leftStream, partitionCount, LeftChild.OutputOrdered, preferStriping, settings);
leftStreamInc = leftStreamResults.GetPartitionedStream();
}
else
{
Contract.Assert(!ExchangeUtilities.IsWorseThan(leftStream.OrdinalIndexState, OrdinalIndexState.Increasing));
leftStreamInc = (PartitionedStream <TSource, int>)(object) leftStream;
}
// Prematurely merge the right results, if necessary
if (m_prematureMergeRight)
{
ListQueryResults <TSource> rightStreamResults =
ExecuteAndCollectResults(rightStream, partitionCount, LeftChild.OutputOrdered, preferStriping, settings);
rightStreamInc = rightStreamResults.GetPartitionedStream();
}
else
{
Contract.Assert(!ExchangeUtilities.IsWorseThan(rightStream.OrdinalIndexState, OrdinalIndexState.Increasing));
rightStreamInc = (PartitionedStream <TSource, int>)(object) rightStream;
}
// Generate the shared data.
IComparer <ConcatKey <int, int> > comparer = ConcatKey <int, int> .MakeComparer(
leftStreamInc.KeyComparer, rightStreamInc.KeyComparer);
var outputStream = new PartitionedStream <TSource, ConcatKey <int, int> >(partitionCount, comparer, OrdinalIndexState);
for (int i = 0; i < partitionCount; i++)
{
outputStream[i] = new ConcatQueryOperatorEnumerator <int, int>(leftStreamInc[i], rightStreamInc[i]);
}
outputRecipient.Receive(outputStream);
}
private readonly bool _limitsParallelism = false; // Whether this operator limits parallelism
//---------------------------------------------------------------------------------------
// Constructs a new instance of the contains search operator.
//
// Arguments:
// child - the child tree to enumerate.
// index - index we are searching for.
//
internal ElementAtQueryOperator(IEnumerable <TSource> child, int index)
: base(child)
{
Contract.Assert(child != null, "child data source cannot be null");
Contract.Assert(index >= 0, "index can't be less than 0");
_index = index;
OrdinalIndexState childIndexState = Child.OrdinalIndexState;
if (ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct))
{
_prematureMerge = true;
_limitsParallelism = childIndexState != OrdinalIndexState.Shuffled;
}
}
private void InitOrdinalIndexState()
{
OrdinalIndexState childIndexState = Child.OrdinalIndexState;
OrdinalIndexState indexState = childIndexState;
if (ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct))
{
_prematureMerge = true;
_limitsParallelism = childIndexState != OrdinalIndexState.Shuffled;
indexState = OrdinalIndexState.Correct;
}
Debug.Assert(!ExchangeUtilities.IsWorseThan(indexState, OrdinalIndexState.Correct));
SetOrdinalIndexState(indexState);
}
private void WrapHelper <TLeftKey, TRightKey>(
PartitionedStream <TSource, TLeftKey> leftStreamInc, PartitionedStream <TSource, TRightKey> rightStream,
IPartitionedStreamRecipient <TSource> outputRecipient, QuerySettings settings, bool preferStriping)
{
// Prematurely merge the right results, if necessary
if (_prematureMergeRight)
{
ListQueryResults <TSource> rightStreamResults =
ExecuteAndCollectResults(rightStream, leftStreamInc.PartitionCount, LeftChild.OutputOrdered, preferStriping, settings);
PartitionedStream <TSource, int> rightStreamInc = rightStreamResults.GetPartitionedStream();
WrapHelper2 <TLeftKey, int>(leftStreamInc, rightStreamInc, outputRecipient);
}
else
{
Debug.Assert(!ExchangeUtilities.IsWorseThan(rightStream.OrdinalIndexState, OrdinalIndexState.Increasing));
WrapHelper2 <TLeftKey, TRightKey>(leftStreamInc, rightStream, outputRecipient);
}
}
public override void WrapPartitionedStream <TLeftKey, TRightKey>(
PartitionedStream <TSource, TLeftKey> leftStream, PartitionedStream <TSource, TRightKey> rightStream,
IPartitionedStreamRecipient <TSource> outputRecipient, bool preferStriping, QuerySettings settings)
{
// Prematurely merge the left results, if necessary
if (_prematureMergeLeft)
{
ListQueryResults <TSource> leftStreamResults =
ExecuteAndCollectResults(leftStream, leftStream.PartitionCount, LeftChild.OutputOrdered, preferStriping, settings);
PartitionedStream <TSource, int> leftStreamInc = leftStreamResults.GetPartitionedStream();
WrapHelper <int, TRightKey>(leftStreamInc, rightStream, outputRecipient, settings, preferStriping);
}
else
{
Contract.Assert(!ExchangeUtilities.IsWorseThan(leftStream.OrdinalIndexState, OrdinalIndexState.Increasing));
WrapHelper <TLeftKey, TRightKey>(leftStream, rightStream, outputRecipient, settings, preferStriping);
}
}
