|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.j256.ormlite.stmt.StatementBuilder<T,ID>
com.j256.ormlite.stmt.QueryBuilder<T,ID>
T - The class that the code will be operating on.ID - The class of the ID column associated with the class. The T class does not require an ID field. The class
needs an ID parameter however so you can use Void or Object to satisfy the compiler.public class QueryBuilder<T,ID>
Assists in building sql query (SELECT) statements for a particular table in a particular database.
Here is a good tutorial of SQL commands.
| Nested Class Summary | |
|---|---|
static class |
QueryBuilder.InternalQueryBuilderWrapper
Internal class used to expose methods to internal classes but through a wrapper instead of a builder. |
| Nested classes/interfaces inherited from class com.j256.ormlite.stmt.StatementBuilder |
|---|
StatementBuilder.StatementInfo, StatementBuilder.StatementType |
| Field Summary |
|---|
| Fields inherited from class com.j256.ormlite.stmt.StatementBuilder |
|---|
addTableName, dao, databaseType, tableInfo, tableName, type, where |
| Constructor Summary | |
|---|---|
QueryBuilder(DatabaseType databaseType,
TableInfo<T,ID> tableInfo,
Dao<T,ID> dao)
|
|
| Method Summary | |
|---|---|
protected void |
appendStatementEnd(StringBuilder sb,
List<ArgumentHolder> argList)
Append the end of our statement string to the StringBuilder. |
protected void |
appendStatementStart(StringBuilder sb,
List<ArgumentHolder> argList)
Append the start of our statement string to the StringBuilder. |
protected void |
appendWhereStatement(StringBuilder sb,
List<ArgumentHolder> argList,
boolean first)
Append the WHERE part of the statement to the StringBuilder. |
void |
clear()
Clear out all of the statement settings so we can reuse the builder. |
long |
countOf()
Sets the count-of query flag using setCountOf(boolean) to true and then calls
Dao.countOf(PreparedQuery). |
QueryBuilder<T,ID> |
distinct()
Add "DISTINCT" clause to the SQL query statement. |
protected FieldType[] |
getResultFieldTypes()
Get the result array from our statement after the StatementBuilder.appendStatementStart(StringBuilder, List) was called. |
QueryBuilder<T,ID> |
groupBy(String columnName)
Add "GROUP BY" clause to the SQL query statement. |
QueryBuilder<T,ID> |
groupByRaw(String rawSql)
Add a raw SQL "GROUP BY" clause to the SQL query statement. |
QueryBuilder<T,ID> |
having(String having)
Add raw SQL "HAVING" clause to the SQL query statement. |
CloseableIterator<T> |
iterator()
A short cut to Dao.iterator(PreparedQuery). |
QueryBuilder<T,ID> |
join(QueryBuilder<?,?> joinedQueryBuilder)
Join with another query builder. |
QueryBuilder<T,ID> |
leftJoin(QueryBuilder<?,?> joinedQueryBuilder)
Similar to join(QueryBuilder) but it will use "LEFT JOIN" instead. |
QueryBuilder<T,ID> |
limit(int maxRows)
Deprecated. Should use limit(Long) |
QueryBuilder<T,ID> |
limit(Long maxRows)
Limit the output to maxRows maximum number of rows. |
QueryBuilder<T,ID> |
offset(int startRow)
Deprecated. Should use offset(Long) |
QueryBuilder<T,ID> |
offset(Long startRow)
Start the output at this row number. |
QueryBuilder<T,ID> |
orderBy(String columnName,
boolean ascending)
Add "ORDER BY" clause to the SQL query statement. |
QueryBuilder<T,ID> |
orderByRaw(String rawSql)
Add raw SQL "ORDER BY" clause to the SQL query statement. |
QueryBuilder<T,ID> |
orderByRaw(String rawSql,
ArgumentHolder... args)
Add raw SQL "ORDER BY" clause to the SQL query statement. |
PreparedQuery<T> |
prepare()
Build and return a prepared query that can be used by Dao.query(PreparedQuery) or
Dao.iterator(PreparedQuery) methods. |
List<T> |
query()
A short cut to Dao.query(PreparedQuery). |
T |
queryForFirst()
A short cut to Dao.queryForFirst(PreparedQuery). |
GenericRawResults<String[]> |
queryRaw()
A short cut to Dao.queryRaw(String, String...). |
String[] |
queryRawFirst()
A short cut to Dao.queryRaw(String, String...) and GenericRawResults.getFirstResult(). |
QueryBuilder<T,ID> |
selectColumns(Iterable<String> columns)
Same as selectColumns(String...) except the columns are specified as an iterable -- probably will be a
Collection. |
QueryBuilder<T,ID> |
selectColumns(String... columns)
Add columns to be returned by the SELECT query. |
QueryBuilder<T,ID> |
selectRaw(String... columns)
Add raw columns or aggregate functions (COUNT, MAX, ...) to the query. |
QueryBuilder<T,ID> |
setCountOf(boolean countOf)
Set whether or not we should only return the count of the results. |
protected boolean |
shouldPrependTableNameToColumns()
Return true if we need to prepend table-name to columns. |
| Methods inherited from class com.j256.ormlite.stmt.StatementBuilder |
|---|
appendStatementString, buildStatementString, prepareStatement, prepareStatementInfo, prepareStatementString, setWhere, verifyColumnName, where |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public QueryBuilder(DatabaseType databaseType,
TableInfo<T,ID> tableInfo,
Dao<T,ID> dao)
| Method Detail |
|---|
public PreparedQuery<T> prepare()
throws SQLException
Dao.query(PreparedQuery) or
Dao.iterator(PreparedQuery) methods. If you change the where or make other calls you will need to re-call
this method to re-prepare the statement for execution.
SQLExceptionpublic QueryBuilder<T,ID> selectColumns(String... columns)
WARNING: If you specify any columns to return, then any foreign-collection fields will be returned as null
unless their ForeignCollectionField.columnName() is also in the list.
public QueryBuilder<T,ID> selectColumns(Iterable<String> columns)
selectColumns(String...) except the columns are specified as an iterable -- probably will be a
Collection. This can be called multiple times to add more columns to select.
public QueryBuilder<T,ID> selectRaw(String... columns)
Dao.queryRaw(String, String...) type of statement. This can be called multiple
times to add more columns to select.
public QueryBuilder<T,ID> groupBy(String columnName)
NOTE: Use of this means that the resulting objects may not have a valid ID column value so cannot be deleted or updated.
public QueryBuilder<T,ID> groupByRaw(String rawSql)
public QueryBuilder<T,ID> orderBy(String columnName,
boolean ascending)
public QueryBuilder<T,ID> orderByRaw(String rawSql)
rawSql - The raw SQL order by clause. This should not include the "ORDER BY".
public QueryBuilder<T,ID> orderByRaw(String rawSql,
ArgumentHolder... args)
rawSql - The raw SQL order by clause. This should not include the "ORDER BY".args - Optional arguments that correspond to any ? specified in the rawSql. Each of the arguments must have
the sql-type set.public QueryBuilder<T,ID> distinct()
NOTE: Use of this means that the resulting objects may not have a valid ID column value so cannot be deleted or updated.
@Deprecated public QueryBuilder<T,ID> limit(int maxRows)
limit(Long)
public QueryBuilder<T,ID> limit(Long maxRows)
@Deprecated
public QueryBuilder<T,ID> offset(int startRow)
throws SQLException
offset(Long)
SQLException
public QueryBuilder<T,ID> offset(Long startRow)
throws SQLException
Dao.iterator() method instead which handles paging with a database cursor.
Otherwise, if you are paging you probably want to specify a orderBy(String, boolean).
NOTE: This is not supported for all databases. Also, for some databases, the limit _must_ also be specified since the offset is an argument of the limit.
SQLExceptionpublic QueryBuilder<T,ID> setCountOf(boolean countOf)
Dao.countOf(PreparedQuery).
To get the count-of directly, use countOf().
public QueryBuilder<T,ID> having(String having)
public QueryBuilder<T,ID> join(QueryBuilder<?,?> joinedQueryBuilder)
throws SQLException
SQLException
public QueryBuilder<T,ID> leftJoin(QueryBuilder<?,?> joinedQueryBuilder)
throws SQLException
join(QueryBuilder) but it will use "LEFT JOIN" instead.
See: LEFT JOIN SQL docs
NOTE: RIGHT and FULL JOIN SQL commands are not supported because we are only returning objects from the "left"
table.
SQLException
public List<T> query()
throws SQLException
Dao.query(PreparedQuery).
SQLException
public GenericRawResults<String[]> queryRaw()
throws SQLException
Dao.queryRaw(String, String...).
SQLException
public T queryForFirst()
throws SQLException
Dao.queryForFirst(PreparedQuery).
SQLException
public String[] queryRawFirst()
throws SQLException
Dao.queryRaw(String, String...) and GenericRawResults.getFirstResult().
SQLException
public CloseableIterator<T> iterator()
throws SQLException
Dao.iterator(PreparedQuery).
SQLException
public long countOf()
throws SQLException
setCountOf(boolean) to true and then calls
Dao.countOf(PreparedQuery).
SQLExceptionpublic void clear()
StatementBuilder
clear in class StatementBuilder<T,ID>
protected void appendStatementStart(StringBuilder sb,
List<ArgumentHolder> argList)
StatementBuilder
appendStatementStart in class StatementBuilder<T,ID>protected FieldType[] getResultFieldTypes()
StatementBuilderStatementBuilder.appendStatementStart(StringBuilder, List) was called.
This will be null except for the QueryBuilder.
getResultFieldTypes in class StatementBuilder<T,ID>
protected void appendWhereStatement(StringBuilder sb,
List<ArgumentHolder> argList,
boolean first)
throws SQLException
StatementBuilder
appendWhereStatement in class StatementBuilder<T,ID>SQLException
protected void appendStatementEnd(StringBuilder sb,
List<ArgumentHolder> argList)
throws SQLException
StatementBuilder
appendStatementEnd in class StatementBuilder<T,ID>SQLExceptionprotected boolean shouldPrependTableNameToColumns()
StatementBuilder
shouldPrependTableNameToColumns in class StatementBuilder<T,ID>
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||