@Override protected DeleteQuery<T2> createQuery() { return new DeleteQuery<T2>(this, dao, sql, initialValues.clone()); } }
/** * Builds a reusable query object for deletion (Query objects can be executed more efficiently than creating a * QueryBuilder for each execution. */ public DeleteQuery<T> buildDelete() { if (!joins.isEmpty()) { throw new DaoException("JOINs are not supported for DELETE queries"); } String tablename = dao.getTablename(); String baseSql = SqlUtils.createSqlDelete(tablename, null); StringBuilder builder = new StringBuilder(baseSql); // tablePrefix gets replaced by table name below. Don't use tableName here because it causes trouble when // table name ends with tablePrefix. appendJoinsAndWheres(builder, tablePrefix); String sql = builder.toString(); // Remove table aliases, not supported for DELETE queries. // TODO(?): don't create table aliases in the first place. sql = sql.replace(tablePrefix + ".\"", '"' + tablename + "\".\""); checkLog(sql); return DeleteQuery.create(dao, sql, values.toArray()); }
@Override public void run() { query.executeDeleteWithoutDetachingEntities(); } });
@Override public void run() { query.forCurrentThread().executeDeleteWithoutDetachingEntities(); } };
public void testThrowOutsideOwnerThread() throws InterruptedException { createQueryFromOtherThread(); try { queryFromOtherThread.executeDeleteWithoutDetachingEntities(); fail("Did not throw"); } catch (DaoException expected) { } try { queryFromOtherThread.setParameter(0, 42); fail("Did not throw"); } catch (DaoException expected) { } }
public void testGetForCurrentThread_TwoThreads() throws InterruptedException { insert(3); createQueryFromOtherThread(); DeleteQuery<TestEntity> query = queryFromOtherThread.forCurrentThread(); assertNotSame(queryFromOtherThread, query); query.setParameter(0, getSimpleInteger(2)); query.executeDeleteWithoutDetachingEntities(); assertEquals(2, dao.count()); }
static <T2> DeleteQuery<T2> create(AbstractDao<T2, ?> dao, String sql, Object[] initialValues) { QueryData<T2> queryData = new QueryData<T2>(dao, sql, toStringArray(initialValues)); return queryData.forCurrentThread(); }
/** * Deletes all matching entities without detaching them from the identity scope (aka session/cache). Note that this * method may lead to stale entity objects in the session cache. Stale entities may be returned when loaded by * their * primary key, but not using queries. */ public void executeDeleteWithoutDetachingEntities() { checkThread(); Database db = dao.getDatabase(); if (db.isDbLockedByCurrentThread()) { dao.getDatabase().execSQL(sql, parameters); } else { // Do TX to acquire a connection before locking this to avoid deadlocks // Locking order as described in AbstractDao db.beginTransaction(); try { dao.getDatabase().execSQL(sql, parameters); db.setTransactionSuccessful(); } finally { db.endTransaction(); } } }
public void testGetForCurrentThread_SameInstance() { DeleteQuery<TestEntity> query = dao.queryBuilder().buildDelete(); assertSame(query, query.forCurrentThread()); }
public void testGetForCurrentThread_ParametersAreReset() { insert(3); int value = getSimpleInteger(1); DeleteQuery<TestEntity> query = dao.queryBuilder().where(Properties.SimpleInteger.eq(value)).buildDelete(); query.setParameter(0, value + 100); query.executeDeleteWithoutDetachingEntities(); assertEquals(3, dao.count()); query = query.forCurrentThread(); query.executeDeleteWithoutDetachingEntities(); assertEquals(2, dao.count()); }
public void testDeleteQueryChangeParameter() { insert(3); String value = getSimpleString(1); DeleteQuery<TestEntity> deleteQuery = dao.queryBuilder().where(Properties.SimpleString.eq(value)).buildDelete(); deleteQuery.executeDeleteWithoutDetachingEntities(); assertEquals(2, dao.count()); deleteQuery.setParameter(0, getSimpleString(0)); deleteQuery.executeDeleteWithoutDetachingEntities(); assertEquals(1, dao.count()); TestEntity remaining = dao.loadAll().get(0); assertEquals(getSimpleString(2), remaining.getSimpleString()); }
static <T2> DeleteQuery<T2> create(AbstractDao<T2, ?> dao, String sql, Object[] initialValues) { QueryData<T2> queryData = new QueryData<T2>(dao, sql, toStringArray(initialValues)); return queryData.forCurrentThread(); }
/** * Deletes all matching entities without detaching them from the identity scope (aka session/cache). Note that this * method may lead to stale entity objects in the session cache. Stale entities may be returned when loaded by * their * primary key, but not using queries. */ public void executeDeleteWithoutDetachingEntities() { checkThread(); Database db = dao.getDatabase(); if (db.isDbLockedByCurrentThread()) { dao.getDatabase().execSQL(sql, parameters); } else { // Do TX to acquire a connection before locking this to avoid deadlocks // Locking order as described in AbstractDao db.beginTransaction(); try { dao.getDatabase().execSQL(sql, parameters); db.setTransactionSuccessful(); } finally { db.endTransaction(); } } }
@Test public void testMockitoMocks() { mock(DaoMaster.class).newSession(); mock(DaoSession.class).getDatabase(); mock(Database.class).getRawDatabase(); mock(DatabaseStatement.class).execute(); mock(IdentityScope.class).clear(); mock(AbstractDao.class).queryBuilder(); mock(MinimalEntityDao.class).queryBuilder(); mock(MinimalEntity.class).getId(); mock(Query.class).forCurrentThread(); mock(QueryBuilder.class).build(); mock(CountQuery.class).forCurrentThread(); mock(DeleteQuery.class).forCurrentThread(); mock(Join.class).getTablePrefix(); mock(LazyList.class).getLoadedCount(); mock(WhereCondition.class).appendValuesTo(null); mock(Property.class).isNull(); mock(DaoException.class).getMessage(); }
public void testDeleteQueryOr() { ArrayList<TestEntity> inserted = insert(3); QueryBuilder<TestEntity> queryBuilder = dao.queryBuilder(); Integer value1 = inserted.get(0).getSimpleInteger(); Integer value2 = inserted.get(2).getSimpleInteger(); queryBuilder.whereOr(Properties.SimpleInteger.eq(value1), Properties.SimpleInteger.eq(value2)); DeleteQuery<TestEntity> deleteQuery = queryBuilder.buildDelete(); deleteQuery.executeDeleteWithoutDetachingEntities(); List<TestEntity> allAfterDelete = dao.loadAll(); assertEquals(1, allAfterDelete.size()); assertEquals(inserted.get(1).getSimpleInteger(), allAfterDelete.get(0).getSimpleInteger()); }
@Override protected DeleteQuery<T2> createQuery() { return new DeleteQuery<T2>(this, dao, sql, initialValues.clone()); } }
/** * Builds a reusable query object for deletion (Query objects can be executed more efficiently than creating a * QueryBuilder for each execution. */ public DeleteQuery<T> buildDelete() { if (!joins.isEmpty()) { throw new DaoException("JOINs are not supported for DELETE queries"); } String tablename = dao.getTablename(); String baseSql = SqlUtils.createSqlDelete(tablename, null); StringBuilder builder = new StringBuilder(baseSql); // tablePrefix gets replaced by table name below. Don't use tableName here because it causes trouble when // table name ends with tablePrefix. appendJoinsAndWheres(builder, tablePrefix); String sql = builder.toString(); // Remove table aliases, not supported for DELETE queries. // TODO(?): don't create table aliases in the first place. sql = sql.replace(tablePrefix + ".\"", '"' + tablename + "\".\""); checkLog(sql); return DeleteQuery.create(dao, sql, values.toArray()); }
public void testDeleteQuerySimple() { ArrayList<TestEntity> inserted = insert(3); int value = getSimpleInteger(1); inserted.get(2).setSimpleInteger(value); dao.update(inserted.get(2)); DeleteQuery<TestEntity> deleteQuery = dao.queryBuilder().where(Properties.SimpleInteger.eq(value)) .buildDelete(); deleteQuery.executeDeleteWithoutDetachingEntities(); List<TestEntity> allAfterDelete = dao.loadAll(); assertEquals(1, allAfterDelete.size()); assertEquals(getSimpleInteger(0), (int) allAfterDelete.get(0).getSimpleInteger()); }
public void testDeleteQueryExecutingMultipleTimes() { insert(3); String value = getSimpleString(1); DeleteQuery<TestEntity> deleteQuery = dao.queryBuilder().where(Properties.SimpleString.eq(value)).buildDelete(); deleteQuery.executeDeleteWithoutDetachingEntities(); assertEquals(2, dao.count()); deleteQuery.executeDeleteWithoutDetachingEntities(); assertEquals(2, dao.count()); insert(3); assertEquals(5, dao.count()); deleteQuery.executeDeleteWithoutDetachingEntities(); assertEquals(4, dao.count()); }
public void testConcurrentDeleteQueryDuringTx() throws InterruptedException { final TestEntity entity = createEntity(null); dao.insert(entity); final DeleteQuery<TestEntity> query = dao.queryBuilder().buildDelete(); Runnable runnable1 = new Runnable() { @Override public void run() { query.forCurrentThread().executeDeleteWithoutDetachingEntities(); } }; initThreads(runnable1); // Builds the statement so it is ready immediately in the thread query.executeDeleteWithoutDetachingEntities(); doTx(new Runnable() { @Override public void run() { query.executeDeleteWithoutDetachingEntities(); } }); latchThreadsDone.await(); }