/** * Same as {@link #updateRow(TableModel)} with the ability to specify a ConflictAlgorithm for handling constraint * violations * * @param item the model to save * @param conflictAlgorithm the conflict algorithm to use * @return true if success, false otherwise */ protected final boolean updateRow(TableModel item, TableStatement.ConflictAlgorithm conflictAlgorithm) { if (!item.isModified()) { // nothing changed return true; } if (!item.isSaved()) { return false; } Class<? extends TableModel> modelClass = item.getClass(); Table table = getTable(modelClass); Update update = Update.table(table).fromTemplate(item).where(table.getRowIdProperty().eq(item.getRowId())); if (conflictAlgorithm != null) { update.onConflict(conflictAlgorithm); } boolean result = updateInternal(update) > 0; if (result) { notifyForTable(DataChangedNotifier.DBOperation.UPDATE, item, table, item.getRowId()); item.markSaved(); } return result; }
public void testAllFields() { Query query = Query.select().from(TestViewModel.VIEW) .leftJoin(Thing.TABLE, TestViewModel.TEST_MODEL_ID.eq(Thing.ID)); List<Field<?>> fields = query.getFields(); for (Property<?> p : TestViewModel.PROPERTIES) { assertTrue(fields.contains(p)); } for (Property<?> p : Thing.PROPERTIES) { assertTrue(fields.contains(p)); } assertEquals(TestViewModel.PROPERTIES.length + Thing.PROPERTIES.length, fields.size()); }
public void testVariableArgumentsWorkInFunctions() { AtomicReference<String> name = new AtomicReference<>("Sam"); Function<Integer> caseWhen = Function.caseWhen(TestModel.FIRST_NAME.eq(name)); BooleanProperty nameMatches = BooleanProperty.fromFunction(caseWhen, "nameMatches"); Query query = Query.select(TestModel.ID, TestModel.FIRST_NAME, nameMatches).where(TestModel.ID.eq(1)); TestModel model = database.fetchByQuery(TestModel.class, query); assertNotNull(model); assertEquals(name.get(), model.getFirstName()); assertTrue(model.get(nameMatches)); name.set("Bob"); model = database.fetchByQuery(TestModel.class, query); assertNotNull(model); assertNotSame(name.get(), model.getFirstName()); assertFalse(model.get(nameMatches)); }
public void testSubqueryJoin() { StringProperty managerName = Employee.NAME.as("managerName"); Query query = Query .fromSubquery(Query.select(Employee.MANAGER_ID).from(Employee.TABLE).groupBy(Employee.MANAGER_ID), "subquery"); query.selectMore(managerName); query.join(Join.inner(Employee.TABLE, query.getTable().qualifyField(Employee.MANAGER_ID).eq(Employee.ID))) .orderBy(Employee.MANAGER_ID.asc()); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(3, cursor.getCount()); cursor.moveToFirst(); assertEquals("bigBird", cursor.get(managerName)); cursor.moveToNext(); assertEquals("cookieMonster", cursor.get(managerName)); cursor.moveToNext(); assertEquals("bert", cursor.get(managerName)); } finally { cursor.close(); } }
public void testAtomicIntegers() { AtomicInteger id = new AtomicInteger(1); Query query = Query.select(Employee.ID).where(Employee.ID.eq(id)); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(1, cursor.getCount()); cursor.moveToFirst(); assertEquals(1, cursor.get(Employee.ID).longValue()); } finally { cursor.close(); } id.set(2); cursor = database.query(Employee.class, query); try { assertEquals(1, cursor.getCount()); cursor.moveToFirst(); assertEquals(2, cursor.get(Employee.ID).longValue()); } finally { cursor.close(); } }
public void testLikeSubquery() { insertBasicTestModel("Sam 1", "A", System.currentTimeMillis() - 5); insertBasicTestModel("Sam 2", "B", System.currentTimeMillis() - 4); insertBasicTestModel("Sam 3", "C", System.currentTimeMillis() - 3); insertBasicTestModel("Bla 1", "D", System.currentTimeMillis() - 2); insertBasicTestModel("Bla 2", "E", System.currentTimeMillis() - 1); Function<String> substr = Function.substr(TestModel.FIRST_NAME, 1, 3); Function<String> strConcat = Function.strConcat(substr, "%"); Query likeFirstName = Query.select().where(TestModel.FIRST_NAME.like( Query.select(strConcat).from(TestModel.TABLE).where(TestModel.ID.eq(1)))).orderBy(TestModel.ID.asc()); SquidCursor<TestModel> cursor = database.query(TestModel.class, likeFirstName); try { assertEquals(3, cursor.getCount()); int index = 1; while (cursor.moveToNext()) { assertEquals("Sam " + index, cursor.get(TestModel.FIRST_NAME)); index++; } } finally { cursor.close(); } }
public void testUnionAll() { Query query = Query.select().from(Employee.TABLE).where(Employee.MANAGER_ID.eq(1)) .unionAll(Query.select().from(Employee.TABLE).where(Employee.ID.eq(2))) .orderBy(Employee.ID.asc()); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(4, cursor.getCount()); cursor.moveToFirst(); assertEquals(cookieMonster, new Employee(cursor)); cursor.moveToNext(); assertEquals(cookieMonster, new Employee(cursor)); cursor.moveToNext(); assertEquals(elmo, new Employee(cursor)); cursor.moveToNext(); assertEquals(oscar, new Employee(cursor)); } finally { cursor.close(); } }
public void testSwapCursorDoesNotCloseOldCursor() { TestAdapter adapter = new TestAdapter(new TestModel()); SquidCursor<TestModel> cursor1 = database.query(TestModel.class, Query.select()); try { adapter.swapCursor(cursor1); SquidCursor<TestModel> cursor2 = database.query(TestModel.class, Query.select().where(TestModel.ID.eq(1))); try { SquidCursor<?> swappedCursor = adapter.swapCursor(cursor2); assertFalse(swappedCursor.isClosed()); } finally { adapter.swapCursor(null); cursor2.close(); } } finally { cursor1.close(); } }
public void testUnion() { Query query = Query.select().from(Employee.TABLE).where(Employee.MANAGER_ID.eq(1)) .union(Query.select().from(Employee.TABLE).where(Employee.ID.eq(2))) .orderBy(Employee.ID.asc()); SquidCursor<Employee> cursor = database.query(Employee.class, query); try { assertEquals(3, cursor.getCount()); cursor.moveToFirst(); assertEquals(cookieMonster, new Employee(cursor)); cursor.moveToNext(); 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(); } }
public void testQueryAsFunction() { Table qualifiedTable = Employee.TABLE.as("e1"); Query subquery = Query.select(Function.add(qualifiedTable.qualifyField(Employee.ID), 1)) .from(qualifiedTable).where(Employee.ID.eq(qualifiedTable.qualifyField(Employee.ID))); Function<Long> fromQuery = subquery.asFunction(); LongProperty idPlus1 = LongProperty.fromFunction(fromQuery, "idPlus1"); Query baseQuery = Query.select(Employee.ID, idPlus1); SquidCursor<Employee> cursor = database.query(Employee.class, baseQuery); try { assertEquals(database.countAll(Employee.class), cursor.getCount()); while (cursor.moveToNext()) { assertEquals(cursor.get(Employee.ID) + 1, cursor.get(idPlus1).longValue()); } } 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 testReadAllFieldsIntoModel() { TestModel testModel = new TestModel().setFirstName("Sam"); database.persist(testModel); Thing thing = new Thing().setFoo("Thingy").setBar(5); database.persist(thing); Query query = Query.select().from(TestViewModel.VIEW) .leftJoin(Thing.TABLE, TestViewModel.TEST_MODEL_ID.eq(Thing.ID)); TestViewModel model = database.fetchByQuery(TestViewModel.class, query); for (Property<?> p : TestViewModel.PROPERTIES) { assertTrue(model.containsValue(p)); } for (Property<?> p : Thing.PROPERTIES) { assertTrue(model.containsValue(p)); } }
@Override public void run() { Criterion.and(null, TestModel.ID.eq(1)); } }, IllegalArgumentException.class);
public Query getOrderedTasksWithTags() { Function<Long> unixNow = Function.multiply(1000, Function.functionWithArguments("strftime", "%s", "now")); Function<Long> sinceCompletion = Function.subtract(unixNow, Task.COMPLETION_DATE); return getTasksWithTagsQuery(Task.COMPLETION_DATE.eq(0) .or(sinceCompletion.lt(60000 * 5))) .orderBy(Function.caseWhen(Task.DUE_DATE.neq(0)).desc(), Task.DUE_DATE.asc()); }
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 testChangeCursorClosesOldCursor() { TestAdapter adapter = new TestAdapter(new TestModel()); SquidCursor<TestModel> cursor1 = database.query(TestModel.class, Query.select()); adapter.swapCursor(cursor1); SquidCursor<TestModel> cursor2 = database.query(TestModel.class, Query.select().where(TestModel.ID.eq(1))); adapter.changeCursor(cursor2); assertTrue(cursor1.isClosed()); adapter.changeCursor(null); cursor2.close(); }
@Override public void run() { Criterion.or(null, TestModel.ID.eq(1)); } }, IllegalArgumentException.class);
/** * Delete the row with the given row ID * * @param modelClass the model class corresponding to the table to delete from * @param id the row ID of the record * @return true if delete was successful */ public boolean delete(Class<? extends TableModel> modelClass, long id) { Table table = getTable(modelClass); int rowsUpdated = deleteInternal(Delete.from(table).where(table.getRowIdProperty().eq(id))); if (rowsUpdated > 0) { notifyForTable(DataChangedNotifier.DBOperation.DELETE, null, table, id); } return rowsUpdated > 0; }
protected <TYPE extends TableModel> SquidCursor<TYPE> fetchItemById(Class<TYPE> modelClass, long id, Property<?>... properties) { Table table = getTable(modelClass); return fetchFirstItem(modelClass, table.getRowIdProperty().eq(id), properties); }