com.j256.ormlite.dao
Class BaseDaoImpl<T,ID>

java.lang.Object
  extended by com.j256.ormlite.dao.BaseDaoImpl<T,ID>
All Implemented Interfaces:
CloseableIterable<T>, Dao<T,ID>, Iterable<T>

public abstract class BaseDaoImpl<T,ID>
extends Object
implements Dao<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.

Author:
graywatson

Field Summary
protected  ConnectionSource connectionSource
           
protected  DatabaseType databaseType
           
protected  Class<T> dataClass
           
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
<CT> CT
callBatchTasks(Callable<CT> callable)
          Call the call-able that will perform a number of batch tasks.
protected  void checkForInitialized()
           
 long countOf()
          Returns the number of rows in the table associated with the data class.
 int create(T data)
          Create a new row in the database from an object.
static
<T,ID> Dao<T,ID>
createDao(ConnectionSource connectionSource, Class<T> clazz)
          Deprecated. You should be using the DaoManager.createDao(ConnectionSource, Class)
static
<T,ID> Dao<T,ID>
createDao(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig)
          Deprecated. You should be using the DaoManager.createDao(ConnectionSource, DatabaseTableConfig)
 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 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.
 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.
 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.
 SelectIterator<T,ID> iterator()
          This satisfies the Iterable interface for the class and allows you to iterate through the objects in the table using SQL.
 SelectIterator<T,ID> iterator(PreparedQuery<T> preparedQuery)
          Same as Dao.iterator() but with a prepared query parameter.
 RawResults iteratorRaw(String query)
          You should be using Dao.queryRaw(String, String...);
 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.
 RawResults queryForAllRaw(String queryString)
          You should be using Dao.queryRaw(String, String...)
 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.
 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.
 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.
<GR> GenericRawResults<GR>
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 RawResults 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 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

statementExecutor

protected StatementExecutor<T,ID> statementExecutor

databaseType

protected DatabaseType databaseType

dataClass

protected final Class<T> dataClass

tableConfig

protected DatabaseTableConfig<T> tableConfig

tableInfo

protected TableInfo<T,ID> tableInfo

connectionSource

protected ConnectionSource connectionSource
Constructor Detail

BaseDaoImpl

protected BaseDaoImpl(Class<T> dataClass)
               throws SQLException
Construct our base DAO using Spring type wiring. The 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"

Parameters:
dataClass - Class associated with this Dao. This must match the T class parameter.
Throws:
SQLException

BaseDaoImpl

protected BaseDaoImpl(ConnectionSource connectionSource,
                      Class<T> dataClass)
               throws SQLException
Construct our base DAO class. The dataClass provided must have its fields marked with DatabaseField or javax.persistance annotations.

Parameters:
connectionSource - Source of our database connections.
dataClass - Class associated with this Dao. This must match the T class parameter.
Throws:
SQLException

BaseDaoImpl

protected BaseDaoImpl(ConnectionSource connectionSource,
                      DatabaseTableConfig<T> tableConfig)
               throws SQLException
Construct our base DAO class.

Parameters:
connectionSource - Source of our database connections.
tableConfig - Hand or Spring wired table configuration information.
Throws:
SQLException
Method Detail

initialize

public void initialize()
                throws SQLException
Initialize the various DAO configurations after the various setters have been called.

Throws:
SQLException

queryForId

public T queryForId(ID id)
             throws SQLException
Description copied from interface: Dao
Retrieves an object associated with a specific ID.

Specified by:
queryForId in interface Dao<T,ID>
Parameters:
id - Identifier that matches a specific row in the database to find and return.
Returns:
The object that has the ID field which equals id or null if no matches.
Throws:
SQLException - on any SQL problems or if more than 1 item with the id are found in the database.

queryForFirst

public T queryForFirst(PreparedQuery<T> preparedQuery)
                throws SQLException
Description copied from interface: Dao
Query for and return the first item in the object table which matches the PreparedQuery. See 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.

Specified by:
queryForFirst in interface Dao<T,ID>
Parameters:
preparedQuery - Query used to match the objects in the database.
Returns:
The first object that matches the query.
Throws:
SQLException - on any SQL problems.

queryForAll

public List<T> queryForAll()
                    throws SQLException
Description copied from interface: Dao
Query for all of the items in the object table. For medium sized or large tables, this may load a lot of objects into memory so you should consider using the Dao.iterator() method instead.

Specified by:
queryForAll in interface Dao<T,ID>
Returns:
A list of all of the objects in the table.
Throws:
SQLException - on any SQL problems.

queryForEq

public List<T> queryForEq(String fieldName,
                          Object value)
                   throws SQLException
