@Override public T call() throws Exception { return daoSession.callInTx(callable); } });
/** Convenient call for {@link AbstractDao#update(Object)}. */ public <T> void update(T entity) { @SuppressWarnings("unchecked") AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass()); dao.update(entity); }
private AsyncOperation enqueueDatabaseOperation(OperationType type, Object param, int flags) { Database database = daoSession.getDatabase(); AsyncOperation operation = new AsyncOperation(type, null, database, param, flags | sessionFlags); executor.enqueue(operation); return operation; }
@Override public Void call() throws Exception { daoSession.runInTx(runnable); return null; } });
@Override public Void call() throws Exception { daoSession.runInTx(runnable); return null; } });
/** Convenient call for {@link AbstractDao#refresh(Object)}. */ public <T> void refresh(T entity) { @SuppressWarnings("unchecked") AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass()); dao.refresh(entity); }
@Override public T call() throws Exception { return daoSession.callInTx(callable); } });
private AsyncOperation enqueueDatabaseOperation(OperationType type, Object param, int flags) { Database database = daoSession.getDatabase(); AsyncOperation operation = new AsyncOperation(type, null, database, param, flags | sessionFlags); executor.enqueue(operation); return operation; }
/** Convenient call for {@link AbstractDao#insert(Object)}. */ public <T> long insert(T entity) { @SuppressWarnings("unchecked") AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass()); return dao.insert(entity); }
/** Convenient call for {@link AbstractDao#load(Object)}. */ public <T, K> T load(Class<T> entityClass, K key) { @SuppressWarnings("unchecked") AbstractDao<T, K> dao = (AbstractDao<T, K>) getDao(entityClass); return dao.load(key); }
/** Convenient call for {@link AbstractDao#loadAll()}. */ public <T, K> List<T> loadAll(Class<T> entityClass) { @SuppressWarnings("unchecked") AbstractDao<T, K> dao = (AbstractDao<T, K>) getDao(entityClass); return dao.loadAll(); }
/** Convenient call for {@link AbstractDao#queryRaw(String, String...)}. */ public <T, K> List<T> queryRaw(Class<T> entityClass, String where, String... selectionArgs) { @SuppressWarnings("unchecked") AbstractDao<T, K> dao = (AbstractDao<T, K>) getDao(entityClass); return dao.queryRaw(where, selectionArgs); }
/** Convenient call for {@link AbstractDao#delete(Object)}. */ public <T> void delete(T entity) { @SuppressWarnings("unchecked") AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass()); dao.delete(entity); }
/** Convenient call for {@link AbstractDao#deleteAll()}. */ public <T> void deleteAll(Class<T> entityClass) { @SuppressWarnings("unchecked") AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entityClass); dao.deleteAll(); }
/** Convenient call for {@link AbstractDao#insertOrReplace(Object)}. */ public <T> long insertOrReplace(T entity) { @SuppressWarnings("unchecked") AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass()); return dao.insertOrReplace(entity); }
/** Convenient call for {@link AbstractDao#queryBuilder()}. */ public <T> QueryBuilder<T> queryBuilder(Class<T> entityClass) { @SuppressWarnings("unchecked") AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entityClass); return dao.queryBuilder(); }
/** * Expands the query to another entity type by using a JOIN. The given sourceJoin's property is used to match the * given destinationProperty of the given destinationEntity. Note that destination entity of the given join is used * as the source for the new join to add. In this way, it is possible to compose complex "join of joins" across * several entities if required. */ public <J> Join<T, J> join(Join<?, T> sourceJoin, Property sourceProperty, Class<J> destinationEntityClass, Property destinationProperty) { AbstractDao<J, ?> destinationDao = (AbstractDao<J, ?>) dao.getSession().getDao(destinationEntityClass); return addJoin(sourceJoin.tablePrefix, sourceProperty, destinationDao, destinationProperty); }
/** * Expands the query to another entity type by using a JOIN. The given sourceProperty is used to match the given * destinationProperty of the given destinationEntity. */ public <J> Join<T, J> join(Property sourceProperty, Class<J> destinationEntityClass, Property destinationProperty) { AbstractDao<J, ?> destinationDao = (AbstractDao<J, ?>) dao.getSession().getDao(destinationEntityClass); return addJoin(tablePrefix, sourceProperty, destinationDao, destinationProperty); }
private <E> AsyncOperation enqueEntityOperation(OperationType type, Class<E> entityClass, Object param, int flags) { AbstractDao<?, ?> dao = daoSession.getDao(entityClass); AsyncOperation operation = new AsyncOperation(type, dao, null, param, flags | sessionFlags); executor.enqueue(operation); return operation; }
/** * Expands the query to another entity type by using a JOIN. The given sourceProperty is used to match the primary * key property of the given destinationEntity. */ public <J> Join<T, J> join(Property sourceProperty, Class<J> destinationEntityClass) { AbstractDao<J, ?> destinationDao = (AbstractDao<J, ?>) dao.getSession().getDao(destinationEntityClass); Property destinationProperty = destinationDao.getPkProperty(); return addJoin(tablePrefix, sourceProperty, destinationDao, destinationProperty); }