| /******************************************************************************* | |
| * Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved. | |
| * This program and the accompanying materials are made available under the | |
| * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
| * which accompanies this distribution. | |
| * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
| * and the Eclipse Distribution License is available at | |
| * http://www.eclipse.org/org/documents/edl-v10.php. | |
| * | |
| * Contributors: | |
| * Oracle - initial API and implementation from Oracle TopLink | |
| ******************************************************************************/ | |
| package org.eclipse.persistence.testing.tests.queries.optimization; | |
| import java.util.List; | |
| import org.eclipse.persistence.tools.schemaframework.PopulationManager; | |
| import org.eclipse.persistence.queries.*; | |
| import org.eclipse.persistence.annotations.BatchFetchType; | |
| import org.eclipse.persistence.expressions.*; | |
| import org.eclipse.persistence.testing.framework.*; | |
| import org.eclipse.persistence.testing.models.employee.domain.*; | |
| import org.eclipse.persistence.testing.models.inheritance.Engineer; | |
| import org.eclipse.persistence.testing.models.ownership.ObjectA; | |
| /** | |
| * Test query optimization features, joining, batch reading, partial object reading. | |
| */ | |
| @SuppressWarnings("deprecation") | |
| public class QueryOptimizationTestSuite extends TestSuite { | |
| public QueryOptimizationTestSuite() { | |
| setDescription("This suite tests query optimization, aggregation and batch reading."); | |
| } | |
| public void addBatchTests() { | |
| addBatchTests(BatchFetchType.JOIN); | |
| addBatchTests(BatchFetchType.EXISTS); | |
| addBatchTests(BatchFetchType.IN); | |
| } | |
| public void addBatchTests(BatchFetchType batchType) { | |
| // Batch reading | |
| ReadAllBatchReadingTest testbb1 = new ReadAllBatchReadingTest(12); | |
| testbb1.setName("ReadAllBatchReadingTestAddressManager" + batchType); | |
| ReadAllQuery querybb1 = new ReadAllQuery(); | |
| querybb1.setBatchFetchType(batchType); | |
| querybb1.setReferenceClass(Employee.class); | |
| querybb1.addBatchReadAttribute("address"); | |
| querybb1.addBatchReadAttribute("manager"); | |
| querybb1.addBatchReadAttribute("phoneNumbers"); | |
| querybb1.addBatchReadAttribute("projects"); | |
| querybb1.addBatchReadAttribute("responsibilitiesList"); | |
| testbb1.setQuery(querybb1); | |
| addTest(testbb1); | |
| ReadAllBatchReadingTest testbb2 = new ReadAllBatchReadingTest(2); | |
| testbb2.setName("ReadAllBatchReadingTestWhereAddressManager" + batchType); | |
| ReadAllQuery querybb2 = new ReadAllQuery(); | |
| querybb2.setBatchFetchType(batchType); | |
| querybb2.setReferenceClass(Employee.class); | |
| querybb2.addBatchReadAttribute("address"); | |
| querybb2.addBatchReadAttribute("manager"); | |
| querybb2.addBatchReadAttribute("phoneNumbers"); | |
| querybb2.addBatchReadAttribute("projects"); | |
| querybb2.addBatchReadAttribute("responsibilitiesList"); | |
| querybb2.setSelectionCriteria(new org.eclipse.persistence.expressions.ExpressionBuilder().get("lastName").equal("Way")); | |
| testbb2.setQuery(querybb2); | |
| addTest(testbb2); | |
| //add the BatchReadingUnitOfWorkTest and BatchReadingUnitOfWorkInTransactionTest | |
| BatchReadingUnitOfWorkTest testbb3 = new BatchReadingUnitOfWorkTest(batchType); | |
| addTest(testbb3); | |
| BatchReadingUnitOfWorkInTransactionTest testbb4 = new BatchReadingUnitOfWorkInTransactionTest(batchType); | |
| addTest(testbb4); | |
| //adding the OneToMany tests | |
| OneToManyBatchReadingTest testbb5 = new OneToManyBatchReadingTest(batchType); | |
| addTest(testbb5); | |
| addTest(new BatchReadingTest(batchType)); | |
| OneToManyBatchReadingCustomSelectionQueryTest testbb6 = new OneToManyBatchReadingCustomSelectionQueryTest(batchType); | |
| addTest(testbb6); | |
| ReadAllBatchReadingTest test3 = new ReadAllBatchReadingTest(2); | |
| test3.setName("ReadAllBatchReadingTestWhereAddressManager-cursor" + batchType); | |
| ReadAllQuery query3 = new ReadAllQuery(); | |
| query3.setBatchFetchType(batchType); | |
| query3.setReferenceClass(Employee.class); | |
| query3.useCursoredStream(); | |
| query3.addBatchReadAttribute("address"); | |
| query3.addBatchReadAttribute("manager"); | |
| query3.addBatchReadAttribute("phoneNumbers"); | |
| query3.addBatchReadAttribute("projects"); | |
| querybb1.addBatchReadAttribute("responsibilitiesList"); | |
| query3.setSelectionCriteria(new org.eclipse.persistence.expressions.ExpressionBuilder().get("lastName").equal("Way")); | |
| test3.setQuery(query3); | |
| addTest(test3); | |
| NestedOneToManyBatchReadAllTest test3_5 = new NestedOneToManyBatchReadAllTest(org.eclipse.persistence.testing.models.collections.Restaurant.class, 15); | |
| test3_5.setName("NestedOneToManyBatchReadAllTest" + batchType); | |
| ReadAllQuery query3_5 = new ReadAllQuery(); | |
| query3_5.setBatchFetchType(batchType); | |
| query3_5.setReferenceClass(org.eclipse.persistence.testing.models.collections.Restaurant.class); | |
| query3_5.addBatchReadAttribute("menus"); | |
| test3_5.setQuery(query3_5); | |
| addTest(test3_5); | |
| //Batch testing on 1-1 mapping | |
| ReadAllTest test4 = new ReadAllTest(org.eclipse.persistence.testing.models.insurance.Policy.class, 3); | |
| test4.setName("ReadAllBatchReadingTestPolicyHolder" + batchType); | |
| ReadAllQuery query4 = new ReadAllQuery(); | |
| query4.setBatchFetchType(batchType); | |
| query4.setReferenceClass(org.eclipse.persistence.testing.models.insurance.Policy.class); | |
| query4.addBatchReadAttribute("policyHolder"); | |
| query4.setSelectionCriteria(new org.eclipse.persistence.expressions.ExpressionBuilder().get("maxCoverage").greaterThan(40000)); | |
| test4.setQuery(query4); | |
| addTest(test4); | |
| addTest(new OneToOneBatchReadingTest(batchType)); | |
| // Batch testing on 1-M mapping. | |
| ReadAllTest test5 = new ReadAllTest(org.eclipse.persistence.testing.models.insurance.Policy.class, 4); | |
| test5.setName("ReadAllBatchReadingTestClaim" + batchType); | |
| ReadAllQuery query5 = new ReadAllQuery(); | |
| query5.setBatchFetchType(batchType); | |
| query5.setReferenceClass(org.eclipse.persistence.testing.models.insurance.Policy.class); | |
| query5.addBatchReadAttribute("claims"); | |
| query5.setSelectionCriteria(new org.eclipse.persistence.expressions.ExpressionBuilder().get("maxCoverage").greaterThan(30000)); | |
| test5.setQuery(query5); | |
| addTest(test5); | |
| addTest(new OneToManyBatchReadingTest(batchType)); | |
| addTest(new NestedBatchReadingTest(batchType)); | |
| addTest(new NestedBatchReadingNPETest(batchType)); | |
| addTest(new AggregateBatchReadingTest(batchType)); | |
| addTest(new BatchReadingBatchReadExpressionTest(batchType)); | |
| addTest(new BatchReadingWithInvalidQueryKeyTest(batchType)); | |
| addTest(new BatchReadValueholderTest(batchType)); | |
| addTest(new BatchReadingStackOverflowTest(batchType)); | |
| } | |
| public void addJoinTests() { | |
| PopulationManager manager = PopulationManager.getDefaultManager(); | |
| Employee object = (Employee)manager.getObject(Employee.class, "0002"); | |
| // Joining | |
| ReadObjectTest test = new ReadObjectTest(object); | |
| test.setName("JoiningReadObjectTestAddress"); | |
| ReadObjectQuery query = new ReadObjectQuery(); | |
| query.setSelectionObject(object); | |
| query.addJoinedAttribute("address"); | |
| test.setQuery(query); | |
| addTest(test); | |
| ReadObjectTest test1a = new ReadObjectTest(object); | |
| test1a.setName("JoiningReadObjectTestAddressManager"); | |
| ReadObjectQuery query1a = new ReadObjectQuery(); | |
| query1a.setSelectionObject(object); | |
| query1a.addJoinedAttribute("address"); | |
| query1a.addJoinedAttribute("manager"); | |
| test1a.setQuery(query1a); | |
| addTest(test1a); | |
| ReadObjectTest test1m = new ReadObjectTest(object); | |
| test1m.setName("JoiningReadObjectTestPhones"); | |
| ReadObjectQuery query1m = new ReadObjectQuery(); | |
| query1m.setSelectionObject(object); | |
| query1m.addJoinedAttribute(query1m.getExpressionBuilder().anyOf("phoneNumbers")); | |
| test1m.setQuery(query1m); | |
| addTest(test1m); | |
| test1m = new ReadObjectTest(object); | |
| test1m.setName("JoiningReadObjectTestPhonesOuter"); | |
| query1m = new ReadObjectQuery(); | |
| query1m.setSelectionObject(object); | |
| query1m.addJoinedAttribute(query1m.getExpressionBuilder().anyOfAllowingNone("phoneNumbers")); | |
| test1m.setQuery(query1m); | |
| addTest(test1m); | |
| addTest(new ReadAnyObjectJoinPhoneTest()); | |
| Object person = manager.getObject(Engineer.class, "example2"); | |
| ReadObjectTest test1b = new ReadObjectTest(person); | |
| test1b.setName("JoiningInheritanceRelationshipTest"); | |
| ReadObjectQuery query1b = new ReadObjectQuery(); | |
| query1b.setSelectionObject(person); | |
| query1b.addJoinedAttribute("bestFriend"); | |
| query1b.addJoinedAttribute("representitive"); | |
| test1b.setQuery(query1b); | |
| addTest(test1b); | |
| ReadObjectTest test1bx = new ReadObjectTest(person); | |
| test1bx.setName("NestedJoiningInheritanceRelationshipTest"); | |
| ReadObjectQuery query1bx = new ReadObjectQuery(); | |
| query1bx.setSelectionObject(person); | |
| query1bx.addJoinedAttribute(query1bx.getExpressionBuilder().get("bestFriend")); | |
| query1bx.addJoinedAttribute(query1bx.getExpressionBuilder().get("bestFriend").getAllowingNull("bestFriend")); | |
| query1bx.addJoinedAttribute(query1bx.getExpressionBuilder().get("bestFriend").getAllowingNull("representitive")); | |
| query1bx.addJoinedAttribute(query1bx.getExpressionBuilder().get("representitive")); | |
| test1bx.setQuery(query1bx); | |
| addTest(test1bx); | |
| ReadObjectTest test1c = new ReadObjectTest(object); | |
| test1c.setName("JoiningReadObjectTestAddressManagerManager"); | |
| ReadObjectQuery query1c = new ReadObjectQuery(); | |
| query1c.setSelectionObject(object); | |
| query1c.addJoinedAttribute("address"); | |
| query1c.addJoinedAttribute("manager"); | |
| query1c.addJoinedAttribute(query1c.getExpressionBuilder().get("manager").get("manager")); | |
| test1c.setQuery(query1c); | |
| addTest(test1c); | |
| ReadAllTest test2 = new ReadAllTest(Employee.class, 12); | |
| test2.setName("JoiningReadAllTestAddress"); | |
| ReadAllQuery query2 = new ReadAllQuery(); | |
| query2.setReferenceClass(Employee.class); | |
| query2.addJoinedAttribute("address"); | |
| query2.addJoinedAttribute(query2.getExpressionBuilder().getAllowingNull("manager")); | |
| test2.setQuery(query2); | |
| addTest(test2); | |
| ReadAllTest testReadAll1m = new ReadAllTest(Employee.class, 12); | |
| testReadAll1m.setName("JoiningReadAllTestPhones"); | |
| ReadAllQuery queryReadAll1m = new ReadAllQuery(); | |
| queryReadAll1m.setReferenceClass(Employee.class); | |
| queryReadAll1m.addJoinedAttribute(queryReadAll1m.getExpressionBuilder().anyOf("phoneNumbers")); | |
| testReadAll1m.setQuery(queryReadAll1m); | |
| addTest(testReadAll1m); | |
| ReadAllTest testReadAll21m = new ReadAllTest(Employee.class, 5); | |
| testReadAll21m.setName("JoiningReadAllTestPhonesManagedEmployeesPhones"); | |
| ReadAllQuery queryReadAll21m = new ReadAllQuery(); | |
| queryReadAll21m.setReferenceClass(Employee.class); | |
| Expression managedEmployee = queryReadAll21m.getExpressionBuilder().anyOf("managedEmployees"); | |
| queryReadAll21m.addJoinedAttribute(queryReadAll21m.getExpressionBuilder().anyOf("phoneNumbers")); | |
| queryReadAll21m.addJoinedAttribute(managedEmployee); | |
| queryReadAll21m.addJoinedAttribute(managedEmployee.anyOf("phoneNumbers")); | |
| testReadAll21m.setQuery(queryReadAll21m); | |
| addTest(testReadAll21m); | |
| ReadAllTest test2a = new ReadAllTest(Employee.class, 2); | |
| test2a.setName("JoiningReadAllTestWhereLastNameWay"); | |
| ReadAllQuery query2a = new ReadAllQuery(); | |
| query2a.setReferenceClass(Employee.class); | |
| query2a.addJoinedAttribute("address"); | |
| query2a.setSelectionCriteria(new ExpressionBuilder().get("lastName").equal("Way")); | |
| test2a.setQuery(query2a); | |
| addTest(test2a); | |
| ReadObjectTest test2az = new ReadObjectTest(object); | |
| test2az.setName("JoiningReadObjectTestCustomSQL"); | |
| ReadObjectQuery query2az = new ReadObjectQuery(); | |
| query2az.setReferenceClass(Employee.class); | |
| query2az.addJoinedAttribute("address"); | |
| query2az.setSQLString("Select * from EMPLOYEE E, SALARY S, ADDRESS A WHERE E.EMP_ID = S.EMP_ID AND E.ADDR_ID = A.ADDRESS_ID AND E.EMP_ID = " + object.getId()); | |
| test2az.setQuery(query2az); | |
| addTest(test2az); | |
| ReadAllTest test2ax = new ReadAllTest(Employee.class, 2); | |
| test2ax.setName("JoiningReadAllTestCustomSQL"); | |
| ReadAllQuery query2ax = new ReadAllQuery(); | |
| query2ax.setReferenceClass(Employee.class); | |
| query2ax.addJoinedAttribute("address"); | |
| query2ax.setSQLString("Select * from EMPLOYEE E, SALARY S, ADDRESS A WHERE E.EMP_ID = S.EMP_ID AND E.ADDR_ID = A.ADDRESS_ID AND E.L_NAME = 'Way'"); | |
| test2ax.setQuery(query2ax); | |
| addTest(test2ax); | |
| ReadAllTest test2aa = new ReadAllTest(Employee.class, 2); | |
| test2aa.setName("JoiningReadAllTestWhereLastNameWay-cursor"); | |
| ReadAllQuery query2aa = new ReadAllQuery(); | |
| query2aa.setReferenceClass(Employee.class); | |
| query2aa.useCursoredStream(); | |
| query2aa.addJoinedAttribute("address"); | |
| query2aa.setSelectionCriteria(new org.eclipse.persistence.expressions.ExpressionBuilder().get("lastName").equal("Way")); | |
| test2aa.setQuery(query2aa); | |
| addTest(test2aa); | |
| ReadAllJoinReadingTest test2b = new ReadAllJoinReadingTest(3, "teamLeader-address"); | |
| ReadAllQuery query2b = new ReadAllQuery(); | |
| query2b.setReferenceClass(LargeProject.class); | |
| query2b.addJoinedAttribute(query2b.getExpressionBuilder().get("teamLeader")); | |
| query2b.addJoinedAttribute(query2b.getExpressionBuilder().get("teamLeader").get("address")); | |
| test2b.setQuery(query2b); | |
| addTest(test2b); | |
| ReadAllTest ownerTest = new ReadAllTest(ObjectA.class, 3); | |
| ownerTest.setName("JoinOwnerA-oneToOne-oneToMany"); | |
| ReadAllQuery ownerQuery = new ReadAllQuery(); | |
| ownerQuery.setReferenceClass(ObjectA.class); | |
| ownerQuery.addJoinedAttribute(ownerQuery.getExpressionBuilder().get("oneToOne")); | |
| ownerQuery.addJoinedAttribute(ownerQuery.getExpressionBuilder().get("oneToOne").anyOf("oneToMany")); | |
| ownerTest.setQuery(ownerQuery); | |
| addTest(ownerTest); | |
| ReadAllTest ownerTest3 = new ReadAllTest(ObjectA.class, 3); | |
| ownerTest3.setName("JoinOwnerA-oneToOne-oneToMany-oneToOne"); | |
| ReadAllQuery ownerQuery3 = new ReadAllQuery(); | |
| ownerQuery3.setReferenceClass(ObjectA.class); | |
| ownerQuery3.addJoinedAttribute(ownerQuery.getExpressionBuilder().get("oneToOne")); | |
| Expression join = ownerQuery.getExpressionBuilder().get("oneToOne").anyOf("oneToMany"); | |
| ownerQuery3.addJoinedAttribute(join); | |
| ownerQuery3.addJoinedAttribute(join.get("oneToOne")); | |
| ownerTest3.setQuery(ownerQuery3); | |
| addTest(ownerTest3); | |
| ReadAllTest ownerTest2 = new ReadAllTest(ObjectA.class, 3); | |
| ownerTest2.setName("JoinOwnerA-oneToOne(mapping)"); | |
| ReadAllQuery ownerQuery2 = new ReadAllQuery(); | |
| ownerQuery2.setReferenceClass(ObjectA.class); | |
| ownerTest2.setQuery(ownerQuery2); | |
| addTest(ownerTest2); | |
| ReadAllTest test3 = new ReadAllTest(LargeProject.class, 3); | |
| ReadAllQuery query3 = new ReadAllQuery(); | |
| query3.setReferenceClass(LargeProject.class); | |
| query3.useCursoredStream(); | |
| query3.addJoinedAttribute(query3.getExpressionBuilder().get("teamLeader")); | |
| query3.addJoinedAttribute(query3.getExpressionBuilder().get("teamLeader").get("address")); | |
| test3.setQuery(query3); | |
| addTest(test3); | |
| addTest(new ReadObjectMappingJoinReadingTest()); | |
| addTest(new MultipleJoinedAttributeQueryTest()); | |
| addTest(new ComplexJoinedAttributeQueryTest()); | |
| } | |
| public void addPartialTests() { | |
| // Partial objects | |
| ReadAllPartialReadingTest test3 = new ReadAllPartialReadingTest(12, "fisrtName"); | |
| test3.setName("ReadAllPartialReadingTest-firstName,salary"); | |
| ReadAllQuery query3 = new ReadAllQuery(); | |
| query3.setReferenceClass(Employee.class); | |
| query3.dontMaintainCache(); | |
| query3.addPartialAttribute("firstName"); | |
| query3.addPartialAttribute("salary"); | |
| test3.setQuery(query3); | |
| addTest(test3); | |
| ReadAllPartialReadingTest test4 = new ReadAllPartialReadingTest(1, "address"); | |
| test4.setName("ReadAllPartialReadingTest-address,period"); | |
| ReadAllQuery query4 = new ReadAllQuery(); | |
| query4.setReferenceClass(Employee.class); | |
| query4.dontMaintainCache(); | |
| query4.addPartialAttribute("address"); | |
| query4.addPartialAttribute("period"); | |
| query4.setSelectionCriteria(new org.eclipse.persistence.expressions.ExpressionBuilder().get("address").get("city").equal("Ottawa")); | |
| test4.setQuery(query4); | |
| addTest(test4); | |
| ReadAllPartialReadingTest test5 = new ReadAllPartialReadingTest(12, "city"); | |
| test5.setName("ReadAllPartialReadingTest-city,salary"); | |
| ReadAllQuery query5 = new ReadAllQuery(); | |
| query5.setReferenceClass(Employee.class); | |
| query5.dontMaintainCache(); | |
| query5.addPartialAttribute(query5.getExpressionBuilder().get("address").get("city")); | |
| query5.addPartialAttribute("salary"); | |
| test5.setQuery(query5); | |
| addTest(test5); | |
| ReadAllPartialReadingTest test6 = new ReadAllPartialReadingTest(12, "city"); | |
| test6.setName("ReadAllPartialReadingTest-city,salary-cursor"); | |
| ReadAllQuery query6 = new ReadAllQuery(); | |
| query6.useCursoredStream(); | |
| query6.setReferenceClass(Employee.class); | |
| query6.dontMaintainCache(); | |
| query6.addPartialAttribute(query6.getExpressionBuilder().get("address").get("city")); | |
| query6.addPartialAttribute("salary"); | |
| test6.setQuery(query6); | |
| addTest(test6); | |
| ReadAllPartialReadingTest test1m = new ReadAllPartialReadingTest(12, "areaCode"); | |
| test1m.setName("ReadAllPartialReadingTest-type-areaCode"); | |
| ReadAllQuery query1m = new ReadAllQuery(); | |
| query1m.setReferenceClass(Employee.class); | |
| query1m.dontMaintainCache(); | |
| Expression phones = query1m.getExpressionBuilder().anyOf("phoneNumbers"); | |
| query1m.addPartialAttribute(phones.get("id")); | |
| query1m.addPartialAttribute(phones.get("type")); | |
| query1m.addPartialAttribute(phones.get("areaCode")); | |
| test1m.setQuery(query1m); | |
| addTest(test1m); | |
| ReadAllTest test9 = new ReadAllTest(Employee.class, 12); | |
| test9.setName("ReadAllPartialReadingTest-PolicyMaxCoverage"); | |
| ReadAllQuery query9 = new ReadAllQuery(); | |
| query9.setReferenceClass(Employee.class); | |
| query9.dontMaintainCache(); | |
| query9.addPartialAttribute("normalHours"); | |
| //query9.addPartialAttribute("policyHolder"); | |
| test9.setQuery(query9); | |
| addTest(test9); | |
| ReadAllPartialReadingTest test10 = new ReadAllPartialReadingTest(12, "id"); | |
| test10.setName("ReadAllPartialReadingTest-id-SelectPrimaryKey"); | |
| ReadAllQuery query10 = new ReadAllQuery(); | |
| query10.setReferenceClass(Employee.class); | |
| query10.dontMaintainCache(); | |
| query10.addPartialAttribute("id"); | |
| test10.setQuery(query10); | |
| addTest(test10); | |
| ReadAllPartialReadingTest test11 = new ReadAllPartialReadingTest(12, "firstName"); | |
| test11.setName("ReadAllPartialReadingTest-firstName-OrderByPrimaryKey"); | |
| ReadAllQuery query11 = new ReadAllQuery(); | |
| query11.setReferenceClass(Employee.class); | |
| query11.dontMaintainCache(); | |
| query11.addPartialAttribute("firstName"); | |
| query11.addAscendingOrdering("id"); | |
| test11.setQuery(query11); | |
| addTest(test11); | |
| ReadAllPartialReadingTest test12 = new ReadAllPartialReadingTest(12, "id"); | |
| test12.setName("ReadAllPartialReadingTest-firstName-SelectAndOrderByPrimaryKey"); | |
| ReadAllQuery query12 = new ReadAllQuery(); | |
| query12.setReferenceClass(Employee.class); | |
| query12.dontMaintainCache(); | |
| query12.addPartialAttribute("id"); | |
| query12.addAscendingOrdering("id"); | |
| test12.setQuery(query12); | |
| addTest(test12); | |
| ReadAllPartialReadingAddressTest test14 = new ReadAllPartialReadingAddressTest(12, "id"); | |
| test14.setName("ReadAllPartialReadingAddressTest - Address - SelectDistinctAndOrderByPrimaryKey"); | |
| ReadAllQuery query14 = new ReadAllQuery(); | |
| query14.setReferenceClass(Address.class); | |
| query14.dontMaintainCache(); | |
| query14.addPartialAttribute("id"); | |
| query14.addAscendingOrdering("id"); | |
| query14.useDistinct(); | |
| test14.setQuery(query14); | |
| addTest(test14); | |
| ReadAllPartialReadingAddressTest test15 = new ReadAllPartialReadingAddressTest(12, "id"); | |
| test15.setName("ReadAllPartialReadingAddressTest - Employee - SelectAddressId"); | |
| ReadAllQuery query15 = new ReadAllQuery(); | |
| query15.setReferenceClass(Employee.class); | |
| query15.dontMaintainCache(); | |
| query15.addPartialAttribute("id"); | |
| query15.addPartialAttribute(new org.eclipse.persistence.expressions.ExpressionBuilder().get("address").get("id")); | |
| test15.setQuery(query15); | |
| addTest(test15); | |
| ReadAllPartialReadingAddressTest test16 = new ReadAllPartialReadingAddressTest(26, "id"); | |
| test16.setName("ReadAllPartialReadingAddressTest - PhoneNumber - Employee - SelectAddressId"); | |
| ReadAllQuery query16 = new ReadAllQuery(); | |
| query16.setReferenceClass(PhoneNumber.class); | |
| query16.dontMaintainCache(); | |
| query16.useDistinct(); | |
| query16.addPartialAttribute(new org.eclipse.persistence.expressions.ExpressionBuilder().get("owner").get("address").get("id")); | |
| test16.setQuery(query16); | |
| addTest(test16); | |
| addTest(new QueryValidationTest()); | |
| } | |
| public void addTests() { | |
| addJoinTests(); | |
| addBatchTests(); | |
| addPartialTests(); | |
| addTest(new ReadAllBindAllParametersTest()); | |
| addTest(buildBatch1mTest()); | |
| } | |
| public TestCase buildBatch1mTest() { | |
| TestCase test = new TestCase() { | |
| public void test() { | |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
| ReadAllQuery query = new ReadAllQuery(); | |
| query.setReferenceClass(Employee.class); | |
| Expression rootExpression = query.getExpressionBuilder(); | |
| Expression filterPart1 = | |
| rootExpression.anyOfAllowingNone("phoneNumbers") | |
| .getAllowingNull("owner").get("firstName").like("%"); | |
| Expression filterPart2 = | |
| rootExpression.anyOfAllowingNone("phoneNumbers") | |
| .get("number").like("%"); | |
| query.setSelectionCriteria(filterPart1.and(filterPart2)); | |
| Expression expression = rootExpression.getAllowingNull("address"); | |
| query.addBatchReadAttribute(expression); | |
| Expression expression2 = rootExpression.getAllowingNull("phoneNumbers"); | |
| query.addBatchReadAttribute(expression2); | |
| List<Employee> result = (List<Employee>) getSession().executeQuery(query); | |
| result.get(0).getPhoneNumbers().size(); | |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
| for (Employee employee : result) { | |
| if (!compareObjects(employee, getSession().readObject(employee))) { | |
| throwError("Employeee does not match:" + employee); | |
| } | |
| } | |
| } | |
| }; | |
| test.setName("Batch1mTest"); | |
| return test; | |
| } | |
| } |