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");
/** * Construct a StringProperty from a {@link Function} and with the given alias, e.g. * "UPPER(column) AS uppercase" * * @param function the function * @param selectAs the alias to use. May be null. */ public static StringProperty fromFunction(Function<String> function, String selectAs) { return new StringProperty(function, selectAs); }
@Override @SuppressWarnings("unchecked") public EnumProperty<T> as(SqlTable<?> newTable, String columnAlias) { return (EnumProperty<T>) super.as(newTable, columnAlias); }
@Override @SuppressWarnings("unchecked") public EnumProperty<T> as(String tableAlias, String columnAlias) { return (EnumProperty<T>) super.as(tableAlias, columnAlias); }
@Override @SuppressWarnings("unchecked") public EnumProperty<T> as(String newAlias) { return (EnumProperty<T>) super.as(newAlias); }
@Override @SuppressWarnings("unchecked") public EnumProperty<T> asSelectionFromTable(SqlTable<?> newTable, String columnAlias) { return (EnumProperty<T>) super.asSelectionFromTable(newTable, columnAlias); } }
/** * Construct a StringProperty from a literal value and with the given alias, e.g. "'hello' AS greeting" * * @param literal the literal value * @param selectAs the alias to use. May be null. */ public static StringProperty literal(String literal, String selectAs) { return new StringProperty(null, SqlUtils.sanitizeStringAsLiteral(literal), selectAs, null); }
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 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 testEqualsAndHashCode() { LongProperty test1 = new LongProperty( new TableModelName(TestModel.class, TestModel.TABLE.getName()), "testCol"); LongProperty test2 = new LongProperty( new TableModelName(TestModel.class, TestModel.TABLE.getName()), "testCol"); assertEquals(test1, test2); assertEquals(test1.hashCode(), test2.hashCode()); StringProperty test3 = new StringProperty( new TableModelName(TestModel.class, TestModel.TABLE.getName()), "testCol"); StringProperty test4 = new StringProperty( new TableModelName(TestModel.class, TestModel.TABLE.getName()), "testCol", "DEFAULT 'A'"); assertEquals(test3, test4); assertEquals(test3.hashCode(), test4.hashCode()); Function<Integer> func1 = Function.count(); Function<Integer> func2 = Function.rawFunction("COUNT(*)"); assertEquals(func1, func2); assertEquals(func1.hashCode(), func2.hashCode()); IntegerProperty test5 = Property.IntegerProperty.fromFunction(func1, "count"); IntegerProperty test6 = Property.IntegerProperty.fromFunction(func2, "count"); assertEquals(test5, test6); assertEquals(test5.hashCode(), test6.hashCode()); }
@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 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 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))); }