FilterApi (Apache Parquet Column 1.7.0 API)

java.lang.Object
- org.apache.parquet.filter2.predicate.FilterApi

```
public final class FilterApi
extends Object
```
The Filter API is expressed through these static methods. Example usage: IntColumn foo = intColumn("foo"); DoubleColumn bar = doubleColumn("x.y.bar"); // foo == 10 || bar <= 17.0 FilterPredicate pred = or(eq(foo, 10), ltEq(bar, 17.0));

Method Summary

Methods
Modifier and Type	Method and Description
`static FilterPredicate`	`and(FilterPredicate left, FilterPredicate right)` Constructs the logical and of two predicates.
`static Operators.BinaryColumn`	`binaryColumn(String columnPath)`
`static Operators.BooleanColumn`	`booleanColumn(String columnPath)`
`static Operators.DoubleColumn`	`doubleColumn(String columnPath)`
`static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsEqNotEq> Operators.Eq<T>`	`eq(C column, T value)` Keeps records if their value is equal to the provided value.
`static Operators.FloatColumn`	`floatColumn(String columnPath)`
`static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.Gt<T>`	`gt(C column, T value)` Keeps records if their value is greater than (but not equal to) the provided value.
`static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.GtEq<T>`	`gtEq(C column, T value)` Keeps records if their value is greater than or equal to the provided value.
`static Operators.IntColumn`	`intColumn(String columnPath)`
`static Operators.LongColumn`	`longColumn(String columnPath)`
`static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.Lt<T>`	`lt(C column, T value)` Keeps records if their value is less than (but not equal to) the provided value.
`static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.LtEq<T>`	`ltEq(C column, T value)` Keeps records if their value is less than or equal to the provided value.
`static FilterPredicate`	`not(FilterPredicate predicate)` Constructs the logical not (or inverse) of a predicate.
`static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsEqNotEq> Operators.NotEq<T>`	`notEq(C column, T value)` Keeps records if their value is not equal to the provided value.
`static FilterPredicate`	`or(FilterPredicate left, FilterPredicate right)` Constructs the logical or of two predicates.
`static <T extends Comparable<T>,U extends UserDefinedPredicate<T>> Operators.UserDefined<T,U>`	`userDefined(Operators.Column<T> column, Class<U> clazz)` Keeps records that pass the provided `UserDefinedPredicate` The provided class must have a default constructor.
`static <T extends Comparable<T>,U extends UserDefinedPredicate<T> & Serializable> Operators.UserDefined<T,U>`	`userDefined(Operators.Column<T> column, U udp)` Keeps records that pass the provided `UserDefinedPredicate` The provided instance of UserDefinedPredicate must be serializable.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - intColumn
```
public static Operators.IntColumn intColumn(String columnPath)
```
  - longColumn
```
public static Operators.LongColumn longColumn(String columnPath)
```
  - floatColumn
```
public static Operators.FloatColumn floatColumn(String columnPath)
```
  - doubleColumn
```
public static Operators.DoubleColumn doubleColumn(String columnPath)
```
  - booleanColumn
```
public static Operators.BooleanColumn booleanColumn(String columnPath)
```
  - binaryColumn
```
public static Operators.BinaryColumn binaryColumn(String columnPath)
```
  - eq
```
public static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsEqNotEq> Operators.Eq<T> eq(C column,
                                                                                                    T value)
```
    Keeps records if their value is equal to the provided value. Nulls are treated the same way the java programming language does. For example: eq(column, null) will keep all records whose value is null. eq(column, 7) will keep all records whose value is 7, and will drop records whose value is null
  - notEq
```
public static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsEqNotEq> Operators.NotEq<T> notEq(C column,
                                                                                                          T value)
```
    Keeps records if their value is not equal to the provided value. Nulls are treated the same way the java programming language does. For example: notEq(column, null) will keep all records whose value is not null. notEq(column, 7) will keep all records whose value is not 7, including records whose value is null. NOTE: this is different from how some query languages handle null. For example, SQL and pig will drop nulls when you filter by not equal to 7. To achieve similar behavior in this api, do: and(notEq(column, 7), notEq(column, null)) NOTE: be sure to read the lt(C, T), ltEq(C, T), gt(C, T), gtEq(C, T) operator's docs for how they handle nulls
  - lt
```
public static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.Lt<T> lt(C column,
                                                                                                 T value)
```
    Keeps records if their value is less than (but not equal to) the provided value. The provided value cannot be null, as less than null has no meaning. Records with null values will be dropped. For example: lt(column, 7) will keep all records whose value is less than (but not equal to) 7, and not null.
  - ltEq
```
public static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.LtEq<T> ltEq(C column,
                                                                                                     T value)
```
    Keeps records if their value is less than or equal to the provided value. The provided value cannot be null, as less than null has no meaning. Records with null values will be dropped. For example: ltEq(column, 7) will keep all records whose value is less than or equal to 7, and not null.
  - gt
```
public static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.Gt<T> gt(C column,
                                                                                                 T value)
```
    Keeps records if their value is greater than (but not equal to) the provided value. The provided value cannot be null, as less than null has no meaning. Records with null values will be dropped. For example: gt(column, 7) will keep all records whose value is greater than (but not equal to) 7, and not null.
  - gtEq
```
public static <T extends Comparable<T>,C extends Operators.Column<T> & Operators.SupportsLtGt> Operators.GtEq<T> gtEq(C column,
                                                                                                     T value)
```
    Keeps records if their value is greater than or equal to the provided value. The provided value cannot be null, as less than null has no meaning. Records with null values will be dropped. For example: gtEq(column, 7) will keep all records whose value is greater than or equal to 7, and not null.
  - userDefined
```
public static <T extends Comparable<T>,U extends UserDefinedPredicate<T>> Operators.UserDefined<T,U> userDefined(Operators.Column<T> column,
                                                                                                 Class<U> clazz)
```
    Keeps records that pass the provided UserDefinedPredicate The provided class must have a default constructor. To use an instance of a UserDefinedPredicate instead, see #userDefined(column, udp) below.
  - userDefined
```
public static <T extends Comparable<T>,U extends UserDefinedPredicate<T> & Serializable> Operators.UserDefined<T,U> userDefined(Operators.Column<T> column,
                                                                                                               U udp)
```
    Keeps records that pass the provided UserDefinedPredicate The provided instance of UserDefinedPredicate must be serializable.
  - and
```
public static FilterPredicate and(FilterPredicate left,
                  FilterPredicate right)
```
    Constructs the logical and of two predicates. Records will be kept if both the left and right predicate agree that the record should be kept.
  - or
```
public static FilterPredicate or(FilterPredicate left,
                 FilterPredicate right)
```
    Constructs the logical or of two predicates. Records will be kept if either the left or right predicate is satisfied (or both).
  - not
```
public static FilterPredicate not(FilterPredicate predicate)
```
    Constructs the logical not (or inverse) of a predicate. Records will be kept if the provided predicate is not satisfied.

Class FilterApi

Method Summary

Methods inherited from class java.lang.Object

Method Detail

intColumn

longColumn

floatColumn

doubleColumn

booleanColumn

binaryColumn

eq

notEq

lt

ltEq

gt

gtEq

userDefined

userDefined

and

or

not