TupleDomain (presto-common 0.278.1 API)

java.lang.Object
- com.facebook.presto.common.predicate.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>

Nested Classes
Modifier and Type	Class and Description
`static class`	`TupleDomain.ColumnDomain<C>`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> TupleDomain<T>`	`all()`
`TupleDomain<T>`	`canonicalize(boolean removeConstants)`
`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)`
`TupleDomain<T>`	`compact(int threshold)`
`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 obj)`
`static <T> Optional<Map<T,NullableValue>>`	`extractFixedValues(TupleDomain<T> tupleDomain)` Extract all column constraints that require exactly one value or only null in their respective Domains.
`static <T> Optional<Map<T,Set<NullableValue>>>`	`extractFixedValueSets(TupleDomain<T> tupleDomain)` Extract all column constraints that require a set of one (or more) values in their respective Domains.
`static <T> TupleDomain<T>`	`fromColumnDomains(Optional<List<TupleDomain.ColumnDomain<T>>> columnDomains)`
`static <T> TupleDomain<T>`	`fromFixedValues(Map<T,NullableValue> fixedValues)` Convert a map of columns to values into the TupleDomain which requires those columns to be fixed to those values.
`Optional<List<TupleDomain.ColumnDomain<T>>>`	`getColumnDomains()`
`Optional<Map<T,Domain>>`	`getDomains()` Gets the TupleDomain as a map of each column to its respective Domain.
`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.
`TupleDomain<T>`	`simplify()`
`static <T,K,U> Collector<T,?,Map<K,U>>`	`toLinkedMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)`
`String`	`toString()`
`String`	`toString(SqlFunctionProperties properties)`
`<U> TupleDomain<U>`	`transform(Function<T,U> function)`
`static <T> TupleDomain<T>`	`withColumnDomains(Map<T,Domain> domains)`

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()
```
  - extractFixedValues
```
public static <T> Optional<Map<T,NullableValue>> extractFixedValues(TupleDomain<T> tupleDomain)
```
    Extract all column constraints that require exactly one value or only null in their respective Domains. Returns an empty Optional if the Domain is none.
  - extractFixedValueSets
```
public static <T> Optional<Map<T,Set<NullableValue>>> extractFixedValueSets(TupleDomain<T> tupleDomain)
```
    Extract all column constraints that require a set of one (or more) values in their respective Domains. All the ranges (see SortedRangeSet) must have fixed values. Returns an empty Optional if the Domain is none.
  - fromFixedValues
```
public static <T> TupleDomain<T> fromFixedValues(Map<T,NullableValue> fixedValues)
```
    Convert a map of columns to values into the TupleDomain which requires those columns to be fixed to those values. Null is allowed as a fixed value.
  - fromColumnDomains
```
public static <T> TupleDomain<T> fromColumnDomains(Optional<List<TupleDomain.ColumnDomain<T>>> columnDomains)
```
  - getColumnDomains
```
public Optional<List<TupleDomain.ColumnDomain<T>>> getColumnDomains()
```
  - 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 Optional<Map<T,Domain>> getDomains()
```
    Gets the TupleDomain as a map of each column to its respective Domain. - Will return an Optional.empty() if this is a 'none' TupleDomain. - 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
  - 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 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 obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(SqlFunctionProperties properties)
```
  - transform
```
public <U> TupleDomain<U> transform(Function<T,U> function)
```
  - simplify
```
public TupleDomain<T> simplify()
```
  - compact
```
public TupleDomain<T> compact(int threshold)
```
  - canonicalize
```
public TupleDomain<T> canonicalize(boolean removeConstants)
```
  - toLinkedMap
```
public static <T,K,U> Collector<T,?,Map<K,U>> toLinkedMap(Function<? super T,? extends K> keyMapper,
                                                          Function<? super T,? extends U> valueMapper)
```

Class TupleDomain<T>

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

withColumnDomains

none

all

extractFixedValues

extractFixedValueSets

fromFixedValues

fromColumnDomains

getColumnDomains

isAll

isNone

getDomains

intersect

columnWiseUnion

columnWiseUnion

overlaps

contains

equals

hashCode

toString

toString

transform

simplify

compact

canonicalize

toLinkedMap