|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectcom.j256.ormlite.dao.BaseDaoImpl<T,ID>
public abstract class BaseDaoImpl<T,ID>
Base class for the Database Access Objects that handle the reading and writing a class from the database.
This class is also Iterable
which means you can do a for (T obj : dao)
type of loop code to iterate
through the table of persisted objects. See iterator()
.
NOTE: If you are using the Spring type wiring, initialize()
should be called after all of the set
methods. In Spring XML, init-method="initialize" should be used.
Nested Class Summary |
---|
Nested classes/interfaces inherited from interface com.j256.ormlite.dao.Dao |
---|
Dao.CreateOrUpdateStatus |
Field Summary | |
---|---|
protected ConnectionSource |
connectionSource
|
protected DatabaseType |
databaseType
|
protected Class<T> |
dataClass
|
protected CloseableIterator<T> |
lastIterator
|
protected StatementExecutor<T,ID> |
statementExecutor
|
protected DatabaseTableConfig<T> |
tableConfig
|
protected TableInfo<T,ID> |
tableInfo
|
Constructor Summary | |
---|---|
protected |
BaseDaoImpl(Class<T> dataClass)
Construct our base DAO using Spring type wiring. |
protected |
BaseDaoImpl(ConnectionSource connectionSource,
Class<T> dataClass)
Construct our base DAO class. |
protected |
BaseDaoImpl(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig)
Construct our base DAO class. |
Method Summary | ||
---|---|---|
|
callBatchTasks(Callable<CT> callable)
Call the call-able that will perform a number of batch tasks. |
|
protected void |
checkForInitialized()
|
|
static void |
clearAllInternalObjectCaches()
Special call mostly used in testing to clear the internal object caches so we can reset state. |
|
void |
clearObjectCache()
Flush the object cache if it has been enabled. |
|
CloseableIterator<T> |
closeableIterator()
Returns an iterator over a set of elements of type T which can be closed. |
|
void |
closeLastIterator()
This closes the last iterator returned by the Dao.iterator() method. |
|
long |
countOf()
Returns the number of rows in the table associated with the data class. |
|
long |
countOf(PreparedQuery<T> preparedQuery)
Returns the number of rows in the table associated with the prepared query passed in. |
|
int |
create(T data)
Create a new row in the database from an object. |
|
T |
createIfNotExists(T data)
This is a convenience method to creating a data item but only if the ID does not already exist in the table. |
|
Dao.CreateOrUpdateStatus |
createOrUpdate(T data)
This is a convenience method for creating an item in the database if it does not exist. |
|
int |
delete(Collection<T> datas)
Delete a collection of objects from the database using an IN SQL clause. |
|
int |
delete(PreparedDelete<T> preparedDelete)
Delete the objects that match the prepared statement argument. |
|
int |
delete(T data)
Delete an object from the database. |
|
DeleteBuilder<T,ID> |
deleteBuilder()
Like Dao.queryBuilder() but allows you to build an DELETE statement. |
|
int |
deleteById(ID id)
Delete an object from the database that has an id. |
|
int |
deleteIds(Collection<ID> ids)
Delete the objects that match the collection of ids from the database using an IN SQL clause. |
|
int |
executeRaw(String statement,
String... arguments)
Run a raw execute SQL statement to the database.The arguments are optional but can be set with strings to expand ? type of SQL. |
|
ID |
extractId(T data)
Returns the ID from the data argument passed in. |
|
FieldType |
findForeignFieldType(Class<?> clazz)
Returns the class of the DAO. |
|
Class<T> |
getDataClass()
Returns the class of the DAO. |
|
|
getEmptyForeignCollection(String fieldName)
Returns an empty collection that can be assigned to a collection field. |
|
ObjectCache |
getObjectCache()
Returns the current object-cache being used by the DAO or null if none. |
|
GenericRowMapper<T> |
getSelectStarRowMapper()
Return a row mapper that is suitable for mapping results from a query to select * (star). |
|
DatabaseTableConfig<T> |
getTableConfig()
Returns the table configuration information associated with the Dao's class or null if none. |
|
TableInfo<T,ID> |
getTableInfo()
Used by internal classes to get the table information structure for the Dao's class. |
|
CloseableWrappedIterable<T> |
getWrappedIterable()
This makes a one time use iterable class that can be closed afterwards. |
|
CloseableWrappedIterable<T> |
getWrappedIterable(PreparedQuery<T> preparedQuery)
Same as Dao.getWrappedIterable() but with a prepared query parameter. |
|
boolean |
idExists(ID id)
Returns true if an object exists that matches this ID otherwise false. |
|
void |
initialize()
Initialize the various DAO configurations after the various setters have been called. |
|
boolean |
isTableExists()
Returns true if the table already exists otherwise false. |
|
boolean |
isUpdatable()
Returns true if we can call update on this class. |
|
CloseableIterator<T> |
iterator()
This satisfies the Iterable interface for the class and allows you to iterate through the objects in the
table using SQL. |
|
CloseableIterator<T> |
iterator(int resultFlags)
Same as Dao.iterator() but while specifying flags for the results. |
|
CloseableIterator<T> |
iterator(PreparedQuery<T> preparedQuery)
Same as Dao.iterator() but with a prepared query parameter. |
|
CloseableIterator<T> |
iterator(PreparedQuery<T> preparedQuery,
int resultFlags)
Same as Dao.iterator(PreparedQuery) but while specifying flags for the results. |
|
T |
mapSelectStarRow(DatabaseResults results)
Return the latest row from the database results from a query to select * (star). |
|
boolean |
objectsEqual(T data1,
T data2)
Return true if the two arguments are equal. |
|
String |
objectToString(T data)
Return the string version of the object with each of the known field values shown. |
|
List<T> |
query(PreparedQuery<T> preparedQuery)
Query for the items in the object table which match the prepared query. |
|
QueryBuilder<T,ID> |
queryBuilder()
Create and return a new query builder object which allows you to build a custom SELECT statement. |
|
List<T> |
queryForAll()
Query for all of the items in the object table. |
|
List<T> |
queryForEq(String fieldName,
Object value)
Query for the items in the object table that match a simple where with a single field = value type of WHERE clause. |
|
List<T> |
queryForFieldValues(Map<String,Object> fieldValues)
Query for the rows in the database that matches all of the field to value entries from the map passed in. |
|
List<T> |
queryForFieldValuesArgs(Map<String,Object> fieldValues)
Same as Dao.queryForFieldValues(Map) but this uses SelectArg and SQL ? arguments. |
|
T |
queryForFirst(PreparedQuery<T> preparedQuery)
Query for and return the first item in the object table which matches the PreparedQuery. |
|
T |
queryForId(ID id)
Retrieves an object associated with a specific ID. |
|
List<T> |
queryForMatching(T matchObj)
Query for the rows in the database that match the object passed in as an argument. |
|
List<T> |
queryForMatchingArgs(T matchObj)
Same as Dao.queryForMatching(Object) but this uses SelectArg and SQL ? arguments. |
|
T |
queryForSameId(T data)
Query for a data item in the table that has the same ID as the data parameter. |
|
GenericRawResults<Object[]> |
queryRaw(String query,
DataType[] columnTypes,
String... arguments)
Similar to the Dao.queryRaw(String, String...) but instead of an array of String results being returned by
the iterator, this uses the column-types parameter to return an array of Objects instead. |
|
|
queryRaw(String query,
RawRowMapper<GR> mapper,
String... arguments)
Similar to the Dao.queryRaw(String, String...) but this iterator returns rows that you can map yourself. |
|
GenericRawResults<String[]> |
queryRaw(String query,
String... arguments)
Similar to the Dao.iterator(PreparedQuery) except it returns a GenericRawResults object associated with the
SQL select query argument. |
|
int |
refresh(T data)
Does a query for the object's id and copies in each of the field values from the database to refresh the data parameter. |
|
void |
setConnectionSource(ConnectionSource connectionSource)
|
|
void |
setObjectCache(boolean enabled)
Call this with true to enable an object cache for the DAO. |
|
void |
setObjectCache(ObjectCache objectCache)
Same as Dao.setObjectCache(boolean) except you specify the actual cache instance to use for the DAO. |
|
void |
setTableConfig(DatabaseTableConfig<T> tableConfig)
Used if you want to configure the class for the Dao by hand or with spring instead of using the DatabaseField annotation in the class. |
|
int |
update(PreparedUpdate<T> preparedUpdate)
Update all rows in the table according to the prepared statement argument. |
|
int |
update(T data)
Save the fields from an object to the database. |
|
UpdateBuilder<T,ID> |
updateBuilder()
Like Dao.queryBuilder() but allows you to build an UPDATE statement. |
|
int |
updateId(T data,
ID newId)
Update an object in the database to change its id to the newId parameter. |
|
int |
updateRaw(String statement,
String... arguments)
Run a raw update SQL statement to the database. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
protected StatementExecutor<T,ID> statementExecutor
protected DatabaseType databaseType
protected final Class<T> dataClass
protected DatabaseTableConfig<T> tableConfig
protected TableInfo<T,ID> tableInfo
protected ConnectionSource connectionSource
protected CloseableIterator<T> lastIterator
Constructor Detail |
---|
protected BaseDaoImpl(Class<T> dataClass) throws SQLException
ConnectionSource
must be set with the
setConnectionSource(com.j256.ormlite.support.ConnectionSource)
method afterwards and then the initialize()
method must be called. The
dataClass provided must have its fields marked with DatabaseField
annotations or the
setTableConfig(com.j256.ormlite.table.DatabaseTableConfig)
method must be called before the initialize()
method is called.
If you are using Spring then your should use: init-method="initialize"
dataClass
- Class associated with this Dao. This must match the T class parameter.
SQLException
protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass) throws SQLException
DatabaseField
or
javax.persistance annotations.
connectionSource
- Source of our database connections.dataClass
- Class associated with this Dao. This must match the T class parameter.
SQLException
protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig) throws SQLException
connectionSource
- Source of our database connections.tableConfig
- Hand or Spring wired table configuration information.
SQLException
Method Detail |
---|
public void initialize() throws SQLException
SQLException
public T queryForId(ID id) throws SQLException
Dao
queryForId
in interface Dao<T,ID>
id
- Identifier that matches a specific row in the database to find and return.
SQLException
- on any SQL problems or if more than 1 item with the id are found in the database.public T queryForFirst(PreparedQuery<T> preparedQuery) throws SQLException
Dao
Dao.queryBuilder()
for more information. This can be used to return the object that matches a single unique
column. You should use Dao.queryForId(Object)
if you want to query for the id column.
queryForFirst
in interface Dao<T,ID>
preparedQuery
- Query used to match the objects in the database.
SQLException
- on any SQL problems.public List<T> queryForAll() throws SQLException
Dao
Dao.iterator()
method instead.
queryForAll
in interface Dao<T,ID>
SQLException
- on any SQL problems.public List<T> queryForEq(String fieldName, Object value) throws SQLException
Dao
queryForEq
in interface Dao<T,ID>
SQLException
- on any SQL problems.public QueryBuilder<T,ID> queryBuilder()
Dao
QueryBuilder.prepare()
once you are
ready to build. This returns a PreparedQuery
object which gets passed to Dao.query(PreparedQuery)
or
Dao.iterator(PreparedQuery)
.
queryBuilder
in interface Dao<T,ID>
public UpdateBuilder<T,ID> updateBuilder()
Dao
Dao.queryBuilder()
but allows you to build an UPDATE statement. You can then call call
UpdateBuilder.prepare()
and pass the returned PreparedUpdate
to Dao.update(PreparedUpdate)
.
updateBuilder
in interface Dao<T,ID>
public DeleteBuilder<T,ID> deleteBuilder()
Dao
Dao.queryBuilder()
but allows you to build an DELETE statement. You can then call call
DeleteBuilder.prepare()
and pass the returned PreparedDelete
to Dao.delete(PreparedDelete)
.
deleteBuilder
in interface Dao<T,ID>
public List<T> query(PreparedQuery<T> preparedQuery) throws SQLException
Dao
Dao.queryBuilder()
for more
information.
NOTE: For medium sized or large tables, this may load a lot of objects into memory so you should consider
using the Dao.iterator(PreparedQuery)
method instead.
query
in interface Dao<T,ID>
preparedQuery
- Query used to match the objects in the database.
SQLException
- on any SQL problems.public List<T> queryForMatching(T matchObj) throws SQLException
Dao
Dao.queryForMatchingArgs(Object)
.
queryForMatching
in interface Dao<T,ID>
SQLException
public List<T> queryForMatchingArgs(T matchObj) throws SQLException
Dao
Dao.queryForMatching(Object)
but this uses SelectArg
and SQL ? arguments. This is slightly
more expensive but you don't have to worry about SQL quote escaping.
queryForMatchingArgs
in interface Dao<T,ID>
SQLException
public List<T> queryForFieldValues(Map<String,Object> fieldValues) throws SQLException
Dao
Dao.queryForFieldValuesArgs(Map)
.
queryForFieldValues
in interface Dao<T,ID>
SQLException
public List<T> queryForFieldValuesArgs(Map<String,Object> fieldValues) throws SQLException
Dao
Dao.queryForFieldValues(Map)
but this uses SelectArg
and SQL ? arguments. This is slightly
more expensive but you don't have to worry about SQL quote escaping.
queryForFieldValuesArgs
in interface Dao<T,ID>
SQLException
public T queryForSameId(T data) throws SQLException
Dao
queryForSameId
in interface Dao<T,ID>
SQLException
public int create(T data) throws SQLException
Dao
create
in interface Dao<T,ID>
data
- The data item that we are creating in the database.
SQLException
public T createIfNotExists(T data) throws SQLException
Dao
Dao.queryForId(Object)
on it, returning the data if it
exists. If it does not exist Dao.create(Object)
will be called with the parameter.
createIfNotExists
in interface Dao<T,ID>
SQLException
public Dao.CreateOrUpdateStatus createOrUpdate(T data) throws SQLException
Dao
createOrUpdate
in interface Dao<T,ID>
SQLException
public int update(T data) throws SQLException
Dao
Dao.updateId(T, ID)
.
update
in interface Dao<T,ID>
data
- The data item that we are updating in the database.
SQLException
- on any SQL problems.public int updateId(T data, ID newId) throws SQLException
Dao
NOTE: Depending on the database type and the id type, you may be unable to change the id of the field.
updateId
in interface Dao<T,ID>
data
- The data item that we are updating in the database with the current id.newId
- The new id that you want to update the data with.
SQLException
- on any SQL problems.public int update(PreparedUpdate<T> preparedUpdate) throws SQLException
Dao
UpdateBuilder
must have set-columns applied to it using the UpdateBuilder.updateColumnValue(String, Object)
or
UpdateBuilder.updateColumnExpression(String, String)
methods.
update
in interface Dao<T,ID>
preparedUpdate
- A prepared statement to match database rows to be deleted and define the columns to update.
SQLException
- on any SQL problems.public int refresh(T data) throws SQLException
Dao
refresh
in interface Dao<T,ID>
data
- The data item that we are refreshing with fields from the database.
SQLException
- on any SQL problems or if the data item is not found in the table or if more than 1 item is found
with data's id.public int delete(T data) throws SQLException
Dao
delete
in interface Dao<T,ID>
data
- The data item that we are deleting from the database.
SQLException
- on any SQL problems.public int deleteById(ID id) throws SQLException
Dao
deleteById
in interface Dao<T,ID>
id
- The id of the item that we are deleting from the database.
SQLException
- on any SQL problems.public int delete(Collection<T> datas) throws SQLException
Dao
delete
in interface Dao<T,ID>
datas
- A collection of data items to be deleted.
SQLException
- on any SQL problems.public int deleteIds(Collection<ID> ids) throws SQLException
Dao
deleteIds
in interface Dao<T,ID>
ids
- A collection of data ids to be deleted.
SQLException
- on any SQL problems.public int delete(PreparedDelete<T> preparedDelete) throws SQLException
Dao
delete
in interface Dao<T,ID>
preparedDelete
- A prepared statement to match database rows to be deleted.
SQLException
- on any SQL problems.public CloseableIterator<T> iterator()
Dao
Iterable
interface for the class and allows you to iterate through the objects in the
table using SQL. You can use code similar to the following:
for (Account account : accountDao) { ... }
WARNING: because the Iterator.hasNext()
, Iterator.next()
, etc. methods can only throw
RuntimeException
, the code has to wrap any SQLException
with IllegalStateException
. Make
sure to catch IllegalStateException
and look for a SQLException
cause.
WARNING: The underlying results object will only be closed if you page all the way to the end of the
iterator using the for() loop or if you call CloseableIterator.close()
directly. You can also call the
Dao.closeLastIterator()
if you are not iterating across this DAO in multiple threads.
iterator
in interface Dao<T,ID>
iterator
in interface Iterable<T>
public CloseableIterator<T> closeableIterator()
CloseableIterable
closeableIterator
in interface CloseableIterable<T>
public CloseableIterator<T> iterator(int resultFlags)
Dao
Dao.iterator()
but while specifying flags for the results. This is necessary with certain database
types.
WARNING: Depending on the database type the underlying connection may never be freed -- even if you go all
of the way through the results. It is strongly recommended that you call the
CloseableIterator.close()
method when you are done with the iterator.
iterator
in interface Dao<T,ID>
public CloseableWrappedIterable<T> getWrappedIterable()
Dao
CloseableWrappedIterable
but multiple threads can each call this to get their own closeable iterable.
This allows you to do something like:
CloseableWrappedIterablewrappedIterable = fooDao.getWrappedIterable(); try { for (Foo foo : wrappedIterable) { ... } } finally { wrappedIterable.close(); }
getWrappedIterable
in interface Dao<T,ID>
public CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery)
Dao
Dao.getWrappedIterable()
but with a prepared query parameter. See Dao.queryBuilder()
or
Dao.iterator(PreparedQuery)
for more information.
getWrappedIterable
in interface Dao<T,ID>
public void closeLastIterator() throws SQLException
Dao
Dao.iterator()
method.
NOTE: This is not reentrant. If multiple threads are getting iterators from this DAO then you should use
the Dao.getWrappedIterable()
method to get a wrapped iterable for each thread instead.
closeLastIterator
in interface Dao<T,ID>
SQLException
public CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery) throws SQLException
Dao
Dao.iterator()
but with a prepared query parameter. See Dao.queryBuilder()
for more information.
You use it like the following:
QueryBuilder<Account, String> qb = accountDao.queryBuilder(); ... custom query builder methods CloseableIterator<Account> iterator = partialDao.iterator(qb.prepare()); try { while (iterator.hasNext()) { Account account = iterator.next(); ... } } finish { iterator.close(); }
iterator
in interface Dao<T,ID>
preparedQuery
- Query used to iterate across a sub-set of the items in the database.
SQLException
- on any SQL problems.public CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags) throws SQLException
Dao
Dao.iterator(PreparedQuery)
but while specifying flags for the results. This is necessary with
certain database types.
iterator
in interface Dao<T,ID>
SQLException
public GenericRawResults<String[]> queryRaw(String query, String... arguments) throws SQLException
Dao
Dao.iterator(PreparedQuery)
except it returns a GenericRawResults object associated with the
SQL select query argument. Although you should use the Dao.iterator()
for most queries, this method allows
you to do special queries that aren't supported otherwise. Like the above iterator methods, you must call close
on the returned RawResults object once you are done with it. The arguments are optional but can be set with
strings to expand ? type of SQL.
You can use the StatementBuilder.prepareStatementString()
method here if you want to build the query using
the structure of the QueryBuilder.
QueryBuilder<Account, Integer> qb = accountDao.queryBuilder(); qb.where().ge("orderCount", 10); results = accountDao.queryRaw(qb.prepareStatementString());If you want to use the QueryBuilder with arguments to the raw query then you should do something like:
QueryBuilder<Account, Integer> qb = accountDao.queryBuilder(); // we specify a SelectArg here to generate a ? in the statement string below qb.where().ge("orderCount", new SelectArg()); // the 10 at the end is an optional argument to fulfill the SelectArg above results = accountDao.queryRaw(qb.prepareStatementString(), rawRowMapper, 10);
queryRaw
in interface Dao<T,ID>
SQLException
public <GR> GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments) throws SQLException
Dao
Dao.queryRaw(String, String...)
but this iterator returns rows that you can map yourself. For
every result that is returned by the database, the RawRowMapper.mapRow(String[], String[])
method is
called so you can convert the result columns into an object to be returned by the iterator. The arguments are
optional but can be set with strings to expand ? type of SQL.
queryRaw
in interface Dao<T,ID>
SQLException
public GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments) throws SQLException
Dao
Dao.queryRaw(String, String...)
but instead of an array of String results being returned by
the iterator, this uses the column-types parameter to return an array of Objects instead. The arguments are
optional but can be set with strings to expand ? type of SQL.
queryRaw
in interface Dao<T,ID>
SQLException
public int executeRaw(String statement, String... arguments) throws SQLException
Dao
executeRaw
in interface Dao<T,ID>
SQLException
public int updateRaw(String statement, String... arguments) throws SQLException
Dao
updateRaw
in interface Dao<T,ID>
SQLException
public <CT> CT callBatchTasks(Callable<CT> callable) throws Exception
Dao
NOTE: If neither auto-commit nor transactions are supported by the database type then this may just call the callable.
callBatchTasks
in interface Dao<T,ID>
Exception
public String objectToString(T data)
Dao
objectToString
in interface Dao<T,ID>
data
- The data item for which we are returning the toString information.public boolean objectsEqual(T data1, T data2) throws SQLException
Dao
objectsEqual
in interface Dao<T,ID>
data1
- One of the data items that we are checking for equality.data2
- The other data item that we are checking for equality.
SQLException
public ID extractId(T data) throws SQLException
Dao
extractId
in interface Dao<T,ID>
SQLException
public Class<T> getDataClass()
Dao
getDataClass
in interface Dao<T,ID>
public FieldType findForeignFieldType(Class<?> clazz)
Dao
findForeignFieldType
in interface Dao<T,ID>
public boolean isUpdatable()
Dao
isUpdatable
in interface Dao<T,ID>
public boolean isTableExists() throws SQLException
Dao
isTableExists
in interface Dao<T,ID>
SQLException
public long countOf() throws SQLException
Dao
countOf
in interface Dao<T,ID>
SQLException
public long countOf(PreparedQuery<T> preparedQuery) throws SQLException
Dao
countOf
in interface Dao<T,ID>
SQLException
public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) throws SQLException
Dao
@ForeignCollectionField(columnName = "orders") Collection<Order> orders;You would then call:
account.orders = accoundDao.getEmptyForeignCollection("orders"); // this would add it the collection and the internal DAO account.orders.add(order1);
getEmptyForeignCollection
in interface Dao<T,ID>
fieldName
- parameter is the field name of the foreign collection field -- you might consider using the
ForeignCollectionField.columnName()
to set the name to a static name.
SQLException
public void setObjectCache(boolean enabled) throws SQLException
Dao
ReferenceObjectCache
of the objects (using
WeakReference
) referenced by the DAO. No support for objects returned by the Dao.queryRaw(java.lang.String, java.lang.String...)
methods.
setObjectCache
in interface Dao<T,ID>
SQLException
- If the DAO's class does not have an id field which is required by the ObjectCache
.public void setObjectCache(ObjectCache objectCache) throws SQLException
Dao
Dao.setObjectCache(boolean)
except you specify the actual cache instance to use for the DAO. This
allows you to use a ReferenceObjectCache
with SoftReference
setting, the LruObjectCache
,
or inject your own cache implementation. Call it with null to disable the cache.
setObjectCache
in interface Dao<T,ID>
SQLException
- If the DAO's class does not have an id field which is required by the ObjectCache
.public ObjectCache getObjectCache()
Dao
getObjectCache
in interface Dao<T,ID>
public void clearObjectCache()
Dao
clearObjectCache
in interface Dao<T,ID>
public static void clearAllInternalObjectCaches()
public T mapSelectStarRow(DatabaseResults results) throws SQLException
Dao
mapSelectStarRow
in interface Dao<T,ID>
SQLException
public GenericRowMapper<T> getSelectStarRowMapper() throws SQLException
Dao
getSelectStarRowMapper
in interface Dao<T,ID>
SQLException
public boolean idExists(ID id) throws SQLException
Dao
idExists
in interface Dao<T,ID>
SQLException
public DatabaseTableConfig<T> getTableConfig()
public TableInfo<T,ID> getTableInfo()
public void setConnectionSource(ConnectionSource connectionSource)
public void setTableConfig(DatabaseTableConfig<T> tableConfig)
DatabaseField
annotation in the class. This must be called before initialize()
.
protected void checkForInitialized()
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |