Tuple last = mergedRange.getStart(); TupleRange tupleRange; tupleRange = new TupleRange(sortSpecs, last, mergedRange.getEnd()); } else { Tuple next = increment(last, term, variableId); tupleRange = new TupleRange(sortSpecs, last, next); last = ranges.get(ranges.size() - 1).getEnd(); reminder = reminder.subtract(term); ranges.get(0).setStart(originalRange.getStart()); ranges.get(ranges.size() - 1).setEnd(originalRange.getEnd()); Preconditions.checkState(ranges.get(i - 2).compareTo(ranges.get(i - 1)) < 0, "Computed ranges are not totally ordered. Previous key=" + ranges.get(i - 2) + ", Current Key=" + ranges.get(i - 1));
public TupleRange(final SortSpec[] sortSpecs, final Tuple start, final Tuple end) { this.comp = new BaseTupleComparator(sortSpecsToSchema(sortSpecs), sortSpecs); // if there is only one value, start == end this.start = start; this.end = end; }
@Test public void testPartitionForFloat8Asc() { Schema schema = SchemaBuilder.builder().add("col1", Type.FLOAT8).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createFloat8(1.0)); e.put(0, DatumFactory.createFloat8(10000.0)); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 64; TupleRange [] ranges = partitioner.partition(partNum); TupleRange prev = null; for (TupleRange r : ranges) { if (prev != null) { assertTrue(prev.compareTo(r) < 0); } prev = r; } assertEquals(partNum, ranges.length); assertTrue(ranges[0].getStart().equals(s)); assertTrue(ranges[partNum - 1].getEnd().equals(e)); }
Tuple previousTuple = dataRange.getStart(); tupleRanges.add(new TupleRange(sortSpecs, previousTuple, endTuple)); previousTuple = endTuple; if (comparator.compare(dataRange.getEnd(), tupleRanges.get(tupleRanges.size() - 1).getStart()) >= 0) { tupleRanges.get(tupleRanges.size() - 1).setEnd(dataRange.getEnd()); } else { tupleRanges.remove(tupleRanges.size() - 1);
return new TupleRange(sortSpecs, startTuple, endTuple);
@Test /** * TODO - Now, in FSM branch, TestUniformRangePartition is ported to Java. * So, this test is located in here. * Later it should be moved TestUniformPartitions. */ public void testTAJO_946() { Schema schema = SchemaBuilder.builder().add("l_orderkey", Type.INT8).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); s.put(0, DatumFactory.createInt8(0)); VTuple e = new VTuple(1); e.put(0, DatumFactory.createInt8(6000000000l)); TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); TupleRange [] ranges = partitioner.partition(967); TupleRange prev = null; for (TupleRange r : ranges) { if (prev == null) { prev = r; } else { assertTrue(prev.compareTo(r) < 0); } } } }
eTuple.put(5, DatumFactory.createFloat8(170)); RangePartitionAlgorithm partitioner = new UniformRangePartition(new TupleRange(sortSpecs, sTuple, eTuple), sortSpecs); TupleRange [] ranges = partitioner.partition(4); TupleRange prev = ranges[0]; for (int i = 1; i < ranges.length; i++) { assertTrue(comp.compare(prev.getStart(), ranges[i].getStart()) < 0); assertTrue(comp.compare(prev.getEnd(), ranges[i].getEnd()) < 0); prev = ranges[i];
case BIT: { long candidate = last.getByte(colId) + inc; byte end = mergedRange.getEnd().getByte(colId); reminder = candidate - end; break; char end = mergedRange.getEnd().getChar(colId); reminder = candidate - end; break; case INT4: { int candidate = (int) (last.getInt4(colId) + inc); int end = mergedRange.getEnd().getInt4(colId); reminder = candidate - end; break; case INET4: { long candidate = last.getInt8(colId) + inc; long end = mergedRange.getEnd().getInt8(colId); reminder = candidate - end; break; float end = mergedRange.getEnd().getFloat4(colId); reminder = (long) (candidate - end); break; double end = mergedRange.getEnd().getFloat8(colId); reminder = (long) Math.ceil(candidate - end); break;
case CHAR: if (overflowFlag[i]) { end.put(i, DatumFactory.createChar((char) (mergedRange.getStart().getChar(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createBit( (byte) (mergedRange.getStart().getByte(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createInt2( (short) (mergedRange.getStart().getInt2(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createInt4( (int) (mergedRange.getStart().getInt4(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createInt8( mergedRange.getStart().getInt8(i) + incs[i].longValue())); } else { if (sortSpecs[i].isAscending()) {
@Override public int compare(TupleRange left, TupleRange right) { return right.compareTo(left); } }
@Test public void testPartitionForUnicodeDiffLenEndTextAsc() { Schema schema = SchemaBuilder.builder().add("col1", Type.TEXT).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createText("가가가")); e.put(0, DatumFactory.createText("하")); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 64; TupleRange [] ranges = partitioner.partition(partNum); TupleRange prev = null; for (TupleRange r : ranges) { if (prev != null) { assertTrue(prev.compareTo(r) < 0); } prev = r; } assertEquals(partNum, ranges.length); assertTrue(ranges[0].getStart().equals(s)); assertTrue(ranges[partNum - 1].getEnd().equals(e)); }
Tuple previousTuple = dataRange.getStart(); tupleRanges.add(new TupleRange(sortSpecs, previousTuple, endTuple)); previousTuple = endTuple; if (comparator.compare(dataRange.getEnd(), tupleRanges.get(tupleRanges.size() - 1).getStart()) >= 0) { tupleRanges.get(tupleRanges.size() - 1).setEnd(dataRange.getEnd()); } else { tupleRanges.remove(tupleRanges.size() - 1);
return new TupleRange(sortSpecs, startTuple, endTuple);
@Test public void testPartition() { Schema schema = SchemaBuilder.builder() .add("l_returnflag", Type.TEXT) .add("l_linestatus", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(2); s.put(0, DatumFactory.createText("A")); s.put(1, DatumFactory.createText("F")); VTuple e = new VTuple(2); e.put(0, DatumFactory.createText("R")); e.put(1, DatumFactory.createText("O")); TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); TupleRange [] ranges = partitioner.partition(31); TupleRange prev = null; for (TupleRange r : ranges) { if (prev != null) { assertTrue(prev.compareTo(r) < 0); } prev = r; } }
case BIT: { long candidate = last.getByte(colId) + inc; byte end = mergedRange.getEnd().getByte(colId); reminder = candidate - end; break; char end = mergedRange.getEnd().getChar(colId); reminder = candidate - end; break; case INT4: { int candidate = (int) (last.getInt4(colId) + inc); int end = mergedRange.getEnd().getInt4(colId); reminder = candidate - end; break; case INT8: { long candidate = last.getInt8(colId) + inc; long end = mergedRange.getEnd().getInt8(colId); reminder = candidate - end; break; float end = mergedRange.getEnd().getFloat4(colId); reminder = (long) (candidate - end); break; double end = mergedRange.getEnd().getFloat8(colId); reminder = (long) Math.ceil(candidate - end); break;
case CHAR: if (overflowFlag[i]) { end.put(i, DatumFactory.createChar((char) (mergedRange.getStart().getChar(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createBit( (byte) (mergedRange.getStart().getByte(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createInt2( (short) (mergedRange.getStart().getInt2(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createInt4( (int) (mergedRange.getStart().getInt4(i) + incs[i].longValue()))); } else { if (sortSpecs[i].isAscending()) { if (overflowFlag[i]) { end.put(i, DatumFactory.createInt8( mergedRange.getStart().getInt8(i) + incs[i].longValue())); } else { if (sortSpecs[i].isAscending()) {