Description copied from interface: Dao
Query for the items in the object table that match a simple where with a single field = value type of WHERE clause. This is a convenience method for calling queryBuilder().where().eq(fieldName, value).query().

Specified by:
queryForEq in interface Dao<T,ID>
Returns:
A list of the objects in the table that match the fieldName = value;
Throws:
SQLException - on any SQL problems.

queryBuilder

public QueryBuilder<T,ID> queryBuilder()
Description copied from interface: Dao
Create and return a new query builder object which allows you to build a custom SELECT statement. You call methods on the builder to construct your statement and then call QueryBuilder.prepare() once you are ready to build. This returns a PreparedQuery object which gets passed to Dao.query(PreparedQuery) or Dao.iterator(PreparedQuery).

Specified by:
queryBuilder in interface Dao<T,ID>

updateBuilder

public UpdateBuilder<T,ID> updateBuilder()
Description copied from interface: Dao
Like 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).

Specified by:
updateBuilder in interface Dao<T,ID>

deleteBuilder

public DeleteBuilder<T,ID> deleteBuilder()
Description copied from interface: Dao
Like 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).

Specified by:
deleteBuilder in interface Dao<T,ID>

query

public List<T> query(PreparedQuery<T> preparedQuery)
              throws SQLException
Description copied from interface: Dao
Query for the items in the object table which match the prepared query. See 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.

Specified by:
query in interface Dao<T,ID>
Parameters:
preparedQuery - Query used to match the objects in the database.
Returns:
A list of all of the objects in the table that match the query.
Throws:
SQLException - on any SQL problems.

queryForAllRaw

public RawResults queryForAllRaw(String queryString)
                          throws SQLException
Description copied from interface: Dao
You should be using Dao.queryRaw(String, String...)

Specified by:
queryForAllRaw in interface Dao<T,ID>
Throws:
SQLException

queryForMatching

public List<T> queryForMatching(T matchObj)
                         throws SQLException
Description copied from interface: Dao
Query for the rows in the database that match the object passed in as an argument. Any fields in the matching object that are not the default value (null, false, 0, 0.0, etc.) are used as the matching parameters with AND.

Specified by:
queryForMatching in interface Dao<T,ID>
Throws:
SQLException

queryForFieldValues

public List<T> queryForFieldValues(Map<String,Object> fieldValues)
                            throws SQLException
Description copied from interface: Dao
Query for the rows in the database that matches all of the field to value entries from the map passed in.

Specified by:
queryForFieldValues in interface Dao<T,ID>
Throws:
SQLException

create

public int create(T data)
           throws SQLException
Description copied from interface: Dao
Create a new row in the database from an object.

Specified by:
create in interface Dao<T,ID>
Parameters:
data - The data item that we are creating in the database.
Returns:
The number of rows updated in the database. This should be 1.
Throws:
SQLException

update

public int update(T data)
           throws SQLException
Description copied from interface: Dao
Save the fields from an object to the database. If you have made changes to an object, this is how you persist those changes to the database. You cannot use this method to update the id field -- see Dao.updateId(T, ID).

Specified by:
update in interface Dao<T,ID>
Parameters:
data - The data item that we are updating in the database.
Returns:
The number of rows updated in the database. This should be 1.
Throws:
SQLException - on any SQL problems.

updateId

public int updateId(T data,
                    ID newId)
             throws SQLException
Description copied from interface: Dao
Update an object in the database to change its id to the newId parameter. The data must have its current id set. If the id field has already changed then it cannot be updated. After the id has been updated in the database, the id field of the data object will also be changed.

NOTE: Depending on the database type and the id type, you may be unable to change the id of the field.

Specified by:
updateId in interface Dao<T,ID>
Parameters:
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.
Returns:
The number of rows updated in the database. This should be 1.
Throws:
SQLException - on any SQL problems.

update

public int update(PreparedUpdate<T> preparedUpdate)
           throws SQLException
Description copied from interface: Dao
Update all rows in the table according to the prepared statement argument. To use this, the UpdateBuilder must have set-columns applied to it using the UpdateBuilder.updateColumnValue(String, Object) or UpdateBuilder.updateColumnExpression(String, String) methods.

Specified by:
update in interface Dao<T,ID>
Parameters:
preparedUpdate - A prepared statement to match database rows to be deleted and define the columns to update.
Returns:
The number of rows updated in the database.
Throws:
SQLException - on any SQL problems.

refresh

public int refresh(T data)
            throws SQLException
Description copied from interface: Dao
Does a query for the object's id and copies in each of the field values from the database to refresh the data parameter. Any local object changes to persisted fields will be overwritten. If the database has been updated this brings your local object up to date.

