org.apache.flink.api.common.typeutils.TypePairComparator Java Examples
The following examples show how to use
org.apache.flink.api.common.typeutils.TypePairComparator.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
| Source File: NonReusingBuildSecondReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
public NonReusingBuildSecondReOpenableHashJoinIterator(
MutableObjectIterator<V1> firstInput,
MutableObjectIterator<V2> secondInput,
TypeSerializer<V1> serializer1,
TypeComparator<V1> comparator1,
TypeSerializer<V2> serializer2,
TypeComparator<V2> comparator2,
TypePairComparator<V1, V2> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean probeSideOuterJoin,
boolean buildSideOuterJoin,
boolean useBitmapFilters) throws MemoryAllocationException {
super(firstInput, secondInput, serializer1, comparator1, serializer2,
comparator2, pairComparator, memManager, ioManager, ownerTask,
memoryFraction, probeSideOuterJoin, buildSideOuterJoin, useBitmapFilters);
reopenHashTable = (ReOpenableMutableHashTable<V2, V1>) hashJoin;
}
Example #2
| Source File: NonReusingBuildSecondReOpenableHashJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
public NonReusingBuildSecondReOpenableHashJoinIterator(
MutableObjectIterator<V1> firstInput,
MutableObjectIterator<V2> secondInput,
TypeSerializer<V1> serializer1,
TypeComparator<V1> comparator1,
TypeSerializer<V2> serializer2,
TypeComparator<V2> comparator2,
TypePairComparator<V1, V2> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean probeSideOuterJoin,
boolean buildSideOuterJoin,
boolean useBitmapFilters) throws MemoryAllocationException {
super(firstInput, secondInput, serializer1, comparator1, serializer2,
comparator2, pairComparator, memManager, ioManager, ownerTask,
memoryFraction, probeSideOuterJoin, buildSideOuterJoin, useBitmapFilters);
reopenHashTable = (ReOpenableMutableHashTable<V2, V1>) hashJoin;
}
Example #3
| Source File: HashJoinIteratorBase.java From flink with Apache License 2.0 | 6 votes |
|
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer,
TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer,
TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBloomFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new MutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager,
useBloomFilters);
}
Example #4
| Source File: NonReusingBuildSecondReOpenableHashJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer,
TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #5
| Source File: AbstractMergeOuterJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
public AbstractMergeOuterJoinIterator(
OuterJoinType outerJoinType,
MutableObjectIterator<T1> input1,
MutableObjectIterator<T2> input2,
TypeSerializer<T1> serializer1, TypeComparator<T1> comparator1,
TypeSerializer<T2> serializer2, TypeComparator<T2> comparator2,
TypePairComparator<T1, T2> pairComparator,
MemoryManager memoryManager,
IOManager ioManager,
int numMemoryPages,
AbstractInvokable parentTask)
throws MemoryAllocationException {
super(input1, input2, serializer1, comparator1, serializer2, comparator2, pairComparator, memoryManager, ioManager, numMemoryPages, parentTask);
this.outerJoinType = outerJoinType;
}
Example #6
| Source File: ReusingBuildFirstReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer, TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #7
| Source File: HashJoinIteratorBase.java From flink with Apache License 2.0 | 6 votes |
|
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer,
TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer,
TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBloomFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new MutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager,
useBloomFilters);
}
Example #8
| Source File: ReusingBuildSecondReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer, TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #9
| Source File: ReusingBuildSecondReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
public ReusingBuildSecondReOpenableHashJoinIterator(
MutableObjectIterator<V1> firstInput,
MutableObjectIterator<V2> secondInput,
TypeSerializer<V1> serializer1,
TypeComparator<V1> comparator1,
TypeSerializer<V2> serializer2,
TypeComparator<V2> comparator2,
TypePairComparator<V1, V2> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean probeSideOuterJoin,
boolean buildSideOuterJoin,
boolean useBitmapFilters) throws MemoryAllocationException {
super(firstInput, secondInput, serializer1, comparator1, serializer2,
comparator2, pairComparator, memManager, ioManager, ownerTask,
memoryFraction, probeSideOuterJoin, buildSideOuterJoin, useBitmapFilters);
reopenHashTable = (ReOpenableMutableHashTable<V2, V1>) hashJoin;
}
Example #10
| Source File: TuplePairComparatorTestBase.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
protected void testGreatSmallAscDescWithReference(boolean ascending) {
try {
Tuple2<T[], R[]> data = getSortedData();
TypePairComparator<T, R> comparator = getComparator(ascending);
//compares every element in high with every element in low
for (int x = 0; x < data.f0.length - 1; x++) {
for (int y = x + 1; y < data.f1.length; y++) {
comparator.setReference(data.f0[x]);
if (ascending) {
assertTrue(comparator.compareToReference(data.f1[y]) > 0);
} else {
assertTrue(comparator.compareToReference(data.f1[y]) < 0);
}
}
}
} catch (Exception e) {
System.err.println(e.getMessage());
e.printStackTrace();
fail("Exception in test: " + e.getMessage());
}
}
Example #11
| Source File: TuplePairComparatorTestBase.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
@Test
public void testEqualityWithReference() {
try {
TypePairComparator<T, R> comparator = getComparator(true);
Tuple2<T[], R[]> data = getSortedData();
for (int x = 0; x < data.f0.length; x++) {
comparator.setReference(data.f0[x]);
assertTrue(comparator.equalToReference(data.f1[x]));
}
} catch (Exception e) {
System.err.println(e.getMessage());
e.printStackTrace();
fail("Exception in test: " + e.getMessage());
}
}
Example #12
| Source File: NonReusingBuildSecondReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer,
TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #13
| Source File: ReusingBuildFirstReOpenableHashJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
public ReusingBuildFirstReOpenableHashJoinIterator(
MutableObjectIterator<V1> firstInput,
MutableObjectIterator<V2> secondInput,
TypeSerializer<V1> serializer1,
TypeComparator<V1> comparator1,
TypeSerializer<V2> serializer2,
TypeComparator<V2> comparator2,
TypePairComparator<V2, V1> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean probeSideOuterJoin,
boolean buildSideOuterJoin,
boolean useBitmapFilters)
throws MemoryAllocationException
{
super(firstInput, secondInput, serializer1, comparator1, serializer2,
comparator2, pairComparator, memManager, ioManager, ownerTask,
memoryFraction, probeSideOuterJoin, buildSideOuterJoin, useBitmapFilters);
reopenHashTable = (ReOpenableMutableHashTable<V1, V2>) hashJoin;
}
Example #14
| Source File: ReusingBuildFirstReOpenableHashJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer, TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #15
| Source File: NonReusingBuildFirstReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer, TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #16
| Source File: NonReusingBuildFirstReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
public NonReusingBuildFirstReOpenableHashJoinIterator(
MutableObjectIterator<V1> firstInput,
MutableObjectIterator<V2> secondInput,
TypeSerializer<V1> serializer1,
TypeComparator<V1> comparator1,
TypeSerializer<V2> serializer2,
TypeComparator<V2> comparator2,
TypePairComparator<V2, V1> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean probeSideOuterJoin,
boolean buildSideOuterJoin,
boolean useBitmapFilters) throws MemoryAllocationException {
super(firstInput, secondInput, serializer1, comparator1, serializer2,
comparator2, pairComparator, memManager, ioManager, ownerTask,
memoryFraction, probeSideOuterJoin, buildSideOuterJoin, useBitmapFilters);
reopenHashTable = (ReOpenableMutableHashTable<V1, V2>) hashJoin;
}
Example #17
| Source File: ReusingMergeOuterJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
public ReusingMergeOuterJoinIterator(
OuterJoinType outerJoinType,
MutableObjectIterator<T1> input1,
MutableObjectIterator<T2> input2,
TypeSerializer<T1> serializer1, TypeComparator<T1> comparator1,
TypeSerializer<T2> serializer2, TypeComparator<T2> comparator2,
TypePairComparator<T1, T2> pairComparator,
MemoryManager memoryManager,
IOManager ioManager,
int numMemoryPages,
AbstractInvokable parentTask)
throws MemoryAllocationException {
super(outerJoinType, input1, input2, serializer1, comparator1, serializer2, comparator2, pairComparator, memoryManager, ioManager, numMemoryPages, parentTask);
this.copy1 = serializer1.createInstance();
this.spillHeadCopy = serializer1.createInstance();
this.copy2 = serializer2.createInstance();
this.blockHeadCopy = serializer2.createInstance();
}
Example #18
| Source File: ReusingBuildSecondReOpenableHashJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer, TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #19
| Source File: RecordPairComparatorFactory.java From flink with Apache License 2.0 | 6 votes |
|
@Override
public TypePairComparator<Record, Record> createComparator21(
TypeComparator<Record> comparator1, TypeComparator<Record> comparator2)
{
if (!(comparator1 instanceof RecordComparator && comparator2 instanceof RecordComparator)) {
throw new IllegalArgumentException("Cannot instantiate pair comparator from the given comparators.");
}
final RecordComparator prc1 = (RecordComparator) comparator1;
final RecordComparator prc2 = (RecordComparator) comparator2;
final int[] pos1 = prc1.getKeyPositions();
final int[] pos2 = prc2.getKeyPositions();
final Class<? extends Value>[] types1 = prc1.getKeyTypes();
final Class<? extends Value>[] types2 = prc2.getKeyTypes();
checkComparators(pos1, pos2, types1, types2);
return new RecordPairComparator(pos2, pos1, types1);
}
Example #20
| Source File: AbstractMergeOuterJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
public AbstractMergeOuterJoinIterator(
OuterJoinType outerJoinType,
MutableObjectIterator<T1> input1,
MutableObjectIterator<T2> input2,
TypeSerializer<T1> serializer1, TypeComparator<T1> comparator1,
TypeSerializer<T2> serializer2, TypeComparator<T2> comparator2,
TypePairComparator<T1, T2> pairComparator,
MemoryManager memoryManager,
IOManager ioManager,
int numMemoryPages,
AbstractInvokable parentTask)
throws MemoryAllocationException {
super(input1, input2, serializer1, comparator1, serializer2, comparator2, pairComparator, memoryManager, ioManager, numMemoryPages, parentTask);
this.outerJoinType = outerJoinType;
}
Example #21
| Source File: ReusingBuildSecondReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
@Override
public <BT, PT> MutableHashTable<BT, PT> getHashJoin(
TypeSerializer<BT> buildSideSerializer, TypeComparator<BT> buildSideComparator,
TypeSerializer<PT> probeSideSerializer, TypeComparator<PT> probeSideComparator,
TypePairComparator<PT, BT> pairComparator,
MemoryManager memManager, IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean useBitmapFilters) throws MemoryAllocationException {
final int numPages = memManager.computeNumberOfPages(memoryFraction);
final List<MemorySegment> memorySegments = memManager.allocatePages(ownerTask, numPages);
return new ReOpenableMutableHashTable<BT, PT>(buildSideSerializer, probeSideSerializer,
buildSideComparator, probeSideComparator, pairComparator,
memorySegments, ioManager, useBitmapFilters);
}
Example #22
| Source File: ReusingMergeOuterJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
public ReusingMergeOuterJoinIterator(
OuterJoinType outerJoinType,
MutableObjectIterator<T1> input1,
MutableObjectIterator<T2> input2,
TypeSerializer<T1> serializer1, TypeComparator<T1> comparator1,
TypeSerializer<T2> serializer2, TypeComparator<T2> comparator2,
TypePairComparator<T1, T2> pairComparator,
MemoryManager memoryManager,
IOManager ioManager,
int numMemoryPages,
AbstractInvokable parentTask)
throws MemoryAllocationException {
super(outerJoinType, input1, input2, serializer1, comparator1, serializer2, comparator2, pairComparator, memoryManager, ioManager, numMemoryPages, parentTask);
this.copy1 = serializer1.createInstance();
this.spillHeadCopy = serializer1.createInstance();
this.copy2 = serializer2.createInstance();
this.blockHeadCopy = serializer2.createInstance();
}
Example #23
| Source File: ReusingMergeInnerJoinIterator.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
public ReusingMergeInnerJoinIterator(
MutableObjectIterator<T1> input1,
MutableObjectIterator<T2> input2,
TypeSerializer<T1> serializer1, TypeComparator<T1> comparator1,
TypeSerializer<T2> serializer2, TypeComparator<T2> comparator2,
TypePairComparator<T1, T2> pairComparator,
MemoryManager memoryManager,
IOManager ioManager,
int numMemoryPages,
AbstractInvokable parentTask)
throws MemoryAllocationException {
super(input1, input2, serializer1, comparator1, serializer2, comparator2, pairComparator, memoryManager, ioManager, numMemoryPages, parentTask);
this.copy1 = serializer1.createInstance();
this.spillHeadCopy = serializer1.createInstance();
this.copy2 = serializer2.createInstance();
this.blockHeadCopy = serializer2.createInstance();
}
Example #24
| Source File: RecordPairComparatorFactory.java From Flink-CEPplus with Apache License 2.0 | 6 votes |
|
@Override
public TypePairComparator<Record, Record> createComparator21(
TypeComparator<Record> comparator1, TypeComparator<Record> comparator2)
{
if (!(comparator1 instanceof RecordComparator && comparator2 instanceof RecordComparator)) {
throw new IllegalArgumentException("Cannot instantiate pair comparator from the given comparators.");
}
final RecordComparator prc1 = (RecordComparator) comparator1;
final RecordComparator prc2 = (RecordComparator) comparator2;
final int[] pos1 = prc1.getKeyPositions();
final int[] pos2 = prc2.getKeyPositions();
final Class<? extends Value>[] types1 = prc1.getKeyTypes();
final Class<? extends Value>[] types2 = prc2.getKeyTypes();
checkComparators(pos1, pos2, types1, types2);
return new RecordPairComparator(pos2, pos1, types1);
}
Example #25
| Source File: ReusingMergeInnerJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
public ReusingMergeInnerJoinIterator(
MutableObjectIterator<T1> input1,
MutableObjectIterator<T2> input2,
TypeSerializer<T1> serializer1, TypeComparator<T1> comparator1,
TypeSerializer<T2> serializer2, TypeComparator<T2> comparator2,
TypePairComparator<T1, T2> pairComparator,
MemoryManager memoryManager,
IOManager ioManager,
int numMemoryPages,
AbstractInvokable parentTask)
throws MemoryAllocationException {
super(input1, input2, serializer1, comparator1, serializer2, comparator2, pairComparator, memoryManager, ioManager, numMemoryPages, parentTask);
this.copy1 = serializer1.createInstance();
this.spillHeadCopy = serializer1.createInstance();
this.copy2 = serializer2.createInstance();
this.blockHeadCopy = serializer2.createInstance();
}
Example #26
| Source File: TuplePairComparatorTestBase.java From flink with Apache License 2.0 | 6 votes |
|
@Test
public void testEqualityWithReference() {
try {
TypePairComparator<T, R> comparator = getComparator(true);
Tuple2<T[], R[]> data = getSortedData();
for (int x = 0; x < data.f0.length; x++) {
comparator.setReference(data.f0[x]);
assertTrue(comparator.equalToReference(data.f1[x]));
}
} catch (Exception e) {
System.err.println(e.getMessage());
e.printStackTrace();
fail("Exception in test: " + e.getMessage());
}
}
Example #27
| Source File: ReusingBuildSecondReOpenableHashJoinIterator.java From flink with Apache License 2.0 | 6 votes |
|
public ReusingBuildSecondReOpenableHashJoinIterator(
MutableObjectIterator<V1> firstInput,
MutableObjectIterator<V2> secondInput,
TypeSerializer<V1> serializer1,
TypeComparator<V1> comparator1,
TypeSerializer<V2> serializer2,
TypeComparator<V2> comparator2,
TypePairComparator<V1, V2> pairComparator,
MemoryManager memManager,
IOManager ioManager,
AbstractInvokable ownerTask,
double memoryFraction,
boolean probeSideOuterJoin,
boolean buildSideOuterJoin,
boolean useBitmapFilters) throws MemoryAllocationException {
super(firstInput, secondInput, serializer1, comparator1, serializer2,
comparator2, pairComparator, memManager, ioManager, ownerTask,
memoryFraction, probeSideOuterJoin, buildSideOuterJoin, useBitmapFilters);
reopenHashTable = (ReOpenableMutableHashTable<V2, V1>) hashJoin;
}
Example #28
| Source File: HashTableTest.java From flink with Apache License 2.0 | 5 votes |
|
public HashTableTest() {
TypeSerializer<?>[] fieldSerializers = { LongSerializer.INSTANCE, BytePrimitiveArraySerializer.INSTANCE };
@SuppressWarnings("unchecked")
Class<Tuple2<Long, byte[]>> clazz = (Class<Tuple2<Long, byte[]>>) (Class<?>) Tuple2.class;
this.buildSerializer = new TupleSerializer<Tuple2<Long, byte[]>>(clazz, fieldSerializers);
this.probeSerializer = LongSerializer.INSTANCE;
TypeComparator<?>[] comparators = { new LongComparator(true) };
TypeSerializer<?>[] comparatorSerializers = { LongSerializer.INSTANCE };
this.buildComparator = new TupleComparator<Tuple2<Long, byte[]>>(new int[] {0}, comparators, comparatorSerializers);
this.probeComparator = new LongComparator(true);
this.pairComparator = new TypePairComparator<Long, Tuple2<Long, byte[]>>() {
private long ref;
@Override
public void setReference(Long reference) {
ref = reference;
}
@Override
public boolean equalToReference(Tuple2<Long, byte[]> candidate) {
//noinspection UnnecessaryUnboxing
return candidate.f0.longValue() == ref;
}
@Override
public int compareToReference(Tuple2<Long, byte[]> candidate) {
long x = ref;
long y = candidate.f0;
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
};
}
Example #29
| Source File: ReusingSortMergeOuterJoinIteratorITCase.java From flink with Apache License 2.0 | 5 votes |
|
@Override
@SuppressWarnings({"unchecked", "rawtypes"})
protected <T1, T2, T3> AbstractMergeOuterJoinIterator createOuterJoinIterator(OuterJoinType outerJoinType, MutableObjectIterator<T1> input1,
MutableObjectIterator<T2> input2, TypeSerializer<T1> serializer1,
TypeComparator<T1> comparator1, TypeSerializer<T2> serializer2, TypeComparator<T2> comparator2,
TypePairComparator<T1, T2> pairComparator, MemoryManager memoryManager, IOManager ioManager,
int numMemoryPages, AbstractInvokable parentTask) throws Exception {
return new ReusingMergeOuterJoinIterator(outerJoinType, input1, input2, serializer1, comparator1,
serializer2, comparator2, pairComparator, memoryManager, ioManager, numMemoryPages, parentTask);
}
Example #30
| Source File: InPlaceMutableHashTableTest.java From Flink-CEPplus with Apache License 2.0 | 5 votes |
|
public InPlaceMutableHashTableTest() {
TypeSerializer<?>[] fieldSerializers = { LongSerializer.INSTANCE, StringSerializer.INSTANCE };
@SuppressWarnings("unchecked")
Class<Tuple2<Long, String>> clazz = (Class<Tuple2<Long, String>>) (Class<?>) Tuple2.class;
this.serializer = new TupleSerializer<Tuple2<Long, String>>(clazz, fieldSerializers);
TypeComparator<?>[] comparators = { new LongComparator(true) };
TypeSerializer<?>[] comparatorSerializers = { LongSerializer.INSTANCE };
this.comparator = new TupleComparator<Tuple2<Long, String>>(new int[] {0}, comparators, comparatorSerializers);
this.probeComparator = new LongComparator(true);
this.pairComparator = new TypePairComparator<Long, Tuple2<Long, String>>() {
private long ref;
@Override
public void setReference(Long reference) {
ref = reference;
}
@Override
public boolean equalToReference(Tuple2<Long, String> candidate) {
//noinspection UnnecessaryUnboxing
return candidate.f0.longValue() == ref;
}
@Override
public int compareToReference(Tuple2<Long, String> candidate) {
long x = ref;
long y = candidate.f0;
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
};
}
