sirius.db.jdbc

Class SmartQuery<E extends SQLEntity>

java.lang.Object

sirius.db.mixing.query.BaseQuery<Q,E>

sirius.db.mixing.query.Query<SmartQuery<E>,E,SQLConstraint>

sirius.db.jdbc.SmartQuery<E>

Type Parameters:

E - the generic type of entities being queried

public class SmartQuery<E extends SQLEntity>
extends Query<SmartQuery<E>,E,SQLConstraint>

Provides a query DSL which is used to query SQLEntity instances from the database.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SmartQuery.Compiler Represents the compiler which is used to generate SQL statements based on a SmartQuery.

Field Summary

Fields

Modifier and Type	Field and Description
protected List<SQLConstraint>	constaints
protected Database	db
protected boolean	distinct
protected List<Mapping>	fields
protected List<sirius.kernel.commons.Tuple<Mapping,Boolean>>	orderBys

Fields inherited from class sirius.db.mixing.query.BaseQuery

descriptor, limit, MAX_LIST_SIZE, mixing, skip

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	SmartQuery(EntityDescriptor descriptor, Database db) Creates a new query instance.

Method Summary

Modifier and Type	Method and Description
SQLQuery	asSQLQuery() Converts this query into a plain SQLQuery which will return rows instead of entities.
SmartQuery<E>	copy() Creates a full copy of the query which can be modified without modifying this query.
long	count() Executes the query and counts the number of results.
void	delete() Deletes all matches using the BaseMapper.delete(BaseEntity) of the appropriate mapper.
SmartQuery<E>	distinctFields(Mapping... fields) Specifies the fields to select, which also have to be DISTINCT.
protected long	execCount(SmartQuery.Compiler compiler, Connection c)
protected void	execIterate(Function<E,Boolean> handler, SmartQuery.Compiler compiler, sirius.kernel.commons.Limit limit, boolean nativeLimit, ResultSet rs)
boolean	exists() Determines if the query would have at least one matching entity.
SmartQuery<E>	fields(Mapping... fields) Specifies which fields to select.
FilterFactory<SQLConstraint>	filters()
EntityDescriptor	getEntityDescriptor() Returns the EntityDescriptor for the type of entities addressed by this query.
void	iterate(Function<E,Boolean> handler) Calls the given function on all items in the result, as long as it returns true.
SmartQuery<E>	orderAsc(Mapping field) Adds a sort constraint to order by the given field ascending.
SmartQuery<E>	orderDesc(Mapping field) Adds a sort constraint to order by the given field descending.
protected sirius.kernel.health.HandledException	queryError(SmartQuery.Compiler compiler, Exception e)
String	toString()
void	truncate() Deletes all matches using the capabilities of the underlying database.
protected void	tuneStatement(PreparedStatement stmt, sirius.kernel.commons.Limit limit, boolean nativeLimit)
SmartQuery<E>	where(SQLConstraint constraint) Applies the given contraints to the query.

Methods inherited from class sirius.db.mixing.query.Query

eq, eqIgnoreNull, ne, queryString

Methods inherited from class sirius.db.mixing.query.BaseQuery

failOnOverflow, first, getDescriptor, getLimit, iterateAll, limit, one, queryFirst, queryList, queryOne, skip

Methods inherited from class java.lang.Object

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

Field Detail

fields

protected List<Mapping> fields

distinct

protected boolean distinct

orderBys

protected List<sirius.kernel.commons.Tuple<Mapping,Boolean>> orderBys

constaints

protected List<SQLConstraint> constaints

db

protected Database db

Constructor Detail

SmartQuery

protected SmartQuery(EntityDescriptor descriptor,
                     Database db)

Creates a new query instance.

Use OMA.select(Class) to create a new query.

Parameters:

descriptor - the descriptor of the type to query

db - the database to operate on

Method Detail

getEntityDescriptor

public EntityDescriptor getEntityDescriptor()

