BlueQueryOnDisk (BlueDB 2.0.4 API)

java.lang.Object
- org.bluedb.disk.query.BlueQueryOnDisk<T>

All Implemented Interfaces:: BlueQuery<T>

public class BlueQueryOnDisk<T extends java.io.Serializable>
extends java.lang.Object
implements BlueQuery<T>

Constructor Summary

Constructors
Constructor and Description

BlueQueryOnDisk(BlueCollectionOnDisk<T> collection)

Constructors
Constructor and Description
`BlueQueryOnDisk(BlueCollectionOnDisk<T> collection)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`BlueQuery<T>`	`afterOrAtTime(long time)` Adds an inclusive min time for the queried time interval.
`BlueQuery<T>`	`afterTime(long time)` Adds an exclusive min time for the queried time interval.
`BlueQuery<T>`	`beforeOrAtTime(long time)` Adds an inclusive max time for the queried time interval.
`BlueQuery<T>`	`beforeTime(long time)` Adds an exclusive max time for the queried time interval.
`BlueQuery<T>`	`byStartTime()` For queries on a collection with a key type of `TimeFrameKey`, this adds a condition that the value starts in the queried interval.
`BlueQueryOnDisk<T>`	`clone()`
`int`	`count()` Executes the query and returns the number of values matching the query
`void`	`delete()` Executes the query and deletes any matching values
`java.util.List<BlueEntity<T>>`	`getEntities()`
`CloseableIterator<T>`	`getIterator()` Begins executing the query and returns an iterator for processing the results.
`java.util.List<T>`	`getList()` Executes the query and returns the results as a list.
`Range`	`getRange()`
`void`	`replace(Mapper<T> mapper)` Executes the query and replaces any matching values
`java.lang.String`	`toString()`
`void`	`update(Updater<T> updater)` Executes the query and updates any matching values
`BlueQuery<T>`	`where(Condition<T> c)` Adds a condition to the query before returning itself.

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

- Constructor Detail
  - BlueQueryOnDisk
```
public BlueQueryOnDisk(BlueCollectionOnDisk<T> collection)
```
- Method Detail
  - where
```
public BlueQuery<T> where(Condition<T> c)
```
    Description copied from interface: BlueQuery
    
    Adds a condition to the query before returning itself.
    
    Specified by:
    
    where in interface BlueQuery<T extends java.io.Serializable>
    
    Parameters:
    
    c - a filter function to be applied to possible matching values
    
    Returns:
    
    itself, with the condition added to the query
  - afterTime
```
public BlueQuery<T> afterTime(long time)
```
    Description copied from interface: BlueQuery
    
    Adds an exclusive min time for the queried time interval. For a TimeFrameKey this means that it ends after the specified time. For a TimeKey it means that it is after the specified time. It doesn't make sense to use it with other key types.
    
    Specified by:
    
    afterTime in interface BlueQuery<T extends java.io.Serializable>
    
    Parameters:
    
    time - an exclusive min time (millis since epoch) for the queried time interval
    
    Returns:
    
    itself, with an exclusive min time for the queried time interval
  - afterOrAtTime
```
public BlueQuery<T> afterOrAtTime(long time)
```
    Description copied from interface: BlueQuery
    
    Adds an inclusive min time for the queried time interval. For a TimeFrameKey this means that it ends after or at the specified time. For a TimeKey it means that it is after or at the specified time. It doesn't make sense to use it with other key types.
    
    Specified by:
    
    afterOrAtTime in interface BlueQuery<T extends java.io.Serializable>
    
    Parameters:
    
    time - an inclusive min time (millis since epoch) for the queried time interval
    
    Returns:
    
    itself, with an exclusive min time for the queried time interval
  - beforeTime
```
public BlueQuery<T> beforeTime(long time)
```
    Description copied from interface: BlueQuery
    
    Adds an exclusive max time for the queried time interval. For a TimeFrameKey this means that it starts before the specified time. For a TimeKey it means that it is before the specified time. It doesn't make sense to use it with other key types.
    
    Specified by:
    
    beforeTime in interface BlueQuery<T extends java.io.Serializable>
    
    Parameters:
    
    time - an exclusive max time (millis since epoch) for the queried time interval
    
    Returns:
    
    itself, with an exclusive max time for the queried time interval
  - beforeOrAtTime
```
public BlueQuery<T> beforeOrAtTime(long time)
```
    Description copied from interface: BlueQuery
    
    Adds an inclusive max time for the queried time interval. For a TimeFrameKey this means that it starts before or at the specified time. For a TimeKey it means that it is before or at the specified time. It doesn't make sense to use it with other key types.
    
    Specified by:
    
    beforeOrAtTime in interface BlueQuery<T extends java.io.Serializable>
    
    Parameters:
    
    time - an inclusive max time (millis since epoch) for the queried time interval
    
    Returns:
    
    itself, with an inclusive max time for the queried time interval
  - byStartTime
```
public BlueQuery<T> byStartTime()
```
    Description copied from interface: BlueQuery
    
    For queries on a collection with a key type of TimeFrameKey, this adds a condition that the value starts in the queried interval. Normally, it is only required that the value's time interval overlaps the queried time interval.
    
    This can be very useful if you want to map reduce the results. Instead of making one query for the entire time interval you can split it into multiple time intervals to be queried and processed individually. By using this condition on all but the first query you can guarantee that each value will only be processed once.
    
    This condition only has an effect on collections with a key type of TimeFrameKey
    
    Specified by:
    
    byStartTime in interface BlueQuery<T extends java.io.Serializable>
    
    Returns:
    
    itself, with the condition added to the query that the key start time be in the queried time interval
  - getList
```
public java.util.List<T> getList()
                          throws BlueDbException