Specified by:
refresh in interface Dao<T,ID>
Parameters:
data - The data item that we are refreshing with fields from the database.
Returns:
The number of rows found in the database that correspond to the data id. This should be 1.
Throws:
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.

delete

public int delete(T data)
           throws SQLException
Description copied from interface: Dao
Delete an object from the database.

Specified by:
delete in interface Dao<T,ID>
Parameters:
data - The data item that we are deleting from the database.
Returns:
The number of rows updated in the database. This should be 1.
Throws:
SQLException - on any SQL problems.

delete

public int delete(Collection<T> datas)
           throws SQLException
Description copied from interface: Dao
Delete a collection of objects from the database using an IN SQL clause.

Specified by:
delete in interface Dao<T,ID>
Parameters:
datas - A collection of data items to be deleted.
Returns:
The number of rows updated in the database. This should be the size() of the collection.
Throws:
SQLException - on any SQL problems.

deleteIds

public int deleteIds(Collection<ID> ids)
              throws SQLException
Description copied from interface: Dao
Delete the objects that match the collection of ids from the database using an IN SQL clause.

Specified by:
deleteIds in interface Dao<T,ID>
Parameters:
ids - A collection of data ids to be deleted.
Returns:
The number of rows updated in the database. This should be the size() of the collection.
Throws:
SQLException - on any SQL problems.

delete

public int delete(PreparedDelete<T> preparedDelete)
           throws SQLException
Description copied from interface: Dao
Delete the objects that match the prepared statement argument.

Specified by:
delete in interface Dao<T,ID>
Parameters:
preparedDelete - A prepared statement to match database rows to be deleted.
Returns:
The number of rows updated in the database.
Throws:
SQLException - on any SQL problems.

iterator

public SelectIterator<T,ID> iterator()
Description copied from interface: Dao
This satisfies the 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. See the SelectIterator source code for more details.

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 SelectIterator.close() directly. It is also closed when it is garbage collected but this is considered bad form.

Specified by:
iterator in interface CloseableIterable<T>
Specified by:
iterator in interface Dao<T,ID>
Specified by:
iterator in interface Iterable<T>
Returns:
An iterator of the class that uses SQL to step across the database table.

iterator

public SelectIterator<T,ID> iterator(PreparedQuery<T> preparedQuery)
                              throws SQLException
Description copied from interface: Dao
Same as 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
 SelectIterator<Account> iterator = partialDao.iterator(qb.prepare());
 try {
     while (iterator.hasNext()) {
         Account account = iterator.next();
         ...
     }
 } finish {
     iterator.close();
 }
 

Specified by:
iterator in interface Dao<T,ID>
Parameters:
preparedQuery - Query used to iterate across a sub-set of the items in the database.
Returns:
An iterator for T.
Throws:
SQLException - on any SQL problems.

iteratorRaw

public RawResults iteratorRaw(String query)
                       throws SQLException
Description copied from interface: Dao
You should be using Dao.queryRaw(String, String...);

Specified by:
iteratorRaw in interface Dao<T,ID>
Throws:
SQLException

queryRaw

public GenericRawResults<String[]> queryRaw(String query,
                                            String... arguments)
                                     throws SQLException
Description copied from interface: Dao
Similar to the Dao.iterator(PreparedQuery) except it returns a RawResults 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.

Specified by:
queryRaw in interface Dao<T,ID>
Throws:
SQLException

queryRaw

public <GR> GenericRawResults<GR> queryRaw(String query,
                                           RawRowMapper<GR> mapper,
                                           String... arguments)
                               throws SQLException
Description copied from interface: Dao
Similar to the 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.

Specified by:
queryRaw in interface Dao<T,ID>
Throws:
SQLException

queryRaw

public GenericRawResults<Object[]> queryRaw(String query,
                                            DataType[] columnTypes,
                                            String... arguments)
                                     throws SQLException
Description copied from interface: Dao
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. The arguments are optional but can be set with strings to expand ? type of SQL.

Specified by:
queryRaw in interface Dao<T,ID>
Throws:
SQLException

executeRaw

public int executeRaw(String statement,
                      String... arguments)
               throws SQLException
Description copied from interface: Dao
Run a raw execute SQL statement to the database.The arguments are optional but can be set with strings to expand ? type of SQL.

Specified by:
executeRaw in interface Dao<T,ID>
Returns:
number of rows affected.
Throws:
SQLException

updateRaw

public int updateRaw(String statement,
                     String... arguments)
              throws SQLException
