org.bluedb.api

Interface BlueQuery<V extends java.io.Serializable>

All Known Implementing Classes:

BlueQueryOnDisk

public interface BlueQuery<V extends java.io.Serializable>

Method Summary

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

Method Detail

where

BlueQuery<V> where(Condition<V> condition)

Adds a condition to the query before returning itself.

Parameters:

condition - a filter function to be applied to possible matching values

Returns:

itself, with the condition added to the query

byStartTime

BlueQuery<V> byStartTime()

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

Returns:

itself, with the condition added to the query that the key start time be in the queried time interval

beforeTime

BlueQuery<V> beforeTime(long time)

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.

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

BlueQuery<V> beforeOrAtTime(long time)

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.

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

afterTime

BlueQuery<V> afterTime(long time)

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.

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

BlueQuery<V> afterOrAtTime(long time)

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.

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

getList

java.util.List<V> getList()
                   throws BlueDbException

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.

Returns:

the query results as a list

Throws:

BlueDbException

getIterator

CloseableIterator<V> getIterator()
                          throws BlueDbException

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.

Returns:

an iterator for the query results

Throws:

BlueDbException

delete

void delete()
     throws BlueDbException

Executes the query and deletes any matching values

Throws:

BlueDbException

update

void update(Updater<V> updater)
     throws BlueDbException

Executes the query and updates any matching values

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

void replace(Mapper<V> mapper)
      throws BlueDbException

Executes the query and replaces any matching values

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

int count()
   throws BlueDbException

Executes the query and returns the number of values matching the query

Returns:

the number of values matching the query

Throws:

BlueDbException