use of com.j256.ormlite.table.DatabaseTableConfig in project robospice by stephanenicolas.
the class InDatabaseObjectPersister method getDatabaseTableConfig.
protected DatabaseTableConfig getDatabaseTableConfig(Class clazz) throws SQLException {
DatabaseTableConfig config = mTableConfigs.get(clazz);
if (config == null) {
config = DatabaseTableConfigUtil.fromClass(databaseHelper.getConnectionSource(), clazz);
if (config != null) {
config.extractFieldTypes(databaseHelper.getConnectionSource());
mTableConfigs.put(clazz, config);
}
}
return config;
}
use of com.j256.ormlite.table.DatabaseTableConfig in project robospice by stephanenicolas.
the class InDatabaseObjectPersister method getIdField.
protected FieldType getIdField(Class clazz) throws SQLException {
DatabaseTableConfig config = getDatabaseTableConfig(clazz);
FieldType[] fieldTypes = config.getFieldTypes(databaseHelper.getConnectionSource().getDatabaseType());
FieldType idFieldType = null;
for (FieldType fieldType : fieldTypes) {
if (fieldType.isId() || fieldType.isGeneratedId() || fieldType.isGeneratedIdSequence()) {
idFieldType = fieldType;
}
}
if (idFieldType == null) {
throw new IllegalStateException("Cannot find id field");
}
return idFieldType;
}
use of com.j256.ormlite.table.DatabaseTableConfig in project ormlite-android by j256.
the class OrmLiteConfigUtil method writeConfigForTable.
private static void writeConfigForTable(BufferedWriter writer, Class<?> clazz) throws SQLException, IOException {
String tableName = DatabaseTableConfig.extractTableName(clazz);
List<DatabaseFieldConfig> fieldConfigs = new ArrayList<DatabaseFieldConfig>();
// walk up the classes finding the fields
try {
for (Class<?> working = clazz; working != null; working = working.getSuperclass()) {
for (Field field : working.getDeclaredFields()) {
DatabaseFieldConfig fieldConfig = DatabaseFieldConfig.fromField(databaseType, tableName, field);
if (fieldConfig != null) {
fieldConfigs.add(fieldConfig);
}
}
}
} catch (Error e) {
System.err.println("Skipping " + clazz + " because we got an error finding its definition: " + e.getMessage());
return;
}
if (fieldConfigs.isEmpty()) {
System.out.println("Skipping " + clazz + " because no annotated fields found");
return;
}
@SuppressWarnings({ "rawtypes", "unchecked" }) DatabaseTableConfig<?> tableConfig = new DatabaseTableConfig(clazz, tableName, fieldConfigs);
DatabaseTableConfigLoader.write(writer, tableConfig);
writer.append("#################################");
writer.newLine();
System.out.println("Wrote config for " + clazz);
}
use of com.j256.ormlite.table.DatabaseTableConfig in project robospice by stephanenicolas.
the class InDatabaseObjectPersister method saveAllForeignObjectsToCache.
/**
* During this operation, we must save a new POJO (parent) into the database. The problem is
* that is the POJO contains children POJOs, then saving the parent would not work as the parent
* must exist in the database prior to saving the children. SO :
* <ul>
* <li>we copy the children into memory,
* <li>put the children to null on parent
* <li>save the parent to the database
* <li>if saving filled the parent with previous children, we remove them
* <li>re inject the children into the parent
* <li>save the children (as the parent now exists in database).
* </ul>
*
* @param data the parent POJO to save in the database.
* @throws SQLException
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
protected <E> void saveAllForeignObjectsToCache(E data) throws SQLException, IllegalAccessException, InvocationTargetException {
// copy children on memory
// set children to null on parents so that we can save the parent
// without cascade
Map<Field, Collection<?>> mapFieldToCollection = new HashMap<Field, Collection<?>>();
Class<? extends Object> parentClass = data.getClass();
for (Field field : parentClass.getDeclaredFields()) {
ForeignCollectionField annotation = field.getAnnotation(ForeignCollectionField.class);
if (annotation != null) {
Collection<?> collectionCopy = new ArrayList();
Method getMethod = DatabaseFieldConfig.findGetMethod(field, true);
Collection collectionInObject = (Collection<?>) getMethod.invoke(data);
if (collectionInObject != null) {
collectionCopy.addAll(collectionInObject);
}
Method setMethod = DatabaseFieldConfig.findSetMethod(field, true);
setMethod.invoke(data, (Object) null);
mapFieldToCollection.put(field, collectionCopy);
}
}
// save parents without cascade
databaseHelper.createOrUpdateInDatabase(data, (Class<E>) parentClass);
// get the child from a previous database record
databaseHelper.refreshFromDatabase(data, (Class<E>) parentClass);
// collection field of the parent
for (Field field : parentClass.getDeclaredFields()) {
if (field.getAnnotation(ForeignCollectionField.class) != null) {
Method getMethod = DatabaseFieldConfig.findGetMethod(field, true);
Collection collectionInObject = (Collection<?>) getMethod.invoke(data);
// lazy collection are not loaded from database, so we load them
if (collectionInObject instanceof LazyForeignCollection) {
((LazyForeignCollection) collectionInObject).refreshCollection();
}
ParameterizedType listType = (ParameterizedType) field.getGenericType();
Class<?> itemInListClass = (Class<?>) listType.getActualTypeArguments()[0];
databaseHelper.deleteFromDataBase(collectionInObject, itemInListClass);
}
}
// we now saved the parent and can fill the foreign key of the children
for (Map.Entry<Field, Collection<?>> entry : mapFieldToCollection.entrySet()) {
Collection<?> collection = entry.getValue();
// re-set complete children to the parent
ConnectionSource connectionSource = databaseHelper.getConnectionSource();
for (Object object : collection) {
DatabaseTableConfig childDatabaseTableConfig = DatabaseTableConfig.fromClass(connectionSource, object.getClass());
for (FieldType childFieldType : childDatabaseTableConfig.getFieldTypes(null)) {
if (parentClass.equals(childFieldType.getType()) && childFieldType.isForeign()) {
childFieldType.assignField(object, data, true, null);
}
}
// save children recursively
saveAllForeignObjectsToCache(object);
}
}
// notify
if (mapHandledClassesToNotificationUri != null && mapHandledClassesToNotificationUri.containsKey(parentClass)) {
Uri notificationUri = mapHandledClassesToNotificationUri.get(parentClass);
if (notificationUri != null) {
getApplication().getContentResolver().notifyChange(notificationUri, null);
Object id = getIdField(data.getClass()).extractJavaFieldValue(data);
Uri itemNotificationUri = notificationUri.buildUpon().appendPath(id.toString()).build();
getApplication().getContentResolver().notifyChange(itemNotificationUri, null);
}
}
// future hook
}
use of com.j256.ormlite.table.DatabaseTableConfig in project ormlite-android by j256.
the class DatabaseTableConfigUtil method fromClass.
/**
* Build our list table config from a class using some annotation fu around.
*/
public static <T> DatabaseTableConfig<T> fromClass(ConnectionSource connectionSource, Class<T> clazz) throws SQLException {
DatabaseType databaseType = connectionSource.getDatabaseType();
String tableName = DatabaseTableConfig.extractTableName(clazz);
List<DatabaseFieldConfig> fieldConfigs = new ArrayList<DatabaseFieldConfig>();
for (Class<?> classWalk = clazz; classWalk != null; classWalk = classWalk.getSuperclass()) {
for (Field field : classWalk.getDeclaredFields()) {
DatabaseFieldConfig config = configFromField(databaseType, tableName, field);
if (config != null && config.isPersisted()) {
fieldConfigs.add(config);
}
}
}
if (fieldConfigs.size() == 0) {
return null;
} else {
return new DatabaseTableConfig<T>(clazz, tableName, fieldConfigs);
}
}
Aggregations