public LeftAntiSemiNestedLoopsIterator(Iterator left, Iterator right, IteratorPredicate predicate, IteratorPredicate passthruPredicate)
{
_left = left;
_right = right;
_predicate = predicate;
_passthruPredicate = passthruPredicate;
}
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_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);
}
}
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 ProbingLeftSemiNestedLoopsIterator(Iterator left, Iterator right, IteratorPredicate predicate)
{
_left = left;
_right = right;
_predicate = predicate;
_rowBuffer = new ProbedRowBuffer(left.RowBuffer);
}
public LeftOuterNestedLoopsIterator(Iterator left, Iterator right, IteratorPredicate predicate, IteratorPredicate passthruPredicate)
{
_left = left;
_right = right;
_predicate = predicate;
_passthruPredicate = passthruPredicate;
_rowBuffer = new LeftOuterNestedLoopsRowBuffer(_left.RowBuffer, _right.RowBuffer);
}
public InnerNestedLoopsIterator(Iterator left, Iterator right, IteratorPredicate predicate, IteratorPredicate passthruPredicate)
{
_left = left;
_right = right;
_predicate = predicate;
_passthruPredicate = passthruPredicate;
RowBuffer = new CombinedRowBuffer(left.RowBuffer, right.RowBuffer);
}
public HashMatchIterator(BoundHashMatchOperator logicalOperator, Iterator build, Iterator probe, int buildIndex, int probeIndex, IteratorPredicate remainder, HashMatchRowBuffer rowBuffer)
{
_logicalOperator = logicalOperator;
_build = build;
_probe = probe;
_buildIndex = buildIndex;
_probeIndex = probeIndex;
_remainder = remainder;
_rowBuffer = rowBuffer;
}
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_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);
}
}
}
internal void Iterators_HashMatch_ReturnsEmpty_IfBuildIsEmpty(BoundHashMatchOperator logicalOperator)
{
var buildRows = new object[0];
var probeRows = new object[] { 2, 3 };
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))
{
AssertEmpty(iterator);
}
}
}
public void Iterators_InnerNestedLoops_ReturnsEmpty_WhenLeftAndRightIsEmpty()
{
var rows = new object[0];
var rightRows = new object[] { 1, 2, 3 };
using (var left = new MockedIterator(rows))
using (var right = new MockedIterator(rightRows))
{
var iteratorPredicate = new IteratorPredicate(() => true);
var passthru = new IteratorPredicate(() => false);
using (var iterator = new InnerNestedLoopsIterator(left, right, iteratorPredicate, passthru))
{
AssertEmpty(iterator);
}
}
}
internal void Iterators_HashMatch_DoesNotMatchNulls(BoundHashMatchOperator logicalOperator)
{
var buildRows = new object[, ]
{
{ null, "Foo" }
};
var probeRows = new object[, ]
{
{ null, "Bar" }
};
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))
{
iterator.Open();
if (logicalOperator == BoundHashMatchOperator.RightOuter ||
logicalOperator == BoundHashMatchOperator.FullOuter)
{
Assert.True(iterator.Read());
Assert.Equal(null, iterator.RowBuffer[0]);
Assert.Equal(null, iterator.RowBuffer[1]);
Assert.Equal(null, iterator.RowBuffer[2]);
Assert.Equal("Bar", iterator.RowBuffer[3]);
}
if (logicalOperator == BoundHashMatchOperator.LeftOuter ||
logicalOperator == BoundHashMatchOperator.FullOuter)
{
Assert.True(iterator.Read());
Assert.Equal(null, iterator.RowBuffer[0]);
Assert.Equal("Foo", iterator.RowBuffer[1]);
Assert.Equal(null, iterator.RowBuffer[2]);
Assert.Equal(null, iterator.RowBuffer[3]);
}
Assert.False(iterator.Read());
}
}
}
public void Iterators_LeftAntiSemiNestedLoops_ReturnsLeft_WhenRightEmpty()
{
var leftRows = new object[] { 1, 2, 3 };
var rightRows = new object[0];
var expected = leftRows;
using (var left = new MockedIterator(leftRows))
using (var right = new MockedIterator(rightRows))
{
var iteratorPredicate = new IteratorPredicate(() => true);
var passthru = new IteratorPredicate(() => false);
using (var iterator = new LeftAntiSemiNestedLoopsIterator(left, right, iteratorPredicate, passthru))
{
AssertProduces(iterator, expected);
}
}
}
public void Iterators_LeftAntiSemiNestedLoops_ReturnsLeft_WhenRightIsNonEmpty_UnlessPassthruIsTrue()
{
var leftRows = new object[] { 1, 2, 3 };
var rightRows = new object[] { 1 };
var expected = new object[] { 2 };
using (var left = new MockedIterator(leftRows))
using (var right = new MockedIterator(rightRows))
{
var iteratorPredicate = new IteratorPredicate(() => true);
var passthru = new IteratorPredicate(() => Equals(left.RowBuffer[0], 2));
using (var iterator = new LeftAntiSemiNestedLoopsIterator(left, right, iteratorPredicate, passthru))
{
AssertProduces(iterator, expected);
}
}
}
public void Iterators_LeftOuterNestedLoops_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, "2-Right" },
{ 3, "3-Right-A" },
{ 3, "3-Right-B" },
{ 5, "5-Right" }
};
var expected = new object[, ]
{
{ 1, "1-Left", null, null },
{ 2, "2-Left-A", 2, "2-Right" },
{ 2, "2-Left-B", 2, "2-Right" },
{ 3, "3-Left", 3, "3-Right-A" },
{ 3, "3-Left", 3, "3-Right-B" },
{ 4, "4-Left", null, null },
{ 5, "5-Left", 5, "5-Right" }
};
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(() => false);
using (var iterator = new LeftOuterNestedLoopsIterator(left, right, iteratorPredicate, passthru))
{
AssertProduces(iterator, expected);
}
}
}
public void Iterators_ProbingLeftSemiNestedLoops_ReturnsLeft_WhenRightIsEmpty()
{
var leftRows = new object[] { 1, 2, 3 };
var rightRows = new object[0];
var expected = new object[, ]
{
{ 1, false },
{ 2, false },
{ 3, false }
};
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))
{
AssertProduces(iterator, expected);
}
}
}
internal void Iterators_HashMatch_ReturnsBuild_IfProbeIsEmpty(BoundHashMatchOperator logicalOperator)
{
var buildRows = new object[] { 1, 2 };
var probeRows = new object[0];
var expected = new object[, ]
{
{ 1, null },
{ 2, null }
};
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_LeftOuterNestedLoops_ReturnsLeft_WhenPredicateIsFalse()
{
var leftRows = new object[] { 1, 2, 3 };
var rightRows = new object[0];
var expected = new object[, ]
{
{ 1, null },
{ 2, null },
{ 3, null }
};
using (var left = new MockedIterator(leftRows))
using (var right = new MockedIterator(rightRows))
{
var iteratorPredicate = new IteratorPredicate(() => false);
var passthru = new IteratorPredicate(() => false);
using (var iterator = new LeftOuterNestedLoopsIterator(left, right, iteratorPredicate, passthru))
{
AssertProduces(iterator, expected);
}
}
}
public AssertIterator(Iterator input, IteratorPredicate predicate, string message)
{
_input = input;
_predicate = predicate;
_message = message;
}
public FilterIterator(Iterator input, IteratorPredicate predicate)
{
_input = input;
_predicate = predicate;
}
internal void Iterators_HashMatch_MatchesWithRemainder(BoundHashMatchOperator logicalOperator)
{
var buildRows = new object[, ]
{
{ 1, 1 },
{ 1, 2 },
{ 2, 1 },
{ 2, 2 },
{ 3, 1 }
};
var probeRows = new object[, ]
{
{ 0, 0, "Unmatched1" },
{ 1, 1, "Project1-Task-1" },
{ 1, 2, "Project1-Task-2" },
{ 1, 3, "Unmatched2" },
{ 2, 1, "Project2-Task-1" },
};
using (var build = new MockedIterator(buildRows))
using (var probe = new MockedIterator(probeRows))
{
// Layout:
// 0 | 1 | 2 | 3 | 4
// ----------------+--------------+-----------------+--------------+---------------
// build.ProjectId | build.TaskId | probe.ProjectId | probe.TaskId | probe.TaskName
var rowBuffer = new HashMatchRowBuffer(build.RowBuffer.Count, probe.RowBuffer.Count);
var remainder = new IteratorPredicate(() => Equals(rowBuffer[1], rowBuffer[3]));
using (var iterator = new HashMatchIterator(logicalOperator, build, probe, 0, 0, remainder, rowBuffer))
{
iterator.Open();
if (logicalOperator == BoundHashMatchOperator.RightOuter ||
logicalOperator == BoundHashMatchOperator.FullOuter)
{
Assert.True(iterator.Read());
Assert.Equal(null, iterator.RowBuffer[0]);
Assert.Equal(null, iterator.RowBuffer[1]);
Assert.Equal(0, iterator.RowBuffer[2]);
Assert.Equal(0, iterator.RowBuffer[3]);
Assert.Equal("Unmatched1", iterator.RowBuffer[4]);
}
Assert.True(iterator.Read());
Assert.Equal(1, iterator.RowBuffer[0]);
Assert.Equal(1, iterator.RowBuffer[1]);
Assert.Equal(1, iterator.RowBuffer[2]);
Assert.Equal(1, iterator.RowBuffer[3]);
Assert.Equal("Project1-Task-1", iterator.RowBuffer[4]);
Assert.True(iterator.Read());
Assert.Equal(1, iterator.RowBuffer[0]);
Assert.Equal(2, iterator.RowBuffer[1]);
Assert.Equal(1, iterator.RowBuffer[2]);
Assert.Equal(2, iterator.RowBuffer[3]);
Assert.Equal("Project1-Task-2", iterator.RowBuffer[4]);
if (logicalOperator == BoundHashMatchOperator.RightOuter ||
logicalOperator == BoundHashMatchOperator.FullOuter)
{
Assert.True(iterator.Read());
Assert.Equal(null, iterator.RowBuffer[0]);
Assert.Equal(null, iterator.RowBuffer[1]);
Assert.Equal(1, iterator.RowBuffer[2]);
Assert.Equal(3, iterator.RowBuffer[3]);
Assert.Equal("Unmatched2", iterator.RowBuffer[4]);
}
Assert.True(iterator.Read());
Assert.Equal(2, iterator.RowBuffer[0]);
Assert.Equal(1, iterator.RowBuffer[1]);
Assert.Equal(2, iterator.RowBuffer[2]);
Assert.Equal(1, iterator.RowBuffer[3]);
Assert.Equal("Project2-Task-1", iterator.RowBuffer[4]);
if (logicalOperator == BoundHashMatchOperator.LeftOuter ||
logicalOperator == BoundHashMatchOperator.FullOuter)
{
Assert.True(iterator.Read());
Assert.Equal(2, iterator.RowBuffer[0]);
Assert.Equal(2, iterator.RowBuffer[1]);
Assert.Equal(null, iterator.RowBuffer[2]);
Assert.Equal(null, iterator.RowBuffer[3]);
Assert.Equal(null, iterator.RowBuffer[4]);
Assert.True(iterator.Read());
Assert.Equal(3, iterator.RowBuffer[0]);
Assert.Equal(1, iterator.RowBuffer[1]);
Assert.Equal(null, iterator.RowBuffer[2]);
Assert.Equal(null, iterator.RowBuffer[3]);
Assert.Equal(null, iterator.RowBuffer[4]);
}
Assert.False(iterator.Read());
}
}
}