|
||||||||||
| 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()
|
|
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. |
|
static
|
createDao(ConnectionSource connectionSource,
Class<T> clazz)
Deprecated. You should be using the DaoManager.createDao(ConnectionSource, Class) |
|
static
|
createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig)
Deprecated. You should be using the DaoManager.createDao(ConnectionSource, DatabaseTableConfig) |
|
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(PreparedQuery<T> preparedQuery)
Same as Dao.iterator() but with a prepared query parameter. |
|
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. |
|
CloseableIterator<T> |
seperateIterator()
Same as iterator() except this doesn't set the last iterator which can be closed with the
closeLastIterator(). |
|
CloseableIterator<T> |
seperateIterator(PreparedQuery<T> preparedQuery)
Same as iterator(PreparedQuery) except this doesn't set the last iterator which can be closed with the
closeLastIterator(). |
|
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
DaoDao.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
DaoDao.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()
DaoQueryBuilder.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()
DaoDao.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()
DaoDao.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
DaoDao.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
DaoDao.queryForMatchingArgs(Object).
queryForMatching in interface Dao<T,ID>SQLException
public List<T> queryForMatchingArgs(T matchObj)
throws SQLException
DaoDao.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
DaoDao.queryForFieldValuesArgs(Map).
queryForFieldValues in interface Dao<T,ID>SQLException
public List<T> queryForFieldValuesArgs(Map<String,Object> fieldValues)
throws SQLException
DaoDao.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
DaoDao.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
DaoDao.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
DaoNOTE: 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
DaoUpdateBuilder
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()
DaoIterable 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> seperateIterator()
iterator() except this doesn't set the last iterator which can be closed with the
closeLastIterator().
public CloseableWrappedIterable<T> getWrappedIterable()
DaoCloseableWrappedIterable 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)
DaoDao.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
DaoDao.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
DaoDao.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> seperateIterator(PreparedQuery<T> preparedQuery)
throws SQLException
iterator(PreparedQuery) except this doesn't set the last iterator which can be closed with the
closeLastIterator().
SQLException
public GenericRawResults<String[]> queryRaw(String query,
String... arguments)
throws SQLException
DaoDao.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
DaoDao.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
DaoDao.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
DaoNOTE: 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>Exceptionpublic 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>SQLExceptionpublic 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
DaoReferenceObjectCache 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
DaoDao.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 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>SQLExceptionpublic 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().
@Deprecated
public static <T,ID> Dao<T,ID> createDao(ConnectionSource connectionSource,
Class<T> clazz)
throws SQLException
DaoManager.createDao(ConnectionSource, Class)
NOTE: You should use DaoManager.createDao(ConnectionSource, DatabaseTableConfig) instead of this
method so you won't have to create the DAO multiple times.
SQLException
@Deprecated
public static <T,ID> Dao<T,ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig)
throws SQLException
DaoManager.createDao(ConnectionSource, DatabaseTableConfig)
TableInfo.
NOTE: You should use DaoManager.createDao(ConnectionSource, DatabaseTableConfig) instead of this
method so you won't have to create the DAO multiple times.
SQLExceptionprotected void checkForInitialized()
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||