internal RecordStateEnumerator(Shaper <T> .RowNestedResultEnumerator rowEnumerator) { this._rowEnumerator = rowEnumerator; this._current = (RecordState)null; this._depth = -1; this._readerConsumed = false; }
public bool MoveNext() { switch (this._state) { case Shaper <T> .ObjectQueryNestedEnumerator.State.Start: if (this.TryReadToNextElement()) { this.ReadElement(); break; } this._state = Shaper <T> .ObjectQueryNestedEnumerator.State.NoRows; break; case Shaper <T> .ObjectQueryNestedEnumerator.State.Reading: this.ReadElement(); break; case Shaper <T> .ObjectQueryNestedEnumerator.State.NoRowsLastElementPending: this._state = Shaper <T> .ObjectQueryNestedEnumerator.State.NoRows; break; } bool flag; if (this._state == Shaper <T> .ObjectQueryNestedEnumerator.State.NoRows) { this._previousElement = default(T); flag = false; } else { flag = true; } return(flag); }
internal RecordState GatherData(Shaper shaper) { int num = this.RecordStateFactory.GatherData(shaper) ? 1 : 0; this._pendingIsNull = false; return(this); }
internal override void ResetCollection(Shaper shaper) { // Check to see if anyone has registered for notification when the current coordinator // is reset. if (null != _handleClose) { _handleClose(shaper, _wrappedElements); _handleClose = null; } // Reset is entered for this collection. IsEntered = false; if (IsUsingElementCollection) { _elements = TypedCoordinatorFactory.InitializeCollection(shaper); _wrappedElements = new List <IEntityWrapper>(); } if (null != Child) { Child.ResetCollection(shaper); } if (null != Next) { Next.ResetCollection(shaper); } }
private void Returns_ObjectQueryNestedEnumerator_for_nested_coordinatorFactories( Func <IDbEnumerator <object>, List <object> > toList) { var sourceEnumerable = new[] { new object[] { 1, "A", null }, new object[] { 2, null, "X" }, new object[] { 3, "B", "Z" }, // Should stop reading at "B", since the coordinators are at the same depth new object[] { 4, "C", null }, new object[] { 4, "D", null } // 4 shouldn't be added as it's repeated }; var actualValuesFromNestedCoordinatorOne = new List <string>(); var nestedCoordinatorFactoryOne = Objects.MockHelper.CreateCoordinatorFactory <string, string>( depth: 1, stateSlot: 1, ordinal: 1, nestedCoordinators: new CoordinatorFactory[0], producedValues: actualValuesFromNestedCoordinatorOne); var actualValuesFromNestedCoordinatorTwo = new List <string>(); var nestedCoordinatorFactoryTwo = Objects.MockHelper.CreateCoordinatorFactory <string, string>( depth: 1, stateSlot: 2, ordinal: 2, nestedCoordinators: new CoordinatorFactory[0], producedValues: actualValuesFromNestedCoordinatorTwo); var actualValuesFromRootCoordinator = new List <object>(); var rootCoordinatorFactory = Objects.MockHelper.CreateCoordinatorFactory <int, object>( depth: 0, stateSlot: 0, ordinal: 0, nestedCoordinators: new[] { nestedCoordinatorFactoryOne, nestedCoordinatorFactoryTwo }, producedValues: actualValuesFromRootCoordinator); var shaper = new Shaper <object>( MockHelper.CreateDbDataReader(sourceEnumerable), /*context*/ null, /*workspace*/ null, MergeOption.AppendOnly, /*stateCount*/ 3, rootCoordinatorFactory, /*readerOwned*/ false, /*useSpatialReader*/ false, shouldReleaseConnection: true); var actualEnumerator = shaper.GetEnumerator(); Assert.Equal(new object[] { 1, 2, 3, 4 }.ToList(), toList(actualEnumerator)); Assert.Equal(new object[] { 1, 2, 3, 4 }.ToList(), actualValuesFromRootCoordinator); Assert.Equal(new[] { "A", "B", "C", "D" }.ToList(), actualValuesFromNestedCoordinatorOne); Assert.Equal(new[] { "X" }.ToList(), actualValuesFromNestedCoordinatorTwo); }
internal RecordState GetDefaultRecordState(Shaper <RecordState> shaper) { RecordState recordState = (RecordState)null; if (this.RecordStateFactories.Count > 0) { recordState = (RecordState)shaper.State[this.RecordStateFactories[0].StateSlotNumber]; recordState.ResetToDefaultState(); } return(recordState); }
internal override void ReadNextElement(Shaper shaper) { T element; IEntityWrapper wrappedElement = null; try { if (TypedCoordinatorFactory.WrappedElement == null) { element = TypedCoordinatorFactory.Element(shaper); } else { wrappedElement = TypedCoordinatorFactory.WrappedElement(shaper); // This cast may throw, in which case it will be immediately caught // and the error handling expression will be used to get the appropriate error message. element = (T)wrappedElement.Entity; } } catch (Exception e) { if (e.IsCatchableExceptionType() && !shaper.Reader.IsClosed) { // Some errors can occur while a close handler is registered. This clears // out the handler so that ElementWithErrorHandling will report the correct // error rather than asserting on the missing close handler. ResetCollection(shaper); // call a variation of the "Element" delegate with more detailed // error handling (to produce a better exception message) element = TypedCoordinatorFactory.ElementWithErrorHandling(shaper); } // rethrow throw; } // Z.EntityFramework.Classic: QueryResultFilter CurrentWrapper = wrappedElement; if (IsUsingElementCollection) { _elements.Add(element); if (wrappedElement != null) { _wrappedElements.Add(wrappedElement); } } else { _current = element; } }
private void ReadElement() { this._previousElement = this._rowEnumerator.RootCoordinator.Current; if (this.TryReadToNextElement()) { this._state = Shaper <T> .ObjectQueryNestedEnumerator.State.Reading; } else { this._state = Shaper <T> .ObjectQueryNestedEnumerator.State.NoRowsLastElementPending; } }
/// <summary> /// Returns the "default" record state (that is, the one we use for PreRead/PastEnd reader states /// </summary> internal RecordState GetDefaultRecordState(Shaper <RecordState> shaper) { RecordState result = null; if (RecordStateFactories.Count > 0) { // CONSIDER: We're relying upon having the default for polymorphic types be // the first item in the list; that sounds kind of risky. result = (RecordState)shaper.State[RecordStateFactories[0].StateSlotNumber]; Debug.Assert(null != result, "did you initialize the record states?"); result.ResetToDefaultState(); } return(result); }
public virtual IDbEnumerator <T> GetEnumerator() { if (this.RootCoordinator.CoordinatorFactory.IsSimple) { return((IDbEnumerator <T>) new Shaper <T> .SimpleEnumerator(this)); } Shaper <T> .RowNestedResultEnumerator rowEnumerator = new Shaper <T> .RowNestedResultEnumerator(this); if (this._isObjectQuery) { return((IDbEnumerator <T>) new Shaper <T> .ObjectQueryNestedEnumerator(rowEnumerator)); } return((IDbEnumerator <T>) new Shaper <T> .RecordStateEnumerator(rowEnumerator)); }
// <summary> // Precondition: the current row has data for the coordinator. // Side-effects: updates keys currently stored in state and updates IsEntered if a new value is encountered. // Determines whether the row contains the next element in this collection. // </summary> internal bool HasNextElement(Shaper shaper) { // check if this row contains a new element for this coordinator var result = false; if (!IsEntered || !CoordinatorFactory.CheckKeys(shaper)) { // remember initial keys values CoordinatorFactory.SetKeys(shaper); IsEntered = true; result = true; } return(result); }
// <summary> // Registers this hierarchy of coordinators in the given shaper. // </summary> internal void Initialize(Shaper shaper) { ResetCollection(shaper); // Add this coordinator to the appropriate state slot in the // shaper so that it is available to materialization delegates. shaper.State[CoordinatorFactory.StateSlot] = this; if (null != Child) { Child.Initialize(shaper); } if (null != Next) { Next.Initialize(shaper); } }
private void Returns_RecordStateEnumerator_for_nested_coordinatorFactories_of_RecordState( Func <IDbEnumerator <RecordState>, List <object> > toList) { var sourceEnumerable = new[] { new object[] { 1, "A", null }, new object[] { 2, null, "X" }, new object[] { 3, "B", "Z" }, // Should stop reading at "B", since the coordinators are at the same depth new object[] { 4, "C", null }, new object[] { 4, "D", null } // 4 shouldn't be added as it's repeated }; var nestedCoordinatorFactoryOne = Objects.MockHelper.CreateCoordinatorFactory <string, RecordState>( depth: 1, stateSlot: 2, ordinal: 1, nestedCoordinators: new CoordinatorFactory[0], producedValues: null); var nestedCoordinatorFactoryTwo = Objects.MockHelper.CreateCoordinatorFactory <string, RecordState>( depth: 1, stateSlot: 4, ordinal: 2, nestedCoordinators: new CoordinatorFactory[0], producedValues: null); var rootCoordinatorFactory = Objects.MockHelper.CreateCoordinatorFactory <int, RecordState>( depth: 0, stateSlot: 0, ordinal: 0, nestedCoordinators: new[] { nestedCoordinatorFactoryOne, nestedCoordinatorFactoryTwo }, producedValues: null); var shaper = new Shaper <RecordState>( MockHelper.CreateDbDataReader(sourceEnumerable), /*context*/ null, /*workspace*/ null, MergeOption.AppendOnly, /*stateCount*/ 6, rootCoordinatorFactory, /*readerOwned*/ false, /*useSpatialReader*/ false); Assert.Equal(new object[] { 1, "A", 2, "X", 3, "B", 4, "C", "D" }.ToList(), toList(shaper.RootEnumerator)); }
private void Returns_SimpleEnumerator_for_simple_CoordinatorFactory( Func <IDbEnumerator <object>, List <object> > toList) { var sourceEnumerable = new[] { new object[] { 1 }, new object[] { 2 } }; var coordinatorFactory = Objects.MockHelper.CreateCoordinatorFactory(s => s.Reader.GetValue(0)); var shaper = new Shaper <object>( MockHelper.CreateDbDataReader(sourceEnumerable), /*context*/ null, /*workspace*/ null, MergeOption.AppendOnly, /*stateCount*/ 1, coordinatorFactory, /*readerOwned*/ false, /*useSpatialReader*/ false); var actualEnumerator = shaper.GetEnumerator(); Assert.Equal(sourceEnumerable.SelectMany(e => e).ToList(), toList(actualEnumerator)); }
internal override void ReadNextElement(Shaper shaper) { IEntityWrapper entityWrapper = (IEntityWrapper)null; T obj1; try { if (this.TypedCoordinatorFactory.WrappedElement == null) { obj1 = this.TypedCoordinatorFactory.Element(shaper); } else { entityWrapper = this.TypedCoordinatorFactory.WrappedElement(shaper); obj1 = (T)entityWrapper.Entity; } } catch (Exception ex) { if (ex.IsCatchableExceptionType() && !shaper.Reader.IsClosed) { this.ResetCollection(shaper); T obj2 = this.TypedCoordinatorFactory.ElementWithErrorHandling(shaper); } throw; } if (this.IsUsingElementCollection) { this._elements.Add(obj1); if (entityWrapper == null) { return; } this._wrappedElements.Add(entityWrapper); } else { this._current = obj1; } }
public void RecordStateEnumerator_MoveNextAsync_returns_reader_consumed_even_if_task_is_being_cancelled() { var coordinatorFactory = Objects.MockHelper.CreateCoordinatorFactory(s => (RecordState)null, s => true); var shaper = new Shaper <RecordState>( new Mock <DbDataReader>().Object, /*context*/ null, /*workspace*/ null, MergeOption.AppendOnly, /*stateCount*/ 1, coordinatorFactory, /*readerOwned*/ false, /*streaming*/ false); using (var enumerator = shaper.GetEnumerator()) { Assert.Contains("RecordStateEnumerator", enumerator.GetType().FullName); enumerator.MoveNext(); Assert.False(enumerator.MoveNextAsync(new CancellationToken(canceled: true)).GetAwaiter().GetResult()); } }
internal override void ResetCollection(Shaper shaper) { if (this._handleClose != null) { this._handleClose(shaper, this._wrappedElements); this._handleClose = (Action <Shaper, List <IEntityWrapper> >)null; } this.IsEntered = false; if (this.IsUsingElementCollection) { this._elements = this.TypedCoordinatorFactory.InitializeCollection(shaper); this._wrappedElements = new List <IEntityWrapper>(); } if (this.Child != null) { this.Child.ResetCollection(shaper); } if (this.Next == null) { return; } this.Next.ResetCollection(shaper); }
public void ObjectQueryNestedEnumerator_MoveNextAsync_throws_OperationCanceledException_if_task_is_cancelled() { var coordinatorFactory = Objects.MockHelper.CreateCoordinatorFactory(s => s.Reader.GetValue(0), s => true); var shaper = new Shaper <object>( new Mock <DbDataReader>().Object, /*context*/ null, /*workspace*/ null, MergeOption.AppendOnly, /*stateCount*/ 1, coordinatorFactory, /*readerOwned*/ false, /*streaming*/ false); using (var enumerator = shaper.GetEnumerator()) { Assert.Contains("ObjectQueryNestedEnumerator", enumerator.GetType().FullName); Assert.Throws <OperationCanceledException>( () => enumerator.MoveNextAsync(new CancellationToken(canceled: true)) .GetAwaiter().GetResult()); } }
public async Task <bool> MoveNextAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); switch (this._state) { case Shaper <T> .ObjectQueryNestedEnumerator.State.Start: if (await this.TryReadToNextElementAsync(cancellationToken).WithCurrentCulture <bool>()) { await this.ReadElementAsync(cancellationToken).WithCurrentCulture(); break; } this._state = Shaper <T> .ObjectQueryNestedEnumerator.State.NoRows; break; case Shaper <T> .ObjectQueryNestedEnumerator.State.Reading: await this.ReadElementAsync(cancellationToken).WithCurrentCulture(); break; case Shaper <T> .ObjectQueryNestedEnumerator.State.NoRowsLastElementPending: this._state = Shaper <T> .ObjectQueryNestedEnumerator.State.NoRows; break; } bool result; if (this._state == Shaper <T> .ObjectQueryNestedEnumerator.State.NoRows) { this._previousElement = default(T); result = false; } else { result = true; } return(result); }
public void SimpleEnumerator_MoveNextAsync_does_not_throw_if_shaper_is_not_active_even_if_task_is_being_cancelled() { var coordinatorFactory = Objects.MockHelper.CreateCoordinatorFactory(s => s.Reader.GetValue(0)); var shaper = new Shaper <object>( new Mock <DbDataReader>().Object, /*context*/ null, /*workspace*/ null, MergeOption.AppendOnly, /*stateCount*/ 1, coordinatorFactory, /*readerOwned*/ false, /*streaming*/ false); using (var enumerator = shaper.GetEnumerator()) { Assert.Contains("SimpleEnumerator", enumerator.GetType().FullName); enumerator.MoveNext(); Assert.False(enumerator.MoveNextAsync(new CancellationToken(canceled: true)) .GetAwaiter().GetResult()); } }
internal SimpleEnumerator(Shaper <T> shaper) { _shaper = shaper; }
// <summary> // Precondition: the current row has data and contains a new element for the coordinator. // Reads the next element in this collection. // </summary> internal abstract void ReadNextElement(Shaper shaper);
internal ObjectQueryNestedEnumerator(Shaper <T> .RowNestedResultEnumerator rowEnumerator) { this._rowEnumerator = rowEnumerator; this._previousElement = default(T); this._state = Shaper <T> .ObjectQueryNestedEnumerator.State.Start; }
private async Task ReadElementAsync(CancellationToken cancellationToken) { this._previousElement = this._rowEnumerator.RootCoordinator.Current; this._state = !await this.TryReadToNextElementAsync(cancellationToken).WithCurrentCulture <bool>() ? Shaper <T> .ObjectQueryNestedEnumerator.State.NoRowsLastElementPending : Shaper <T> .ObjectQueryNestedEnumerator.State.Reading; }
internal RowNestedResultEnumerator(Shaper <T> shaper) { _shaper = shaper; _current = new Coordinator[_shaper.RootCoordinator.MaxDistanceToLeaf() + 1]; }
// <summary> // Called from the Element expression on the Coordinator to gather all // the data for the record; we just turn around and call the expression // we build on the RecordStateFactory. // </summary> internal RecordState GatherData(Shaper shaper) { RecordStateFactory.GatherData(shaper); _pendingIsNull = false; return(this); }
// <summary> // This method is called when the current collection is finished and it's time to move to the next collection. // Recursively initializes children and siblings as well. // </summary> internal abstract void ResetCollection(Shaper shaper);