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); } }