Description copied from interface: Dao
Run a raw update SQL statement to the database. The statement must be an SQL INSERT, UPDATE or DELETE statement.The arguments are optional but can be set with strings to expand ? type of SQL.

Specified by:
updateRaw in interface Dao<T,ID>
Returns:
number of rows affected.
Throws:
SQLException

callBatchTasks

public <CT> CT callBatchTasks(Callable<CT> callable)
                  throws Exception
Description copied from interface: Dao
Call the call-able that will perform a number of batch tasks. This is for performance when you want to run a number of database operations at once -- maybe loading data from a file. This will turn off what databases call "auto-commit" mode, run the call-able and then re-enable "auto-commit". If auto-commit is not supported then a transaction will be used instead.

NOTE: If neither auto-commit nor transactions are supported by the database type then this may just call the callable.

Specified by:
callBatchTasks in interface Dao<T,ID>
Throws:
Exception

objectToString

public String objectToString(T data)
Description copied from interface: Dao
Return the string version of the object with each of the known field values shown. Useful for testing and debugging.

Specified by:
objectToString in interface Dao<T,ID>
Parameters:
data - The data item for which we are returning the toString information.

objectsEqual

public boolean objectsEqual(T data1,
                            T data2)
                     throws SQLException
Description copied from interface: Dao
Return true if the two arguments are equal. This checks each of the fields defined in the database to see if they are equal. Useful for testing and debugging.

Specified by:
objectsEqual in interface Dao<T,ID>
Parameters:
data1 - One of the data items that we are checking for equality.
data2 - The other data item that we are checking for equality.
Throws:
SQLException

extractId

public ID extractId(T data)
             throws SQLException
Description copied from interface: Dao
Returns the ID from the data argument passed in. This is used by some of the internal queries to be able to search by id.

Specified by:
extractId in interface Dao<T,ID>
Throws:
SQLException

getDataClass

public Class<T> getDataClass()
Description copied from interface: Dao
Returns the class of the DAO. This is used by internal query operators.

Specified by:
getDataClass in interface Dao<T,ID>

findForeignFieldType

public FieldType findForeignFieldType(Class<?> clazz)
Description copied from interface: Dao
Returns the class of the DAO. This is used by internal query operators.

Specified by:
findForeignFieldType in interface Dao<T,ID>

isUpdatable

public boolean isUpdatable()
Description copied from interface: Dao
Returns true if we can call update on this class. This is used most likely by folks who are extending the base dao classes.

Specified by:
isUpdatable in interface Dao<T,ID>

isTableExists

public boolean isTableExists()
                      throws SQLException
Description copied from interface: Dao
Returns true if the table already exists otherwise false. This is not supported on Android.

Specified by:
isTableExists in interface Dao<T,ID>
Throws:
SQLException

countOf

public long countOf()
             throws SQLException
Description copied from interface: Dao
Returns the number of rows in the table associated with the data class. Depending on the size of the table and the database type, this may be expensive and take a while.

Specified by:
countOf in interface Dao<T,ID>
Throws:
SQLException

getTableConfig

public DatabaseTableConfig<T> getTableConfig()
Returns the table configuration information associated with the Dao's class or null if none.


getTableInfo

public TableInfo<T,ID> getTableInfo()
Used by internal classes to get the table information structure for the Dao's class.


setConnectionSource

public void setConnectionSource(ConnectionSource connectionSource)

setTableConfig

public 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. This must be called before initialize().


createDao

@Deprecated
public static <T,ID> Dao<T,ID> createDao(ConnectionSource connectionSource,
                                                    Class<T> clazz)
                           throws SQLException
Deprecated. You should be using the DaoManager.createDao(ConnectionSource, Class)

Helper method to create a Dao object without having to define a class. Dao classes are supposed to be convenient but if you have a lot of classes, they can seem to be a pain.

NOTE: You should use DaoManager.createDao(ConnectionSource, DatabaseTableConfig) instead of this method so you won't have to create the DAO multiple times.

Throws:
SQLException

createDao

@Deprecated
public static <T,ID> Dao<T,ID> createDao(ConnectionSource connectionSource,
                                                    DatabaseTableConfig<T> tableConfig)
                           throws SQLException
Deprecated. You should be using the DaoManager.createDao(ConnectionSource, DatabaseTableConfig)

Helper method to create a Dao object used by some internal methods that already have the TableInfo.

NOTE: You should use DaoManager.createDao(ConnectionSource, DatabaseTableConfig) instead of this method so you won't have to create the DAO multiple times.

Throws:
SQLException

checkForInitialized

protected void checkForInitialized()


Copyright © 2011. All Rights Reserved.