/// <summary> /// Determines the order index state for the output operator /// </summary> private void InitOrderIndexState() { // SkipWhile/TakeWhile needs an increasing index. However, if the predicate expression depends on the index, // the index needs to be correct, not just increasing. OrdinalIndexState requiredIndexState = OrdinalIndexState.Increasing; OrdinalIndexState childIndexState = Child.OrdinalIndexState; if (_indexedPredicate != null) { requiredIndexState = OrdinalIndexState.Correct; _limitsParallelism = childIndexState == OrdinalIndexState.Increasing; } OrdinalIndexState indexState = ExchangeUtilities.Worse(childIndexState, OrdinalIndexState.Correct); if (indexState.IsWorseThan(requiredIndexState)) { _prematureMerge = true; } if (!_take) { // If the index was correct, now it is only increasing. indexState = indexState.Worse(OrdinalIndexState.Increasing); } SetOrdinalIndexState(indexState); }
private readonly TSource _defaultValue; // The default value to use (if empty). //--------------------------------------------------------------------------------------- // Initializes a new reverse operator. // // Arguments: // child - the child whose data we will reverse // internal DefaultIfEmptyQueryOperator(IEnumerable <TSource> child, TSource defaultValue) : base(child) { Debug.Assert(child != null, "child data source cannot be null"); _defaultValue = defaultValue; SetOrdinalIndexState(ExchangeUtilities.Worse(Child.OrdinalIndexState, OrdinalIndexState.Correct)); }
/// <summary> /// Determines the order index state for the output operator /// </summary> private OrdinalIndexState OutputOrderIndexState() { // SkipWhile/TakeWhile needs an increasing index. However, if the predicate expression depends on the index, // the index needs to be correct, not just increasing. OrdinalIndexState requiredIndexState = OrdinalIndexState.Increasing; if (m_indexedPredicate != null) { requiredIndexState = OrdinalIndexState.Correct; } OrdinalIndexState indexState = ExchangeUtilities.Worse(Child.OrdinalIndexState, OrdinalIndexState.Correct); if (indexState.IsWorseThan(requiredIndexState)) { m_prematureMerge = true; } if (!m_take) { // If the index was correct, now it is only increasing. indexState = indexState.Worse(OrdinalIndexState.Increasing); } return(indexState); }
//--------------------------------------------------------------------------------------- // Initializes a new where operator. // // Arguments: // child - the child operator or data source from which to pull data // predicate - a delegate representing the predicate function // // Assumptions: // predicate must be non null. // internal WhereQueryOperator(IEnumerable <TInputOutput> child, Func <TInputOutput, bool> predicate) : base(child) { Debug.Assert(child != null, "child data source cannot be null"); Debug.Assert(predicate != null, "need a filter function"); SetOrdinalIndexState( ExchangeUtilities.Worse(Child.OrdinalIndexState, OrdinalIndexState.Increasing)); _predicate = predicate; }
private readonly bool _prematureMergeRight; // Whether to prematurely merge the right data source //--------------------------------------------------------------------------------------- // Initializes a new concatenation operator. // // Arguments: // child - the child whose data we will reverse // internal ConcatQueryOperator(ParallelQuery <TSource> firstChild, ParallelQuery <TSource> secondChild) : base(firstChild, secondChild) { Debug.Assert(firstChild != null, "first child data source cannot be null"); Debug.Assert(secondChild != null, "second child data source cannot be null"); _outputOrdered = LeftChild.OutputOrdered || RightChild.OutputOrdered; _prematureMergeLeft = LeftChild.OrdinalIndexState.IsWorseThan(OrdinalIndexState.Increasing); _prematureMergeRight = RightChild.OrdinalIndexState.IsWorseThan(OrdinalIndexState.Increasing); if ((LeftChild.OrdinalIndexState == OrdinalIndexState.Indexable) && (RightChild.OrdinalIndexState == OrdinalIndexState.Indexable)) { SetOrdinalIndex(OrdinalIndexState.Indexable); } else { SetOrdinalIndex( ExchangeUtilities.Worse(OrdinalIndexState.Increasing, ExchangeUtilities.Worse(LeftChild.OrdinalIndexState, RightChild.OrdinalIndexState))); } }