/** * Construct a new Select statement that queries all the {@link Field Fields} of the given {@link View} * * @param view the View to select from * @return a new Query object */ public static Query fromView(View view) { return Query.select(view.qualifiedFields()).from(view); }
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(); } }
protected <TYPE extends AbstractModel> SquidCursor<TYPE> fetchFirstItem(Class<TYPE> modelClass, Criterion criterion, Property<?>... properties) { return fetchFirstItem(modelClass, Query.select(properties).where(criterion)); }
/** * Construct a new Select statement that queries all the {@link Field}s of the given subquery * * @param subquery the inner Query object * @param subqueryAlias the name to alias the subquery * @return a new Query object */ public static Query fromSubquery(Query subquery, String subqueryAlias) { SubqueryTable table = subquery.as(subqueryAlias); return Query.select(table.qualifiedFields()).from(table); }
/** * Count the number of rows matching a given {@link Criterion}. Use null to count all rows. * * @param modelClass the model class corresponding to the table * @param criterion the criterion to match * @return the number of rows matching the given criterion */ public int count(Class<? extends AbstractModel> modelClass, Criterion criterion) { Property.IntegerProperty countProperty = Property.IntegerProperty.countProperty(); Query query = Query.select(countProperty); if (criterion != null) { query.where(criterion); } query = inferTableForQuery(modelClass, query); CompiledStatement compiled = query.compile(getCompileContext()); acquireNonExclusiveLock(); try { return (int) getDatabase().simpleQueryForLong(compiled.sql, compiled.sqlArgs); } finally { releaseNonExclusiveLock(); } }
/** * Build a {@link Query} combining this object's internal state with the arguments passed. If a * {@link ProjectionMap} is set, the projection elements will be evaluated and transformed accordingly. If the * sortOrder is null or empty, the default order will be used (if one was set). * * @param projection the raw column names to be selected * @param selection a raw selection string * @param selectionArgs array of strings which substitute replaceable arguments in the selection string * @param sortOrder a raw ordering clause * @return a {@link Query} using the projection, selection, selection args, and sort order */ public Query build(String[] projection, String selection, String[] selectionArgs, String sortOrder) { Query query = Query.select(computeProjection(projection)).from(dataSource); boolean hasUserSelection = !SqlUtils.isEmpty(selection); if (hasUserSelection) { query.where(Criterion.fromRawSelection(selection, selectionArgs)); } if (!SqlUtils.isEmpty(sortOrder)) { query.orderBy(Order.fromExpression(sortOrder)); } else if (defaultOrder != null && defaultOrder.length > 0) { query.orderBy(defaultOrder); } if (strictMode && hasUserSelection) { query.requestValidation(); } return query; }
@Override public void run() { Function<String> json = JSONFunctions.json(" { \"this\" : \"is\", \"a\": [ \"test\" ] } "); String minified = database.simpleQueryForString(Query.select(json)); assertEquals("{\"this\":\"is\",\"a\":[\"test\"]}", minified); } });
@Override public void run() { Function<Integer> valid = JSONFunctions.jsonValid(" { \"this\" : \"is\", \"a\": [ \"test\" ] } "); Function<Integer> invalid = JSONFunctions.jsonValid(" { \"this\" : \"is\", \"a\": [ \"test\" } "); long validResult = database.simpleQueryForLong(Query.select(valid)); assertEquals(1, validResult); long invalidResult = database.simpleQueryForLong(Query.select(invalid)); assertEquals(0, invalidResult); } });
public void testObservableEmitsCustomObject() { final AtomicBoolean objectsMatch = new AtomicBoolean(false); final Query originalQuery = Query.select().from(TestModel.TABLE); Observable<Query> observable = database.observeTableAndEmit(TestModel.TABLE, originalQuery, true); observable.subscribe(new Action1<Query>() { @Override public void call(Query query) { objectsMatch.set(originalQuery == query); } }); assertTrue(objectsMatch.get()); }
@Override public void run() { database.query(TestModel.class, Query.select().from(TestModel.TABLE)); } });
private boolean isJson1ExtensionEnabled() { try { return database.simpleQueryForLong(Query.select(JSONFunctions.jsonValid("{ \"a\" : \"b\" }"))) != 0; } catch (RuntimeException e) { Logger.d("JSONFunctionTest", "JSON1 extension not available", e); return false; } }
public void testReusableQuery() { AtomicReference<String> name = new AtomicReference<>(); Query query = Query.select().where(Employee.NAME.eq(name)); testReusableQueryInternal(name, "bigBird", query); testReusableQueryInternal(name, "cookieMonster", query); testReusableQueryInternal(name, "elmo", query); }
public void testValidationPropagatesToSubqueryJoinAndCompoundSelect() { Query subquery = Query.select(Thing.FOO).from(Thing.TABLE).where(Thing.BAR.gt(0)); Query joinSubquery = Query.select(Thing.BAR).from(Thing.TABLE).where(Thing.FOO.isNotEmpty()); Query compoundSubquery = Query.select(Thing.BAZ).from(Thing.TABLE).where(Thing.IS_ALIVE.isTrue()); SubqueryTable subqueryTable = subquery.as("t1"); SubqueryTable joinTable = joinSubquery.as("t2"); Query query = Query.select().from(subqueryTable).innerJoin(joinTable, (Criterion[]) null) .union(compoundSubquery); final int queryLength = query.compile(database.getCompileContext()).sql.length(); String withValidation = query.sqlForValidation(database.getCompileContext()); assertEquals(queryLength + 6, withValidation.length()); }
public void testIdColumnForTableModels() { Query query = Query.select(TestModel.PROPERTIES).orderBy(TestModel.ID.asc()); testCursorAdapterInternal(new TestModel(), null, query, new CursorAdapterTest() { @Override public void testCursorAdapter(SquidCursorAdapter<AbstractModel> adapter) { assertTrue(adapter.hasStableIds()); assertEquals(1, adapter.getItemId(0)); assertEquals(2, adapter.getItemId(1)); } }); }
private void testJsonTypeInternal(String json, String path, String expectedType) { Function<String> type; if (path == null) { type = JSONFunctions.jsonType(json); } else { type = JSONFunctions.jsonType(json, path); } String result = database.simpleQueryForString(Query.select(type)); assertEquals(expectedType, result); }
public void testFunctionOnAmbiguousColumnName() { IntegerProperty happyCount = IntegerProperty.countProperty(Employee.IS_HAPPY, false); Query test = Query.select(TestModel.ID, TestModel.FIRST_NAME, TestModel.IS_HAPPY, happyCount) .join(Join.inner(Employee.TABLE, Employee.IS_HAPPY.eq(TestModel.IS_HAPPY))); // just test that the query compiles with the function database.query(TestModel.class, test); }
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 testMin() { LongProperty minId = LongProperty.fromFunction(Function.min(TestModel.ID), "minId"); SquidCursor<TestModel> cursor = database.query(TestModel.class, Query.select(minId)); try { cursor.moveToFirst(); assertEquals(model1.getRowId(), cursor.get(minId).longValue()); } finally { cursor.close(); } }
public void testBindArgsProtectsInjection() { Query q = Query.select().where(Employee.NAME.eq("'Sam'); drop table " + Employee.TABLE.getName() + ";")); SquidCursor<Employee> cursor = database.query(Employee.class, q); try { assertFalse(database.countAll(Employee.class) == 0); } finally { cursor.close(); } }
public void testQueryFreeze() { Query base = Query.select().from(Employee.TABLE).limit(1).freeze(); Query fork = base.limit(2); assertFalse(base == fork); assertEquals(Field.field("1"), base.getLimit()); assertEquals(Field.field("2"), fork.getLimit()); assertEquals(base.getTable(), fork.getTable()); }