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 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); }
@Override public void run() { final String fname1 = "Alan"; final String lname1 = "Turing"; final String fname2 = "Linus"; final String lname2 = "Torvalds"; Insert insert = Insert.into(TestModel.TABLE) .columns(TestModel.FIRST_NAME, TestModel.LAST_NAME) .values(fname1, lname1) .values(fname2, lname2); CompiledStatement compiled = insert.compile(database.getCompileContext()); verifyCompiledSqlArgs(compiled, 4, fname1, lname1, fname2, lname2); assertEquals(3, database.insert(insert)); Criterion where = TestModel.FIRST_NAME.eq(fname1).and(TestModel.LAST_NAME.eq(lname1)); assertNotNull(database.fetchByCriterion(TestModel.class, where, TestModel.PROPERTIES)); where = TestModel.FIRST_NAME.eq(fname2).and(TestModel.LAST_NAME.eq(lname2)); assertNotNull(database.fetchByCriterion(TestModel.class, where, TestModel.PROPERTIES)); } });
public void testOrderByFunction() { AtomicReference<String> name = new AtomicReference<>("Sam"); Function<Integer> caseWhen = Function.caseWhen(TestModel.FIRST_NAME.eq(name)); BooleanProperty nameMatches = BooleanProperty.fromFunction(caseWhen, "nameMatches");
public void testUpdateWithConflictReplace() { final String samLastName = sam.getLastName(); final String kevinFirstName = kevin.getFirstName(); // check preconditions TestModel modelWithSamLastName = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(samLastName), TestModel.PROPERTIES); TestModel modelWithKevinFirstName = database .fetchByCriterion(TestModel.class, TestModel.FIRST_NAME.eq(kevinFirstName), TestModel.PROPERTIES); assertNotNull(modelWithSamLastName); assertNotNull(modelWithKevinFirstName); assertFalse(modelWithSamLastName.equals(modelWithKevinFirstName)); int shouldBeOne = database.count(TestModel.class, TestModel.LAST_NAME.eq(samLastName)); assertEquals(1, shouldBeOne); shouldBeOne = database.count(TestModel.class, TestModel.FIRST_NAME.eq(kevinFirstName)); assertEquals(1, shouldBeOne); // update or replace testModels set lastName = 'Bosley' where firstName = 'Kevin' Update update = Update.table(TestModel.TABLE).onConflict(ConflictAlgorithm.REPLACE).set(TestModel.LAST_NAME, samLastName).where(TestModel.FIRST_NAME.eq(kevinFirstName)); CompiledStatement compiled = update.compile(database.getCompileContext()); verifyCompiledSqlArgs(compiled, 2, samLastName, kevinFirstName); assertEquals(1, database.update(update)); modelWithSamLastName = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(samLastName), TestModel.PROPERTIES); modelWithKevinFirstName = database.fetchByCriterion(TestModel.class, TestModel.FIRST_NAME.eq(kevinFirstName), TestModel.PROPERTIES); assertNotNull(modelWithSamLastName); assertNotNull(modelWithKevinFirstName); assertEquals(modelWithSamLastName, modelWithKevinFirstName); }
public void testInsertWithCoflictReplace() { final String lname = sam.getLastName(); // check preconditions // last name is unique TestModel shouldNotBeNull = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(lname), TestModel.PROPERTIES); assertNotNull(shouldNotBeNull); // insert or replace into testModels (firstName, lastName, isHappy, luckyNumber) values ("Jack", "Bosley", 0, // 777); final String fname = "Jack"; final boolean isHappy = false; final int luckyNumber = 777; Insert insert = Insert.into(TestModel.TABLE) .onConflict(ConflictAlgorithm.REPLACE) .columns(TestModel.FIRST_NAME, TestModel.LAST_NAME, TestModel.IS_HAPPY, TestModel.LUCKY_NUMBER) .values(fname, lname, isHappy, luckyNumber); CompiledStatement compiled = insert.compile(database.getCompileContext()); verifyCompiledSqlArgs(compiled, 4, fname, lname, isHappy, luckyNumber); int rowsBeforeInsert = database.countAll(Thing.class); assertEquals(rowsBeforeInsert, database.insert(insert)); // Expect replace int rowsAfterInsert = database.countAll(Thing.class); assertEquals(rowsBeforeInsert, rowsAfterInsert); TestModel modelWithSamLastName = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(lname), TestModel.PROPERTIES); assertEquals(fname, modelWithSamLastName.getFirstName()); assertEquals(lname, modelWithSamLastName.getLastName()); assertEquals(Boolean.valueOf(isHappy), modelWithSamLastName.isHappy()); assertEquals(Integer.valueOf(luckyNumber), modelWithSamLastName.getLuckyNumber()); }
public void testInsertWithCoflictIgnore() { final String lname = sam.getLastName(); // check preconditions // last name is unique TestModel shouldNotBeNull = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(lname), TestModel.PROPERTIES); assertNotNull(shouldNotBeNull); // insert or replace into testModels (firstName, lastName, isHappy, luckyNumber) values ("Jack", "Bosley", 0, // 777); final String fname = "Jack"; final boolean isHappy = false; final int luckyNumber = 777; Insert insert = Insert.into(TestModel.TABLE) .onConflict(ConflictAlgorithm.IGNORE) .columns(TestModel.FIRST_NAME, TestModel.LAST_NAME, TestModel.IS_HAPPY, TestModel.LUCKY_NUMBER) .values(fname, lname, isHappy, luckyNumber); CompiledStatement compiled = insert.compile(database.getCompileContext()); verifyCompiledSqlArgs(compiled, 4, fname, lname, isHappy, luckyNumber); int rowsBeforeInsert = database.countAll(Thing.class); assertEquals(-1, database.insert(insert)); // Expect conflict int rowsAfterInsert = database.countAll(Thing.class); assertEquals(rowsBeforeInsert, rowsAfterInsert); TestModel withSamLastName = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(lname), TestModel.PROPERTIES); assertEquals(sam.getFirstName(), withSamLastName.getFirstName()); assertEquals(sam.getLastName(), withSamLastName.getLastName()); assertEquals(sam.isHappy(), withSamLastName.isHappy()); assertEquals(sam.getLuckyNumber(), withSamLastName.getLuckyNumber()); }
public void testUpdateWithConflictIgnore() { final String samLastName = sam.getLastName(); final String kevinFirstName = kevin.getFirstName(); // check preconditions TestModel modelWithSamLastName = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(samLastName), TestModel.PROPERTIES); TestModel modelWithKevinFirstName = database .fetchByCriterion(TestModel.class, TestModel.FIRST_NAME.eq(kevinFirstName), TestModel.PROPERTIES); assertNotNull(modelWithSamLastName); assertNotNull(modelWithKevinFirstName); assertFalse(modelWithSamLastName.equals(modelWithKevinFirstName)); // update or ignore testModels set lastName = 'Bosley' where firstName = 'Kevin' Update update = Update.table(TestModel.TABLE).onConflict(ConflictAlgorithm.IGNORE).set(TestModel.LAST_NAME, samLastName).where(TestModel.FIRST_NAME.eq(kevinFirstName)); CompiledStatement compiled = update.compile(database.getCompileContext()); verifyCompiledSqlArgs(compiled, 2, samLastName, kevinFirstName); assertEquals(0, database.update(update)); // Expect ignore int shouldBeOne = database.count(TestModel.class, TestModel.LAST_NAME.eq(samLastName)); assertEquals(1, shouldBeOne); modelWithSamLastName = database.fetchByCriterion(TestModel.class, TestModel.LAST_NAME.eq(samLastName), TestModel.PROPERTIES); assertNotNull(modelWithSamLastName); assertEquals(sam.getFirstName(), modelWithSamLastName.getFirstName()); assertEquals(samLastName, modelWithSamLastName.getLastName()); assertEquals(sam.getBirthday(), modelWithSamLastName.getBirthday()); assertEquals(sam.getLuckyNumber(), modelWithSamLastName.getLuckyNumber()); }
public void testCrudMethods() { // insert TestVirtualModel model = new TestVirtualModel() .setTitle("Charlie") .setBody("Charlie and the Chocolate Factory"); assertTrue(database.createNew(model)); assertEquals(1, database.countAll(TestVirtualModel.class)); // query final long id = model.getRowId(); TestVirtualModel fetched = database.fetch(TestVirtualModel.class, id, TestVirtualModel.PROPERTIES); assertEquals(model, fetched); // update model.setTitle("Charlie Brown").setBody("It's the Easter Beagle, Charlie Brown"); assertTrue(database.saveExisting(model)); assertEquals(1, database.countAll(TestVirtualModel.class)); assertEquals(1, database.count(TestVirtualModel.class, TestVirtualModel.TITLE.eq("Charlie Brown"))); // update using setId on a template TestVirtualModel model2 = new TestVirtualModel().setTitle("Charlie Brown 2").setRowId(model.getRowId()); assertTrue(database.saveExisting(model2)); assertEquals(1, database.countAll(TestVirtualModel.class)); assertEquals(1, database.count(TestVirtualModel.class, TestVirtualModel.TITLE.eq("Charlie Brown 2"))); // delete assertTrue(database.delete(TestVirtualModel.class, id)); assertEquals(0, database.countAll(TestVirtualModel.class)); }
public void testConflict() { insertBasicTestModel(); TestModel conflict = new TestModel(); conflict.setFirstName("Dave"); conflict.setLastName("Bosley"); boolean result = database.persistWithOnConflict(conflict, TableStatement.ConflictAlgorithm.IGNORE); assertFalse(result); TestModel shouldntExist = database.fetchByCriterion(TestModel.class, TestModel.FIRST_NAME.eq("Dave").and(TestModel.LAST_NAME.eq("Bosley")), TestModel.PROPERTIES); assertNull(shouldntExist); RuntimeException expected = null; try { conflict.clearValue(TestModel.ID); database.persistWithOnConflict(conflict, TableStatement.ConflictAlgorithm.FAIL); } catch (RuntimeException e) { expected = e; } assertNotNull(expected); }
public void testMultiColumnPrimaryKey() { TestMultiColumnKey test = new TestMultiColumnKey() .setKeyCol1("A") .setKeyCol2("B") .setKeyCol3("C") .setOtherData("ABC"); assertTrue(database.persist(test)); assertEquals(1, test.getRowId()); TestMultiColumnKey fetched = database.fetch(TestMultiColumnKey.class, test.getRowId()); assertEquals(test, fetched); TestMultiColumnKey fetched2 = database.fetchByCriterion(TestMultiColumnKey.class, TestMultiColumnKey.KEY_COL_1.eq("A") .and(TestMultiColumnKey.KEY_COL_2.eq("B") .and(TestMultiColumnKey.KEY_COL_3.eq("C")))); assertEquals(test, fetched2); }
public void testInstanceVsStaticConjunction() { Criterion c1 = TestModel.FIRST_NAME.eq("Sam"); Criterion c2 = TestModel.LAST_NAME.eq("Bosley"); Criterion c3 = TestModel.LUCKY_NUMBER.eq(7); Criterion c = c1.and(c2); Criterion cand = c.and(c3); assertNotSame(c, cand); // Tests immutability of conjunction criterions when appending with the same operator assertEquals(Criterion.and(c1, c2, c3), c1.and(c2).and(c3)); assertEquals(Criterion.and(Arrays.asList(c1, c2, c3)), c1.and(c2).and(c3)); assertEquals(Criterion.or(c1, c2, c3), c1.or(c2).or(c3)); assertEquals(Criterion.or(Arrays.asList(c1, c2, c3)), c1.or(c2).or(c3)); assertEquals(Criterion.or(Criterion.and(c1, c2), c3), c1.and(c2).or(c3)); assertEquals(Criterion.and(Criterion.or(c1, c2), c3), c1.or(c2).and(c3)); assertEquals(Criterion.and(c1, Criterion.or(c2, c3)), c1.and(c2.or(c3))); assertEquals(Criterion.or(c1, Criterion.and(c2, c3)), c1.or(c2.and(c3))); }
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 testCriterionNegation() { assertNegationEqualsTheOther(TestModel.FIRST_NAME.eq("Sam"), TestModel.FIRST_NAME.neq("Sam")); assertNegationEqualsTheOther(TestModel.FIRST_NAME.isNull(), TestModel.FIRST_NAME.isNotNull()); assertNegationEqualsTheOther(TestModel.LUCKY_NUMBER.gt(5), TestModel.LUCKY_NUMBER.lte(5)); assertNegationEqualsTheOther(TestModel.LUCKY_NUMBER.gte(5), TestModel.LUCKY_NUMBER.lt(5)); assertNegationEqualsTheOther(TestModel.FIRST_NAME.in(Collections.EMPTY_SET), TestModel.FIRST_NAME.notIn(Collections.EMPTY_SET)); assertNegationEqualsTheOther(TestModel.FIRST_NAME.isNull(), TestModel.FIRST_NAME.isNotNull()); assertNegationEqualsTheOther(TestModel.LUCKY_NUMBER.between(1, 2), TestModel.LUCKY_NUMBER.notBetween(1, 2)); assertNegationEqualsTheOther(TestModel.FIRST_NAME.like("A"), TestModel.FIRST_NAME.notLike("A")); assertNegationEqualsTheOther(TestModel.FIRST_NAME.glob("A*"), TestModel.FIRST_NAME.notGlob("A*")); }
public void testSelectionArgsGeneration() { Query query = Query.select(TestModel.PROPERTIES) .where(TestModel.FIRST_NAME.eq("Sam") .and(TestModel.BIRTHDAY.gt(17)) .and(TestModel.LAST_NAME.neq("Smith"))); CompiledStatement compiledQuery = query.compile(database.getCompileContext()); verifyCompiledSqlArgs(compiledQuery, 3, "Sam", 17, "Smith"); }
public void testWithNonLiteralCriterion() { TestModel model = new TestModel().setFirstName("Sam").setLastName("Sam"); database.persist(model); TestModel fetch = database .fetchByQuery(TestModel.class, Query.select().where(TestModel.FIRST_NAME.eq(TestModel.LAST_NAME))); assertNotNull(fetch); assertEquals(fetch.getFirstName(), fetch.getLastName()); }
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 testNonIntegerPrimaryKey() { TestNonIntegerPrimaryKey test = new TestNonIntegerPrimaryKey() .setKey("A") .setValue("B"); assertTrue(database.persist(test)); assertEquals(1, test.getRowId()); TestNonIntegerPrimaryKey fetched = database.fetch(TestNonIntegerPrimaryKey.class, test.getRowId()); assertEquals(test, fetched); TestNonIntegerPrimaryKey fetched2 = database.fetchByCriterion(TestNonIntegerPrimaryKey.class, TestNonIntegerPrimaryKey.KEY.eq("A")); assertEquals(test, fetched2); }
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(); } }
/** * @return a {@link Criterion} that the property is null or the empty string '' */ public Criterion isEmpty() { return isNull().or(eq("")); }