public RangeParam(TupleRange range, boolean lastInclusive, RowStoreEncoder encoder) { this.start = encoder.toBytes(range.getStart()); this.end = encoder.toBytes(range.getEnd()); this.lastInclusive = lastInclusive; }
public RangeParam(TupleRange range, boolean lastInclusive, RowStoreEncoder encoder) { this.start = encoder.toBytes(range.getStart()); this.end = encoder.toBytes(range.getEnd()); this.lastInclusive = lastInclusive; }
@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)); }
@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)); }
@Test public void testPartitionForINT8Asc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.INT8).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createInt8(1)); e.put(0, DatumFactory.createInt8(10000)); 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)); }
@Test public void testIncrementOfUnicodeOneCharMultiPartition() { Schema schema = SchemaBuilder.builder() .add("col1", Type.TEXT).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); s.put(0, DatumFactory.createText("가")); VTuple e = new VTuple(1); e.put(0, DatumFactory.createText("꽥")); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 8; 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)); }
@Test public void testPartitionForMultipleChars() { Schema schema = SchemaBuilder.builder() .add("KEY1", Type.TEXT).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); s.put(0, DatumFactory.createText("AAA")); VTuple e = new VTuple(1); e.put(0, DatumFactory.createText("ZZZ")); TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); TupleRange [] ranges = partitioner.partition(48); TupleRange prev = null; for (int i = 0; i < ranges.length; i++) { if (prev != null) { assertTrue(i + "th, prev=" + prev + ",cur=" + ranges[i], prev.compareTo(ranges[i]) < 0); } prev = ranges[i]; } assertEquals(48, ranges.length); assertTrue(ranges[0].getStart().equals(s)); assertTrue(ranges[47].getEnd().equals(e)); }
@Test public void testPartitionForFloat4Asc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.FLOAT4) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createFloat4((float) 1.0)); e.put(0, DatumFactory.createFloat4((float) 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)); }
@Test public void testPartitionForUnicodeTextAsc() { 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)); }
@Test public void testPartitionForUnicodeDiffLenBeginTextAsc() { 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)); }
@Test public void testPartitionForMultipleCharsWithSameFirstChar() { Schema schema = SchemaBuilder.builder() .add("KEY1", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); s.put(0, DatumFactory.createText("AAA")); VTuple e = new VTuple(1); e.put(0, DatumFactory.createText("AAZ")); final int partNum = 4; TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); 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)); }
@Test public void testPartitionForMultipleChars2() { Schema schema = SchemaBuilder .builder() .add("KEY1", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); s.put(0, DatumFactory.createText("A1")); VTuple e = new VTuple(1); e.put(0, DatumFactory.createText("A999975")); final int partNum = 2; TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); 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)); }
@Test public void testPartitionForUnicodeDiffLenBeginTextDesc() { Schema schema = SchemaBuilder.builder().add("col1", Type.TEXT).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); sortSpecs[0].setDescOrder(); 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)); }
@Test public void testPartitionForINT4Desc() { Schema schema = SchemaBuilder.builder().add("col1", Type.INT4).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); sortSpecs[0].setDescOrder(); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createInt4(10000)); e.put(0, DatumFactory.createInt4(1)); 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)); }
@Test public void testPartitionForINT2Asc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.INT2) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createInt2((short) 1)); e.put(0, DatumFactory.createInt2((short) 30000)); 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)); }
@Test public void testPartitionForINT4Asc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.INT4) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createInt4(1)); e.put(0, DatumFactory.createInt4(10000)); 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)); }
@Test public void testIncrementOfUnicodeOneCharSinglePartition() { Schema schema = SchemaBuilder.builder() .add("col1", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); s.put(0, DatumFactory.createText("가")); VTuple e = new VTuple(1); e.put(0, DatumFactory.createText("다")); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 1; 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)); }
@Test public void testPartitionForUnicodeDiffLenEndTextDesc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); sortSpecs[0].setDescOrder(); 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)); }
@Test public void testPartitionForUnicodeTextDesc() { Schema schema = SchemaBuilder.builder().add("col1", Type.TEXT).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); sortSpecs[0].setDescOrder(); 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)); }
@Test public void testPartitionForFloat4Desc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.FLOAT4) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); sortSpecs[0].setDescOrder(); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createFloat4((float) 10000.0)); e.put(0, DatumFactory.createFloat4((float) 1.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)); }