/** Internal query to resolve the "toManyTarget2List" to-many relationship of RelationSource2. */ public List<ToManyTarget2> _queryRelationSource2_ToManyTarget2List(Long fkId) { synchronized (this) { if (relationSource2_ToManyTarget2ListQuery == null) { QueryBuilder<ToManyTarget2> queryBuilder = queryBuilder(); queryBuilder.where(Properties.FkId.eq(null)); relationSource2_ToManyTarget2ListQuery = queryBuilder.build(); } } Query<ToManyTarget2> query = relationSource2_ToManyTarget2ListQuery.forCurrentThread(); query.setParameter(0, fkId); return query.list(); }
public void testSimpleQuery() { insert(3); QueryBuilder<AbcdefEntity> queryBuilder = dao.queryBuilder().where(Properties.A.eq(1)).orderAsc(Properties.A); List<AbcdefEntity> result = queryBuilder.list(); assertEquals(1, result.size()); assertEquals(1, queryBuilder.count()); AbcdefEntity resultEntity = result.get(0); assertEquals(1, (int) resultEntity.getA()); queryBuilder.buildDelete().executeDeleteWithoutDetachingEntities(); }
public void testOrderWithSpecialNames() { QueryBuilder<SpecialNamesEntity> queryBuilder = dao.queryBuilder(); queryBuilder.orderAsc(Properties.Avg); queryBuilder.orderAsc(Properties.Count); queryBuilder.orderAsc(Properties.Distinct); queryBuilder.orderAsc(Properties.Index); queryBuilder.orderAsc(Properties.Join); queryBuilder.orderAsc(Properties.On); queryBuilder.orderAsc(Properties.Select); queryBuilder.orderAsc(Properties.Sum); queryBuilder.orderAsc(Properties.Order); queryBuilder.list(); }
/** Internal query to resolve the "toManyTargetEntityList" to-many relationship of ToManyEntity. */ public List<ToManyTargetEntity> _queryToManyEntity_ToManyTargetEntityList(Long toManyId) { synchronized (this) { if (toManyEntity_ToManyTargetEntityListQuery == null) { QueryBuilder<ToManyTargetEntity> queryBuilder = queryBuilder(); queryBuilder.where(Properties.ToManyId.eq(null)); queryBuilder.orderRaw("T.'_id' ASC"); toManyEntity_ToManyTargetEntityListQuery = queryBuilder.build(); } } Query<ToManyTargetEntity> query = toManyEntity_ToManyTargetEntityListQuery.forCurrentThread(); query.setParameter(0, toManyId); return query.list(); }
public List<Message> fetchMessagesForThreadWithID (long threadID, int limit, Date olderThan) { List<Message> list ; QueryBuilder<Message> qb = daoSession.queryBuilder(Message.class); qb.where(MessageDao.Properties.ThreadId.eq(threadID)); // Making sure no null messages infected the sort. qb.where(MessageDao.Properties.Date.isNotNull()); qb.where(MessageDao.Properties.SenderId.isNotNull()); if(olderThan != null) { qb.where(MessageDao.Properties.Date.lt(olderThan.getTime())); } qb.orderDesc(MessageDao.Properties.Date); if (limit != -1) qb.limit(limit); list = qb.list(); return list; }
public void testNotEqString() { ArrayList<TestEntity> inserted = insert(3); String value = getSimpleString(1); List<TestEntity> result = dao.queryBuilder().where(Properties.SimpleString.notEq(value)).list(); assertEquals(2, result.size()); TestEntity resultEntity1 = result.get(0); TestEntity resultEntity2 = result.get(1); long loId = Math.min(resultEntity1.getId(), resultEntity2.getId()); long hiId = Math.max(resultEntity1.getId(), resultEntity2.getId()); assertEquals((long) inserted.get(0).getId(), loId); assertEquals((long) inserted.get(2).getId(), hiId); }
public void testOr() { insert(3); QueryBuilder<AbcdefEntity> queryBuilder = dao.queryBuilder(); queryBuilder.whereOr(Properties.A.eq(1), Properties.A.eq(101)); List<AbcdefEntity> result = queryBuilder.orderAsc(Properties.A).list(); assertEquals(2, result.size()); assertEquals(2, queryBuilder.count()); assertEquals(1, (int) result.get(0).getA()); assertEquals(101, (int) result.get(1).getA()); queryBuilder.buildDelete().executeDeleteWithoutDetachingEntities(); }
public void testQueryBuilderOffsetAndLimitWithWhere() { insert(10); List<TestEntity> result = dao.queryBuilder().where(Properties.SimpleInteger.gt(getSimpleInteger(1))).offset(2) .limit(3).orderAsc(Properties.SimpleInt).list(); assertEquals(3, result.size()); assertEquals(getSimpleInteger(4), result.get(0).getSimpleInteger().intValue()); assertEquals(getSimpleInteger(5), result.get(1).getSimpleInteger().intValue()); assertEquals(getSimpleInteger(6), result.get(2).getSimpleInteger().intValue()); }
public void testNotIn() { ArrayList<TestEntity> inserted = insert(5); String value1 = getSimpleString(0); String value2 = getSimpleString(2); String value3 = getSimpleString(4); List<TestEntity> result = dao.queryBuilder().where(Properties.SimpleString.notIn(value1, value2, value3)) .orderAsc(Properties.SimpleString).list(); assertEquals(2, result.size()); TestEntity resultEntity1 = result.get(0); assertEquals(inserted.get(1).getId(), resultEntity1.getId()); TestEntity resultEntity2 = result.get(1); assertEquals(inserted.get(3).getId(), resultEntity2.getId()); }
public void testWhereWithSpecialNames() { QueryBuilder<SpecialNamesEntity> queryBuilder = dao.queryBuilder(); queryBuilder.where(Properties.Avg.isNotNull()); queryBuilder.where(Properties.Count.isNotNull()); queryBuilder.where(Properties.Distinct.isNotNull()); queryBuilder.where(Properties.Index.isNotNull()); queryBuilder.where(Properties.Join.isNotNull()); queryBuilder.where(Properties.On.isNotNull()); queryBuilder.where(Properties.Select.isNotNull()); queryBuilder.where(Properties.Sum.isNotNull()); queryBuilder.where(Properties.Order.isNotNull()); queryBuilder.list(); queryBuilder.buildCount().count(); queryBuilder.buildDelete().executeDeleteWithoutDetachingEntities(); }
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); setUpViews(); // get the note DAO DaoSession daoSession = ((App) getApplication()).getDaoSession(); noteDao = daoSession.getNoteDao(); // query all notes, sorted a-z by their text notesQuery = noteDao.queryBuilder().orderAsc(NoteDao.Properties.Text).build(); updateNotes(); }
/** Fetch messages list from the db for current thread, Messages will be order Desc/Asc on demand.*/ @Keep public List<Message> getMessagesWithOrder(int order, int limit) { QueryBuilder<Message> qb = daoSession.queryBuilder(Message.class); qb.where(MessageDao.Properties.ThreadId.eq(getId())); if(order == DaoCore.ORDER_ASC) { qb.orderAsc(MessageDao.Properties.Date); } else if(order == DaoCore.ORDER_DESC) { qb.orderDesc(MessageDao.Properties.Date); } // Making sure no null messages infected the sort. qb.where(MessageDao.Properties.Date.isNotNull()); if (limit > 0) { qb.limit(limit); } Query<Message> query = qb.build().forCurrentThread(); return query.list(); }
@Override public void run() { QueryBuilder<TestEntity> builder = dao.queryBuilder(); builder.where(Properties.SimpleInteger.eq(getSimpleInteger(1))); queryFromOtherThread = builder.buildCount(); } };
@Override public void run() { QueryBuilder<TestEntity> builder = dao.queryBuilder(); builder.where(Properties.SimpleInteger.eq(getSimpleInteger(1))); queryFromOtherThread = builder.buildDelete(); } };
public void testBuildQueryAndCountQuery() { insert(3); int value = getSimpleInteger(1); QueryBuilder<TestEntity> builder = dao.queryBuilder().where(Properties.SimpleInteger.eq(value)); Query<TestEntity> query = builder.build(); CountQuery<TestEntity> countQuery = builder.buildCount(); assertEquals(1, query.list().size()); assertEquals(1, countQuery.count()); }
public void testBuildQueryAndDeleteQuery() { insert(3); int value = getSimpleInteger(1); QueryBuilder<TestEntity> builder = dao.queryBuilder().where(Properties.SimpleInteger.eq(value)); Query<TestEntity> query = builder.build(); DeleteQuery<TestEntity> deleteQuery = builder.buildDelete(); assertEquals(1, query.list().size()); deleteQuery.executeDeleteWithoutDetachingEntities(); assertEquals(0, query.list().size()); }
public void testDistinct() { TestEntity entity = insert(3).get(1); Query<TestEntity> query = dao.queryBuilder().distinct() .where(Properties.SimpleString.eq(entity.getSimpleString())).build(); TestEntity entity2 = query.uniqueOrThrow(); assertEquals(entity.getId(), entity2.getId()); // TODO improve test to check functionality }
public static <T extends CoreEntity> List<T> fetchEntitiesWithPropertiesAndOrderAndLimit(Class<T> c, int limit, Property whereOrder, int order, Property properties[], Object... values){ if (values == null || properties == null) throw new NullPointerException("You must have at least one value and one property"); if (values.length != properties.length) throw new IllegalArgumentException("Values size should match properties size"); QueryBuilder<T> qb = daoSession.queryBuilder(c); qb.where(properties[0].eq(values[0])); if (values.length > 1) for (int i = 0 ; i < values.length ; i++) qb.where(properties[i].eq(values[i])); if (whereOrder != null && order != -1) switch (order) { case ORDER_ASC: qb.orderAsc(whereOrder); break; case ORDER_DESC: qb.orderDesc(whereOrder); break; } if (limit != -1) qb.limit(limit); return qb.listLazy(); }