com.googlecode.n_orm.query

Class SearchableClassConstraintBuilder<T extends PersistingElement>

java.lang.Object

com.googlecode.n_orm.query.ClassConstraintBuilder<T>

com.googlecode.n_orm.query.SearchableClassConstraintBuilder<T>

public class SearchableClassConstraintBuilder<T extends PersistingElement>
extends ClassConstraintBuilder<T>

Constructor Summary

Constructors

Constructor and Description
SearchableClassConstraintBuilder(Class<T> clazz)

Method Summary

Modifier and Type	Method and Description
SearchableClassConstraintBuilder<T>	andActivate(String... families) Requests for some more family activations while executing the query, in addition to simple properties and families marked as ImplicitActivation.
SearchableClassConstraintBuilder<T>	andActivateAllFamilies() Activate all known families for this class (see ConstraintBuilder.ofClass(Class)).
SearchableKeyConstraintBuilder<T>	andWithKey(String key)
T	any() Runs the query to find an element matching the query.
long	count() Runs the query to find the number of matching elements.
KeyConstraintBuilder<T>	createKeyBuilder(Field f)
long	exportTo(ObjectOutputStream out) Runs the query to find at most N matching elements and serialize a representation into the output stream.
long	exportTo(String file) Runs the query to find at most N matching elements and serialize a representation into the output stream.
Process.ProcessReport<T>	forEach(Process<T> action) Performs an action for each element corresponding to the query.
Process.ProcessReport<T>	forEach(Process<T> action, int threadNumber, long timeoutMs) Performs an action for each element corresponding to the query using parallel threads.
Process.ProcessReport<T>	forEach(Process<T> action, int threadNumber, long timeoutMs, ExecutorService executor) Performs an action for each element corresponding to the query using parallel threads ; method might return before process is ended.
Process.ProcessReport<T>	forEach(Process<T> action, int threadNumber, ProcessCanceller canceller) Performs an action for each element corresponding to the query using parallel threads.
Process.ProcessReport<T>	forEach(Process<T> action, int threadNumber, ProcessCanceller canceller, ExecutorService executor) Performs an action for each element corresponding to the query using parallel threads ; method might return before process is ended.
Class<T>	getClazz()
Constraint	getConstraint()
String	getTablePostfix()
NavigableSet<T>	go() Runs the query to find at most N matching elements.
boolean	hasNoLimit() Returns whether a limit was set for this query.
SearchableClassConstraintBuilder<T>	inTableWithPostfix(String tablePostfix) Sets the table to look for.
CloseableIterator<T>	iterate() Runs the query to find at most N matching elements.
void	remoteForEach(Process<T> action, Callback callBack, int threadNumber, long timeout) Performs asynchronously an action for each element corresponding to the query.
LimitConstraintBuilder<T>	withAtMost(int limit)
T	withId(String id) Finds the element with the given id.
SearchableKeyConstraintBuilder<T>	withKey(String key)

Methods inherited from class com.googlecode.n_orm.query.ClassConstraintBuilder

withKeyInt

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SearchableClassConstraintBuilder

public SearchableClassConstraintBuilder(Class<T> clazz)

Method Detail

hasNoLimit

public boolean hasNoLimit()

Returns whether a limit was set for this query.

getTablePostfix

public String getTablePostfix()

getClazz

public Class<T> getClazz()

createKeyBuilder

public KeyConstraintBuilder<T> createKeyBuilder(Field f)

Specified by:

createKeyBuilder in class ClassConstraintBuilder<T extends PersistingElement>

withAtMost

public LimitConstraintBuilder<T> withAtMost(int limit)

inTableWithPostfix

public SearchableClassConstraintBuilder<T> inTableWithPostfix(String tablePostfix)

Sets the table to look for. This is only possible in case searched element is over a federated table. Element is thus searched from only one sigle table, whose name is the original table, postfixed by the given parameter.

Parameters:

tablePostfix - the table to look for has to have the given postfix (can be "" for original table)

Throws:

IllegalArgumentException - in case this class is not over a federated table

IllegalArgumentException - in case this table cannot be part of the federation for searched class (i.e. it does not starts with original table name)

IllegalArgumentException - in case a different table was already set in the query

getConstraint

public Constraint getConstraint()

Overrides:

getConstraint in class ClassConstraintBuilder<T extends PersistingElement>

andActivate

public SearchableClassConstraintBuilder<T> andActivate(String... families)

Requests for some more family activations while executing the query, in addition to simple properties and families marked as ImplicitActivation.

Parameters:

families - the names of the families to be activated (i.e. name of the Map or Set property).