```
    Description copied from interface: BlueQuery
    
    Executes the query and returns the results as a list. Use getIterator if you don't want to load all matching values into memory at once.
    
    Specified by:
    
    getList in interface BlueQuery<T extends java.io.Serializable>
    
    Returns:
    
    the query results as a list
    
    Throws:
    
    BlueDbException
  - getIterator
```
public CloseableIterator<T> getIterator()
                                 throws BlueDbException
```
    Description copied from interface: BlueQuery
    
    Begins executing the query and returns an iterator for processing the results. BlueDB will iterate over the collection on disk as you iterate over it in memory. This makes the iterator an extremely memory efficient way to read large collections.
    
    Important: Use within a try-with-resources statement and iterate through as quickly as possible in order to ensure that you don't block other BlueDB tasks. If you fail to call next for 15 seconds then the iterator will timeout and release resources.
    
    Specified by:
    
    getIterator in interface BlueQuery<T extends java.io.Serializable>
    
    Returns:
    
    an iterator for the query results
    
    Throws:
    
    BlueDbException
  - delete
```
public void delete()
            throws BlueDbException
```
    Description copied from interface: BlueQuery
    
    Executes the query and deletes any matching values
    
    Specified by:
    
    delete in interface BlueQuery<T extends java.io.Serializable>
    
    Throws:
    
    BlueDbException
  - update
```
public void update(Updater<T> updater)
            throws BlueDbException
```
    Description copied from interface: BlueQuery
    
    Executes the query and updates any matching values
    
    Specified by:
    
    update in interface BlueQuery<T extends java.io.Serializable>
    
    Parameters:
    
    updater - a function that mutates the values in the query results
    
    Throws:
    
    BlueDbException - if there are any problems, such as an exception thrown by the updater
  - replace
```
public void replace(Mapper<T> mapper)
             throws BlueDbException
```
    Description copied from interface: BlueQuery
    
    Executes the query and replaces any matching values
    
    Specified by:
    
    replace in interface BlueQuery<T extends java.io.Serializable>
    
    Parameters:
    
    mapper - a function that replaces the values in the query results
    
    Throws:
    
    BlueDbException - if there are any problems, such as an exception thrown by the mapper
  - count
```
public int count()
          throws BlueDbException
```
    Description copied from interface: BlueQuery
    
    Executes the query and returns the number of values matching the query
    
    Specified by:
    
    count in interface BlueQuery<T extends java.io.Serializable>
    
    Returns:
    
    the number of values matching the query
    
    Throws:
    
    BlueDbException
  - getEntities
```
public java.util.List<BlueEntity<T>> getEntities()
                                          throws BlueDbException
```
    Throws:
    
    BlueDbException
  - clone
```
public BlueQueryOnDisk<T> clone()
```
    Overrides:
    
    clone in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getRange
```
public Range getRange()
```

Class BlueQueryOnDisk<T extends java.io.Serializable>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BlueQueryOnDisk

Method Detail

where

afterTime

afterOrAtTime

beforeTime

beforeOrAtTime

byStartTime

getList

getIterator

delete

update

replace

count

getEntities

clone

toString

getRange