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; }
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)); } }
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 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 testMax() { LongProperty maxId = LongProperty.fromFunction(Function.max(TestModel.ID), "maxId"); SquidCursor<TestModel> cursor = database.query(TestModel.class, Query.select(maxId)); try { cursor.moveToFirst(); assertEquals(model3.getRowId(), cursor.get(maxId).longValue()); } finally { 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(); } } }
public void testSelectDistinct() { Query query = Query.selectDistinct(Employee.MANAGER_ID).orderBy(Employee.MANAGER_ID.asc()); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(4, cursor.getCount()); cursor.moveToFirst(); assertEquals(Long.valueOf(0), cursor.get(Employee.MANAGER_ID)); cursor.moveToNext(); assertEquals(Long.valueOf(1), cursor.get(Employee.MANAGER_ID)); cursor.moveToNext(); assertEquals(Long.valueOf(2), cursor.get(Employee.MANAGER_ID)); cursor.moveToNext(); assertEquals(Long.valueOf(5), cursor.get(Employee.MANAGER_ID)); } finally { cursor.close(); } }
public void testSumAndSumDistinct() { setUpAggregateTest(); IntegerProperty sum = IntegerProperty.fromFunction( Function.sum(TestModel.LUCKY_NUMBER), "sum"); IntegerProperty sumDistinct = IntegerProperty.fromFunction( Function.sumDistinct(TestModel.LUCKY_NUMBER), "sumDistinct"); SquidCursor<TestModel> cursor = database.query(TestModel.class, Query.select(sum, sumDistinct)); try { assertEquals(1, cursor.getCount()); cursor.moveToFirst(); assertEquals(12, cursor.get(sum).intValue()); assertEquals(8, cursor.get(sumDistinct).intValue()); } 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 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 testBooleanFunctionPropertyConstants() { BooleanProperty alwaysTrue = BooleanProperty.fromFunction(Function.TRUE, "alwaysTrue"); BooleanProperty alwaysFalse = BooleanProperty.fromFunction(Function.FALSE, "alwaysFalse"); SquidCursor<TestModel> cursor = database.query(TestModel.class, Query.select(alwaysTrue, alwaysFalse)); try { cursor.moveToFirst(); assertTrue(cursor.get(alwaysTrue)); assertFalse(cursor.get(alwaysFalse)); } 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 testAvgAndAvgDistinct() { setUpAggregateTest(); DoubleProperty avg = DoubleProperty.fromFunction(Function.avg(TestModel.LUCKY_NUMBER), "avg"); DoubleProperty avgDistinct = DoubleProperty.fromFunction( Function.avgDistinct(TestModel.LUCKY_NUMBER), "avgDistinct"); SquidCursor<TestModel> cursor = database.query(TestModel.class, Query.select(avg, avgDistinct)); try { cursor.moveToFirst(); assertEquals(2.0, cursor.get(avg)); assertEquals(4.0, cursor.get(avgDistinct)); } finally { cursor.close(); } }
public void testBooleanFunctionOnCriterion() { BooleanProperty onCriterion = BooleanProperty .fromFunction(Function.caseWhen(TestModel.FIRST_NAME.eq("Sam")), "firstNameSam"); SquidCursor<TestModel> cursor = database .query(TestModel.class, Query.select(onCriterion).orderBy(Order.asc(TestModel.ID))); try { cursor.moveToFirst(); assertTrue(cursor.get(onCriterion)); cursor.moveToNext(); assertFalse(cursor.get(onCriterion)); } finally { cursor.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 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(); } }
public void testSelectFromView() { View view = View.fromQuery(Query.select(Employee.PROPERTIES) .from(Employee.TABLE).where(Employee.MANAGER_ID.eq(bigBird.getRowId())), "bigBirdsEmployees"); database.tryCreateView(view); Query fromView = Query.fromView(view).orderBy(view.qualifyField(Employee.ID).asc()); SquidCursor<Employee> cursor = database.query(Employee.class, fromView); try { assertEquals(3, cursor.getCount()); cursor.moveToFirst(); assertEquals("cookieMonster", cursor.get(Employee.NAME)); cursor.moveToNext(); assertEquals("elmo", cursor.get(Employee.NAME)); cursor.moveToNext(); assertEquals("oscar", cursor.get(Employee.NAME)); } finally { cursor.close(); } }