@Override protected final void attachEntity(RelationSource2 entity) { super.attachEntity(entity); entity.__setDaoSession(daoSession); }
switch (operation.type) { case Delete: operation.dao.delete(operation.parameter); break; case DeleteInTxIterable: operation.dao.deleteInTx((Iterable<Object>) operation.parameter); break; case DeleteInTxArray: operation.dao.deleteInTx((Object[]) operation.parameter); break; case Insert: operation.dao.insert(operation.parameter); break; case InsertInTxIterable: operation.dao.insertInTx((Iterable<Object>) operation.parameter); break; case InsertInTxArray: operation.dao.insertInTx((Object[]) operation.parameter); break; case InsertOrReplace: operation.dao.insertOrReplace(operation.parameter); break; case InsertOrReplaceInTxIterable: operation.dao.insertOrReplaceInTx((Iterable<Object>) operation.parameter); break; case InsertOrReplaceInTxArray: operation.dao.insertOrReplaceInTx((Object[]) operation.parameter); break; case Update:
/** 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(); }
/** * Inserts the given entities in the database using a transaction. * * @param entities The entities to insert. */ public void insertInTx(Iterable<T> entities) { insertInTx(entities, isEntityUpdateable()); }
/** * "Saves" an entity to the database: depending on the existence of the key property, it will be inserted * (key is null) or updated (key is not null). * <p> * This is similar to {@link #insertOrReplace(Object)}, but may be more efficient, because if a key is present, * it does not have to query if that key already exists. */ public void save(T entity) { if (hasKey(entity)) { update(entity); } else { insert(entity); } }
protected void runOneByOneTests(List<T> list, int loadCount, int modifyCount) { dao.insertInTx(list); List<K> keys = new ArrayList<K>(loadCount); for (int i = 0; i < loadCount; i++) { keys.add(daoAccess.getKey(list.get(i))); } clearIdentityScopeIfAny(); list = runLoadOneByOne(keys, "load-one-by-one-1"); list = runLoadOneByOne(keys, "load-one-by-one-2"); Debug.stopMethodTracing(); dao.deleteAll(); startClock("insert-one-by-one"); for (int i = 0; i < modifyCount; i++) { dao.insert(list.get(i)); } stopClock(); startClock("update-one-by-one"); for (int i = 0; i < modifyCount; i++) { dao.update(list.get(i)); } stopClock(); startClock("delete-one-by-one"); for (int i = 0; i < modifyCount; i++) { dao.delete(list.get(i)); } stopClock(); }
public void testDeleteAll() { List<T> entityList = new ArrayList<T>(); for (int i = 0; i < 10; i++) { T entity = createEntityWithRandomPk(); entityList.add(entity); } dao.insertInTx(entityList); dao.deleteAll(); assertEquals(0, dao.count()); for (T entity : entityList) { K key = daoAccess.getKey(entity); assertNotNull(key); assertNull(dao.load(key)); } }
public void testDeleteByKeyInTx() { List<T> entityList = new ArrayList<T>(); for (int i = 0; i < 10; i++) { T entity = createEntityWithRandomPk(); entityList.add(entity); } dao.insertInTx(entityList); List<K> keysToDelete = new ArrayList<K>(); keysToDelete.add(daoAccess.getKey(entityList.get(0))); keysToDelete.add(daoAccess.getKey(entityList.get(3))); keysToDelete.add(daoAccess.getKey(entityList.get(4))); keysToDelete.add(daoAccess.getKey(entityList.get(8))); dao.deleteByKeyInTx(keysToDelete); assertEquals(entityList.size() - keysToDelete.size(), dao.count()); for (K key : keysToDelete) { assertNotNull(key); assertNull(dao.load(key)); } }
public void testDeleteInTx() { List<T> entityList = new ArrayList<T>(); for (int i = 0; i < 10; i++) { T entity = createEntityWithRandomPk(); entityList.add(entity); } dao.insertInTx(entityList); List<T> entitiesToDelete = new ArrayList<T>(); entitiesToDelete.add(entityList.get(0)); entitiesToDelete.add(entityList.get(3)); entitiesToDelete.add(entityList.get(4)); entitiesToDelete.add(entityList.get(8)); dao.deleteInTx(entitiesToDelete); assertEquals(entityList.size() - entitiesToDelete.size(), dao.count()); for (T deletedEntity : entitiesToDelete) { K key = daoAccess.getKey(deletedEntity); assertNotNull(key); assertNull(dao.load(key)); } }
/** Resets all locally changed properties of the entity by reloading the values from the database. */ public void refresh(T entity) { assertSinglePk(); K key = getKeyVerified(entity); String sql = statements.getSelectByKey(); String[] keyArray = new String[]{key.toString()}; Cursor cursor = db.rawQuery(sql, keyArray); try { boolean available = cursor.moveToFirst(); if (!available) { throw new DaoException("Entity does not exist in the database anymore: " + entity.getClass() + " with key " + key); } else if (!cursor.isLast()) { throw new DaoException("Expected unique result, but count was " + cursor.getCount()); } readEntity(cursor, entity, 0); attachEntity(key, entity, true); } finally { cursor.close(); } }
public void testLoadAll() { dao.deleteAll(); List<T> list = new ArrayList<T>(); for (int i = 0; i < 15; i++) { T entity = createEntity(nextPk()); list.add(entity); } dao.insertInTx(list); List<T> loaded = dao.loadAll(); assertEquals(list.size(), loaded.size()); }
protected void updateInsideSynchronized(T entity, DatabaseStatement stmt, boolean lock) { // To do? Check if it's worth not to bind PKs here (performance). bindValues(stmt, entity); int index = config.allColumns.length + 1; K key = getKey(entity); if (key instanceof Long) { stmt.bindLong(index, (Long) key); } else if (key == null) { throw new DaoException("Cannot update entity without key - was it inserted before?"); } else { stmt.bindString(index, key.toString()); } stmt.execute(); attachEntity(key, entity, lock); }
public void testInsertInTx() { dao.deleteAll(); List<T> list = new ArrayList<T>(); for (int i = 0; i < 20; i++) { list.add(createEntityWithRandomPk()); } dao.insertInTx(list); assertEquals(list.size(), dao.count()); }
public void testDelete() { K pk = nextPk(); dao.deleteByKey(pk); T entity = createEntity(pk); dao.insert(entity); assertNotNull(dao.load(pk)); dao.deleteByKey(pk); assertNull(dao.load(pk)); }
return entity; } else { entity = readEntity(cursor, offset); attachEntity(entity); if (lock) { identityScopeLong.put2(key, entity); K key = readKey(cursor, offset); if (offset != 0 && key == null) { return entity; } else { entity = readEntity(cursor, offset); attachEntity(key, entity, lock); return entity; K key = readKey(cursor, offset); if (key == null) { T entity = readEntity(cursor, offset); attachEntity(entity); return entity;
int insertCount = 0; for (T entity : entities) { if (hasKey(entity)) { updateCount++; } else { List<T> toInsert = new ArrayList<>(insertCount); for (T entity : entities) { if (hasKey(entity)) { toUpdate.add(entity); } else { updateInTx(toUpdate); insertInTx(toInsert); db.setTransactionSuccessful(); } finally { insertInTx(entities); } else if (updateCount > 0) { updateInTx(entities);
protected void updateKeyAfterInsertAndAttach(T entity, long rowId, boolean lock) { if (rowId != -1) { K key = updateKeyAfterInsert(entity, rowId); attachEntity(key, entity, lock); } else { // TODO When does this actually happen? Should we throw instead? DaoLog.w("Could not insert row (executeInsert returned -1)"); } }
public void testAssignPk() { if (daoAccess.isEntityUpdateable()) { T entity1 = createEntity(null); if (entity1 != null) { T entity2 = createEntity(null); dao.insert(entity1); dao.insert(entity2); Long pk1 = daoAccess.getKey(entity1); assertNotNull(pk1); Long pk2 = daoAccess.getKey(entity2); assertNotNull(pk2); assertFalse(pk1.equals(pk2)); assertNotNull(dao.load(pk1)); assertNotNull(dao.load(pk2)); } else { DaoLog.d("Skipping testAssignPk for " + daoClass + " (createEntity returned null for null key)"); } } else { DaoLog.d("Skipping testAssignPk for not updateable " + daoClass); } }