TupleDomain (presto-spi 0.83 API)

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>

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.
`Map<T,SerializableNativeValue>`	`extractNullableFixedValues()` Extract all column constraints that require exactly one value or only null 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.
`static <T> TupleDomain<T>`	`withNullableFixedValues(Map<T,SerializableNativeValue> 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.
  - withNullableFixedValues
```
public static <T> TupleDomain<T> withNullableFixedValues(Map<T,SerializableNativeValue> 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.
  - 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.
  - extractNullableFixedValues
```
public Map<T,SerializableNativeValue> extractNullableFixedValues()
```
    Extract all column constraints that require exactly one value or only null 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)
```

Class TupleDomain<T>

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

withColumnDomains

none

all

withFixedValues

withNullableFixedValues

fromNullableColumnDomains

getNullableColumnDomains

isAll

isNone

getDomains

extractFixedValues

extractNullableFixedValues

intersect

columnWiseUnion

columnWiseUnion

overlaps

contains

equals

hashCode

toString

transform