@Override protected ExtractionResult visitNullLiteral(NullLiteral node, Boolean complement) { return new ExtractionResult(TupleDomain.none(), TRUE_LITERAL); } }
@JsonCreator // Available for Jackson deserialization only! public static <T> TupleDomain<T> fromColumnDomains(@JsonProperty("columnDomains") Optional<List<ColumnDomain<T>>> columnDomains) { if (!columnDomains.isPresent()) { return none(); } return withColumnDomains(columnDomains.get().stream() .collect(toMap(ColumnDomain::getColumn, ColumnDomain::getDomain))); }
public static <V> Constraint<V> alwaysFalse() { return new Constraint<>(TupleDomain.<V>none(), Optional.of(bindings -> false)); }
@VisibleForTesting static TupleDomain<ColumnHandle> createPredicate(List<ColumnHandle> partitionColumns, List<HivePartition> partitions) { if (partitions.isEmpty()) { return TupleDomain.none(); } return withColumnDomains( partitionColumns.stream() .collect(Collectors.toMap( identity(), column -> buildColumnDomain(column, partitions)))); }
public <U> TupleDomain<U> transform(Function<T, U> function) { if (!domains.isPresent()) { return TupleDomain.none(); } HashMap<U, Domain> result = new HashMap<>(domains.get().size()); for (Map.Entry<T, Domain> entry : domains.get().entrySet()) { U key = function.apply(entry.getKey()); if (key == null) { continue; } Domain previous = result.put(key, entry.getValue()); if (previous != null) { throw new IllegalArgumentException(String.format("Every argument must have a unique mapping. %s maps to %s and %s", entry.getKey(), entry.getValue(), previous)); } } return TupleDomain.withColumnDomains(result); }
/** * Returns the strict intersection of the TupleDomains. * The resulting TupleDomain represents the set of tuples that would be valid * in both TupleDomains. */ public TupleDomain<T> intersect(TupleDomain<T> other) { if (this.isNone() || other.isNone()) { return none(); } Map<T, Domain> intersected = new HashMap<>(this.getDomains().get()); for (Map.Entry<T, Domain> entry : other.getDomains().get().entrySet()) { Domain intersectionDomain = intersected.get(entry.getKey()); if (intersectionDomain == null) { intersected.put(entry.getKey(), entry.getValue()); } else { intersected.put(entry.getKey(), intersectionDomain.intersect(entry.getValue())); } } return withColumnDomains(intersected); }
public static TupleDomain<ColumnDescriptor> getParquetTupleDomain(Map<List<String>, RichColumnDescriptor> descriptorsByPath, TupleDomain<HiveColumnHandle> effectivePredicate) { if (effectivePredicate.isNone()) { return TupleDomain.none(); } ImmutableMap.Builder<ColumnDescriptor, Domain> predicate = ImmutableMap.builder(); for (Entry<HiveColumnHandle, Domain> entry : effectivePredicate.getDomains().get().entrySet()) { HiveColumnHandle columnHandle = entry.getKey(); // skip looking up predicates for complex types as Parquet only stores stats for primitives if (!columnHandle.getHiveType().getCategory().equals(PRIMITIVE)) { continue; } RichColumnDescriptor descriptor = descriptorsByPath.get(ImmutableList.of(columnHandle.getName())); if (descriptor != null) { predicate.put(descriptor, entry.getValue()); } } return TupleDomain.withColumnDomains(predicate.build()); }
@Test public void testExtractFixedValuesFromNone() { assertFalse(TupleDomain.extractFixedValues(TupleDomain.none()).isPresent()); }
@Test public void testNoneIntersection() { assertEquals(TupleDomain.none().intersect(TupleDomain.all()), TupleDomain.none()); assertEquals(TupleDomain.all().intersect(TupleDomain.none()), TupleDomain.none()); assertEquals(TupleDomain.none().intersect(TupleDomain.none()), TupleDomain.none()); assertEquals( TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.onlyNull(BIGINT))) .intersect(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.notNull(BIGINT)))), TupleDomain.<ColumnHandle>none()); }
@Override protected ExtractionResult visitBooleanLiteral(BooleanLiteral node, Boolean complement) { boolean value = complement ? !node.getValue() : node.getValue(); return new ExtractionResult(value ? TupleDomain.all() : TupleDomain.none(), TRUE_LITERAL); }
@Test public void testNone() { assertTrue(TupleDomain.none().isNone()); assertEquals(TupleDomain.<ColumnHandle>none(), TupleDomain.withColumnDomains(ImmutableMap.of( A, Domain.none(BIGINT)))); assertEquals(TupleDomain.<ColumnHandle>none(), TupleDomain.withColumnDomains(ImmutableMap.of( A, Domain.all(BIGINT), B, Domain.none(VARCHAR)))); }
@Test public void testNoPathFilter() throws Exception { BackgroundHiveSplitLoader backgroundHiveSplitLoader = backgroundHiveSplitLoader( TEST_FILES, TupleDomain.none()); HiveSplitSource hiveSplitSource = hiveSplitSource(backgroundHiveSplitLoader, TupleDomain.none()); backgroundHiveSplitLoader.start(hiveSplitSource); assertEquals(drain(hiveSplitSource).size(), 2); }
@Test public void testNoneColumnWiseUnion() { assertEquals(columnWiseUnion(TupleDomain.none(), TupleDomain.all()), TupleDomain.all()); assertEquals(columnWiseUnion(TupleDomain.all(), TupleDomain.none()), TupleDomain.all()); assertEquals(columnWiseUnion(TupleDomain.none(), TupleDomain.none()), TupleDomain.none()); assertEquals( columnWiseUnion( TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.onlyNull(BIGINT))), TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.notNull(BIGINT)))), TupleDomain.<ColumnHandle>all()); }
@Test public void testEmptyFileWithNoBlocks() throws Exception { BackgroundHiveSplitLoader backgroundHiveSplitLoader = backgroundHiveSplitLoader( ImmutableList.of(locatedFileStatusWithNoBlocks(RETURNED_PATH)), TupleDomain.none()); HiveSplitSource hiveSplitSource = hiveSplitSource(backgroundHiveSplitLoader, TupleDomain.none()); backgroundHiveSplitLoader.start(hiveSplitSource); List<HiveSplit> splits = drainSplits(hiveSplitSource); assertEquals(splits.size(), 1); assertEquals(splits.get(0).getPath(), RETURNED_PATH.toString()); assertEquals(splits.get(0).getLength(), 0); }
@Test public void testNoneRoundTrip() { TupleDomain<Symbol> tupleDomain = TupleDomain.none(); ExtractionResult result = fromPredicate(toPredicate(tupleDomain)); assertEquals(result.getRemainingExpression(), TRUE_LITERAL); assertEquals(result.getTupleDomain(), tupleDomain); }
case LESS_THAN_OR_EQUAL: case NOT_EQUAL: return new ExtractionResult(TupleDomain.none(), TRUE_LITERAL);
@Test public void testJsonSerialization() throws Exception { TestingTypeManager typeManager = new TestingTypeManager(); TestingBlockEncodingSerde blockEncodingSerde = new TestingBlockEncodingSerde(typeManager); ObjectMapper mapper = new ObjectMapperProvider().get() .registerModule(new SimpleModule() .addDeserializer(ColumnHandle.class, new JsonDeserializer<ColumnHandle>() { @Override public ColumnHandle deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return new ObjectMapperProvider().get().readValue(jsonParser, TestingColumnHandle.class); } }) .addDeserializer(Type.class, new TestingTypeDeserializer(typeManager)) .addSerializer(Block.class, new TestingBlockJsonSerde.Serializer(blockEncodingSerde)) .addDeserializer(Block.class, new TestingBlockJsonSerde.Deserializer(blockEncodingSerde))); TupleDomain<ColumnHandle> tupleDomain = TupleDomain.all(); assertEquals(tupleDomain, mapper.readValue(mapper.writeValueAsString(tupleDomain), new TypeReference<TupleDomain<ColumnHandle>>() {})); tupleDomain = TupleDomain.none(); assertEquals(tupleDomain, mapper.readValue(mapper.writeValueAsString(tupleDomain), new TypeReference<TupleDomain<ColumnHandle>>() {})); tupleDomain = TupleDomain.fromFixedValues(ImmutableMap.of(A, NullableValue.of(BIGINT, 1L), B, NullableValue.asNull(VARCHAR))); assertEquals(tupleDomain, mapper.readValue(mapper.writeValueAsString(tupleDomain), new TypeReference<TupleDomain<ColumnHandle>>() {})); }
@Test public void replaceWithExistsWhenNoLayoutExist() { ColumnHandle columnHandle = new TpchColumnHandle("nationkey", BIGINT); tester().assertThat(pickTableLayout.pickTableLayoutForPredicate()) .on(p -> p.filter(expression("nationkey = BIGINT '44'"), p.tableScan( nationTableHandle, ImmutableList.of(p.symbol("nationkey", BIGINT)), ImmutableMap.of(p.symbol("nationkey", BIGINT), columnHandle), Optional.of(nationTableLayoutHandle), TupleDomain.none(), TupleDomain.none()))) .matches(values("A")); }
tableLayout = getTableOnlyLayout(tpchMetadata, session, tableHandle, new Constraint<>(domain, convertToPredicate(domain, PartColumn.TYPE))); assertTupleDomainEquals(tableLayout.getUnenforcedConstraint(), TupleDomain.all(), session); assertTupleDomainEquals(tableLayout.getTableLayout().getPredicate(), TupleDomain.none(), session); tableLayout = getTableOnlyLayout(tpchMetadata, session, tableHandle, new Constraint<>(domain, convertToPredicate(domain, PartColumn.CONTAINER))); assertTupleDomainEquals(tableLayout.getUnenforcedConstraint(), TupleDomain.all(), session); assertTupleDomainEquals(tableLayout.getTableLayout().getPredicate(), TupleDomain.none(), session); tableLayout = getTableOnlyLayout(tpchMetadata, session, tableHandle, new Constraint<>(domain, convertToPredicate(domain, PartColumn.TYPE, PartColumn.CONTAINER))); assertTupleDomainEquals(tableLayout.getUnenforcedConstraint(), TupleDomain.all(), session); assertTupleDomainEquals(tableLayout.getTableLayout().getPredicate(), TupleDomain.none(), session);