RealmQuery (Realm 5.15.1)

java.lang.Object
- io.realm.RealmQuery<E>

Type Parameters:

E - the class of the objects to be queried.
```
public class RealmQuery<E>
extends Object
```
A RealmQuery encapsulates a query on a Realm or a RealmResults using the Builder pattern. The query is executed using either findAll() or findFirst().
The input to many of the query functions take a field name as String. Note that this is not type safe. If a RealmObject class is refactored care has to be taken to not break any queries.
A Realm is unordered, which means that there is no guarantee that querying a Realm will return the objects in the order they where inserted. Use sort(String) (String)} and similar methods if a specific order is required.
A RealmQuery cannot be passed between different threads.

See Also:

Builder pattern, Realm.where(Class), RealmResults.where()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RealmQuery<E>`	`alwaysFalse()` This predicate will never match, resulting in the query always returning 0 results.
`RealmQuery<E>`	`alwaysTrue()` This predicate will always match.
`RealmQuery<E>`	`and()` Logical-and two conditions Realm automatically applies logical-and between all query statements, so this is intended only as a mean to increase readability.
`double`	`average(String fieldName)` Returns the average of a given field.
`RealmQuery<E>`	`beginGroup()` Begin grouping of conditions ("left parenthesis").
`RealmQuery<E>`	`beginsWith(String fieldName, String value)` Condition that the value of field begins with the specified string.
`RealmQuery<E>`	`beginsWith(String fieldName, String value, Case casing)` Condition that the value of field begins with the specified substring.
`RealmQuery<E>`	`between(String fieldName, Date from, Date to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, double from, double to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, float from, float to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, int from, int to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, long from, long to)` Between condition.
`RealmQuery<E>`	`contains(String fieldName, String value)` Condition that value of field contains the specified substring.
`RealmQuery<E>`	`contains(String fieldName, String value, Case casing)` Condition that value of field contains the specified substring.
`long`	`count()` Counts the number of objects that fulfill the query conditions.
`RealmQuery<E>`	`distinct(String fieldName)` Selects a distinct set of objects of a specific class.
`RealmQuery<E>`	`distinct(String firstFieldName, String... remainingFieldNames)` Selects a distinct set of objects of a specific class.
`RealmQuery<E>`	`endGroup()` End grouping of conditions ("right parenthesis") which was opened by a call to `beginGroup()`.
`RealmQuery<E>`	`endsWith(String fieldName, String value)` Condition that the value of field ends with the specified string.
`RealmQuery<E>`	`endsWith(String fieldName, String value, Case casing)` Condition that the value of field ends with the specified substring.
`RealmQuery<E>`	`equalTo(String fieldName, Boolean value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Byte value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, byte[] value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Date value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Double value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Float value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Integer value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Long value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Short value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, String value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, String value, Case casing)` Equal-to comparison.
`RealmResults<E>`	`findAll()` Finds all objects that fulfill the query conditions.
`RealmResults<E>`	`findAllAsync()` Finds all objects that fulfill the query conditions.
`RealmResults<E>`	`findAllAsync(String subscriptionName)` Finds all objects that fulfill the query condition(s).
`RealmResults<E>`	`findAllAsync(String subscriptionName, boolean update)` Finds all objects that fulfil the query condition(s).
`RealmResults<E>`	`findAllAsync(String subscriptionName, long timeToLive, TimeUnit timeUnit)` Finds all objects that fulfil the query condition(s).
`RealmResults<E>`	`findAllAsync(String subscriptionName, long timeToLive, TimeUnit timeUnit, boolean update)` Finds all objects that fulfil the query condition(s).
`E`	`findFirst()` Finds the first object that fulfills the query conditions.
`E`	`findFirstAsync()` Similar to `findFirst()` but runs asynchronously on a worker thread.
`String`	`getDescription()` Returns a textual description of this query.
`Realm`	`getRealm()` Returns the `Realm` instance to which this query belongs.
`String`	`getTypeQueried()` Returns the internal Realm name of the type being queried.
`RealmQuery<E>`	`greaterThan(String fieldName, Date value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, double value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, float value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, int value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, long value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, Date value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, double value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, float value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, int value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, long value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`in(String fieldName, Boolean[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Byte[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Date[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Double[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Float[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Integer[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Long[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Short[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, String[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, String[] values, Case casing)` In comparison.
`RealmQuery<E>`	`includeLinkingObjects(String firstIncludePath, String... remainingFieldPaths)` This predicate is only relevant for Query-based Realms.
`RealmQuery<E>`	`isEmpty(String fieldName)` Condition that finds values that are considered "empty" i.e., an empty list, the 0-length string or byte array.
`RealmQuery<E>`	`isNotEmpty(String fieldName)` Condition that finds values that are considered "Not-empty" i.e., a list, a string or a byte array with not-empty values.
`RealmQuery<E>`	`isNotNull(String fieldName)` Tests if a field is not `null`.
`RealmQuery<E>`	`isNull(String fieldName)` Tests if a field is `null`.
`boolean`	`isValid()` Checks if `RealmQuery` is still valid to use i.e., the `Realm` instance hasn't been closed and any parent `RealmResults` is still valid.
`RealmQuery<E>`	`lessThan(String fieldName, Date value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, double value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, float value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, int value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, long value)` Less-than comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, Date value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, double value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, float value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, int value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, long value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`like(String fieldName, String value)` Condition that the value of field matches with the specified substring, with wildcards: '*' matches [0, n] unicode chars '?' matches a single unicode char.
`RealmQuery<E>`	`like(String fieldName, String value, Case casing)` Condition that the value of field matches with the specified substring, with wildcards: '*' matches [0, n] unicode chars '?' matches a single unicode char.
`RealmQuery<E>`	`limit(long limit)` Limits the number of objects returned in case the query matched more objects.
`Number`	`max(String fieldName)` Finds the maximum value of a field.
`Date`	`maximumDate(String fieldName)` Finds the maximum value of a field.
`Number`	`min(String fieldName)` Finds the minimum value of a field.
`Date`	`minimumDate(String fieldName)` Finds the minimum value of a field.
`RealmQuery<E>`	`not()` Negate condition.
`RealmQuery<E>`	`notEqualTo(String fieldName, Boolean value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Byte value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, byte[] value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Date value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Double value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Float value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Integer value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Long value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Short value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, String value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, String value, Case casing)` Not-equal-to comparison.
`RealmQuery<E>`	`or()` Logical-or two conditions.
`RealmQuery<E>`	`sort(String fieldName)` Sorts the query result by the specific field name in ascending order.
`RealmQuery<E>`	`sort(String[] fieldNames, Sort[] sortOrders)` Sorts the query result by the specific field names in the provided orders.
`RealmQuery<E>`	`sort(String fieldName, Sort sortOrder)` Sorts the query result by the specified field name and order.
`RealmQuery<E>`	`sort(String fieldName1, Sort sortOrder1, String fieldName2, Sort sortOrder2)` Sorts the query result by the specific field names in the provided orders.
`Subscription`	`subscribe()` Creates an anonymous subscription from this query or returns the existing Subscription if one already existed.
`Subscription`	`subscribe(String name)` Creates a named subscription from this query or returns the existing Subscription if one already existed.
`Subscription`	`subscribe(String name, long timeToLive, TimeUnit timeUnit)` Creates a named subscription from this query or returns the existing Subscription if one already exists.
`Subscription`	`subscribeOrUpdate(String name)` Creates a named subscription from this query or returns the existing Subscription if one already existed.
`Subscription`	`subscribeOrUpdate(String name, long timeToLive, TimeUnit timeUnit)` Creates a named subscription from this query or returns the existing Subscription if one already existed.
`Number`	`sum(String fieldName)` Calculates the sum of a given field.

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

- Method Detail
  - isValid
```
public boolean isValid()
```
    Checks if RealmQuery is still valid to use i.e., the Realm instance hasn't been closed and any parent RealmResults is still valid.
    
    Returns:
    
    true if still valid to use, false otherwise.
  - isNull
```
public RealmQuery<E> isNull(String fieldName)
```
    Tests if a field is null. Only works for nullable fields.
    For link queries, if any part of the link path is null the whole path is considered to be null e.g., isNull("linkField.stringField") will be considered to be null if either linkField or linkField.stringField is null.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field is not nullable.
    
    See Also:
    
    for further infomation.
  - isNotNull
```
public RealmQuery<E> isNotNull(String fieldName)
```
    Tests if a field is not null. Only works for nullable fields.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field is not nullable.
    
    See Also:
    
    for further infomation.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             String value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             String value,
                             Case casing)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Byte value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             byte[] value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Short value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Integer value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Long value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Double value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Float value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    The query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Boolean value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Date value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - in