Returns the EntityDescriptor for the type of entities addressed by this query.

Returns:

the underlying entity descriptor of this query.

where

public SmartQuery<E> where(SQLConstraint constraint)

Description copied from class: Query

Applies the given contraints to the query.

Specified by:

where in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

Parameters:

constraint - the constraint which has to be fullfilled

Returns:

the query itself for fluent method calls

filters

public FilterFactory<SQLConstraint> filters()

Specified by:

filters in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

orderAsc

public SmartQuery<E> orderAsc(Mapping field)

Description copied from class: Query

Adds a sort constraint to order by the given field ascending.

Specified by:

orderAsc in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

Parameters:

field - the field to order by.

Returns:

the builder itself for fluent method calls

orderDesc

public SmartQuery<E> orderDesc(Mapping field)

Description copied from class: Query

Adds a sort constraint to order by the given field descending.

Specified by:

orderDesc in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

Parameters:

field - the field to order by.

Returns:

the builder itself for fluent method calls

distinctFields

public SmartQuery<E> distinctFields(Mapping... fields)

Specifies the fields to select, which also have to be DISTINCT.

Parameters:

fields - the fields to select and to apply a DISTINCT filter on.

Returns:

the query itself for fluent method calls

fields

public SmartQuery<E> fields(Mapping... fields)

Specifies which fields to select.

If no fields are given, * is selected

Parameters:

fields - the list of fields to select

Returns:

the query itself for fluent method calls

count

public long count()

Description copied from class: Query

Executes the query and counts the number of results.

Specified by:

count in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

Returns:

the number of matched result entries

queryError

protected sirius.kernel.health.HandledException queryError(SmartQuery.Compiler compiler,
                                                           Exception e)

execCount

protected long execCount(SmartQuery.Compiler compiler,
                         Connection c)
                  throws SQLException

Throws:

SQLException

exists

public boolean exists()

Description copied from class: Query

Determines if the query would have at least one matching entity.

Specified by:

exists in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

Returns:

true if at least one entity matches the query, false otherwise.

delete

public void delete()

Description copied from class: Query

Deletes all matches using the BaseMapper.delete(BaseEntity) of the appropriate mapper.

Be aware that this might be slow for very large result sets.

Specified by:

delete in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

truncate

public void truncate()

Description copied from class: Query

Deletes all matches using the capabilities of the underlying database.

Therefore no checks or anything will be invoked for the deleted entities.

Use this for larger result sets where integrity and constraints do not matter or are managed manually.

Specified by:

truncate in class Query<SmartQuery<E extends SQLEntity>,E extends SQLEntity,SQLConstraint>

asSQLQuery

public SQLQuery asSQLQuery()

Converts this query into a plain SQLQuery which will return rows instead of entities.

Returns:

the query converted into a plain SQL query.

copy

public SmartQuery<E> copy()

Creates a full copy of the query which can be modified without modifying this query.

Returns:

a copy of this query

iterate

public void iterate(Function<E,Boolean> handler)

Description copied from class: BaseQuery

Calls the given function on all items in the result, as long as it returns true.

Note that this method is intended for large results as not all items in the result need to be kept in memory when iterating through them.

Specified by:

iterate in class BaseQuery<SmartQuery<E extends SQLEntity>,E extends SQLEntity>

Parameters:

handler - the handle to be invoked for each item in the result

execIterate

protected void execIterate(Function<E,Boolean> handler,
                           SmartQuery.Compiler compiler,
                           sirius.kernel.commons.Limit limit,
                           boolean nativeLimit,
                           ResultSet rs)
                    throws Exception

Throws:

Exception

tuneStatement

protected void tuneStatement(PreparedStatement stmt,
                             sirius.kernel.commons.Limit limit,
                             boolean nativeLimit)
                      throws SQLException

Throws:

SQLException

toString

public String toString()

Overrides:

toString in class Object