Google Git
Sign in
apache / db-jdo / refs/heads/jdo-816-tilmann / . / tck / src / main / java / org / apache / jdo / tck / query / api / SampleQueries.java
blob: cc9a10050cb768c1999364f502b0c3af2dd60fd8 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
<<<<<<< Updated upstream
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
=======
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
>>>>>>> Stashed changes
* limitations under the License.
*/
package org.apache.jdo.tck.query.api;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.jdo.JDOQLTypedQuery;
import javax.jdo.JDOQLTypedSubquery;
import javax.jdo.Query;
import javax.jdo.Transaction;
import javax.jdo.query.CollectionExpression;
import javax.jdo.query.NumericExpression;
import javax.jdo.query.StringExpression;
import org.apache.jdo.tck.pc.company.CompanyModelReader;
import org.apache.jdo.tck.pc.company.Department;
import org.apache.jdo.tck.pc.company.Employee;
import org.apache.jdo.tck.pc.company.FullTimeEmployee;
import org.apache.jdo.tck.pc.company.Person;
import org.apache.jdo.tck.pc.company.QDepartment;
import org.apache.jdo.tck.pc.company.QEmployee;
import org.apache.jdo.tck.pc.company.QFullTimeEmployee;
import org.apache.jdo.tck.query.QueryTest;
import org.apache.jdo.tck.util.BatchTestRunner;
import org.apache.jdo.tck.util.EqualityHelper;
/**
* <B>Title:</B> SampleQueries <br>
* <B>Keywords:</B> query <br>
* <B>Assertion IDs:</B> <br>
* <B>Assertion Description: </B> This test class runs the example queries from the JDO
* specification.
*
* <p>There are up to six test methods per test case: testQueryxxa: runtime constructed JDO query
* using execute to run the query testQueryxxb: runtime constructed JDO query using
* setNamedParameters to specify the parameter values and
* executeList/executeResultList/executeResultUnique to run the query testQueryxxc: runtime
* constructed JDO query using setParameters to specify the parameter values and
* executeList/executeResultList/executeResultUnique to run the query testQueryxxd: single string
* version of the JDO query testQueryxxe: named query version of the JDO query testQueryxxf:
* JDOQLTypedQuery version
*/
public class SampleQueries extends QueryTest {
/** */
private static final String ASSERTION_FAILED = "Assertion (SampleQueries) failed: ";
/** */
private static final String SAMPLE_QUERIES_TEST_COMPANY_TESTDATA =
"org/apache/jdo/tck/pc/company/companyForSampleQueriesTest.xml";
/**
* The <code>main</code> is called when the class is directly executed from the command line.
*
* @param args The arguments passed to the program.
*/
public static void main(String[] args) {
BatchTestRunner.run(SampleQueries.class);
}
private static final String SINGLE_STRING_QUERY_01 =
"select from org.apache.jdo.tck.pc.company.FullTimeEmployee where salary > 30000";
private static final String SINGLE_STRING_QUERY_02 =
"select from org.apache.jdo.tck.pc.company.FullTimeEmployee "
+ "where salary > 30000 order by salary ascending";
private static final String SINGLE_STRING_QUERY_03 =
"select from org.apache.jdo.tck.pc.company.FullTimeEmployee "
+ "where salary > :sal && firstname.startsWith(:begin)";
private static final String SINGLE_STRING_QUERY_04 =
"select from org.apache.jdo.tck.pc.company.Employee where department.name == :dep";
private static final String SINGLE_STRING_QUERY_05 =
"select from org.apache.jdo.tck.pc.company.Department "
+ "where employees.contains(emp) && emp.weeklyhours > :hours variables Employee emp";
private static final String SINGLE_STRING_QUERY_06 =
"select from org.apache.jdo.tck.pc.company.Department where :depts.contains(name)";
private static final String SINGLE_STRING_QUERY_07 =
"select firstname from org.apache.jdo.tck.pc.company.Employee where department.name == :deptName";
private static final String SINGLE_STRING_QUERY_08 =
"select firstname, salary, manager as reportsTo into org.apache.jdo.tck.query.api.SampleQueries$Info "
+ "from org.apache.jdo.tck.pc.company.FullTimeEmployee where department.name == :deptName";
private static final String SINGLE_STRING_QUERY_09 =
"select new org.apache.jdo.tck.query.api.SampleQueries$Info (firstname, salary, manager) "
+ "from org.apache.jdo.tck.pc.company.FullTimeEmployee where department.name == :deptName";
private static final String SINGLE_STRING_QUERY_10 =
"select avg(salary) from org.apache.jdo.tck.pc.company.FullTimeEmployee "
+ "where department.name == :deptName";
private static final String SINGLE_STRING_QUERY_11 =
"select avg(salary), sum(salary) from org.apache.jdo.tck.pc.company.FullTimeEmployee "
+ "where department.name == :deptName";
private static final String SINGLE_STRING_QUERY_12 =
"select avg(salary), sum(salary), department.name "
+ "from org.apache.jdo.tck.pc.company.FullTimeEmployee "
+ "group by department.name having count(department.name) > 1";
private static final String SINGLE_STRING_QUERY_13 =
"select unique this from org.apache.jdo.tck.pc.company.Employee where firstname == :empName";
private static final String SINGLE_STRING_QUERY_14 =
"select unique salary from org.apache.jdo.tck.pc.company.FullTimeEmployee "
+ "where firstname == :empName";
private static final String SINGLE_STRING_QUERY_15 =
"select into org.apache.jdo.tck.query.api.SampleQueries$EmpWrapper "
+ "from org.apache.jdo.tck.pc.company.FullTimeEmployee where salary > :sal";
private static final String SINGLE_STRING_QUERY_16 =
"select into org.apache.jdo.tck.query.api.SampleQueries$EmpInfo "
+ "from org.apache.jdo.tck.pc.company.FullTimeEmployee where salary > :sal";
private static final String SINGLE_STRING_QUERY_17 =
"select e.firstname from org.apache.jdo.tck.pc.company.Department "
+ "where name.startsWith('R&D') && employees.contains(e) "
+ "variables org.apache.jdo.tck.pc.company.Employee e";
private static final String SINGLE_STRING_QUERY_18 =
"select firstname from org.apache.jdo.tck.pc.company.Employee "
+ "where this.weeklyhours > (select avg(e.weeklyhours) from org.apache.jdo.tck.pc.company.Employee e)";
private static final String SINGLE_STRING_QUERY_19 =
"select firstname from org.apache.jdo.tck.pc.company.Employee "
+ "where this.weeklyhours > "
+ " (select AVG(e.weeklyhours) from this.department.employees e where e.manager == this.manager)";
/**
* Basic query.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000. Note that the float value for salary is unwrapped for the
* comparison with the literal int value, which is promoted to float using numeric promotion. If
* the value for the salary field in a candidate instance isnull, then it cannot be unwrapped for
* the comparison, and the candidate instance is rejected.
*/
@SuppressWarnings("unchecked")
public void testQuery01a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp2", "emp5");
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > 30000")) {
List<FullTimeEmployee> emps = (List<FullTimeEmployee>) q.execute();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_01, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Basic query.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000. Note that the float value for salary is unwrapped for the
* comparison with the literal int value, which is promoted to float using numeric promotion. If
* the value for the salary field in a candidate instance isnull, then it cannot be unwrapped for
* the comparison, and the candidate instance is rejected.
*/
public void testQuery01b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp2", "emp5");
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > 30000")) {
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_01, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Basic query.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000. Note that the float value for salary is unwrapped for the
* comparison with the literal int value, which is promoted to float using numeric promotion. If
* the value for the salary field in a candidate instance isnull, then it cannot be unwrapped for
* the comparison, and the candidate instance is rejected.
*/
@SuppressWarnings("unchecked")
public void testQuery01d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp2", "emp5");
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_01)) {
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_01, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Basic query.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000. Note that the float value for salary is unwrapped for the
* comparison with the literal int value, which is promoted to float using numeric promotion. If
* the value for the salary field in a candidate instance isnull, then it cannot be unwrapped for
* the comparison, and the candidate instance is rejected.
*/
public void testQuery01f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp2", "emp5");
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
q.filter(cand.salary.gt(30000.));
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_01, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Basic query with ordering.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000, and returns a Collection ordered based on employee salary.
*/
@SuppressWarnings("unchecked")
public void testQuery02a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp5", "emp2");
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > 30000")) {
q.setOrdering("salary ascending");
List<FullTimeEmployee> emps = (List<FullTimeEmployee>) q.execute();
checkQueryResultWithOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_02, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Basic query with ordering.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000, and returns a Collection ordered based on employee salary.
*/
public void testQuery02b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp5", "emp2");
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > 30000")) {
q.setOrdering("salary ascending");
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_02, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Basic query with ordering.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000, and returns a Collection ordered based on employee salary.
*/
@SuppressWarnings("unchecked")
public void testQuery02d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp5", "emp2");
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_02)) {
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_02, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Basic query with ordering.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the constant 30000, and returns a Collection ordered based on employee salary.
*/
public void testQuery02f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1", "emp5", "emp2");
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
q.filter(cand.salary.gt(30000.)).orderBy(cand.salary.asc());
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_02, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Parameter passing.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the value passed as a parameter and the name starts with the value passed as a
* second parameter. If the value for the salary field in a candidate instance is null, then it
* cannot be unwrapped for the comparison, and the candidate instance is rejected.
*/
@SuppressWarnings("unchecked")
public void testQuery03a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1");
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "salary > sal && firstname.startsWith(begin)")) {
q.declareParameters("Double sal, String begin");
List<FullTimeEmployee> emps = (List<FullTimeEmployee>) q.execute(30000., "M");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_03, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Parameter passing.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the value passed as a parameter and the name starts with the value passed as a
* second parameter. If the value for the salary field in a candidate instance is null, then it
* cannot be unwrapped for the comparison, and the candidate instance is rejected.
*/
public void testQuery03b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1");
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "salary > sal && firstname.startsWith(begin)")) {
q.declareParameters("Double sal, String begin");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("sal", 30000.);
paramValues.put("begin", "M");
q.setNamedParameters(paramValues);
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_03, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Parameter passing.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the value passed as a parameter and the name starts with the value passed as a
* second parameter. If the value for the salary field in a candidate instance is null, then it
* cannot be unwrapped for the comparison, and the candidate instance is rejected.
*/
public void testQuery03c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1");
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "salary > sal && firstname.startsWith(begin)")) {
q.declareParameters("Double sal, String begin");
q.setParameters(30000., "M");
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_03, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Parameter passing.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the value passed as a parameter and the name starts with the value passed as a
* second parameter. If the value for the salary field in a candidate instance is null, then it
* cannot be unwrapped for the comparison, and the candidate instance is rejected.
*/
@SuppressWarnings("unchecked")
public void testQuery03d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1");
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_03)) {
List<FullTimeEmployee> emps = (List<FullTimeEmployee>) q.execute(30000., "M");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_03, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Parameter passing.
*
* <p>This query selects all Employee instances from the candidate collection where the salary is
* greater than the value passed as a parameter and the name starts with the value passed as a
* second parameter. If the value for the salary field in a candidate instance is null, then it
* cannot be unwrapped for the comparison, and the candidate instance is rejected.
*/
public void testQuery03f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<FullTimeEmployee> expected =
getTransientCompanyModelInstancesAsList(FullTimeEmployee.class, "emp1");
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
NumericExpression<Double> sal = q.numericParameter("sal", Double.class);
StringExpression begin = q.stringParameter("begin");
q.filter(cand.salary.gt(sal).and(cand.firstname.startsWith(begin)));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("sal", 30000.);
paramValues.put("begin", "M");
q.setParameters(paramValues);
List<FullTimeEmployee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_03, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through single-valued field.
*
* <p>This query selects all Employee instances from the candidate collection where the value of
* the name field in the Department instance associated with the Employee instance is equal to the
* value passed as a parameter. If the value for the dept field in a candidate instance is null,
* then it cannot be navigated for the comparison, and the candidate instance is rejected.
*/
@SuppressWarnings("unchecked")
public void testQuery04a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Employee> expected =
getTransientCompanyModelInstancesAsList(Employee.class, "emp1", "emp2", "emp3");
try (Query<Employee> q = pm.newQuery(Employee.class, "department.name == dep")) {
q.declareParameters("String dep");
List<Employee> emps = (List<Employee>) q.execute("R&D");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_04, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through single-valued field.
*
* <p>This query selects all Employee instances from the candidate collection where the value of
* the name field in the Department instance associated with the Employee instance is equal to the
* value passed as a parameter. If the value for the dept field in a candidate instance is null,
* then it cannot be navigated for the comparison, and the candidate instance is rejected.
*/
public void testQuery04b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Employee> expected =
getTransientCompanyModelInstancesAsList(Employee.class, "emp1", "emp2", "emp3");
try (Query<Employee> q = pm.newQuery(Employee.class, "department.name == dep")) {
q.declareParameters("String dep");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("dep", "R&D");
q.setNamedParameters(paramValues);
List<Employee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_04, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through single-valued field.
*
* <p>This query selects all Employee instances from the candidate collection where the value of
* the name field in the Department instance associated with the Employee instance is equal to the
* value passed as a parameter. If the value for the dept field in a candidate instance is null,
* then it cannot be navigated for the comparison, and the candidate instance is rejected.
*/
public void testQuery04c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Employee> expected =
getTransientCompanyModelInstancesAsList(Employee.class, "emp1", "emp2", "emp3");
try (Query<Employee> q = pm.newQuery(Employee.class, "department.name == dep")) {
q.declareParameters("String dep");
q.setParameters("R&D");
List<Employee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_04, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through single-valued field.
*
* <p>This query selects all Employee instances from the candidate collection where the value of
* the name field in the Department instance associated with the Employee instance is equal to the
* value passed as a parameter. If the value for the dept field in a candidate instance is null,
* then it cannot be navigated for the comparison, and the candidate instance is rejected.
*/
@SuppressWarnings("unchecked")
public void testQuery04d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Employee> expected =
getTransientCompanyModelInstancesAsList(Employee.class, "emp1", "emp2", "emp3");
try (Query<Employee> q = pm.newQuery(SINGLE_STRING_QUERY_04)) {
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("dep", "R&D");
q.setNamedParameters(paramValues);
List<Employee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_04, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through single-valued field.
*
* <p>This query selects all Employee instances from the candidate collection where the value of
* the name field in the Department instance associated with the Employee instance is equal to the
* value passed as a parameter. If the value for the dept field in a candidate instance is null,
* then it cannot be navigated for the comparison, and the candidate instance is rejected.
*/
public void testQuery04f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Employee> expected =
getTransientCompanyModelInstancesAsList(Employee.class, "emp1", "emp2", "emp3");
try (JDOQLTypedQuery<Employee> q = pm.newJDOQLTypedQuery(Employee.class)) {
QEmployee cand = QEmployee.candidate();
StringExpression dep = q.stringParameter("dep");
q.filter(cand.department.name.eq(dep));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("dep", "R&D");
q.setParameters(paramValues);
List<Employee> emps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_04, emps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through multi-valued field.
*
* <p>This query selects all Department instances from the candidate collection where the
* collection of Employee instances contains at least one Employee instance having a salary
* greater than the value passed as a parameter.
*/
@SuppressWarnings("unchecked")
public void testQuery05a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1");
try (Query<Department> q =
pm.newQuery(Department.class, "employees.contains (emp) && emp.weeklyhours > hours")) {
q.declareVariables("Employee emp");
q.declareParameters("double hours");
List<Department> deps = (List<Department>) q.execute(30.);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_05, deps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through multi-valued field.
*
* <p>This query selects all Department instances from the candidate collection where the
* collection of Employee instances contains at least one Employee instance having a salary
* greater than the value passed as a parameter.
*/
public void testQuery05b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1");
try (Query<Department> q =
pm.newQuery(Department.class, "employees.contains (emp) && emp.weeklyhours > hours")) {
q.declareVariables("Employee emp");
q.declareParameters("double hours");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("hours", 30.);
q.setNamedParameters(paramValues);
List<Department> deps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_05, deps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through multi-valued field.
*
* <p>This query selects all Department instances from the candidate collection where the
* collection of Employee instances contains at least one Employee instance having a salary
* greater than the value passed as a parameter.
*/
public void testQuery05c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1");
try (Query<Department> q =
pm.newQuery(Department.class, "employees.contains (emp) && emp.weeklyhours > hours")) {
q.declareVariables("Employee emp");
q.declareParameters("double hours");
q.setParameters(30.);
List<Department> deps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_05, deps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through multi-valued field.
*
* <p>This query selects all Department instances from the candidate collection where the
* collection of Employee instances contains at least one Employee instance having a salary
* greater than the value passed as a parameter.
*/
@SuppressWarnings("unchecked")
public void testQuery05d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1");
try (Query<Department> q = pm.newQuery(SINGLE_STRING_QUERY_05)) {
List<Department> deps = (List<Department>) q.execute(30.);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_05, deps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Navigation through multi-valued field.
*
* <p>This query selects all Department instances from the candidate collection where the
* collection of Employee instances contains at least one Employee instance having a salary
* greater than the value passed as a parameter.
*/
@SuppressWarnings("unchecked")
public void testQuery05f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1");
try (JDOQLTypedQuery<Department> q = pm.newJDOQLTypedQuery(Department.class)) {
QDepartment cand = QDepartment.candidate();
QEmployee emp = QEmployee.variable("emp");
NumericExpression<Double> hours = q.numericParameter("hours", double.class);
q.filter(cand.employees.contains(emp).and(emp.weeklyhours.gt(hours)));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("hours", 30.);
q.setParameters(paramValues);
List<Department> deps = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_05, deps, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Membership in a collection.
*
* <p>This query selects all Department instances where the name field is contained in a parameter
* collection, which in this example consists of three department names.
*/
@SuppressWarnings("unchecked")
public void testQuery06a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1", "dept2", "dept3");
try (Query<Department> q = pm.newQuery(Department.class, "depts.contains(name)")) {
q.declareParameters("java.util.Collection depts");
List<String> deptNames = Arrays.asList("R&D", "Sales", "Marketing");
List<Department> result = (List<Department>) q.execute(deptNames);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_06, result, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Membership in a collection.
*
* <p>This query selects all Department instances where the name field is contained in a parameter
* collection, which in this example consists of three department names.
*/
public void testQuery06b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1", "dept2", "dept3");
try (Query<Department> q = pm.newQuery(Department.class, "depts.contains(name)")) {
q.declareParameters("java.util.Collection depts");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("depts", Arrays.asList("R&D", "Sales", "Marketing"));
q.setNamedParameters(paramValues);
List<Department> result = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_06, result, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Membership in a collection.
*
* <p>This query selects all Department instances where the name field is contained in a parameter
* collection, which in this example consists of three department names.
*/
public void testQuery06c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1", "dept2", "dept3");
try (Query<Department> q = pm.newQuery(Department.class, "depts.contains(name)")) {
q.declareParameters("java.util.Collection depts");
q.setParameters(Arrays.asList("R&D", "Sales", "Marketing"));
List<Department> result = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_06, result, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Membership in a collection.
*
* <p>This query selects all Department instances where the name field is contained in a parameter
* collection, which in this example consists of three department names.
*/
@SuppressWarnings("unchecked")
public void testQuery06d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1", "dept2", "dept3");
try (Query<Department> q = pm.newQuery(SINGLE_STRING_QUERY_06)) {
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("depts", Arrays.asList("R&D", "Sales", "Marketing"));
q.setNamedParameters(paramValues);
List<Department> result = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_06, result, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Membership in a collection.
*
* <p>This query selects all Department instances where the name field is contained in a parameter
* collection, which in this example consists of three department names.
*/
public void testQuery06f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Department> expected =
getTransientCompanyModelInstancesAsList(Department.class, "dept1", "dept2", "dept3");
try (JDOQLTypedQuery<Department> q = pm.newJDOQLTypedQuery(Department.class)) {
QDepartment cand = QDepartment.candidate();
CollectionExpression<Collection<String>, String> depts =
q.collectionParameter("depts", String.class);
q.filter(depts.contains(cand.name));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("depts", Arrays.asList("R&D", "Sales", "Marketing"));
q.setParameters(paramValues);
List<Department> result = q.executeList();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_06, result, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of a Single Field.
*
* <p>This query selects names of all Employees who work in the parameter department.
*/
@SuppressWarnings("unchecked")
public void testQuery07a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Joe", "Craig", "Michael");
try (Query<Employee> q = pm.newQuery(Employee.class, "department.name == deptName")) {
q.setResult("firstname");
q.declareParameters("String deptName");
List<String> names = (List<String>) q.execute("R&D");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_07, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of a Single Field.
*
* <p>This query selects names of all Employees who work in the parameter department.
*/
public void testQuery07b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Joe", "Craig", "Michael");
try (Query<Employee> q = pm.newQuery(Employee.class, "department.name == deptName")) {
q.setResult("firstname");
q.declareParameters("String deptName");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setNamedParameters(paramValues);
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_07, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of a Single Field.
*
* <p>This query selects names of all Employees who work in the parameter department.
*/
public void testQuery07c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Joe", "Craig", "Michael");
try (Query<Employee> q = pm.newQuery(Employee.class, "department.name == deptName")) {
q.setResult("firstname");
q.declareParameters("String deptName");
q.setParameters("R&D");
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_07, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of a Single Field.
*
* <p>This query selects names of all Employees who work in the parameter department.
*/
@SuppressWarnings("unchecked")
public void testQuery07d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Joe", "Craig", "Michael");
try (Query<Employee> q = pm.newQuery(SINGLE_STRING_QUERY_07)) {
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setNamedParameters(paramValues);
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_07, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of a Single Field.
*
* <p>This query selects names of all Employees who work in the parameter department.
*/
public void testQuery07f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Joe", "Craig", "Michael");
try (JDOQLTypedQuery<Employee> q = pm.newJDOQLTypedQuery(Employee.class)) {
QEmployee cand = QEmployee.candidate();
StringExpression deptName = q.stringParameter("deptName");
q.filter(cand.department.name.eq(deptName)).result(false, cand.firstname);
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setParameters(paramValues);
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_07, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department.
*/
@SuppressWarnings("unchecked")
public void testQuery08a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<SampleQueries.Info> expected = testQuery08Helper();
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("firstname, salary, manager as reportsTo");
q.setResultClass(Info.class);
q.declareParameters("String deptName");
List<Info> infos = (List<Info>) q.execute("R&D");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_08, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department.
*/
public void testQuery08b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected = testQuery08Helper();
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("firstname, salary, manager as reportsTo");
q.setResultClass(Info.class);
q.declareParameters("String deptName");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setNamedParameters(paramValues);
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_08, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department.
*/
public void testQuery08c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected = testQuery08Helper();
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("firstname, salary, manager as reportsTo");
q.setResultClass(Info.class);
q.declareParameters("String deptName");
q.setParameters("R&D");
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_08, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department.
*/
@SuppressWarnings("unchecked")
public void testQuery08d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected = testQuery08Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_08)) {
q.setParameters("R&D");
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_08, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department.
*/
public void testQuery08f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected = testQuery08Helper();
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
StringExpression deptName = q.stringParameter("deptName");
q.result(false, cand.firstname, cand.salary, cand.manager.as("reportsTo"))
.filter(cand.department.name.eq(deptName));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setParameters(paramValues);
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_08, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions into a Constructed instance.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department, and uses the constructor for the result class.
*/
@SuppressWarnings("unchecked")
public void testQuery09a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected =
Arrays.asList(
new Info("Michael", 40000., getTransientCompanyModelInstance(Employee.class, "emp2")),
new Info("Craig", 50000., null));
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult(
"new org.apache.jdo.tck.query.api.SampleQueries$Info(firstname, salary, manager)");
q.declareParameters("String deptName");
List<Info> infos = (List<Info>) q.execute("R&D");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_09, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions into a Constructed instance.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department, and uses the constructor for the result class.
*/
public void testQuery09b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected =
Arrays.asList(
new Info("Michael", 40000., getTransientCompanyModelInstance(Employee.class, "emp2")),
new Info("Craig", 50000., null));
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult(
"new org.apache.jdo.tck.query.api.SampleQueries$Info(firstname, salary, manager)");
q.declareParameters("String deptName");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setNamedParameters(paramValues);
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_09, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions into a Constructed instance.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department, and uses the constructor for the result class.
*/
public void testQuery09c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected =
Arrays.asList(
new Info("Michael", 40000., getTransientCompanyModelInstance(Employee.class, "emp2")),
new Info("Craig", 50000., null));
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult(
"new org.apache.jdo.tck.query.api.SampleQueries$Info(firstname, salary, manager)");
q.declareParameters("String deptName");
q.setParameters("R&D");
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_09, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions into a Constructed instance.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department, and uses the constructor for the result class.
*/
@SuppressWarnings("unchecked")
public void testQuery09d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected =
Arrays.asList(
new Info("Michael", 40000., getTransientCompanyModelInstance(Employee.class, "emp2")),
new Info("Craig", 50000., null));
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_09)) {
q.setParameters("R&D");
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_09, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions into a Constructed instance.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department, and uses the constructor for the result class.
*/
public void testQuery09e() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected =
Arrays.asList(
new Info("Michael", 40000., getTransientCompanyModelInstance(Employee.class, "emp2")),
new Info("Craig", 50000., null));
try (Query<FullTimeEmployee> q = pm.newNamedQuery(FullTimeEmployee.class, "constructor")) {
q.setParameters("R&D");
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_09, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of Multiple Fields and Expressions into a Constructed instance.
*
* <p>This query selects names, salaries, and bosses of Employees who work in the parameter
* department, and uses the constructor for the result class.
*/
public void testQuery09f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<Info> expected =
Arrays.asList(
new Info("Michael", 40000., getTransientCompanyModelInstance(Employee.class, "emp2")),
new Info("Craig", 50000., null));
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
StringExpression deptName = q.stringParameter("deptName");
q.result(false, cand.firstname, cand.salary, cand.manager)
.filter(cand.department.name.eq(deptName));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setParameters(paramValues);
List<Info> infos = q.executeResultList(Info.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_09, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of a single Field.
*
* <p>This query averages the salaries of Employees who work in the parameter department and
* returns a single value.
*/
public void testQuery10a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expected = 45000.;
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("avg(salary)");
q.declareParameters("String deptName");
Double avgSalary = (Double) q.execute("R&D");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_10, avgSalary, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of a single Field.
*
* <p>This query averages the salaries of Employees who work in the parameter department and
* returns a single value.
*/
public void testQuery10b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expected = 45000.;
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("avg(salary)");
q.declareParameters("String deptName");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setNamedParameters(paramValues);
Double avgSalary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_10, avgSalary, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of a single Field.
*
* <p>This query averages the salaries of Employees who work in the parameter department and
* returns a single value.
*/
public void testQuery10c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expected = 45000.;
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("avg(salary)");
q.declareParameters("String deptName");
q.setParameters("R&D");
Double avgSalary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_10, avgSalary, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of a single Field.
*
* <p>This query averages the salaries of Employees who work in the parameter department and
* returns a single value.
*/
@SuppressWarnings("unchecked")
public void testQuery10d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expected = 45000.;
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_10)) {
q.setParameters("R&D");
Double avgSalary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_10, avgSalary, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of a single Field.
*
* <p>This query averages the salaries of Employees who work in the parameter department and
* returns a single value.
*/
public void testQuery10f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expected = 45000.;
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
StringExpression deptName = q.stringParameter("deptName");
q.result(false, cand.salary.avg()).filter(cand.department.name.eq(deptName));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setParameters(paramValues);
Double avgSalary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_10, avgSalary, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple Fields and Expressions.
*
* <p>This query averages and sums the salaries of Employees who work in the parameter department.
*/
public void testQuery11a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double[] expected = new Double[] {45000., 90000.};
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("avg(salary), sum(salary)");
q.declareParameters("String deptName");
Object[] avgSum = (Object[]) q.execute("R&D");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_11, avgSum, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple Fields and Expressions.
*
* <p>This query averages and sums the salaries of Employees who work in the parameter department.
*/
public void testQuery11b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double[] expected = new Double[] {45000., 90000.};
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("avg(salary), sum(salary)");
q.declareParameters("String deptName");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setNamedParameters(paramValues);
Object[] avgSum = q.executeResultUnique(Object[].class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_11, avgSum, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple Fields and Expressions.
*
* <p>This query averages and sums the salaries of Employees who work in the parameter department.
*/
public void testQuery11c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double[] expected = new Double[] {45000., 90000.};
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "department.name == deptName")) {
q.setResult("avg(salary), sum(salary)");
q.declareParameters("String deptName");
q.setParameters("R&D");
Object[] avgSum = q.executeResultUnique(Object[].class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_11, avgSum, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple Fields and Expressions.
*
* <p>This query averages and sums the salaries of Employees who work in the parameter department.
*/
@SuppressWarnings("unchecked")
public void testQuery11d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double[] expected = new Double[] {45000., 90000.};
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_11)) {
q.setParameters("R&D");
Object[] avgSum = q.executeResultUnique(Object[].class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_11, avgSum, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple Fields and Expressions.
*
* <p>This query averages and sums the salaries of Employees who work in the parameter department.
*/
public void testQuery11f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double[] expected = new Double[] {45000., 90000.};
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
StringExpression deptName = q.stringParameter("deptName");
q.result(false, cand.salary.avg(), cand.salary.sum())
.filter(cand.department.name.eq(deptName));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("deptName", "R&D");
q.setParameters(paramValues);
Object[] avgSum = q.executeResultUnique(Object[].class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_11, avgSum, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple fields with Grouping.
*
* <p>This query averages and sums the salaries of Employees who work in all departments having
* more than one employee and aggregates by department name.
*/
@SuppressWarnings("unchecked")
public void testQuery12a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] expectedRow = new Object[] {45000., 90000., "R&D"};
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class)) {
q.setResult("avg(salary), sum(salary), department.name");
q.setGrouping("department.name having count(department.name) > 1");
List<Object[]> results = (List<Object[]>) q.execute();
if (results.size() != 1) {
fail(
ASSERTION_FAILED,
"Query result has size " + results.size() + ", expected query result of size 1");
}
Object[] row = results.get(0);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_12, row, expectedRow);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple fields with Grouping.
*
* <p>This query averages and sums the salaries of Employees who work in all departments having
* more than one employee and aggregates by department name.
*/
public void testQuery12b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] expectedRow = new Object[] {45000., 90000., "R&D"};
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class)) {
q.setResult("avg(salary), sum(salary), department.name");
q.setGrouping("department.name having count(department.name) > 1");
List<Object[]> results = q.executeResultList(Object[].class);
if (results.size() != 1) {
fail(
ASSERTION_FAILED,
"Query result has size " + results.size() + ", expected query result of size 1");
}
Object[] row = results.get(0);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_12, row, expectedRow);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple fields with Grouping.
*
* <p>This query averages and sums the salaries of Employees who work in all departments having
* more than one employee and aggregates by department name.
*/
@SuppressWarnings("unchecked")
public void testQuery12d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] expectedRow = new Object[] {45000., 90000., "R&D"};
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_12)) {
List<Object[]> results = q.executeResultList(Object[].class);
if (results.size() != 1) {
fail(
ASSERTION_FAILED,
"Query result has size " + results.size() + ", expected query result of size 1");
}
Object[] row = results.get(0);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_12, row, expectedRow);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple fields with Grouping.
*
* <p>This query averages and sums the salaries of Employees who work in all departments having
* more than one employee and aggregates by department name.
*/
public void testQuery12e() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] expectedRow = new Object[] {45000., 90000., "R&D"};
try (Query<FullTimeEmployee> q = pm.newNamedQuery(FullTimeEmployee.class, "grouping")) {
List<Object[]> results = q.executeResultList(Object[].class);
if (results.size() != 1) {
fail(
ASSERTION_FAILED,
"Query result has size " + results.size() + ", expected query result of size 1");
}
Object[] row = results.get(0);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_12, row, expectedRow);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Aggregation of Multiple fields with Grouping.
*
* <p>This query averages and sums the salaries of Employees who work in all departments having
* more than one employee and aggregates by department name.
*/
public void testQuery12f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Object[] expectedRow = new Object[] {45000., 90000., "R&D"};
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
q.result(false, cand.salary.avg(), cand.salary.sum(), cand.department.name)
.groupBy(cand.department.name)
.having(cand.department.name.count().gt(1L));
List<Object[]> results = q.executeResultList(Object[].class);
if (results.size() != 1) {
fail(
ASSERTION_FAILED,
"Query result has size " + results.size() + ", expected query result of size 1");
}
Object[] row = results.get(0);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_12, row, expectedRow);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Instance.
*
* <p>This query returns a single instance of Employee.
*/
public void testQuery13a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Employee expectedEmp = getTransientCompanyModelInstance(Employee.class, "emp1");
try (Query<Employee> q = pm.newQuery(Employee.class, "firstname == empName")) {
q.setUnique(true);
q.declareParameters("String empName");
Employee emp = (Employee) q.execute("Michael");
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_13, emp, expectedEmp);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Instance.
*
* <p>This query returns a single instance of Employee.
*/
public void testQuery13b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Employee expectedEmp = getTransientCompanyModelInstance(Employee.class, "emp1");
try (Query<Employee> q = pm.newQuery(Employee.class, "firstname == empName")) {
q.setUnique(true);
q.declareParameters("String empName");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("empName", "Michael");
q.setNamedParameters(paramValues);
Employee emp = q.executeUnique();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_13, emp, expectedEmp);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Instance.
*
* <p>This query returns a single instance of Employee.
*/
public void testQuery13c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Employee expectedEmp = getTransientCompanyModelInstance(Employee.class, "emp1");
try (Query<Employee> q = pm.newQuery(Employee.class, "firstname == empName")) {
q.setUnique(true);
q.declareParameters("String empName");
q.setParameters("Michael");
Employee emp = q.executeUnique();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_13, emp, expectedEmp);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Instance.
*
* <p>This query returns a single instance of Employee.
*/
@SuppressWarnings("unchecked")
public void testQuery13d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Employee expectedEmp = getTransientCompanyModelInstance(Employee.class, "emp1");
try (Query<Employee> q = pm.newQuery(SINGLE_STRING_QUERY_13)) {
q.setParameters("Michael");
Employee emp = q.executeResultUnique(Employee.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_13, emp, expectedEmp);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Instance.
*
* <p>This query returns a single instance of Employee.
*/
public void testQuery13f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Employee expectedEmp = getTransientCompanyModelInstance(Employee.class, "emp1");
try (JDOQLTypedQuery<Employee> q = pm.newJDOQLTypedQuery(Employee.class)) {
QEmployee cand = QEmployee.candidate();
StringExpression empName = q.stringParameter("empName");
q.filter(cand.firstname.eq(empName));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("empName", "Michael");
q.setParameters(paramValues);
Employee emp = q.executeUnique();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_13, emp, expectedEmp);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Field.
*
* <p>This query returns a single field of a single Employee.
*/
public void testQuery14a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expectedSalary = 40000.;
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "firstname == empName")) {
q.setResult("salary");
q.setResultClass(Double.class);
q.setUnique(true);
q.declareParameters("String empName");
Double salary = (Double) q.execute("Michael");
checkQueryResultWithoutOrder(
ASSERTION_FAILED, SINGLE_STRING_QUERY_14, salary, expectedSalary);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Field.
*
* <p>This query returns a single field of a single Employee.
*/
public void testQuery14b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expectedSalary = 40000.;
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "firstname == empName")) {
q.setResult("salary");
q.setResultClass(Double.class);
q.declareParameters("String empName");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("empName", "Michael");
q.setNamedParameters(paramValues);
Double salary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(
ASSERTION_FAILED, SINGLE_STRING_QUERY_14, salary, expectedSalary);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Field.
*
* <p>This query returns a single field of a single Employee.
*/
public void testQuery14c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expectedSalary = 40000.;
try (Query<FullTimeEmployee> q =
pm.newQuery(FullTimeEmployee.class, "firstname == empName")) {
q.setResult("salary");
q.setResultClass(Double.class);
q.declareParameters("String empName");
q.setParameters("Michael");
Double salary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(
ASSERTION_FAILED, SINGLE_STRING_QUERY_14, salary, expectedSalary);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Field.
*
* <p>This query returns a single field of a single Employee.
*/
@SuppressWarnings("unchecked")
public void testQuery14d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expectedSalary = 40000.;
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_14)) {
q.setParameters("Michael");
Double salary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(
ASSERTION_FAILED, SINGLE_STRING_QUERY_14, salary, expectedSalary);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Selection of a Single Field.
*
* <p>This query returns a single field of a single Employee.
*/
public void testQuery14f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Double expectedSalary = 40000.;
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
StringExpression empName = q.stringParameter("empName");
q.result(false, cand.salary).filter(cand.firstname.eq(empName));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("empName", "Michael");
q.setParameters(paramValues);
Double salary = q.executeResultUnique(Double.class);
checkQueryResultWithoutOrder(
ASSERTION_FAILED, SINGLE_STRING_QUERY_14, salary, expectedSalary);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Field.
*
* <p>This query selects instances of Employee who make more than the parameter salary and stores
* the result in a user-defined class. Since the default is "distinct this as FullTimeEmployee",
* the field must be named FullTimeEmployee and be of type FullTimeEmployee.
*/
@SuppressWarnings("unchecked")
public void testQuery15a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpWrapper> expected = testQuery15Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > sal")) {
q.setResultClass(EmpWrapper.class);
q.declareParameters("Double sal");
List<EmpWrapper> infos = (List<EmpWrapper>) q.execute(30000.);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_15, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Field.
*
* <p>This query selects instances of Employee who make more than the parameter salary and stores
* the result in a user-defined class. Since the default is "distinct this as FullTimeEmployee",
* the field must be named FullTimeEmployee and be of type FullTimeEmployee.
*/
public void testQuery15b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpWrapper> expected = testQuery15Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > sal")) {
q.setResultClass(EmpWrapper.class);
q.declareParameters("Double sal");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("sal", 30000.);
q.setNamedParameters(paramValues);
List<EmpWrapper> infos = q.executeResultList(EmpWrapper.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_15, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Field.
*
* <p>This query selects instances of Employee who make more than the parameter salary and stores
* the result in a user-defined class. Since the default is "distinct this as FullTimeEmployee",
* the field must be named FullTimeEmployee and be of type FullTimeEmployee.
*/
public void testQuery15c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpWrapper> expected = testQuery15Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > sal")) {
q.setResultClass(EmpWrapper.class);
q.declareParameters("Double sal");
q.setParameters(30000.);
List<EmpWrapper> infos = q.executeResultList(EmpWrapper.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_15, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Field.
*
* <p>This query selects instances of Employee who make more than the parameter salary and stores
* the result in a user-defined class. Since the default is "distinct this as FullTimeEmployee",
* the field must be named FullTimeEmployee and be of type FullTimeEmployee.
*/
@SuppressWarnings("unchecked")
public void testQuery15d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpWrapper> expected = testQuery15Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_15)) {
q.setParameters(30000.);
List<EmpWrapper> infos = q.executeResultList(EmpWrapper.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_15, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Field.
*
* <p>This query selects instances of Employee who make more than the parameter salary and stores
* the result in a user-defined class. Since the default is "distinct this as FullTimeEmployee",
* the field must be named FullTimeEmployee and be of type FullTimeEmployee.
*/
public void testQuery15f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpWrapper> expected = testQuery15Helper();
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
NumericExpression<Double> sal = q.numericParameter("sal", Double.class);
q.result(true, cand.as("FullTimeEmployee")).filter(cand.salary.gt(sal));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("sal", 30000.);
q.setParameters(paramValues);
List<EmpWrapper> infos = q.executeResultList(EmpWrapper.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_15, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Method
*
* <p>This query selects instances of FullTimeEmployee who make more than the parameter salary and
* stores the result in a user-defined class.
*/
@SuppressWarnings("unchecked")
public void testQuery16a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpInfo> expected = testQuery16Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > sal")) {
q.setResultClass(EmpInfo.class);
q.declareParameters("Double sal");
List<EmpInfo> infos = (List<EmpInfo>) q.execute(30000.);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_16, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Method
*
* <p>This query selects instances of FullTimeEmployee who make more than the parameter salary and
* stores the result in a user-defined class.
*/
public void testQuery16b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpInfo> expected = testQuery16Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > sal")) {
q.setResultClass(EmpInfo.class);
q.declareParameters("Double sal");
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("sal", 30000.);
q.setNamedParameters(paramValues);
List<EmpInfo> infos = q.executeResultList(EmpInfo.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_16, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Method
*
* <p>This query selects instances of FullTimeEmployee who make more than the parameter salary and
* stores the result in a user-defined class.
*/
public void testQuery16c() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpInfo> expected = testQuery16Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > sal")) {
q.setResultClass(EmpInfo.class);
q.declareParameters("Double sal");
q.setParameters(30000.);
List<EmpInfo> infos = q.executeResultList(EmpInfo.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_16, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Method
*
* <p>This query selects instances of FullTimeEmployee who make more than the parameter salary and
* stores the result in a user-defined class.
*/
@SuppressWarnings("unchecked")
public void testQuery16d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpInfo> expected = testQuery16Helper();
try (Query<FullTimeEmployee> q = pm.newQuery(SINGLE_STRING_QUERY_16)) {
q.setParameters(30000.);
List<EmpInfo> infos = q.executeResultList(EmpInfo.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_16, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of "this" to User-defined Result Class with Matching Method
*
* <p>This query selects instances of FullTimeEmployee who make more than the parameter salary and
* stores the result in a user-defined class.
*/
public void testQuery16f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<EmpInfo> expected = testQuery16Helper();
try (JDOQLTypedQuery<FullTimeEmployee> q = pm.newJDOQLTypedQuery(FullTimeEmployee.class)) {
QFullTimeEmployee cand = QFullTimeEmployee.candidate();
NumericExpression<Double> sal = q.numericParameter("sal", Double.class);
q.result(true, cand.as("FullTimeEmployee")).filter(cand.salary.gt(sal));
Map<String, Object> paramValues = new HashMap<>();
paramValues.put("sal", 30000.);
q.setParameters(paramValues);
List<EmpInfo> infos = q.executeResultList(EmpInfo.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_16, infos, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of variables.
*
* <p>This query returns the names of all Employees of all "Research" departments.
*/
@SuppressWarnings("unchecked")
public void testQuery17a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig", "Joe");
try (Query<Department> q = pm.newQuery(Department.class)) {
q.declareVariables("org.apache.jdo.tck.pc.company.Employee e");
q.setFilter("name.startsWith('R&D') && employees.contains(e)");
q.setResult("e.firstname");
List<String> names = (List<String>) q.execute();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_17, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of variables.
*
* <p>This query returns the names of all Employees of all "Research" departments.
*/
public void testQuery17b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig", "Joe");
try (Query<Department> q = pm.newQuery(Department.class)) {
q.declareVariables("org.apache.jdo.tck.pc.company.Employee e");
q.setFilter("name.startsWith('R&D') && employees.contains(e)");
q.setResult("e.firstname");
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_17, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of variables.
*
* <p>This query returns the names of all Employees of all "Research" departments.
*/
@SuppressWarnings("unchecked")
public void testQuery17d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig", "Joe");
try (Query<Department> q = pm.newQuery(SINGLE_STRING_QUERY_17)) {
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_17, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of variables.
*
* <p>This query returns the names of all Employees of all "Research" departments.
*/
public void testQuery17e() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig", "Joe");
try (Query<Department> q = pm.newNamedQuery(Department.class, "projectingVariables")) {
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_17, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Projection of variables.
*
* <p>This query returns the names of all Employees of all "Research" departments.
*/
@SuppressWarnings("unchecked")
public void testQuery17f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig", "Joe");
try (JDOQLTypedQuery<Department> q = pm.newJDOQLTypedQuery(Department.class)) {
QDepartment cand = QDepartment.candidate();
QEmployee e = QEmployee.variable("e");
q.filter(cand.name.startsWith("R&D").and(cand.employees.contains(e)))
.result(false, e.firstname);
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_17, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Non-correlated subquery
*
* <p>This query returns names of employees who work more than the average of all employees.
*/
@SuppressWarnings("unchecked")
public void testQuery18a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig");
try (Query<Employee> q = pm.newQuery(Employee.class)) {
Query<Employee> subq = pm.newQuery(Employee.class);
subq.setResult("avg(weeklyhours)");
q.setFilter("this.weeklyhours > average_hours");
q.setResult("this.firstname");
q.addSubquery(subq, "double average_hours", null);
List<String> names = (List<String>) q.execute();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_18, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Non-correlated subquery
*
* <p>This query returns names of employees who work more than the average of all employees.
*/
public void testQuery18b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig");
try (Query<Employee> q = pm.newQuery(Employee.class)) {
Query<Employee> subq = pm.newQuery(Employee.class);
subq.setResult("avg(weeklyhours)");
q.setFilter("this.weeklyhours > average_hours");
q.setResult("this.firstname");
q.addSubquery(subq, "double average_hours", null);
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_18, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Non-correlated subquery
*
* <p>This query returns names of employees who work more than the average of all employees.
*/
@SuppressWarnings("unchecked")
public void testQuery18d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig");
try (Query<Employee> q = pm.newQuery(SINGLE_STRING_QUERY_18)) {
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_18, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Non-correlated subquery
*
* <p>This query returns names of employees who work more than the average of all employees.
*/
public void testQuery18f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael", "Craig");
try (JDOQLTypedQuery<Employee> q = pm.newJDOQLTypedQuery(Employee.class)) {
QEmployee cand = QEmployee.candidate();
JDOQLTypedSubquery<Employee> subquery = q.subquery("e");
QEmployee candsub = QEmployee.candidate("e");
q.result(false, cand.firstname)
.filter(cand.weeklyhours.gt(subquery.selectUnique(candsub.weeklyhours.avg())));
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_18, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Correlated subquery.
*
* <p>This query returns names of employees who work more than the average of employees in the
* same department having the same manager. The candidate collection of the subquery is the
* collection of employees in the department of the candidate employee and the parameter passed to
* the subquery is the manager of the candidate employee.
*/
@SuppressWarnings("unchecked")
public void testQuery19a() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael");
try (Query<Employee> q = pm.newQuery(Employee.class)) {
Query<Employee> subq = pm.newQuery(Employee.class);
subq.setFilter("this.manager == :manager");
subq.setResult("avg(weeklyhours)");
q.setFilter("this.weeklyhours > average_hours");
q.setResult("firstname");
q.addSubquery(subq, "double average_hours", "this.department.employees", "this.manager");
List<String> names = (List<String>) q.execute();
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_19, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Correlated subquery.
*
* <p>This query returns names of employees who work more than the average of employees in the
* same department having the same manager. The candidate collection of the subquery is the
* collection of employees in the department of the candidate employee and the parameter passed to
* the subquery is the manager of the candidate employee.
*/
public void testQuery19b() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael");
try (Query<Employee> q = pm.newQuery(Employee.class)) {
Query<Employee> subq = pm.newQuery(Employee.class);
subq.setFilter("this.manager == :manager");
subq.setResult("avg(weeklyhours)");
q.setFilter("this.weeklyhours > average_hours");
q.setResult("firstname");
q.addSubquery(subq, "double average_hours", "this.department.employees", "this.manager");
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_19, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Correlated subquery.
*
* <p>This query returns names of employees who work more than the average of employees in the
* same department having the same manager. The candidate collection of the subquery is the
* collection of employees in the department of the candidate employee and the parameter passed to
* the subquery is the manager of the candidate employee.
*/
@SuppressWarnings("unchecked")
public void testQuery19d() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael");
try (Query<Employee> q = pm.newQuery(SINGLE_STRING_QUERY_19)) {
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_19, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Correlated subquery.
*
* <p>This query returns names of employees who work more than the average of employees in the
* same department having the same manager. The candidate collection of the subquery is the
* collection of employees in the department of the candidate employee and the parameter passed to
* the subquery is the manager of the candidate employee.
*/
@SuppressWarnings("unchecked")
public void testQuery19f() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
List<String> expected = Arrays.asList("Michael");
try (JDOQLTypedQuery<Employee> q = pm.newJDOQLTypedQuery(Employee.class)) {
QEmployee cand = QEmployee.candidate();
JDOQLTypedSubquery<Employee> subquery =
q.subquery(cand.department.employees, Employee.class, "e");
QEmployee candsub = QEmployee.candidate("e");
subquery.filter(candsub.manager.eq(cand.manager));
q.result(false, cand.firstname)
.filter(cand.weeklyhours.gt(subquery.selectUnique(candsub.weeklyhours.avg())));
List<String> names = q.executeResultList(String.class);
checkQueryResultWithoutOrder(ASSERTION_FAILED, SINGLE_STRING_QUERY_19, names, expected);
} catch (Exception ex) {
fail(ASSERTION_FAILED, ex.getLocalizedMessage());
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
/**
* Deleting Multiple Instances.
*
* <p>This query deletes all Employees who make more than the parameter salary.
*/
public void testQuery20() {
Transaction tx = pm.currentTransaction();
try {
tx.begin();
Query<FullTimeEmployee> empQuery = pm.newQuery(FullTimeEmployee.class, "personid == 5");
empQuery.setUnique(true);
FullTimeEmployee emp5 = empQuery.executeUnique();
Object emp5Oid = pm.getObjectId(emp5);
Query<FullTimeEmployee> q = pm.newQuery(FullTimeEmployee.class, "salary > sal");
q.declareParameters("Double sal");
q.deletePersistentAll(30000.);
tx.commit();
tx.begin();
Query<FullTimeEmployee> allQuery = pm.newQuery(FullTimeEmployee.class);
List<FullTimeEmployee> allFTE = allQuery.executeList();
if (!allFTE.isEmpty()) {
fail(
ASSERTION_FAILED,
"All FullTimeEmployee instances should have been deleted,"
+ " there are still "
+ allFTE.size()
+ " instances left.");
}
tx.commit();
} finally {
if (tx.isActive()) {
tx.rollback();
}
}
}
private List<Info> testQuery08Helper() {
Info info1 = new Info();
info1.firstname = "Michael";
info1.salary = 40000.;
info1.reportsTo = getTransientCompanyModelInstance(Employee.class, "emp2");
Info info2 = new Info();
info2.firstname = "Craig";
info2.salary = 50000.;
info2.reportsTo = null;
return Arrays.asList(info1, info2);
}
private List<EmpWrapper> testQuery15Helper() {
EmpWrapper wrapper1 = new EmpWrapper();
wrapper1.FullTimeEmployee = getTransientCompanyModelInstance(FullTimeEmployee.class, "emp1");
EmpWrapper wrapper2 = new EmpWrapper();
wrapper2.FullTimeEmployee = getTransientCompanyModelInstance(FullTimeEmployee.class, "emp2");
EmpWrapper wrapper3 = new EmpWrapper();
wrapper3.FullTimeEmployee = getTransientCompanyModelInstance(FullTimeEmployee.class, "emp5");
return Arrays.asList(wrapper1, wrapper2, wrapper3);
}
private List<EmpInfo> testQuery16Helper() {
EmpInfo info1 = new EmpInfo();
info1.setFullTimeEmployee(getTransientCompanyModelInstance(FullTimeEmployee.class, "emp1"));
EmpInfo info2 = new EmpInfo();
info2.setFullTimeEmployee(getTransientCompanyModelInstance(FullTimeEmployee.class, "emp2"));
EmpInfo info3 = new EmpInfo();
info3.setFullTimeEmployee(getTransientCompanyModelInstance(FullTimeEmployee.class, "emp5"));
return Arrays.asList(info1, info2, info3);
}
public static class Info {
public String firstname;
public Double salary;
public Person reportsTo;
public Info() {}
public Info(String firstname, Double salary, Person reportsTo) {
this.firstname = firstname;
this.salary = salary;
this.reportsTo = reportsTo;
}
public boolean equals(Object obj) {
if (!(obj instanceof Info)) {
return false;
}
Info other = (Info) obj;
if (!EqualityHelper.equals(firstname, other.firstname)) {
return false;
}
if (!EqualityHelper.equals(salary, other.salary)) {
return false;
}
if (!EqualityHelper.equals(reportsTo, other.reportsTo)) {
return false;
}
return true;
}
public int hashCode() {
int hashCode = 0;
hashCode += firstname == null ? 0 : firstname.hashCode();
hashCode += salary == null ? 0 : salary.hashCode();
hashCode += reportsTo == null ? 0 : reportsTo.hashCode();
return hashCode;
}
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Info(");
builder.append("firstname:").append(firstname);
builder.append(", salary:").append(salary);
builder.append(", reportsTo:").append(reportsTo == null ? "null" : reportsTo.getFirstname());
builder.append(")");
return builder.toString();
}
}
public static class EmpWrapper {
public FullTimeEmployee FullTimeEmployee;
public EmpWrapper() {}
// Need constructor to prevent
// java.lang.NullPointerException
// at
// org.datanucleus.query.QueryUtils.createResultObjectUsingDefaultConstructorAndSetters(QueryUtils.java:293)
public EmpWrapper(FullTimeEmployee FullTimeEmployee) {
this.FullTimeEmployee = FullTimeEmployee;
}
public boolean equals(Object obj) {
if (!(obj instanceof EmpWrapper)) {
return false;
}
EmpWrapper other = (EmpWrapper) obj;
if (!EqualityHelper.equals(FullTimeEmployee, other.FullTimeEmployee)) {
return false;
}
return true;
}
public int hashCode() {
int hashCode = 0;
hashCode += FullTimeEmployee == null ? 0 : FullTimeEmployee.hashCode();
return hashCode;
}
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("EmpWrapper(");
builder
.append("FullTimeEmployee:")
.append(FullTimeEmployee == null ? "null" : FullTimeEmployee.getFirstname());
builder.append(")");
return builder.toString();
}
}
public static class EmpInfo {
private FullTimeEmployee worker;
public EmpInfo() {}
// Need constructor to prevent
// java.lang.NullPointerException
// at
// org.datanucleus.query.QueryUtils.createResultObjectUsingDefaultConstructorAndSetters(QueryUtils.java:293)
public EmpInfo(FullTimeEmployee worker) {
this.worker = worker;
}
public FullTimeEmployee getWorker() {
return worker;
}
public void setFullTimeEmployee(FullTimeEmployee e) {
worker = e;
}
public boolean equals(Object obj) {
if (!(obj instanceof EmpInfo)) {
return false;
}
EmpInfo other = (EmpInfo) obj;
if (!EqualityHelper.equals(worker, other.worker)) {
return false;
}
return true;
}
public int hashCode() {
int hashCode = 0;
hashCode += worker == null ? 0 : worker.hashCode();
return hashCode;
}
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("EmpInfo(");
builder.append("worker:").append(worker == null ? "null" : worker.getFirstname());
builder.append(")");
return builder.toString();
}
}
/**
* @see org.apache.jdo.tck.JDO_Test#localSetUp()
*/
@Override
protected void localSetUp() {
addTearDownClass(CompanyModelReader.getTearDownClasses());
loadAndPersistCompanyModel(getPM());
}
/**
* Returns the name of the company test data resource.
*
* @return name of the company test data resource.
*/
@Override
protected String getCompanyTestDataResource() {
return SAMPLE_QUERIES_TEST_COMPANY_TESTDATA;
}
}