public void Iterators_Projection_ForwardsProperly() { var rows = new object[] { 1, 2 }; var expected = rows; using (var input = new MockedIterator(rows)) { var entries = new[] { new RowBufferEntry(input.RowBuffer, 0) }; using (var iterator = new ProjectionIterator(input, entries)) { for (var i = 0; i < 2; i++) { AssertProduces(iterator, expected); } } Assert.Equal(2, input.TotalOpenCount); Assert.Equal(4, input.TotalReadCount); Assert.Equal(1, input.DisposalCount); } }
public void Iterators_InnerNestedLoops_ForwardsProperly() { var leftRows = new object[] { 1, 2 }; var rightRows = new object[] { 3, 4, 5 }; var expected = new object[, ] { { 1, 3 }, { 1, 4 }, { 1, 5 }, { 2, 3 }, { 2, 4 }, { 2, 5 } }; using (var left = new MockedIterator(leftRows)) using (var right = new MockedIterator(rightRows)) { using (var iterator = new InnerNestedLoopsIterator(left, right, () => true, () => false)) { for (var i = 0; i < 2; i++) { AssertProduces(iterator, expected); } } Assert.Equal(2, left.TotalOpenCount); Assert.Equal(4, left.TotalReadCount); Assert.Equal(1, left.DisposalCount); Assert.Equal(4, right.TotalOpenCount); Assert.Equal(12, right.TotalReadCount); Assert.Equal(1, right.DisposalCount); } }
public void Iterators_ProbingLeftSemiNestedLoops_MatchesRows() { var leftRows = new object[, ] { { 1, "1-Left" }, { 2, "2-Left-A" }, { 2, "2-Left-B" }, { 3, "3-Left" }, { 4, "4-Left" }, { 5, "5-Left" } }; var rightRows = new object[] { 2, 3, 3, 5 }; var expected = new object[, ] { { 1, "1-Left", false }, { 2, "2-Left-A", true }, { 2, "2-Left-B", true }, { 3, "3-Left", true }, { 4, "4-Left", false }, { 5, "5-Left", true } }; using (var left = new MockedIterator(leftRows)) using (var right = new MockedIterator(rightRows)) { var iteratorPredicate = new IteratorPredicate(() => Equals(left.RowBuffer[0], right.RowBuffer[0])); using (var iterator = new ProbingLeftSemiNestedLoopsIterator(left, right, iteratorPredicate)) { AssertProduces(iterator, expected); } } }
public void Iterators_ComputeScalar_ComputesValues() { var rows = new object[] { 4, 6, 8 }; var expected = new object[, ] { { 4, 12 }, { 6, 18 }, { 8, 24 } }; using (var input = new MockedIterator(rows)) { var values = new IteratorFunction[] { () => (int)input.RowBuffer[0] * 3 }; using (var iterator = new ComputeScalarIterator(input, values)) { AssertProduces(iterator, expected); } } }
public void Iterators_TableSpool_ReturnsInput_AndPushes() { var rows = new object[, ] { { 1, "One" }, { 2, "Two" } }; var expected = rows; var tableSpoolStack = new TableSpoolStack(1); using (var input = new MockedIterator(rows)) using (var iterator = new TableSpoolIterator(input, tableSpoolStack)) { AssertProduces(iterator, expected); var stackRows = new List <RowBuffer>(); while (!tableSpoolStack.IsEmpty) { stackRows.Add(tableSpoolStack.Pop()); } for (var i = 0; i < rows.GetLength(0); i++) { var originalLine = rows.GetLength(0) - i - 1; for (var j = 0; j < rows.GetLength(1); j++) { Assert.Equal(rows[originalLine, j], stackRows[i][j]); } } } }
internal void Iterators_HashMatch_MatchesDuplicates(BoundHashMatchOperator logicalOperator) { var buildRows = new object[] { 1, 2, 3 }; var probeRows = new object[, ] { { 1, "First" }, { 2, "Second1" }, { 2, "Second2" }, { 3, "Third" } }; var expected = new object[, ] { { 1, 1, "First" }, { 2, 2, "Second1" }, { 2, 2, "Second2" }, { 3, 3, "Third" } }; using (var build = new MockedIterator(buildRows)) using (var probe = new MockedIterator(probeRows)) { var rowBuffer = new HashMatchRowBuffer(build.RowBuffer.Count, probe.RowBuffer.Count); var remainder = new IteratorPredicate(() => true); using (var iterator = new HashMatchIterator(logicalOperator, build, probe, 0, 0, remainder, rowBuffer)) { AssertProduces(iterator, expected); } } }
public void Iterators_LeftAntiSemiNestedLoops_ForwardsProperly() { var leftRows = new object[] { 1, 2 }; var rightRows = new object[] { 3, 4 }; using (var left = new MockedIterator(leftRows)) using (var right = new MockedIterator(rightRows)) { using (var iterator = new LeftAntiSemiNestedLoopsIterator(left, right, () => true, () => false)) { for (var i = 0; i < 2; i++) { AssertEmpty(iterator); } } Assert.Equal(2, left.TotalOpenCount); Assert.Equal(4, left.TotalReadCount); Assert.Equal(1, left.DisposalCount); Assert.Equal(4, right.TotalOpenCount); Assert.Equal(4, right.TotalReadCount); Assert.Equal(1, right.DisposalCount); } }
public void Iterators_LeftAntiSemiNestedLoops_NoReadsOnRight_WhenPassthruIsTrue() { var leftRows = new object[] { 1, 2, 3, 4, 5 }; var rightRows = new object[] { 1, 2, 3 }; var expected = new object[] { 2, 4, 5 }; using (var left = new MockedIterator(leftRows)) using (var right = new MockedIterator(rightRows)) { var iteratorPredicate = new IteratorPredicate(() => Equals(left.RowBuffer[0], right.RowBuffer[0])); var passthru = new IteratorPredicate(() => (int)left.RowBuffer[0] % 2 == 0); using (var iterator = new LeftAntiSemiNestedLoopsIterator(left, right, iteratorPredicate, passthru)) { AssertProduces(iterator, expected); } Assert.Equal(1, left.TotalOpenCount); Assert.Equal(5, left.TotalReadCount); Assert.Equal(1, left.DisposalCount); Assert.Equal(3, right.TotalOpenCount); Assert.Equal(7, right.TotalReadCount); Assert.Equal(1, right.DisposalCount); } }
public void Iterators_StreamAggregate_ForwardsProperly() { var rows = new object[] { 1, 2 }; var expected = new object[1, 0]; using (var input = new MockedIterator(rows)) { var groupEntries = Enumerable.Empty <RowBufferEntry>(); var comparers = ImmutableArray <IComparer> .Empty; var aggregators = Enumerable.Empty <IAggregator>(); var argumentFunctions = Enumerable.Empty <IteratorFunction>(); using (var iterator = new StreamAggregateIterator(input, groupEntries, comparers, aggregators, argumentFunctions)) { for (var i = 0; i < 2; i++) { AssertProduces(iterator, expected); } } Assert.Equal(2, input.TotalOpenCount); Assert.Equal(4, input.TotalReadCount); Assert.Equal(1, input.DisposalCount); } }
public void Iterators_StreamAggregate_ComputeAggregates_WhenNotGrouped() { var rows = new object[] { 1, 2, 3 }; var expected = new object[, ] { { 3, 1 } }; using (var input = new MockedIterator(rows)) { var groupEntries = Enumerable.Empty <RowBufferEntry>(); var comparers = ImmutableArray <IComparer> .Empty; var aggregators = new [] { new MaxAggregateDefinition().CreateAggregatable(typeof(int)).CreateAggregator(), new MinAggregateDefinition().CreateAggregatable(typeof(int)).CreateAggregator() }; var function = new IteratorFunction(() => input.RowBuffer[0]); var argumentFunctions = new[] { function, function }; using (var iterator = new StreamAggregateIterator(input, groupEntries, comparers, aggregators, argumentFunctions)) { AssertProduces(iterator, expected); } } }
public void Iterators_Sort_Sorts_WithOuterEntries() { var rows = new object[] { null, 1, 2, 1 }; var expected = new object[] { null, 1, 1, 2 }; var outerRowBuffer = new MockedRowBuffer(new object[] { "Outer Reference" }); using (var input = new MockedIterator(rows)) { var sortEntries = new[] { new RowBufferEntry(outerRowBuffer, 0), new RowBufferEntry(input.RowBuffer, 0) }; var comparers = new[] { Comparer.Default, Comparer.Default }; using (var iterator = new SortIterator(input, sortEntries, comparers)) { AssertProduces(iterator, expected); } } }
public void Iterators_Projection_SwapsEntries() { var rows = new object[, ] { { 1, "One" }, { 2, "Two" } }; var expected = new object[, ] { { "One", 1 }, { "Two", 2 } }; using (var input = new MockedIterator(rows)) { var entries = new[] { new RowBufferEntry(input.RowBuffer, 1), new RowBufferEntry(input.RowBuffer, 0) }; using (var iterator = new ProjectionIterator(input, entries)) { AssertProduces(iterator, expected); } } }
public void Iterators_Projection_ReturnsEmpty_IfInputEmpty() { var rows = new object[0]; using (var input = new MockedIterator(rows)) using (var iterator = new ProjectionIterator(input, Enumerable.Empty <RowBufferEntry>())) { AssertEmpty(iterator); } }
public void Iterators_Filter_ReturnsEmpty_IfInputIsEmpty() { var rows = new object[0]; using (var input = new MockedIterator(rows)) using (var iterator = new FilterIterator(input, () => true)) { AssertEmpty(iterator); } }
public void Iterators_TopWithTies_ReturnsEmpty_IfLimitIsZero() { var rows = new object[] { 1 }; using (var input = new MockedIterator(rows)) using (var iterator = CreateIterator(input, 0)) { AssertEmpty(iterator); } }
public void Iterators_TopWithTies_ReturnsEmpty_IfInputIsEmpty() { var rows = new object[0]; using (var input = new MockedIterator(rows)) using (var iterator = CreateIterator(input, 1)) { AssertEmpty(iterator); } }
public void Iterators_Assert_DoesNotTriggerAssert_WhenFalseAndInputEmpty() { var rows = new object[0]; var expected = rows; using (var input = new MockedIterator(rows)) using (var iterator = new AssertIterator(input, () => false, string.Empty)) { AssertProduces(iterator, expected); } }
public void Iterators_Assert_DoesNotTriggerAssert_WhenTrue() { var rows = new object[] { 1 }; var expected = rows; using (var input = new MockedIterator(rows)) using (var iterator = new AssertIterator(input, () => true, string.Empty)) { AssertProduces(iterator, expected); } }
public void Iterators_Filter_Filters() { var rows = new object[] { 1, 2, 3, 4 }; var expected = new object[] { 2, 4 }; using (var input = new MockedIterator(rows)) using (var iterator = new FilterIterator(input, () => (int)input.RowBuffer[0] % 2 == 0)) { AssertProduces(iterator, expected); } }
public void Iterators_TopWithTies_ReturnsAllRows_IfLimitIsLarger() { var rows = new object[] { 1, 2, 3 }; var expected = rows; var limit = expected.Length + 1; using (var input = new MockedIterator(rows)) using (var iterator = CreateIterator(input, limit)) { AssertProduces(iterator, expected); } }
public void Iterators_TopWithTies_LimitsRows_AndBreaksTies() { var rows = new object[] { 1, 2, 3, 3, 4 }; var expected = new object[] { 1, 2, 3, 3 }; const int limit = 3; using (var input = new MockedIterator(rows)) using (var iterator = CreateIterator(input, limit)) { AssertProduces(iterator, expected); } }
internal void Iterators_HashMatch_ForwardsProperly(BoundHashMatchOperator logicalOperator) { var buildRows = new object[] { 1, 2 }; var probeRows = new object[] { 2, 3 }; using (var build = new MockedIterator(buildRows)) using (var probe = new MockedIterator(probeRows)) { const int passCount = 2; var rowBuffer = new HashMatchRowBuffer(build.RowBuffer.Count, probe.RowBuffer.Count); var remainder = new IteratorPredicate(() => true); using (var iterator = new HashMatchIterator(logicalOperator, build, probe, 0, 0, remainder, rowBuffer)) { for (var i = 0; i < passCount; i++) { iterator.Open(); Assert.True(iterator.Read()); Assert.Equal(2, iterator.RowBuffer[0]); Assert.Equal(2, iterator.RowBuffer[1]); if (logicalOperator == BoundHashMatchOperator.RightOuter || logicalOperator == BoundHashMatchOperator.FullOuter) { Assert.True(iterator.Read()); Assert.Equal(null, iterator.RowBuffer[0]); Assert.Equal(3, iterator.RowBuffer[1]); } if (logicalOperator == BoundHashMatchOperator.LeftOuter || logicalOperator == BoundHashMatchOperator.FullOuter) { Assert.True(iterator.Read()); Assert.Equal(1, iterator.RowBuffer[0]); Assert.Equal(null, iterator.RowBuffer[1]); } Assert.False(iterator.Read()); } } var inputs = new[] { build, probe }; foreach (var input in inputs) { Assert.Equal(passCount, input.TotalOpenCount); Assert.Equal(passCount * 2, input.TotalReadCount); Assert.Equal(1, input.DisposalCount); } } }
public void Iterators_TableSpool_ReturnsEmpty_IfInputEmpty() { var rows = new object[0]; var tableSpoolStack = new TableSpoolStack(1); using (var input = new MockedIterator(rows)) using (var iterator = new TableSpoolIterator(input, tableSpoolStack)) { AssertEmpty(iterator); Assert.True(tableSpoolStack.IsEmpty); } }
public void Iterators_TopWithTies_LimitsRows_WhenNoTies() { var rows = new object[] { 1, 2, 3 }; var expected = new object[] { 1, 2 }; var limit = expected.Length; using (var input = new MockedIterator(rows)) using (var iterator = CreateIterator(input, limit)) { AssertProduces(iterator, expected); } }
public void Iterators_Sort_Sorts_TwoEntries() { var rows = new object[, ] { { "Kirkland", "USA" }, { "London", "UK" }, { "London", null }, { "Redmond", "USA" }, { "Seattle", "USA" }, { "London", "UK" }, { "Seattle", "USA" }, { "Tacoma", "USA" }, { "London", "UK" }, { null, "USA" }, { null, null } }; var expected = new object[, ] { { null, null }, { "London", null }, { null, "USA" }, { "Kirkland", "USA" }, { "Redmond", "USA" }, { "Seattle", "USA" }, { "Seattle", "USA" }, { "Tacoma", "USA" }, { "London", "UK" }, { "London", "UK" }, { "London", "UK" } }; using (var input = new MockedIterator(rows)) { var sortEntries = new[] { new RowBufferEntry(input.RowBuffer, 1), new RowBufferEntry(input.RowBuffer, 0) }; var comparers = new[] { Comparer <string> .Create((x, y) => y.CompareTo(x)), Comparer <string> .Create((x, y) => x.CompareTo(y)) }; using (var iterator = new SortIterator(input, sortEntries, comparers)) { AssertProduces(iterator, expected); } } }
public void Iterators_ComputeScalar_ReturnsEmpty_IfInputIsEmpty() { var rows = new object[0]; var values = new IteratorFunction[] { () => 1 }; using (var input = new MockedIterator(rows)) using (var iterator = new ComputeScalarIterator(input, values)) { AssertEmpty(iterator); } }
public void Iterators_Assert_TriggersAssert_WhenFalseAndInputNonEmpty() { const string message = "This should be detected"; var rows = new object[] { 1 }; using (var input = new MockedIterator(rows)) using (var iterator = new AssertIterator(input, () => false, message)) { iterator.Open(); var exception = Assert.Throws <InvalidOperationException>(() => iterator.Read()); Assert.Equal(exception.Message, message); } }
public void Iterators_Sort_ReturnsEmpty_IfInputIsEmpty() { var rows = new object[0]; using (var input = new MockedIterator(rows)) { var sortEntries = new[] { new RowBufferEntry(input.RowBuffer, 0) }; var comparers = new[] { Comparer.Default }; using (var iterator = new SortIterator(input, sortEntries, comparers)) { AssertEmpty(iterator); } } }
public void Iterators_ProbingLeftSemiNestedLoops_ReturnsEmpty_WhenLeftIsEmpty() { var leftRows = new object[0]; var rightRows = new object[0]; using (var left = new MockedIterator(leftRows)) using (var right = new MockedIterator(rightRows)) { var iteratorPredicate = new IteratorPredicate(() => true); using (var iterator = new ProbingLeftSemiNestedLoopsIterator(left, right, iteratorPredicate)) { AssertEmpty(iterator); } } }
public void Iterators_StreamAggregate_ReturnsEmpty_IfInputEmptyAndGrouped() { var rows = new object[0]; using (var input = new MockedIterator(rows)) { var groupEntries = new [] { new RowBufferEntry(input.RowBuffer, 0) }; var comparers = ImmutableArray.Create <IComparer>(Comparer.Default); var aggregators = Enumerable.Empty <IAggregator>(); var argumentFunctions = Enumerable.Empty <IteratorFunction>(); using (var iterator = new StreamAggregateIterator(input, groupEntries, comparers, aggregators, argumentFunctions)) { AssertEmpty(iterator); } } }