com.facebook.presto.spi

Class TupleDomain<T>

java.lang.Object

com.facebook.presto.spi.TupleDomain<T>

public final class TupleDomain<T>
extends Object

Defines a set of valid tuples according to the constraints on each of its constituent columns

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	TupleDomain.ColumnDomain<C>
static interface	TupleDomain.Function<F,T>

Method Summary

Methods

Modifier and Type	Method and Description
static <T> TupleDomain<T>	all()
static <T> TupleDomain<T>	columnWiseUnion(List<TupleDomain<T>> tupleDomains) Returns a TupleDomain in which corresponding column Domains are unioned together.
static <T> TupleDomain<T>	columnWiseUnion(TupleDomain<T> first, TupleDomain<T> second, TupleDomain<T>... rest)
boolean	contains(TupleDomain<T> other) Returns true only if the this TupleDomain contains all possible tuples that would be allowable by the other TupleDomain.
boolean	equals(Object o)
Map<T,Comparable<?>>	extractFixedValues() Extract all column constraints that require exactly one value in their respective Domains.
static <T> TupleDomain<T>	fromNullableColumnDomains(List<TupleDomain.ColumnDomain<T>> nullableColumnDomains)
Map<T,Domain>	getDomains() Gets the TupleDomain as a map of each column to its respective Domain.
List<TupleDomain.ColumnDomain<T>>	getNullableColumnDomains()
int	hashCode()
TupleDomain<T>	intersect(TupleDomain<T> other) Returns the strict intersection of the TupleDomains.
boolean	isAll() Returns true if any tuples would satisfy this TupleDomain
boolean	isNone() Returns true if no tuple could ever satisfy this TupleDomain
static <T> TupleDomain<T>	none()
boolean	overlaps(TupleDomain<T> other) Returns true only if there exists a strict intersection between the TupleDomains.
String	toString()
<U> TupleDomain<U>	transform(TupleDomain.Function<T,U> function)
static <T> TupleDomain<T>	withColumnDomains(Map<T,Domain> domains)
static <T> TupleDomain<T>	withFixedValues(Map<T,Comparable<?>> fixedValues) Convert a map of columns to values into the TupleDomain which requires those columns to be fixed to those values.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Method Detail

withColumnDomains

public static <T> TupleDomain<T> withColumnDomains(Map<T,Domain> domains)

none

public static <T> TupleDomain<T> none()

all

public static <T> TupleDomain<T> all()

withFixedValues

public static <T> TupleDomain<T> withFixedValues(Map<T,Comparable<?>> fixedValues)

Convert a map of columns to values into the TupleDomain which requires those columns to be fixed to those values.

fromNullableColumnDomains

public static <T> TupleDomain<T> fromNullableColumnDomains(List<TupleDomain.ColumnDomain<T>> nullableColumnDomains)

getNullableColumnDomains

public List<TupleDomain.ColumnDomain<T>> getNullableColumnDomains()

isAll

public boolean isAll()

Returns true if any tuples would satisfy this TupleDomain

isNone

public boolean isNone()

Returns true if no tuple could ever satisfy this TupleDomain

getDomains

public Map<T,Domain> getDomains()

Gets the TupleDomain as a map of each column to its respective Domain. - You must check to make sure that this TupleDomain is not None before calling this method - Unmentioned columns have an implicit value of Domain.all() - The column Domains can be thought of as AND'ed to together to form the whole predicate

extractFixedValues

public Map<T,Comparable<?>> extractFixedValues()

Extract all column constraints that require exactly one value in their respective Domains.

intersect

public TupleDomain<T> intersect(TupleDomain<T> other)

Returns the strict intersection of the TupleDomains. The resulting TupleDomain represents the set of tuples that would would be valid in both TupleDomains.

columnWiseUnion

@SafeVarargs
public static <T> TupleDomain<T> columnWiseUnion(TupleDomain<T> first,
                                             TupleDomain<T> second,
                                             TupleDomain<T>... rest)

columnWiseUnion

public static <T> TupleDomain<T> columnWiseUnion(List<TupleDomain<T>> tupleDomains)

Returns a TupleDomain in which corresponding column Domains are unioned together. Note that this is NOT equivalent to a strict union as the final result may allow tuples that do not exist in either TupleDomain. For example: TupleDomain X: a => 1, b => 2 TupleDomain Y: a => 2, b => 3 Column-wise unioned TupleDomain: a = > 1 OR 2, b => 2 OR 3 In the above resulting TupleDomain, tuple (a => 1, b => 3) would be considered valid but would not be valid for either TupleDomain X or TupleDomain Y. However, this result is guaranteed to be a superset of the strict union.

overlaps

public boolean overlaps(TupleDomain<T> other)

Returns true only if there exists a strict intersection between the TupleDomains. i.e. there exists some potential tuple that would be allowable in both TupleDomains.

contains

public boolean contains(TupleDomain<T> other)

Returns true only if the this TupleDomain contains all possible tuples that would be allowable by the other TupleDomain.

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object

transform

public <U> TupleDomain<U> transform(TupleDomain.Function<T,U> function)