andActivateAllFamilies

public SearchableClassConstraintBuilder<T> andActivateAllFamilies()

Activate all known families for this class (see ConstraintBuilder.ofClass(Class)). Please note that only column families for this class (or inherited) are activated, and not families for subclasses, even if found elements are instance of a subclass for this class. This remark does not hold for properties, which are all activated, regardless of the fact they are declared in this class or in a subclass.

withId

public T withId(String id)
         throws DatabaseNotReachedException

Finds the element with the given id. Any limit set by withAtMost(int) will be ignored. Specified column families are activated if not already (i.e. this element is already known by this thread) (see PersistingElement.activateIfNotAlready(String...)) ; you should rather perform an PersistingElement.activate(String...) without specifying any column family with andActivate(String...) to force activation.

Parameters:

id - non printable character string

Returns:

element with given id and class ; null if not found

Throws:

DatabaseNotReachedException

go

public NavigableSet<T> go()
                   throws DatabaseNotReachedException

Runs the query to find at most N matching elements. The maximum limit N must be set before using withAtMost(int). Elements activated (see andActivate(String...)), and their keys are all loaded into memory.

Returns:

A (possibly empty) set of elements matching the query limited to the maximum limit.

Throws:

DatabaseNotReachedException

iterate

public CloseableIterator<T> iterate()
                             throws DatabaseNotReachedException

Runs the query to find at most N matching elements. The maximum limit N must be set before using withAtMost(int). Elements activated (see andActivate(String...)). Instead of this function, you should consider using forEach(Process).

Returns:

A (possibly empty) set of elements matching the query limited to the maximum limit, that has to be closed once performed.

Throws:

DatabaseNotReachedException

any

public T any()
      throws DatabaseNotReachedException

Runs the query to find an element matching the query. Any limit set by withAtMost(int) will be ignored (as it is considered to be 1). The element is activated according to declared column families (see andActivate(String...)).

Returns:

A (possibly null) element matching the query.

Throws:

DatabaseNotReachedException

count

public long count()
           throws DatabaseNotReachedException

Runs the query to find the number of matching elements. Any limit set by withAtMost(int) will be ignored.

Throws:

DatabaseNotReachedException

withKey

public SearchableKeyConstraintBuilder<T> withKey(String key)

andWithKey

public SearchableKeyConstraintBuilder<T> andWithKey(String key)

forEach

public Process.ProcessReport<T> forEach(Process<T> action)
                                 throws DatabaseNotReachedException,
                                        InterruptedException,
                                        ProcessException

Performs an action for each element corresponding to the query. The maximum limit N must be set before using withAtMost(int).

Parameters:

action - the action to be performed over each element of the query.

Throws:

DatabaseNotReachedException

InterruptedException - in case threads are interrupted or timeout is reached

ProcessException - in case some process sent an exception while running

forEach

public Process.ProcessReport<T> forEach(Process<T> action,
                                        int threadNumber,
                                        long timeoutMs)
                                 throws DatabaseNotReachedException,
                                        InterruptedException,
                                        ProcessException

Performs an action for each element corresponding to the query using parallel threads. The maximum limit N must be set before using withAtMost(int). Invoking this method is blocking until execution is completed.
In case you only use one thread, process will be performed in this thread.
Be aware that process will not use cache for the current thread, and as such you might need to PersistingElement.activate(String...) elements stored in the process to see changes.

Parameters:

action - the action to be performed over each element of the query.

threadNumber - the maximum number of concurrent threads

timeoutMs - the max allowed time to execute this task ; useless in case threadNumber is 1

Throws:

DatabaseNotReachedException

InterruptedException - in case threads are interrupted or timeout is reached

ProcessException - in case some process sent an exception while running

forEach

public Process.ProcessReport<T> forEach(Process<T> action,
                                        int threadNumber,
                                        ProcessCanceller canceller)
                                 throws DatabaseNotReachedException,
                                        InterruptedException,
                                        ProcessException

Performs an action for each element corresponding to the query using parallel threads. The maximum limit N must be set before using withAtMost(int). Invoking this method is blocking until execution is completed.
In case you only use one thread, process will be performed in this thread.
Be aware that process will not use cache for the current thread, and as such you might need to PersistingElement.activate(String...) elements stored in the process to see changes.

Parameters:

action - the action to be performed over each element of the query.

threadNumber - the maximum number of concurrent threads

canceller - a canceller object regularly observed while performing request ; in case this object responds false after invoked ProcessCanceller.isCancelled(), this methods returns a ProcessException with message found by ProcessCanceller.getErrorMessage(Process)

Throws:

DatabaseNotReachedException

InterruptedException - in case threads are interrupted or canceler responds false to ProcessCanceller.isCancelled()

ProcessException - in case some process sent an exception while running

forEach

public Process.ProcessReport<T> forEach(Process<T> action,
                                        int threadNumber,
                                        long timeoutMs,
                                        ExecutorService executor)
                                 throws DatabaseNotReachedException,
                                        InterruptedException,
                                        ProcessException

Performs an action for each element corresponding to the query using parallel threads ; method might return before process is ended. The maximum limit N must be set before using withAtMost(int). Invoking this method can be blocking as long as threadNumber is less that the number of elements to be treated.
Be aware that process will not use cache for the current thread, and as such you might need to PersistingElement.activate(String...) elements stored in the process to see changes.

Parameters:

action - the action to be performed over each element of the query.

threadNumber - the maximum number of concurrent threads

timeoutMs - the max allowed time to execute this task ; useless in case threadNumber is 1

executor - the executor to run process ; you need to call ExecutorService.awaitTermination(long, java.util.concurrent.TimeUnit) to be sure that all elements are processed ; if null, this method is equivalent to forEach(Process, int, long)

Throws:

DatabaseNotReachedException

InterruptedException - in case threads are interrupted or timeout is reached

ProcessException - in case some process sent an exception while running

forEach

public Process.ProcessReport<T> forEach(Process<T> action,
                                        int threadNumber,
                                        ProcessCanceller canceller,
                                        ExecutorService executor)
                                 throws DatabaseNotReachedException,
                                        InterruptedException,
                                        ProcessException

Performs an action for each element corresponding to the query using parallel threads ; method might return before process is ended. The maximum limit N must be set before using withAtMost(int). Invoking this method can be blocking as long as threadNumber is less that the number of elements to be treated.
Be aware that process will not use cache for the current thread, and as such you might need to PersistingElement.activate(String...) elements stored in the process to see changes.

Parameters:

action - the action to be performed over each element of the query.

threadNumber - the maximum number of concurrent threads

canceller - a canceller object regularly observed while performing request ; in case this object responds false after invoked ProcessCanceller.isCancelled(), this methods returns a ProcessException with message found by ProcessCanceller.getErrorMessage(Process)

executor - the executor to run process ; you need to call ExecutorService.awaitTermination(long, java.util.concurrent.TimeUnit) to be sure that all elements are processed ; if null, this method is equivalent to forEach(Process, int, long)

Throws:

DatabaseNotReachedException

InterruptedException - in case threads are interrupted or canceler responds false to ProcessCanceller.isCancelled()

ProcessException - in case some process sent an exception while running

remoteForEach

public void remoteForEach(Process<T> action,
                          Callback callBack,
                          int threadNumber,
                          long timeout)
                   throws DatabaseNotReachedException,
                          InstantiationException,
                          IllegalAccessException

Performs asynchronously an action for each element corresponding to the query. In case store for class is not implementing ActionnableStore, this action is equivalent to an asynchronous call to forEach(Process), and the maximum limit N must be set before using withAtMost(int). Otherwise, the action is performed directly using the data store server process, and the limit is useless. In order to wait for process completion, you can use WaitingCallBack.

Parameters:

action - class of the action to be performed over each element of the query ; must have a default constructor

callBack - a callback to be invoked as soon as the process completes ; can be null

timeout - in case store does not support ActionnableStore

Throws:

DatabaseNotReachedException

IllegalAccessException

InstantiationException

exportTo

public long exportTo(ObjectOutputStream out)
              throws IOException,
                     DatabaseNotReachedException

Runs the query to find at most N matching elements and serialize a representation into the output stream. The maximum limit N can be set before using withAtMost(int), but is not mandatory. Dependencies are not serialized. Consider carefully setting families to be activated before ; it is advised to use andActivateAllFamilies(). Implementation tries to optimize as much as possible memory impact.

Parameters:

out - an output stream that must support InputStream.markSupported() ; note that only one ObjectOutputStream must be created for a given OutputStream

Throws:

IOException

DatabaseNotReachedException

exportTo

public long exportTo(String file)
              throws IOException,
                     DatabaseNotReachedException

Runs the query to find at most N matching elements and serialize a representation into the output stream. The maximum limit N can be set before using withAtMost(int), but is not mandatory. Dependencies are not serialized. Consider carefully setting families to be activated before ; it is advised to use andActivateAllFamilies(). Implementation tries to optimize as much as possible memory impact.

Parameters:

file - the file where elements are to be stored ; overwritten if exists

Throws:

IOException

DatabaseNotReachedException