protected <TYPE extends AbstractModel> TYPE returnFetchResult(Class<TYPE> modelClass, SquidCursor<TYPE> cursor) { try { if (cursor.getCount() == 0) { return null; } TYPE toReturn = modelClass.newInstance(); toReturn.readPropertiesFromCursor(cursor); return toReturn; } catch (Exception e) { throw new RuntimeException(e); } finally { cursor.close(); } }
@Override public int getCount() { return this.cursor != null ? this.cursor.getCount() : 0; }
@Override public int getItemCount() { return cursor == null ? 0 : cursor.getCount(); }
@Override public SquidCursor<T> loadInBackground() { SquidCursor<T> result = database.query(modelClass, query); if (result != null) { result.getCount(); // Make sure the window is filled Cursor androidResult = (Cursor) result.getCursor(); androidResult.registerContentObserver(observer); if (notificationUri != null) { androidResult.setNotificationUri(getContext().getContentResolver(), notificationUri); } } return result; }
@Override public SquidCursor<T> loadInBackground() { SquidCursor<T> result = database.query(modelClass, query); if (result != null) { result.getCount(); // Make sure the window is filled Cursor androidResult = (Cursor) result.getCursor(); androidResult.registerContentObserver(observer); if (notificationUri != null) { androidResult.setNotificationUri(getContext().getContentResolver(), notificationUri); } } return result; }
private void testReusableQueryWithInCriterionInternal(Collection<String> collection, Query query, String... list) { collection.clear(); collection.addAll(Arrays.asList(list)); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(collection.size(), cursor.getCount()); while (cursor.moveToNext()) { String name = cursor.get(Employee.NAME); assertTrue(collection.contains(name)); } } finally { cursor.close(); } }
private void testMaxSqlArgRowIds(Query query, int expectedSize) { SquidCursor<TestModel> cursor = database.query(TestModel.class, query); try { assertEquals(expectedSize, cursor.getCount()); } finally { if (cursor != null) { cursor.close(); } } }
private void testInQuery(List<String> expectedNames, Query query) { SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(expectedNames.size(), cursor.getCount()); for (String name : expectedNames) { cursor.moveToNext(); assertEquals(name, cursor.get(Employee.NAME)); } } finally { cursor.close(); } }
private void testReusableQueryInternal(AtomicReference<String> ref, String name, Query query) { ref.set(name); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { cursor.moveToFirst(); assertEquals(1, cursor.getCount()); assertEquals(name, cursor.get(Employee.NAME)); } finally { cursor.close(); } }
private void testBetween(List<Long> expectedIds, boolean useNotBetween) { SquidCursor<Employee> cursor = database.query(Employee.class, Query.select(Employee.ID).where(useNotBetween ? Employee.ID.notBetween(2, 5) : Employee.ID.between(2, 5)).orderBy(Employee.ID.asc())); try { assertEquals(expectedIds.size(), cursor.getCount()); for (Long id : expectedIds) { cursor.moveToNext(); assertEquals(id.longValue(), cursor.get(Employee.ID).longValue()); } } finally { cursor.close(); } }
private void assertExpectedValues(Query query, Property<?> property, Object... expectedValues) { final int expectedCount = expectedValues == null ? 0 : expectedValues.length; SquidCursor<?> cursor = database.query(null, query); try { assertEquals(expectedCount, cursor.getCount()); for (int i = 0; i < expectedCount; i++) { cursor.moveToPosition(i); assertEquals(expectedValues[i], cursor.get(property)); } } finally { cursor.close(); } }
public void testBoundArgumentsWorkInHavingClause() { Query query = Query.select(Employee.PROPERTIES) .groupBy(Employee.MANAGER_ID) .having(Function.count(Employee.MANAGER_ID).gt(2)); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(1, cursor.getCount()); cursor.moveToFirst(); assertEquals(bigBird.getRowId(), cursor.get(Employee.MANAGER_ID).longValue()); } finally { cursor.close(); } }
public void testSelectLiteral() { StringProperty literal = StringProperty.literal("literal", "name"); LongProperty literalLong = LongProperty.literal(12, "twelve"); SquidCursor<?> c = database.query(null, Query.select(literal, literalLong)); try { assertEquals(1, c.getCount()); c.moveToFirst(); assertEquals("literal", c.get(literal)); assertEquals(12, c.get(literalLong).longValue()); } finally { if (c != null) { c.close(); } } }
public void testQueryBindingTypes() { insertBasicTestModel(); Field<Integer> one = Field.field("1"); SquidCursor<TestModel> cursor = database.query(TestModel.class, Query.select().where(Function.abs(one).eq(1))); try { assertEquals(1, cursor.getCount()); } finally { cursor.close(); } }
public void testOrderByArray() { Long[] order = new Long[]{5L, 1L, 4L}; SquidCursor<Employee> cursor = database.query(Employee.class, Query.select(Employee.ID).limit(order.length).orderBy(Employee.ID.byArray(order))); try { assertEquals(order.length, cursor.getCount()); for (int i = 0; i < order.length; i++) { cursor.moveToPosition(i); assertEquals(order[i], cursor.get(Employee.ID)); } } finally { cursor.close(); } }
public void testAggregateCount() { TestModel model1 = insertBasicTestModel(); TestModel model2 = new TestModel().setFirstName(model1.getFirstName()).setLastName("Smith"); database.persist(model2); IntegerProperty groupCount = IntegerProperty.countProperty(TestModel.FIRST_NAME, false); Query query = Query.select(TestModel.PROPERTIES).selectMore(groupCount).groupBy(TestModel.FIRST_NAME); SquidCursor<TestModel> groupedCursor = database.query(TestModel.class, query); try { groupedCursor.moveToFirst(); assertEquals(1, groupedCursor.getCount()); assertEquals(2, groupedCursor.get(groupCount).intValue()); } finally { groupedCursor.close(); } }
public void testSimpleSubquerySelect() { Query query = Query.fromSubquery(Query.select(Employee.NAME).from(Employee.TABLE), "subquery"); StringProperty name = query.getTable().qualifyField(Employee.NAME); query.where(name.eq("bigBird")); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(1, cursor.getCount()); cursor.moveToFirst(); Employee employee = new Employee(cursor); assertEquals("bigBird", employee.getName()); } finally { cursor.close(); } }
public void testFrozenQueryWorksWithDatabase() { Query query = Query.select().limit(2).freeze(); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(2, cursor.getCount()); assertNull(query.getTable()); } finally { cursor.close(); } Employee employee = database.fetchByQuery(Employee.class, query); assertNotNull(employee); assertNull(query.getTable()); assertEquals(Field.field("2"), query.getLimit()); }
public void testIntersect() { Query query = Query.select().from(Employee.TABLE).where(Employee.MANAGER_ID.eq(1)) .intersect(Query.select().from(Employee.TABLE).where(Employee.ID.eq(2))) .orderBy(Employee.ID.asc()); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(1, cursor.getCount()); cursor.moveToFirst(); assertEquals(cookieMonster, new Employee(cursor)); } finally { cursor.close(); } }
public void testExcept() { Query query = Query.select().from(Employee.TABLE).where(Employee.MANAGER_ID.eq(1)) .except(Query.select().from(Employee.TABLE).where(Employee.ID.eq(2))) .orderBy(Employee.ID.asc()); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(2, cursor.getCount()); cursor.moveToFirst(); assertEquals(elmo, new Employee(cursor)); cursor.moveToNext(); assertEquals(oscar, new Employee(cursor)); } finally { cursor.close(); } }