/** * Construct a BooleanProperty from a literal value and with the given alias, e.g. "1 AS true" * * @param literal the literal value * @param selectAs the alias to use. May be null. */ public static BooleanProperty literal(boolean literal, String selectAs) { return new BooleanProperty(null, String.valueOf(literal ? 1 : 0), selectAs, null); }
public Criterion isTrue() { return neq(Function.FALSE); }
public Criterion isFalse() { return eq(Function.FALSE); }
/** * Construct a BooleanProperty from a literal value and with the given alias, e.g. "1 AS true" * * @param literal the literal value * @param selectAs the alias to use. May be null. */ public static BooleanProperty literal(boolean literal, String selectAs) { return new BooleanProperty(null, String.valueOf(literal ? 1 : 0), selectAs, null); }
/** * Construct a BooleanProperty from a {@link Function} and with the given alias, * e.g. "CASE WHEN column > 10 THEN 1 ELSE 0 END AS moreThanTen" * * @param function the function * @param selectAs the alias to use. May be null. */ public static BooleanProperty fromFunction(Function<Integer> function, String selectAs) { return new BooleanProperty(function, selectAs); }
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"); Query query = Query.select(TestModel.ID, TestModel.FIRST_NAME, nameMatches).orderBy(nameMatches.asc()); SquidCursor<TestModel> cursor = database.query(TestModel.class, query); try { query = Query.select(TestModel.ID, TestModel.FIRST_NAME, nameMatches).orderBy(nameMatches.desc()); cursor = database.query(TestModel.class, query); try {
public void testLiteralCriterions() { // null and not null evaluate to false assertEquals(0, database.count(Employee.class, Criterion.literal(null))); assertEquals(0, database.count(Employee.class, Criterion.literal(null).negate())); // numeric literal; values other than 0 (including negative) evaluate to true assertEquals(0, database.count(Employee.class, Criterion.literal(0))); assertEquals(6, database.count(Employee.class, Criterion.literal(10))); assertEquals(6, database.count(Employee.class, Criterion.literal(-10))); assertEquals(6, database.count(Employee.class, Criterion.literal(0).negate())); assertEquals(0, database.count(Employee.class, Criterion.literal(10).negate())); // text literal; SQLite will try to coerce to a number assertEquals(0, database.count(Employee.class, Criterion.literal("sqlite"))); assertEquals(6, database.count(Employee.class, Criterion.literal("sqlite").negate())); assertEquals(6, database.count(Employee.class, Criterion.literal("1sqlite"))); // coerces to 1 assertEquals(0, database.count(Employee.class, Criterion.literal("1sqlite").negate())); // numeric column Criterion isHappyCriterion = Employee.IS_HAPPY.asCriterion(); assertEquals(5, database.count(Employee.class, isHappyCriterion)); assertEquals(1, database.count(Employee.class, isHappyCriterion.negate())); // text column Criterion nameCriterion = Employee.NAME.asCriterion(); assertEquals(0, database.count(Employee.class, nameCriterion)); assertEquals(6, database.count(Employee.class, nameCriterion.negate())); // function Criterion f = Function.functionWithArguments("length", "sqlite").asCriterion(); assertEquals(6, database.count(Employee.class, f)); assertEquals(0, database.count(Employee.class, f.negate())); }
public void testQueriesWithBooleanPropertiesWork() { insertBasicTestModel(); TestModel model; SquidCursor<TestModel> result = database.query(TestModel.class, Query.select(TestModel.PROPERTIES).where(TestModel.IS_HAPPY.isTrue())); try { assertEquals(1, result.getCount()); result.moveToFirst(); model = new TestModel(result); assertTrue(model.isHappy()); model.setIsHappy(false); database.persist(model); } finally { result.close(); } result = database.query(TestModel.class, Query.select(TestModel.PROPERTIES).where(TestModel.IS_HAPPY.isFalse())); try { assertEquals(1, result.getCount()); result.moveToFirst(); model = new TestModel(result); assertFalse(model.isHappy()); } finally { result.close(); } }
public void testAtomicBoolean() { AtomicBoolean isHappy = new AtomicBoolean(false); Query query = Query.select().where(Employee.IS_HAPPY.eq(isHappy)); SquidCursor<Employee> unhappyEmployee = database.query(Employee.class, query); try { assertEquals(1, unhappyEmployee.getCount()); unhappyEmployee.moveToFirst(); assertEquals(oscar.getRowId(), unhappyEmployee.get(Employee.ID).longValue()); } finally { unhappyEmployee.close(); } isHappy.set(true); SquidCursor<Employee> happyEmployees = database.query(Employee.class, query); try { assertEquals(5, happyEmployees.getCount()); } finally { happyEmployees.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 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)); }
@Override public void run() { Update update = Update.table(TestModel.TABLE).where(TestModel.IS_HAPPY.isTrue()); update.compile(database.getCompileContext()); } }, IllegalStateException.class);
public void testMissingStatementsThrowsIllegalStateException() { final Trigger trigger = Trigger.after("trigger").insertOn(TestModel.TABLE) .when(TestModel.IS_HAPPY.isFalse()); testThrowsException(new Runnable() { public void run() { trigger.compile(database.getCompileContext()); } }, IllegalStateException.class); }
public void testMissingTriggerEventThrowsIllegalStateException() { Delete delete = Delete.from(TestModel.TABLE).where(TestModel.IS_HAPPY.isFalse()); final Trigger trigger = Trigger.after("trigger").when(TestModel.IS_HAPPY.isFalse()) .perform(delete); testThrowsException(new Runnable() { public void run() { trigger.compile(database.getCompileContext()); } }, IllegalStateException.class); }
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); }
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 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 Criterion isFalse() { return eq(Function.FALSE); }