private boolean meetsPredicate(List<String> fields) { if (!timestampOrdinalPosition.isPresent() || !domain.isPresent()) { return true; } long millis = Instant.from(ISO_FORMATTER.parse(fields.get(timestampOrdinalPosition.getAsInt()))).toEpochMilli(); return domain.get().includesNullableValue(millis); }
private static boolean pathMatchesPredicate(Optional<Domain> pathDomain, String path) { if (!pathDomain.isPresent()) { return true; } return pathDomain.get().includesNullableValue(utf8Slice(path)); } }
private static boolean isThisServerIncluded(HostAddress address, TupleDomain<LocalFileColumnHandle> predicate, LocalFileTableHandle table) { if (!table.getServerAddressColumn().isPresent()) { return true; } Optional<Map<LocalFileColumnHandle, Domain>> domains = predicate.getDomains(); if (!domains.isPresent()) { return true; } Set<Domain> serverAddressDomain = domains.get().entrySet().stream() .filter(entry -> entry.getKey().getOrdinalPosition() == table.getServerAddressColumn().getAsInt()) .map(Map.Entry::getValue) .collect(toSet()); if (serverAddressDomain.isEmpty()) { return true; } for (Domain domain : serverAddressDomain) { if (domain.includesNullableValue(Slices.utf8Slice(address.toString()))) { return true; } } return false; }
private Optional<HivePartition> parseValuesAndFilterPartition( SchemaTableName tableName, String partitionId, List<HiveColumnHandle> partitionColumns, List<Type> partitionColumnTypes, Constraint<ColumnHandle> constraint) { HivePartition partition = parsePartition(tableName, partitionId, partitionColumns, partitionColumnTypes, timeZone); Map<ColumnHandle, Domain> domains = constraint.getSummary().getDomains().get(); for (HiveColumnHandle column : partitionColumns) { NullableValue value = partition.getKeys().get(column); Domain allowedDomain = domains.get(column); if (allowedDomain != null && !allowedDomain.includesNullableValue(value.getValue())) { return Optional.empty(); } } if (constraint.predicate().isPresent() && !constraint.predicate().get().test(partition.getKeys())) { return Optional.empty(); } return Optional.of(partition); }
@Test public void testOrderableNone() { Domain domain = Domain.none(BIGINT); assertTrue(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(BIGINT)); assertEquals(domain.getType(), BIGINT); assertFalse(domain.includesNullableValue(Long.MIN_VALUE)); assertFalse(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(Long.MAX_VALUE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.all(BIGINT)); }
@Test public void testOrderableNotNull() { Domain domain = Domain.notNull(BIGINT); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(BIGINT)); assertEquals(domain.getType(), BIGINT); assertTrue(domain.includesNullableValue(Long.MIN_VALUE)); assertTrue(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(Long.MAX_VALUE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.onlyNull(BIGINT)); }
@Test public void testOrderableAll() { Domain domain = Domain.all(BIGINT); assertFalse(domain.isNone()); assertTrue(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(BIGINT)); assertEquals(domain.getType(), BIGINT); assertTrue(domain.includesNullableValue(Long.MIN_VALUE)); assertTrue(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(Long.MAX_VALUE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.none(BIGINT)); }
@Test public void testOrderableNullOnly() { Domain domain = Domain.onlyNull(BIGINT); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertTrue(domain.isNullAllowed()); assertTrue(domain.isNullableSingleValue()); assertTrue(domain.isOnlyNull()); assertEquals(domain.getValues(), ValueSet.none(BIGINT)); assertEquals(domain.getType(), BIGINT); assertFalse(domain.includesNullableValue(Long.MIN_VALUE)); assertFalse(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(Long.MAX_VALUE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.notNull(BIGINT)); assertEquals(domain.getNullableSingleValue(), null); }
@Test public void testUncomparableNone() { Domain domain = Domain.none(HYPER_LOG_LOG); assertTrue(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertFalse(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.all(HYPER_LOG_LOG)); }
@Test public void testUncomparableAll() { Domain domain = Domain.all(HYPER_LOG_LOG); assertFalse(domain.isNone()); assertTrue(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertTrue(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.none(HYPER_LOG_LOG)); }
@Test public void testEquatableNone() { Domain domain = Domain.none(ID); assertTrue(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(ID)); assertEquals(domain.getType(), ID); assertFalse(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.all(ID)); }
@Test public void testEquatableAll() { Domain domain = Domain.all(ID); assertFalse(domain.isNone()); assertTrue(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(ID)); assertEquals(domain.getType(), ID); assertTrue(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.none(ID)); }
@Test public void testEquatableNotNull() { Domain domain = Domain.notNull(ID); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(ID)); assertEquals(domain.getType(), ID); assertTrue(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.onlyNull(ID)); }
@Test public void testUncomparableNotNull() { Domain domain = Domain.notNull(HYPER_LOG_LOG); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertTrue(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.onlyNull(HYPER_LOG_LOG)); }
@Test public void testEquatableNullOnly() { Domain domain = Domain.onlyNull(ID); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertTrue(domain.isNullableSingleValue()); assertTrue(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(ID)); assertEquals(domain.getType(), ID); assertFalse(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.notNull(ID)); assertEquals(domain.getNullableSingleValue(), null); }
@Test public void testUncomparableNullOnly() { Domain domain = Domain.onlyNull(HYPER_LOG_LOG); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertTrue(domain.isNullableSingleValue()); assertTrue(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertFalse(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.notNull(HYPER_LOG_LOG)); assertEquals(domain.getNullableSingleValue(), null); }
@Test public void testOrderableSingleValue() { Domain domain = Domain.singleValue(BIGINT, 0L); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertTrue(domain.isSingleValue()); assertTrue(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.ofRanges(Range.equal(BIGINT, 0L))); assertEquals(domain.getType(), BIGINT); assertFalse(domain.includesNullableValue(Long.MIN_VALUE)); assertTrue(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(Long.MAX_VALUE)); assertEquals(domain.complement(), Domain.create(ValueSet.ofRanges(Range.lessThan(BIGINT, 0L), Range.greaterThan(BIGINT, 0L)), true)); assertEquals(domain.getSingleValue(), 0L); assertEquals(domain.getNullableSingleValue(), 0L); try { Domain.create(ValueSet.ofRanges(Range.range(BIGINT, 1L, true, 2L, true)), false).getSingleValue(); fail(); } catch (IllegalStateException e) { } }
@Test public void testEquatableSingleValue() { Domain domain = Domain.singleValue(ID, 0L); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertTrue(domain.isSingleValue()); assertTrue(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.of(ID, 0L)); assertEquals(domain.getType(), ID); assertTrue(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.create(ValueSet.of(ID, 0L).complement(), true)); assertEquals(domain.getSingleValue(), 0L); assertEquals(domain.getNullableSingleValue(), 0L); try { Domain.create(ValueSet.of(ID, 0L, 1L), false).getSingleValue(); fail(); } catch (IllegalStateException e) { } }
private Optional<Map<ColumnHandle, NullableValue>> parseValuesAndFilterPartition(String partitionName, List<HiveColumnHandle> partitionColumns, TupleDomain<ColumnHandle> predicate) { checkArgument(predicate.getDomains().isPresent()); List<String> partitionValues = extractPartitionKeyValues(partitionName); Map<ColumnHandle, Domain> domains = predicate.getDomains().get(); ImmutableMap.Builder<ColumnHandle, NullableValue> builder = ImmutableMap.builder(); for (int i = 0; i < partitionColumns.size(); i++) { HiveColumnHandle column = partitionColumns.get(i); NullableValue parsedValue = parsePartitionValue(partitionName, partitionValues.get(i), column.getHiveType(), timeZone); Domain allowedDomain = domains.get(column); if (allowedDomain != null && !allowedDomain.includesNullableValue(parsedValue.getValue())) { return Optional.empty(); } builder.put(column, parsedValue); } return Optional.of(builder.build()); }