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 long getItemId(int position) { if (hasStableIds()) { if (cursor != null && cursor.moveToPosition(position)) { return cursor.get(columnForId); } } return 0; }
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 <T extends Number> void testMath(Property<T> property, T expectedValue) { SquidCursor<?> cursor = database.query(null, Query.select(property)); try { cursor.moveToFirst(); T value = cursor.get(property); assertEquals(expectedValue, value); } finally { cursor.close(); } }
public void testRawSelection() { String selection = COL_LUCKY_NUMBER + " > ? AND " + COL_IS_HAPPY + " != ?"; String[] selectionArgs = new String[]{"50", "0"}; ContentProviderQueryBuilder builder = getBuilder(); Query query = builder.setDataSource(TestModel.TABLE).build(null, selection, selectionArgs, null); CompiledStatement compiled = query.compile(database.getCompileContext()); verifyCompiledSqlArgs(compiled, 2, "50", "0"); SquidCursor<TestModel> cursor = null; try { cursor = database.query(TestModel.class, query); assertEquals(1, cursor.getCount()); cursor.moveToFirst(); assertEquals(model2, buildModelFromCursor(cursor)); } finally { if (cursor != null) { cursor.close(); } } }
public void testSelectFunction() { Function<String> upper = Function.upper(TestModel.LAST_NAME); SquidCursor<TestModel> cursor = database .query(TestModel.class, Query.select(TestModel.PROPERTIES).selectMore(upper)); try { cursor.moveToFirst(); new TestModel(cursor); // Should succeed without throwing an exception } finally { cursor.close(); } }
public void testCast() { Function<String> castToString = Function.cast(Field.field("x'61'"), "TEXT"); SquidCursor<?> cursor = database.query(null, Query.select(castToString)); try { cursor.moveToFirst(); assertEquals("a", cursor.getString(0)); } finally { cursor.close(); } } }
private void testQueryResults(Criterion criterion, TestVirtualModel... expectedResults) { Query query = Query.select(TestVirtualModel.PROPERTIES).where(criterion); SquidCursor<TestVirtualModel> cursor = database.query(TestVirtualModel.class, query); try { int expectedCount = expectedResults == null ? 0 : expectedResults.length; assertEquals(expectedCount, cursor.getCount()); if (expectedCount == 0) { return; } for (int i = 0; i < expectedCount; i++) { cursor.moveToPosition(i); assertEquals(expectedResults[i], new TestVirtualModel(cursor)); } } finally { cursor.close(); } } }
/** * Change the cursor backing this adapter and close the old cursor if necessary * * @param newCursor the new cursor */ public void changeCursor(SquidCursor<? extends T> newCursor) { SquidCursor<? extends T> oldCursor = swapCursor(newCursor); if (oldCursor != null) { oldCursor.close(); } } }
public void testEnumProperties() { final TestEnum enumValue = TestEnum.APPLE; final String enumAsString = enumValue.name(); TestModel model = new TestModel() .setFirstName("A") .setLastName("Z") .setBirthday(System.currentTimeMillis()) .setSomeEnum(enumValue); ValuesStorage setValues = model.getSetValues(); assertEquals(enumAsString, setValues.get(TestModel.SOME_ENUM.getName())); database.persist(model); SquidCursor<TestModel> cursor = database.query(TestModel.class, Query.select() .where(TestModel.SOME_ENUM.eq(TestEnum.APPLE))); assertEquals(1, cursor.getCount()); assertTrue(cursor.moveToFirst()); assertEquals(enumAsString, cursor.get(TestModel.SOME_ENUM)); TestModel fromDatabase = new TestModel(cursor); assertEquals(enumValue, fromDatabase.getSomeEnum()); }
private void scanCursor(SquidCursor<Thing> cursor, String formatString) { for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { int i = cursor.getPosition(); assertEquals(String.format(formatString, i), cursor.get(Thing.FOO)); } }
@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 int getCount() { return this.cursor != null ? this.cursor.getCount() : 0; }
private void readFieldIntoModel(SquidCursor<?> cursor, com.yahoo.squidb.sql.Field<?> field) { try { if (field instanceof Property<?>) { Property<?> property = (Property<?>) field; saver.save(property, values, cursor.get(property)); } } catch (IllegalArgumentException e) { // underlying cursor may have changed, suppress } }
@Override public void onBindViewHolder(V holder, int position) { if (cursor == null || !cursor.moveToPosition(position)) { throw new IllegalStateException("this should only be called when the cursor is valid"); } holder.item.readPropertiesFromCursor(cursor); onBindSquidViewHolder(holder, position); }
protected <TYPE extends AbstractModel> SquidCursor<TYPE> fetchFirstItem(Class<TYPE> modelClass, Query query) { boolean immutableQuery = query.isImmutable(); Field<Integer> beforeLimit = query.getLimit(); SqlTable<?> beforeTable = query.getTable(); query = query.limit(1); // If argument was frozen, we may get a new object SquidCursor<TYPE> cursor = query(modelClass, query); if (!immutableQuery) { query.from(beforeTable).limit(beforeLimit); // Reset for user } cursor.moveToFirst(); return cursor; }
/** * Query the database * * @param modelClass the type to parameterize the cursor by. If the query does not contain a FROM clause, the table * or view corresponding to this model class will be used. * @param query the query to execute * @return a {@link SquidCursor} containing the query results */ public <TYPE extends AbstractModel> SquidCursor<TYPE> query(Class<TYPE> modelClass, Query query) { query = inferTableForQuery(modelClass, query); CompiledStatement compiled = query.compile(getCompileContext()); if (compiled.needsValidation) { String validateSql = query.sqlForValidation(getCompileContext()); ensureSqlCompiles(validateSql); // throws if the statement fails to compile } ICursor cursor = rawQuery(compiled.sql, compiled.sqlArgs); return new SquidCursor<>(cursor, modelClass, query.getFields()); }