```
public RealmQuery<E> in(String fieldName,
                        String[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a String field.
  - in
```
public RealmQuery<E> in(String fieldName,
                        String[] values,
                        Case casing)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    casing - how casing is handled. Case.INSENSITIVE works only for the Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a String field.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Byte[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Byte field.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Short[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Short field.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Integer[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Integer field.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Long[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Long field. empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Double[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Double field. empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Float[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Float field.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Boolean[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Boolean. or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Date[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with. If null or the empty array is provided the query will never match any results.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Date field.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                String value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                String value,
                                Case casing)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    casing - how casing is handled. Case.INSENSITIVE works only for the Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Byte value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                byte[] value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Short value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Integer value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Long value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Double value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Float value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Boolean value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Date value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 int value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 long value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 double value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 float value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 Date value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          int value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          long value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          double value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          float value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          Date value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              int value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              long value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              double value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              float value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              Date value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       int value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       long value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       double value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       float value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       Date value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             int from,
                             int to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             long from,
                             long to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             double from,
                             double to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             float from,
                             float to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             Date from,
                             Date to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - contains
```
public RealmQuery<E> contains(String fieldName,
                              String value)
```
    Condition that value of field contains the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - contains
```
public RealmQuery<E> contains(String fieldName,
                              String value,
                              Case casing)
```
    Condition that value of field contains the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    The query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - beginsWith
```
public RealmQuery<E> beginsWith(String fieldName,
                                String value)
```
    Condition that the value of field begins with the specified string.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the string.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - beginsWith
```
public RealmQuery<E> beginsWith(String fieldName,
                                String value,
                                Case casing)
```
    Condition that the value of field begins with the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - endsWith
```
public RealmQuery<E> endsWith(String fieldName,
                              String value)
```
    Condition that the value of field ends with the specified string.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the string.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - endsWith
```
public RealmQuery<E> endsWith(String fieldName,
                              String value,
                              Case casing)
```
    Condition that the value of field ends with the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - like
```
public RealmQuery<E> like(String fieldName,
                          String value)
```
    Condition that the value of field matches with the specified substring, with wildcards:
    - '*' matches [0, n] unicode chars
    - '?' matches a single unicode char.
    Parameters:
    
    fieldName - the field to compare.
    
    value - the wildcard string.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - like
```
public RealmQuery<E> like(String fieldName,
                          String value,
                          Case casing)
```
    Condition that the value of field matches with the specified substring, with wildcards:
    - '*' matches [0, n] unicode chars
    - '?' matches a single unicode char.
    Parameters:
    
    fieldName - the field to compare.
    
    value - the wildcard string.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - beginGroup
```
public RealmQuery<E> beginGroup()
```
    Begin grouping of conditions ("left parenthesis"). A group must be closed with a call to endGroup().
    
    Returns:
    
    the query object.
    
    See Also:
    
    endGroup()
  - endGroup
```
public RealmQuery<E> endGroup()
```
    End grouping of conditions ("right parenthesis") which was opened by a call to beginGroup().
    
    Returns:
    
    the query object.
    
    See Also:
    
    beginGroup()
  - or
```
public RealmQuery<E> or()
```
    Logical-or two conditions.
    
    Returns:
    
    the query object.
  - and
```
public RealmQuery<E> and()
```
    Logical-and two conditions Realm automatically applies logical-and between all query statements, so this is intended only as a mean to increase readability.
    
    Returns:
    
    the query object
  - not
```
public RealmQuery<E> not()
```
    Negate condition.
    
    Returns:
    
    the query object.
  - isEmpty
```
public RealmQuery<E> isEmpty(String fieldName)
```
    Condition that finds values that are considered "empty" i.e., an empty list, the 0-length string or byte array.
    
    Parameters:
    
    fieldName - the field to compare.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field name isn't valid or its type isn't either a RealmList, String or byte array.
  - isNotEmpty
```
public RealmQuery<E> isNotEmpty(String fieldName)
```
    Condition that finds values that are considered "Not-empty" i.e., a list, a string or a byte array with not-empty values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field name isn't valid or its type isn't either a RealmList, String or byte array.
  - sum
```
public Number sum(String fieldName)
```
    Calculates the sum of a given field.
    
    Parameters:
    
    fieldName - the field to sum. Only number fields are supported.
    
    Returns:
    
    the sum of fields of the matching objects. If no objects exist or they all have null as the value for the given field, 0 will be returned. When computing the sum, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - average
```
public double average(String fieldName)
```
    Returns the average of a given field. Does not support dotted field notation.
    
    Parameters:
    
    fieldName - the field to calculate average on. Only number fields are supported.
    
    Returns:
    
    the average for the given field amongst objects in query results. This will be of type double for all types of number fields. If no objects exist or they all have null as the value for the given field, 0 will be returned. When computing the average, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - min
```
public Number min(String fieldName)
```
    Finds the minimum value of a field.
    
    Parameters:
    
    fieldName - the field to look for a minimum on. Only number fields are supported.
    
    Returns:
    
    if no objects exist or they all have null as the value for the given field, null will be returned. Otherwise the minimum value is returned. When determining the minimum value, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - minimumDate
```
public Date minimumDate(String fieldName)
```
    Finds the minimum value of a field.
    
    Parameters:
    
    fieldName - the field name
    
    Returns:
    
    if no objects exist or they all have null as the value for the given date field, null will be returned. Otherwise the minimum date is returned. When determining the minimum date, objects with null values are ignored.
    
    Throws:
    
    UnsupportedOperationException - if the query is not valid ("syntax error").
  - max
```
public Number max(String fieldName)
```
    Finds the maximum value of a field.
    
    Parameters:
    
    fieldName - the field to look for a maximum on. Only number fields are supported.
    
    Returns:
    
    if no objects exist or they all have null as the value for the given field, null will be returned. Otherwise the maximum value is returned. When determining the maximum value, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - maximumDate
```
public Date maximumDate(String fieldName)
```
    Finds the maximum value of a field.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    if no objects exist or they all have null as the value for the given date field, null will be returned. Otherwise the maximum date is returned. When determining the maximum date, objects with null values are ignored.
    
    Throws:
    
    UnsupportedOperationException - if the query is not valid ("syntax error").
  - count
```
public long count()
```
    Counts the number of objects that fulfill the query conditions.
    
    Returns:
    
    the number of matching objects.
    
    Throws:
    
    UnsupportedOperationException - if the query is not valid ("syntax error").
  - findAll
```
public RealmResults<E> findAll()
```
    Finds all objects that fulfill the query conditions.
    
    Returns:
    
    a RealmResults containing objects. If no objects match the condition, a list with zero objects is returned.
    
    See Also:
    
    RealmResults
  - findAllAsync
```
public RealmResults<E> findAllAsync()
```
    Finds all objects that fulfill the query conditions. This method is only available from a Looper thread.
    If the Realm is a Query-based synchronized Realms, this method will also create an anonymous subscription that will download all server data matching the query.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    See Also:
    
    RealmResults
  - findAllAsync
```
public RealmResults<E> findAllAsync(String subscriptionName)
```
    Finds all objects that fulfill the query condition(s). This method is only available from a Looper thread.
    This method is only available on query-based synchronized Realms and will also create a named subscription that will synchronize all server data matching the query. Named subscriptions can be removed again by calling Realm.unsubscribe(subscriptionName.
    
    Parameters:
    
    subscriptionName - name of the underlying subscription being created.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalStateException - If the Realm is a not a query-based synchronized Realm or the query is on a RealmList.
    
    See Also:
    
    RealmResults
  - findAllAsync
```
public RealmResults<E> findAllAsync(String subscriptionName,
                                    boolean update)
```
    Finds all objects that fulfil the query condition(s). This method is only available from a Looper thread.
    This method is only available on query-based synchronized Realms and will also create a named subscription that will synchronize all server data matching the query. Named subscriptions can be removed again by calling Realm.unsubscribe(subscriptionName.
    
    Parameters:
    
    subscriptionName - name of the underlying subscription being created.
    
    update - if an existing subscription exists with a different query. It will be replaced with this one instead of an error being reported through OrderedRealmCollectionChangeListener.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalStateException - If the Realm is a not a query-based synchronized Realm or the query is on a RealmList.
    
    See Also:
    
    RealmResults
  - findAllAsync
```
public RealmResults<E> findAllAsync(String subscriptionName,
                                    long timeToLive,
                                    TimeUnit timeUnit)
```
    Finds all objects that fulfil the query condition(s). This method is only available from a Looper thread.
    This method is only available on query-based synchronized Realms and will also create a named subscription that will synchronize all server data matching the query. Named subscriptions can be removed again by calling Realm.unsubscribe(subscriptionName.
    
    Parameters:
    
    subscriptionName - name of the underlying subscription being created.
    
    timeToLive - the amount of time the Subscription must be kept alive after last being used. After this period Realm will automatically remove it.
    
    timeUnit - the unit for timeToLive.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalStateException - If the Realm is a not a query-based synchronized Realm or the query is on a RealmList.
    
    See Also:
    
    RealmResults
  - findAllAsync
```
public RealmResults<E> findAllAsync(String subscriptionName,
                                    long timeToLive,
                                    TimeUnit timeUnit,
                                    boolean update)
```
    Finds all objects that fulfil the query condition(s). This method is only available from a Looper thread.
    This method is only available on query-based synchronized Realms and will also create a named subscription that will synchronize all server data matching the query. Named subscriptions can be removed again by calling Realm.unsubscribe(subscriptionName.
    
    Parameters:
    
    subscriptionName - name of the underlying subscription being created.
    
    timeToLive - the amount of time the Subscription must be kept alive after last being used. After this period Realm will automatically remove it.
    
    timeUnit - the unit for timeToLive.
    
    update - if an existing subscription exists with a different query. It will be replaced with this one instead of an error being reported through OrderedRealmCollectionChangeListener.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalStateException - If the Realm is a not a query-based synchronized Realm or the query is on a RealmList.
    
    See Also:
    
    RealmResults
  - sort
```
public RealmQuery<E> sort(String fieldName)
```
    Sorts the query result by the specific field name in ascending order.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldName - the field name to sort by.
    
    Throws:
    
    IllegalArgumentException - if the field name does not exist.
    
    IllegalStateException - if a sorting order was already defined.
  - sort
```
public RealmQuery<E> sort(String fieldName,
                          Sort sortOrder)
```
    Sorts the query result by the specified field name and order.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldName - the field name to sort by.
    
    sortOrder - how to sort the results.
    
    Throws:
    
    IllegalArgumentException - if the field name does not exist.
    
    IllegalStateException - if a sorting order was already defined.
  - sort
```
public RealmQuery<E> sort(String fieldName1,
                          Sort sortOrder1,
                          String fieldName2,
                          Sort sortOrder2)
```
    Sorts the query result by the specific field names in the provided orders. fieldName2 is only used in case of equal values in fieldName1.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldName1 - first field name
    
    sortOrder1 - sort order for first field
    
    fieldName2 - second field name
    
    sortOrder2 - sort order for second field
    
    Throws:
    
    IllegalArgumentException - if the field name does not exist.
    
    IllegalStateException - if a sorting order was already defined.
  - sort
```
public RealmQuery<E> sort(String[] fieldNames,
                          Sort[] sortOrders)
```
    Sorts the query result by the specific field names in the provided orders. Later fields will only be used if the previous field values are equal.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldNames - an array of field names to sort by.
    
    sortOrders - how to sort the field names.
    
    Throws:
    
    IllegalArgumentException - if the field name does not exist.
    
    IllegalStateException - if a sorting order was already defined.
  - distinct
```
public RealmQuery<E> distinct(String fieldName)
```
    Selects a distinct set of objects of a specific class. If the result is sorted, the first object will be returned in case of multiple occurrences, otherwise it is undefined which object is returned.
    Adding Index to the corresponding field will make this operation much faster.
    
    Parameters:
    
    fieldName - the field name.
    
    Throws:
    
    IllegalArgumentException - if a field is null, does not exist, is an unsupported type, or points to linked fields.
    
    IllegalStateException - if distinct field names were already defined.
  - distinct
```
public RealmQuery<E> distinct(String firstFieldName,
                              String... remainingFieldNames)
```
    Selects a distinct set of objects of a specific class. When multiple distinct fields are given, all unique combinations of values in the fields will be returned. In case of multiple matches, it is undefined which object is returned. Unless the result is sorted, then the first object will be returned.
    
    Parameters:
    
    firstFieldName - first field name to use when finding distinct objects.
    
    remainingFieldNames - remaining field names when determining all unique combinations of field values.
    
    Throws:
    
    IllegalArgumentException - if field names is empty or null, does not exist, is an unsupported type, or points to a linked field.
    
    IllegalStateException - if distinct field names were already defined.
  - limit
```
public RealmQuery<E> limit(long limit)
```
    Limits the number of objects returned in case the query matched more objects.
    Note that when using this method in combination with sort(String) and distinct(String) they will be executed in the order they where added which can affect the end result.
    
    Parameters:
    
    limit - a limit that is ≥ 1.
    
    Throws:
    
    IllegalArgumentException - if the provided limit is less than 1.
  - includeLinkingObjects
```
public RealmQuery<E> includeLinkingObjects(String firstIncludePath,
                                           String... remainingFieldPaths)
```
    This predicate is only relevant for Query-based Realms.
    Objects referenced through fields marked with LinkingObjects are normally not downloaded as part of the subscription in Query-based Realms, but by using this predicate, it is possible to specify which linking objects relationships should also be included in the subscription as well.
    Note, that all "forward" object references like object references and lists are always downloaded as part of the subscription by default.
    This predicate can be called multiple times, in which case all fields will be added to the subscription.
    NOTE: This method is only supported when connecting to Realm Object Server 3.21.0 or later. If you use it with previous versions of Realm Object Server, an IllegalArgumentException will be sent to OrderedCollectionChangeSet.getError().
    
    Parameters:
    
    firstIncludePath - the first LinkingObjects field to add.
    
    remainingFieldPaths - any remaining LinkingObjects fields to add.
    
    Throws:
    
    IllegalStateException - if called on a non-query-based Realm.
    
    IllegalArgumentException - if the path does not end with a field marked with LinkingObjects.
  - alwaysTrue
```
public RealmQuery<E> alwaysTrue()
```
    This predicate will always match.
  - alwaysFalse
```
public RealmQuery<E> alwaysFalse()
```
    This predicate will never match, resulting in the query always returning 0 results.
  - getRealm
```
public Realm getRealm()
```
    Returns the Realm instance to which this query belongs.
    Calling BaseRealm.close() on the returned instance is discouraged as it is the same as calling it on the original Realm instance which may cause the Realm to fully close invalidating the query.
    
    Returns:
    
    Realm instance this query belongs to.
    
    Throws:
    
    IllegalStateException - if the Realm is an instance of DynamicRealm or the Realm was already closed.
  - subscribe
```
public Subscription subscribe()
```
    Creates an anonymous subscription from this query or returns the existing Subscription if one already existed.
    
    Returns:
    
    the subscription representing this query.
    
    Throws:
    
    IllegalStateException - if this method is not called inside a write transaction or if the query is on a DynamicRealm
  - subscribe
```
public Subscription subscribe(String name)
```
    Creates a named subscription from this query or returns the existing Subscription if one already existed. Subscriptions created this way will live forever or until the subscription is manually deleted.
    
    Returns:
    
    the name of the subscription representing this query.
    
    Throws:
    
    IllegalStateException - if this method is not called inside a write transaction, if the query is on a DynamicRealm or a RealmList.
    
    IllegalArgumentException - if a subscription for a different query with the same name already exists.
  - subscribe
```
public Subscription subscribe(String name,
                              long timeToLive,
                              TimeUnit timeUnit)
```
    Creates a named subscription from this query or returns the existing Subscription if one already exists.
    timeToLive indicates for how long Realm must keep the subscription alive after last being used. After this period expires Realm are allowed to delete the subscription. This happens automatically. The period is reset, whenever someone resubscribes or updates the subscription itself.
    When a subscription is deleted, the data covered by the subscription is removed from the device, but not the server.
    
    Parameters:
    
    name - the name subscription representing this query.
    
    timeToLive - the amount of time the Subscription must be kept alive after last being used. After this period Realm will automatically remove it.
    
    timeUnit - the unit for timeToLive.
    
    Returns:
    
    the subscription representing this query.
    
    Throws:
    
    IllegalStateException - if this method is not called inside a write transaction, if the query is on a DynamicRealm or a RealmList.
    
    IllegalArgumentException - if a subscription for a different query with the same name already exists.
  - subscribeOrUpdate
```
public Subscription subscribeOrUpdate(String name)
```
    Creates a named subscription from this query or returns the existing Subscription if one already existed. If an existing subscription already exists and the existing query is different, it will be replaced by this query.
    It is only allowed to update a subscription that queries for objects of the same type. If the existing subscription queries for objects of a different type, an IllegalArgumentException is thrown.
    
    Parameters:
    
    name - the name of the subscription.
    
    Returns:
    
    the subscription representing this query.
    
    Throws:
    
    IllegalStateException - if this method is not called inside a write transaction, if the query is on a DynamicRealm or a RealmList.
    
    IllegalArgumentException - if this query are for other objects than those already being returned by an existing subscription.
  - subscribeOrUpdate
```
public Subscription subscribeOrUpdate(String name,
                                      long timeToLive,
                                      TimeUnit timeUnit)
```
    Creates a named subscription from this query or returns the existing Subscription if one already existed. If a subscription already exists and the query is different, it will be replaced by this query.
    It is only allowed to update a subscription that queries for objects of the same type. If the existing subscription queries for objects of a different type, an IllegalArgumentException is thrown.
    timeToLive indicates for how long Realm must keep the subscription alive after last being used. After this period expires Realm are allowed to delete the subscription. This happens automatically. The period is reset, whenever the subscription is resubscribed or updated
    When a subscription is deleted, the data covered by the subscription is removed from the device, but not the server.
    
    Parameters:
    
    name - the name of the subscription.
    
    timeToLive - the amount of time the Subscription must be kept alive after last being used.
    
    timeUnit - the unit for timeToLive.
    
    Returns:
    
    the subscription representing this query.
    
    Throws:
    
    IllegalStateException - if this method is not called inside a write transaction, if the query is on a DynamicRealm or a RealmList.
    
    IllegalArgumentException - if this query are for other objects than those already being returned by an existing subscription.
  - getDescription
```
public String getDescription()
```
    Returns a textual description of this query.
    
    Returns:
    
    the textual description of the query.
  - getTypeQueried
```
public String getTypeQueried()
```
    Returns the internal Realm name of the type being queried.
    
    Returns:
    
    the internal name of the Realm model class being queried.
  - findFirst
```
public E findFirst()
```
    Finds the first object that fulfills the query conditions.
    
    Returns:
    
    the object found or null if no object matches the query conditions.
    
    See Also:
    
    RealmObject
  - findFirstAsync
```
public E findFirstAsync()
```
    Similar to findFirst() but runs asynchronously on a worker thread. An listener should be registered to the returned RealmObject to get the notification when query completes. The registered listener will also be triggered if there are changes made to the queried RealmObject. If the RealmObject is deleted, the listener will be called one last time and then stop. The query will not be re-run.
    
    Returns:
    
    immediately an empty RealmObject with isLoaded() == false. Trying to access any field on the returned object before it is loaded will throw an IllegalStateException.
    
    Throws:
    
    IllegalStateException - if this is called on a non-looper thread.

Class RealmQuery<E>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isValid

isNull

isNotNull

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

in

in

in

in

in

in

in

in

in

in

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

greaterThan

greaterThan

greaterThan

greaterThan

greaterThan

greaterThanOrEqualTo

greaterThanOrEqualTo

greaterThanOrEqualTo

greaterThanOrEqualTo

greaterThanOrEqualTo

lessThan

lessThan

lessThan

lessThan

lessThan

lessThanOrEqualTo

lessThanOrEqualTo

lessThanOrEqualTo

lessThanOrEqualTo

lessThanOrEqualTo

between

between

between

between

between

contains

contains

beginsWith

beginsWith

endsWith

endsWith

like

like

beginGroup

endGroup

or

and

not

isEmpty

isNotEmpty

sum