Refine search
List<Range> orderedRanges = ranges.getOrderedRanges(); SortedRangeSet sortedRangeSet = SortedRangeSet.copyOf(type, orderedRanges); SortedRangeSet complement = sortedRangeSet.complement(); List<Range> singleValueExclusionsList = complement.getOrderedRanges().stream().filter(Range::isSingleValue).collect(toList()); List<Range> originalUnionSingleValues = SortedRangeSet.copyOf(type, singleValueExclusionsList).union(sortedRangeSet).getOrderedRanges(); PeekingIterator<Range> singleValueExclusions = peekingIterator(singleValueExclusionsList.iterator()); if (range.isSingleValue()) { singleValues.add(literalEncoder.toExpression(range.getSingleValue(), type)); continue; while (singleValueExclusions.hasNext() && range.contains(singleValueExclusions.peek())) { singleValuesInRange.add(literalEncoder.toExpression(singleValueExclusions.next().getSingleValue(), type));
@Override public void consume(Consumer<Ranges> rangesConsumer, Consumer<DiscreteValues> valuesConsumer, Consumer<AllOrNone> allOrNoneConsumer) { rangesConsumer.accept(getRanges()); } };
@Test public void testEntireSet() { SortedRangeSet rangeSet = SortedRangeSet.all(BIGINT); assertEquals(rangeSet.getType(), BIGINT); assertFalse(rangeSet.isNone()); assertTrue(rangeSet.isAll()); assertFalse(rangeSet.isSingleValue()); assertEquals(rangeSet.getRangeCount(), 1); assertEquals(rangeSet.complement(), SortedRangeSet.none(BIGINT)); assertTrue(rangeSet.includesMarker(Marker.lowerUnbounded(BIGINT))); assertTrue(rangeSet.includesMarker(Marker.exactly(BIGINT, 0L))); assertTrue(rangeSet.includesMarker(Marker.upperUnbounded(BIGINT))); }
@Override public SortedRangeSet union(Collection<ValueSet> valueSets) { Builder builder = new Builder(type); builder.addAll(this.getOrderedRanges()); for (ValueSet valueSet : valueSets) { builder.addAll(checkCompatibility(valueSet).getOrderedRanges()); } return builder.build(); }
@Test public void testGetSingleValue() { assertEquals(SortedRangeSet.of(BIGINT, 0L).getSingleValue(), 0L); try { SortedRangeSet.all(BIGINT).getSingleValue(); fail(); } catch (IllegalStateException e) { } }
@Test public void testSpan() { try { SortedRangeSet.none(BIGINT).getSpan(); fail(); } catch (IllegalStateException e) { } assertEquals(SortedRangeSet.all(BIGINT).getSpan(), Range.all(BIGINT)); assertEquals(SortedRangeSet.of(BIGINT, 0L).getSpan(), Range.equal(BIGINT, 0L)); assertEquals(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L)).getSpan(), Range.range(BIGINT, 0L, true, 1L, true)); assertEquals(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.greaterThan(BIGINT, 1L)).getSpan(), Range.greaterThanOrEqual(BIGINT, 0L)); assertEquals(SortedRangeSet.of(Range.lessThan(BIGINT, 0L), Range.greaterThan(BIGINT, 1L)).getSpan(), Range.all(BIGINT)); }
@Test public void testBuildSqlWithFloat() throws SQLException { TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains(ImmutableMap.of( columns.get(10), Domain.create(SortedRangeSet.copyOf(REAL, ImmutableList.of( Range.equal(REAL, (long) floatToRawIntBits(100.0f + 0)), Range.equal(REAL, (long) floatToRawIntBits(100.008f + 0)), Range.equal(REAL, (long) floatToRawIntBits(100.0f + 14)))), false))); Connection connection = database.getConnection(); try (PreparedStatement preparedStatement = new QueryBuilder("\"").buildSql(jdbcClient, connection, "", "", "test_table", columns, tupleDomain, Optional.empty()); ResultSet resultSet = preparedStatement.executeQuery()) { ImmutableSet.Builder<Long> longBuilder = ImmutableSet.builder(); ImmutableSet.Builder<Float> floatBuilder = ImmutableSet.builder(); while (resultSet.next()) { longBuilder.add((Long) resultSet.getObject("col_0")); floatBuilder.add((Float) resultSet.getObject("col_10")); } assertEquals(longBuilder.build(), ImmutableSet.of(0L, 14L)); assertEquals(floatBuilder.build(), ImmutableSet.of(100.0f, 114.0f)); } }
@Test public void testNormalBuildSql() throws SQLException TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains(ImmutableMap.<ColumnHandle, Domain>builder() .put(columns.get(0), Domain.create(SortedRangeSet.copyOf(BIGINT, ImmutableList.of( Range.equal(BIGINT, 128L), Range.equal(BIGINT, 180L), Range.equal(BIGINT, 233L), .put(columns.get(1), Domain.create(SortedRangeSet.copyOf(DOUBLE, ImmutableList.of( .put(columns.get(7), Domain.create(SortedRangeSet.copyOf(TINYINT, ImmutableList.of( false)) .put(columns.get(8), Domain.create(SortedRangeSet.copyOf(SMALLINT, .put(columns.get(9), Domain.create(SortedRangeSet.copyOf(INTEGER, .put(columns.get(2), Domain.create(SortedRangeSet.copyOf(BOOLEAN, builder.add((Long) resultSet.getObject("col_0")); assertEquals(builder.build(), ImmutableSet.of(68L, 180L, 196L));
@Test public void testSingleValue() { SortedRangeSet rangeSet = SortedRangeSet.of(BIGINT, 10L); SortedRangeSet complement = SortedRangeSet.of(Range.greaterThan(BIGINT, 10L), Range.lessThan(BIGINT, 10L)); assertEquals(rangeSet.getType(), BIGINT); assertFalse(rangeSet.isNone()); assertFalse(rangeSet.isAll()); assertTrue(rangeSet.isSingleValue()); assertTrue(Iterables.elementsEqual(rangeSet.getOrderedRanges(), ImmutableList.of(Range.equal(BIGINT, 10L)))); assertEquals(rangeSet.getRangeCount(), 1); assertEquals(rangeSet.complement(), complement); assertFalse(rangeSet.includesMarker(Marker.lowerUnbounded(BIGINT))); assertTrue(rangeSet.includesMarker(Marker.exactly(BIGINT, 10L))); assertFalse(rangeSet.includesMarker(Marker.exactly(BIGINT, 9L))); assertFalse(rangeSet.includesMarker(Marker.upperUnbounded(BIGINT))); }
SortedRangeSet rangeSet = SortedRangeSet.of( Range.greaterThan(BIGINT, 10L), Range.lessThanOrEqual(BIGINT, 0L), Range.range(BIGINT, 2L, true, 4L, false), Range.range(BIGINT, 4L, true, 6L, false), Range.range(BIGINT, 1L, false, 2L, false), Range.range(BIGINT, 9L, false, 11L, false)); SortedRangeSet complement = SortedRangeSet.of( Range.range(BIGINT, 0L, false, 1L, true), Range.range(BIGINT, 6L, true, 9L, true)); assertEquals(rangeSet.getType(), BIGINT); assertFalse(rangeSet.isNone()); assertFalse(rangeSet.isAll()); assertFalse(rangeSet.isSingleValue()); assertTrue(Iterables.elementsEqual(rangeSet.getOrderedRanges(), normalizedResult)); assertEquals(rangeSet, SortedRangeSet.copyOf(BIGINT, normalizedResult)); assertEquals(rangeSet.getRangeCount(), 3); assertEquals(rangeSet.complement(), complement); assertTrue(rangeSet.includesMarker(Marker.lowerUnbounded(BIGINT))); assertTrue(rangeSet.includesMarker(Marker.exactly(BIGINT, 0L))); assertTrue(rangeSet.includesMarker(Marker.exactly(BIGINT, 4L))); assertFalse(rangeSet.includesMarker(Marker.exactly(BIGINT, 7L))); assertTrue(rangeSet.includesMarker(Marker.upperUnbounded(BIGINT)));
private void assertUnion(SortedRangeSet first, SortedRangeSet second, SortedRangeSet expected) { assertEquals(first.union(second), expected); assertEquals(first.union(ImmutableList.of(first, second)), expected); } }
@Test public void testOverlaps() { assertTrue(SortedRangeSet.all(BIGINT).overlaps(SortedRangeSet.all(BIGINT))); assertFalse(SortedRangeSet.all(BIGINT).overlaps(SortedRangeSet.none(BIGINT))); assertTrue(SortedRangeSet.all(BIGINT).overlaps(SortedRangeSet.of(BIGINT, 0L))); assertTrue(SortedRangeSet.all(BIGINT).overlaps(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L)))); assertTrue(SortedRangeSet.all(BIGINT).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L)))); assertTrue(SortedRangeSet.all(BIGINT).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L), Range.lessThan(BIGINT, 0L)))); assertFalse(SortedRangeSet.none(BIGINT).overlaps(SortedRangeSet.all(BIGINT))); assertFalse(SortedRangeSet.none(BIGINT).overlaps(SortedRangeSet.none(BIGINT))); assertFalse(SortedRangeSet.none(BIGINT).overlaps(SortedRangeSet.of(BIGINT, 0L))); assertFalse(SortedRangeSet.none(BIGINT).overlaps(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L)))); assertFalse(SortedRangeSet.none(BIGINT).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L)))); assertFalse(SortedRangeSet.none(BIGINT).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L), Range.lessThan(BIGINT, 0L)))); assertTrue(SortedRangeSet.of(BIGINT, 0L).overlaps(SortedRangeSet.all(BIGINT))); assertFalse(SortedRangeSet.of(BIGINT, 0L).overlaps(SortedRangeSet.none(BIGINT))); assertTrue(SortedRangeSet.of(BIGINT, 0L).overlaps(SortedRangeSet.of(BIGINT, 0L))); assertTrue(SortedRangeSet.of(BIGINT, 0L).overlaps(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L)))); assertFalse(SortedRangeSet.of(BIGINT, 0L).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L)))); assertFalse(SortedRangeSet.of(BIGINT, 0L).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L), Range.lessThan(BIGINT, 0L)))); assertTrue(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L)).overlaps(SortedRangeSet.of(Range.equal(BIGINT, 1L)))); assertFalse(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L)).overlaps(SortedRangeSet.of(Range.equal(BIGINT, 2L)))); assertTrue(SortedRangeSet.of(Range.greaterThanOrEqual(BIGINT, 0L)).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L)))); assertTrue(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L)).overlaps(SortedRangeSet.of(Range.greaterThanOrEqual(BIGINT, 0L)))); assertFalse(SortedRangeSet.of(Range.lessThan(BIGINT, 0L)).overlaps(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L)))); }
assertEquals( SortedRangeSet.none(BIGINT).intersect( SortedRangeSet.none(BIGINT)), SortedRangeSet.none(BIGINT)); assertEquals( SortedRangeSet.all(BIGINT).intersect( SortedRangeSet.all(BIGINT)), SortedRangeSet.all(BIGINT)); assertEquals( SortedRangeSet.none(BIGINT).intersect( SortedRangeSet.all(BIGINT)), SortedRangeSet.none(BIGINT)); SortedRangeSet.of(Range.equal(BIGINT, 1L), Range.equal(BIGINT, 2L), Range.equal(BIGINT, 3L)).intersect( SortedRangeSet.of(Range.equal(BIGINT, 2L), Range.equal(BIGINT, 4L))), SortedRangeSet.of(Range.equal(BIGINT, 2L))); SortedRangeSet.all(BIGINT).intersect( SortedRangeSet.of(Range.equal(BIGINT, 2L), Range.equal(BIGINT, 4L))), SortedRangeSet.of(Range.equal(BIGINT, 2L), Range.equal(BIGINT, 4L))); SortedRangeSet.of(Range.range(BIGINT, 0L, true, 4L, false)).intersect( SortedRangeSet.of(Range.equal(BIGINT, 2L), Range.greaterThan(BIGINT, 3L))), SortedRangeSet.of(Range.equal(BIGINT, 2L), Range.range(BIGINT, 3L, false, 4L, false))); SortedRangeSet.of(Range.greaterThanOrEqual(BIGINT, 0L)).intersect( SortedRangeSet.of(Range.lessThanOrEqual(BIGINT, 0L))),
assertEquals( SortedRangeSet.all(BIGINT).subtract(SortedRangeSet.all(BIGINT)), SortedRangeSet.none(BIGINT)); assertEquals( SortedRangeSet.all(BIGINT).subtract(SortedRangeSet.none(BIGINT)), SortedRangeSet.all(BIGINT)); assertEquals( SortedRangeSet.all(BIGINT).subtract(SortedRangeSet.of(BIGINT, 0L)), SortedRangeSet.of(BIGINT, 0L).complement()); assertEquals( SortedRangeSet.all(BIGINT).subtract(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L))), SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L)).complement()); assertEquals( SortedRangeSet.all(BIGINT).subtract(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L))), SortedRangeSet.of(Range.lessThanOrEqual(BIGINT, 0L))); SortedRangeSet.none(BIGINT).subtract(SortedRangeSet.all(BIGINT)), SortedRangeSet.none(BIGINT)); assertEquals( SortedRangeSet.none(BIGINT).subtract(SortedRangeSet.none(BIGINT)), SortedRangeSet.none(BIGINT)); assertEquals( SortedRangeSet.none(BIGINT).subtract(SortedRangeSet.of(BIGINT, 0L)), SortedRangeSet.none(BIGINT)); assertEquals( SortedRangeSet.none(BIGINT).subtract(SortedRangeSet.of(Range.equal(BIGINT, 0L), Range.equal(BIGINT, 1L))), SortedRangeSet.none(BIGINT)); assertEquals( SortedRangeSet.none(BIGINT).subtract(SortedRangeSet.of(Range.greaterThan(BIGINT, 0L))),
@Test public void testJsonSerialization() throws Exception { TestingTypeManager typeManager = new TestingTypeManager(); TestingBlockEncodingSerde blockEncodingSerde = new TestingBlockEncodingSerde(typeManager); ObjectMapper mapper = new ObjectMapperProvider().get() .registerModule(new SimpleModule() .addDeserializer(Type.class, new TestingTypeDeserializer(typeManager)) .addSerializer(Block.class, new TestingBlockJsonSerde.Serializer(blockEncodingSerde)) .addDeserializer(Block.class, new TestingBlockJsonSerde.Deserializer(blockEncodingSerde))); SortedRangeSet set = SortedRangeSet.all(BIGINT); assertEquals(set, mapper.readValue(mapper.writeValueAsString(set), SortedRangeSet.class)); set = SortedRangeSet.none(DOUBLE); assertEquals(set, mapper.readValue(mapper.writeValueAsString(set), SortedRangeSet.class)); set = SortedRangeSet.of(VARCHAR, utf8Slice("abc")); assertEquals(set, mapper.readValue(mapper.writeValueAsString(set), SortedRangeSet.class)); set = SortedRangeSet.of(Range.equal(BOOLEAN, true), Range.equal(BOOLEAN, false)); assertEquals(set, mapper.readValue(mapper.writeValueAsString(set), SortedRangeSet.class)); }
@Test public void testUnion() { assertUnion(SortedRangeSet.none(BIGINT), SortedRangeSet.none(BIGINT), SortedRangeSet.none(BIGINT)); assertUnion(SortedRangeSet.all(BIGINT), SortedRangeSet.all(BIGINT), SortedRangeSet.all(BIGINT)); assertUnion(SortedRangeSet.none(BIGINT), SortedRangeSet.all(BIGINT), SortedRangeSet.all(BIGINT)); assertUnion( SortedRangeSet.of(Range.equal(BIGINT, 1L), Range.equal(BIGINT, 2L)), SortedRangeSet.of(Range.equal(BIGINT, 2L), Range.equal(BIGINT, 3L)), SortedRangeSet.of(Range.equal(BIGINT, 1L), Range.equal(BIGINT, 2L), Range.equal(BIGINT, 3L))); assertUnion(SortedRangeSet.all(BIGINT), SortedRangeSet.of(Range.equal(BIGINT, 0L)), SortedRangeSet.all(BIGINT)); assertUnion( SortedRangeSet.of(Range.range(BIGINT, 0L, true, 4L, false)), SortedRangeSet.of(Range.greaterThan(BIGINT, 3L)), SortedRangeSet.of(Range.greaterThanOrEqual(BIGINT, 0L))); assertUnion( SortedRangeSet.of(Range.greaterThanOrEqual(BIGINT, 0L)), SortedRangeSet.of(Range.lessThanOrEqual(BIGINT, 0L)), SortedRangeSet.of(Range.all(BIGINT))); assertUnion( SortedRangeSet.of(Range.greaterThan(BIGINT, 0L)), SortedRangeSet.of(Range.lessThan(BIGINT, 0L)), SortedRangeSet.of(BIGINT, 0L).complement()); }
public static PrestoThriftRangeValueSet fromSortedRangeSet(SortedRangeSet valueSet) { List<PrestoThriftRange> ranges = valueSet.getOrderedRanges().stream() .map(PrestoThriftRange::fromRange) .collect(toImmutableList()); return new PrestoThriftRangeValueSet(ranges); }
ColumnSchema columnSchema = schema.getColumnByIndex(position); Domain domain = columnDomain.getDomain(); if (domain.isNone()) { return false; else if (domain.isAll()) { else if (domain.isOnlyNull()) { builder.addPredicate(KuduPredicate.newIsNullPredicate(columnSchema)); Ranges ranges = ((SortedRangeSet) valueSet).getRanges(); Range span = ranges.getSpan(); Marker low = span.getLow(); if (!low.isLowerUnbounded()) { KuduPredicate.ComparisonOp op = (low.getBound() == Marker.Bound.ABOVE) builder.addPredicate(predicate); Marker high = span.getHigh(); if (!high.isUpperUnbounded()) { KuduPredicate.ComparisonOp op = (low.getBound() == Marker.Bound.BELOW)
@Override public SortedRangeSet intersect(ValueSet other) { SortedRangeSet otherRangeSet = checkCompatibility(other); Builder builder = new Builder(type); Iterator<Range> iterator1 = getOrderedRanges().iterator(); Iterator<Range> iterator2 = otherRangeSet.getOrderedRanges().iterator(); if (iterator1.hasNext() && iterator2.hasNext()) { Range range1 = iterator1.next(); Range range2 = iterator2.next(); while (true) { if (range1.overlaps(range2)) { builder.add(range1.intersect(range2)); } if (range1.getHigh().compareTo(range2.getHigh()) <= 0) { if (!iterator1.hasNext()) { break; } range1 = iterator1.next(); } else { if (!iterator2.hasNext()) { break; } range2 = iterator2.next(); } } } return builder.build(); }
/** * Provided discrete values that are unioned together to form the SortedRangeSet */ static SortedRangeSet of(Type type, Object first, Object... rest) { List<Range> ranges = new ArrayList<>(rest.length + 1); ranges.add(Range.equal(type, first)); for (Object value : rest) { ranges.add(Range.equal(type, value)); } return copyOf(type, ranges); }