/******************************************************************************* | |
* 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.workbenchintegration; | |
import java.sql.Date; | |
import java.util.Calendar; | |
import java.util.GregorianCalendar; | |
import java.util.Map; | |
import org.eclipse.persistence.descriptors.ClassDescriptor; | |
import org.eclipse.persistence.descriptors.DescriptorQueryManager; | |
import org.eclipse.persistence.descriptors.invalidation.DailyCacheInvalidationPolicy; | |
import org.eclipse.persistence.descriptors.invalidation.NoExpiryCacheInvalidationPolicy; | |
import org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy; | |
import org.eclipse.persistence.expressions.Expression; | |
import org.eclipse.persistence.expressions.ExpressionBuilder; | |
import org.eclipse.persistence.queries.DataReadQuery; | |
import org.eclipse.persistence.queries.DatabaseQuery; | |
import org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy; | |
import org.eclipse.persistence.queries.QueryResultsCachePolicy; | |
import org.eclipse.persistence.queries.ReadAllQuery; | |
import org.eclipse.persistence.queries.ReadObjectQuery; | |
import org.eclipse.persistence.queries.ReportQuery; | |
import org.eclipse.persistence.sessions.Project; | |
import org.eclipse.persistence.testing.framework.TestExecutor; | |
import org.eclipse.persistence.testing.models.employee.domain.Address; | |
import org.eclipse.persistence.testing.models.employee.domain.Employee; | |
import org.eclipse.persistence.testing.models.employee.domain.LargeProject; | |
import org.eclipse.persistence.testing.models.employee.domain.PhoneNumber; | |
import org.eclipse.persistence.testing.models.employee.domain.SmallProject; | |
import org.eclipse.persistence.testing.models.employee.relational.EmployeeProject; | |
import org.eclipse.persistence.testing.models.employee.relational.EmployeeSystem; | |
/** | |
* This test system uses the Employee test system to test the integration | |
* between the Mapping Workbench and the Foundation Library. To do this, it | |
* writes our test project to an XML file and then reads the XML file and runs | |
* the employee tests on it. | |
* @author Tom Ware | |
*/ | |
public class EmployeeWorkbenchIntegrationSystem extends EmployeeSystem { | |
public static String PROJECT_FILE = "MWIntegrationTestEmployeeProject"; | |
// A large enough value to ensure queries do not timeout, but a value we can test for | |
public static int QUERY_MANAGER_TIMEOUT = 250; | |
private Project initialProject; | |
/** | |
* Override the constructor for employee system to allow us to read and write XML | |
*/ | |
public EmployeeWorkbenchIntegrationSystem() { | |
super(); | |
buildInitialProject(); | |
buildProject(); | |
} | |
protected void buildProject() { | |
project = WorkbenchIntegrationSystemHelper.buildProjectXML(getInitialProject(), PROJECT_FILE); | |
} | |
public org.eclipse.persistence.sessions.Project getInitialProject() { | |
return initialProject; | |
} | |
protected void buildInitialProject() { | |
initialProject = new EmployeeProject(); | |
Map<Class, ClassDescriptor> descriptors = initialProject.getDescriptors(); | |
// Amend the employee descriptor | |
ClassDescriptor employeeDescriptor = descriptors.get(Employee.class); | |
DescriptorQueryManager queryManager = employeeDescriptor.getQueryManager(); | |
queryManager.addQuery("PersistenceTestGetEqual", buildPersistenceTestGetEqualQuery()); | |
queryManager.addQuery("PersistenceTestAnyOfEqual", buildPersistenceTestAnyOfEqualQuery()); | |
queryManager.addQuery("PersistenceTestGetAllowingNullEqual", buildPersistenceTestGetAllowingNullEqualQuery()); | |
queryManager.addQuery("PersistenceTestAnyOfAllowingNoneEqual", buildPersistenceTestAnyOfAllowingNoneEqualQuery()); | |
queryManager.addQuery("PersistenceTestGetGreaterThan", buildPersistenceTestGetGreaterThanQuery()); | |
queryManager.addQuery("PersistenceTestGetGreaterThanEqual", buildPersistenceTestGetGreaterThanEqualQuery()); | |
queryManager.addQuery("PersistenceTestGetIsNull", buildPersistenceTestGetIsNullQuery()); | |
queryManager.addQuery("PersistenceTestGetEqualIgnoringCase", buildPersistenceTestGetEqualIgnoringCaseQuery()); | |
queryManager.addQuery("PersistenceTestGetLessThan", buildPersistenceTestGetLessThanQuery()); | |
queryManager.addQuery("PersistenceTestGetLessThanEqual", buildPersistenceTestGetLessThanEqualQuery()); | |
queryManager.addQuery("PersistenceTestGetLike", buildPersistenceTestGetLikeQuery()); | |
queryManager.addQuery("PersistenceTestGetNot", buildPersistenceTestGetNotQuery()); | |
queryManager.addQuery("PersistenceTestGetNotEqual", buildPersistenceTestGetNotEqualQuery()); | |
queryManager.addQuery("PersistenceTestGetNotLike", buildPersistenceTestGetNotLikeQuery()); | |
queryManager.addQuery("PersistenceTestGetNotNull", buildPersistenceTestGetNotNullQuery()); | |
queryManager.addQuery("PersistenceTestEmptyStringAndNull", buildPersistenceTestEmptyStringAndNull()); | |
queryManager.addQuery("PersistenceTestGreaterThanEqualDate", buildPersistenceTestGreaterThanEqualDateQuery()); | |
//ReportQuery | |
queryManager.addQuery("AddAttributeReportQuery", buildAddAttributeReportQueryTest()); | |
queryManager.addQuery("AddAverageReportQuery", buildAddAverageReportQueryTest()); | |
queryManager.addQuery("AddCountReportQuery", buildAddCountReportQueryTest()); | |
queryManager.addQuery("AddFunctionItemReportQuery", buildAddFunctionItemReportQueryTest()); | |
queryManager.addQuery("AddGroupingReportQuery", buildAddGroupingReportQueryTest()); | |
queryManager.addQuery("AddItemReportQuery", buildAddItemReportQueryTest()); | |
queryManager.addQuery("AddMaximumReportQuery", buildAddMaximumReportQueryTest()); | |
queryManager.addQuery("AddMinimumReportQuery", buildAddMinimumReportQueryTest()); | |
queryManager.addQuery("AddStandardDeviationReportQuery", buildAddStandardDeviationReportQueryTest()); | |
queryManager.addQuery("AddSumReportQuery", buildAddSumReportQueryTest()); | |
queryManager.addQuery("AddVarianceReportQuery", buildAddVarianceReportQueryTest()); | |
queryManager.addQuery("AddJoinedObjectLevelReadQuery", buildAddJoinedReportQueryTest()); | |
queryManager.addQuery("AddOrderingReadAllQuery", buildAddOrderingReportQueryTest()); | |
queryManager.addQuery("AddBatchReadReadAllQuery", buildAddBatchReadReportQueryTest()); | |
// Query options | |
buildMemoryQueryReturnConfirmedQuery(queryManager); | |
buildMemoryQueryThrowExceptionQuery(queryManager); | |
buildMemoryQueryReturnNotConfirmedQuery(queryManager); | |
buildMemoryQueryTriggerIndirectionQuery(queryManager); | |
buildCacheQueryResultsQuery(queryManager); | |
buildRefreshIdentityMapResultsQuery(queryManager); | |
buildMaxRowsQuery(queryManager); | |
buildFirstResultQuery(queryManager); | |
buildQueryTimeOutQuery(queryManager); | |
buildUseDistinctQuery(queryManager); | |
buildDoNotUseDistinctQuery(queryManager); | |
buildShouldPrepareQuery(queryManager); | |
buildReadOnlyQuery(queryManager); | |
// Amend the project descriptor | |
ClassDescriptor projectDescriptor = descriptors.get(org.eclipse.persistence.testing.models.employee.domain.Project.class); | |
// Postgres throws an error if you try to set the timeout. | |
if (!TestExecutor.getDefaultExecutor().getSession().getPlatform().isPostgreSQL()) { | |
projectDescriptor.getQueryManager().setQueryTimeout(QUERY_MANAGER_TIMEOUT); | |
} | |
projectDescriptor.setCacheSynchronizationType(ClassDescriptor.SEND_NEW_OBJECTS_WITH_CHANGES); // Setting added for validation only - no tests currently run against this setting - Bug 3599101 | |
projectDescriptor.setCacheInvalidationPolicy(new NoExpiryCacheInvalidationPolicy()); // Setting added for validation only - no tests currently run against this setting - Bug 3599101 | |
// Query options | |
buildJoinSubclassesQuery(projectDescriptor.getQueryManager()); | |
// Setting invalidation policies | |
employeeDescriptor.setCacheInvalidationPolicy(new TimeToLiveCacheInvalidationPolicy(10000000)); | |
descriptors.get(Address.class).setCacheInvalidationPolicy(new TimeToLiveCacheInvalidationPolicy(10000000)); | |
descriptors.get(PhoneNumber.class).setCacheInvalidationPolicy(new TimeToLiveCacheInvalidationPolicy(10000000)); | |
GregorianCalendar calendar = new GregorianCalendar(); | |
calendar.add(Calendar.HOUR_OF_DAY, 2); | |
descriptors.get(LargeProject.class).setCacheInvalidationPolicy(new DailyCacheInvalidationPolicy(calendar.get(Calendar.HOUR_OF_DAY), | |
calendar.get(Calendar.MINUTE), | |
calendar.get(Calendar.SECOND), | |
calendar.get(Calendar.MILLISECOND))); | |
descriptors.get(SmallProject.class).setCacheInvalidationPolicy(new DailyCacheInvalidationPolicy(calendar.get(Calendar.HOUR_OF_DAY), | |
calendar.get(Calendar.MINUTE), | |
calendar.get(Calendar.SECOND), | |
calendar.get(Calendar.MILLISECOND))); | |
} | |
public static DatabaseQuery buildPersistenceTestGetEqualQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("address").get("city").equal("Toronto"); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetEqualIgnoringCaseQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("address").get("city").equalsIgnoreCase("Toronto"); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestAnyOfEqualQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.anyOf("phoneNumbers").get("areaCode").equal("613"); | |
ReadAllQuery query = new ReadAllQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetAllowingNullEqualQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.getAllowingNull("address").get("city").equal("Toronto"); | |
ReadAllQuery query = new ReadAllQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestAnyOfAllowingNoneEqualQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.anyOfAllowingNone("phoneNumbers").get("areaCode").equal("613"); | |
ReadAllQuery query = new ReadAllQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetGreaterThanQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("salary").greaterThan(0); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetGreaterThanEqualQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("salary").greaterThanEqual(0); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetIsNullQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("address").isNull(); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetLessThanQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("salary").lessThan(15); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetLessThanEqualQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("salary").lessThanEqual(15); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetLikeQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("address").get("city").like("Toronto"); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetNotQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("address").get("city").equal("Toronto").not(); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetNotEqualQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("address").get("city").notEqual("Toronto"); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetNotLikeQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("address").get("city").notLike("Toronto"); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestEmptyStringAndNull() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("firstName").lessThan(null).or(builder.get("firstName").equal("")); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGetNotNullQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Expression expression = builder.get("firstName").notNull(); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildPersistenceTestGreaterThanEqualDateQuery() { | |
ExpressionBuilder builder = new ExpressionBuilder(Employee.class); | |
Date date = Date.valueOf("2001-07-01"); | |
Expression expression = builder.get("period").get("startDate").greaterThanEqual(date); | |
ReadObjectQuery query = new ReadObjectQuery(Employee.class); | |
query.setSelectionCriteria(expression); | |
return query; | |
} | |
public static DatabaseQuery buildAddAttributeReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addAttribute("gender"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddAverageReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addAverage("salary"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddCountReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addCount("id"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddFunctionItemReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addFunctionItem("salary", reportQuery.getExpressionBuilder().get("salary"), "AVG"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddGroupingReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addAttribute("gender"); | |
reportQuery.addGrouping("gender"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddItemReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addItem("name", reportQuery.getExpressionBuilder().get("firstName")); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddMaximumReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addMaximum("salary"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddMinimumReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addMinimum("managerSalary", reportQuery.getExpressionBuilder().get("manager").get("salary")); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddStandardDeviationReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addStandardDeviation("salary"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddSumReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addSum("salary"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddVarianceReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addVariance("id"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddJoinedReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addAttribute("gender"); | |
reportQuery.addJoinedAttribute("address"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddOrderingReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addAttribute("gender"); | |
reportQuery.addDescendingOrdering("firstName"); | |
return reportQuery; | |
} | |
public static DatabaseQuery buildAddBatchReadReportQueryTest() { | |
ReportQuery reportQuery = new ReportQuery(new ExpressionBuilder()); | |
reportQuery.setReferenceClass(Employee.class); | |
reportQuery.addAttribute("gender"); | |
reportQuery.addBatchReadAttribute("phoneNumbers"); | |
return reportQuery; | |
} | |
public void buildMemoryQueryReturnConfirmedQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(Employee.class); | |
namedQuery.setInMemoryQueryIndirectionPolicy(new InMemoryQueryIndirectionPolicy(2)); | |
queryManager.addQuery("memoryQueryReturnConfirmedQuery", namedQuery); | |
} | |
public void buildMemoryQueryThrowExceptionQuery(DescriptorQueryManager queryManager) { | |
ReadObjectQuery namedQuery = new ReadObjectQuery(Employee.class); | |
namedQuery.setInMemoryQueryIndirectionPolicy(new InMemoryQueryIndirectionPolicy(0)); | |
queryManager.addQuery("memoryQueryThrowExceptionQuery", namedQuery); | |
} | |
public void buildMemoryQueryReturnNotConfirmedQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(Employee.class); | |
namedQuery.setInMemoryQueryIndirectionPolicy(new InMemoryQueryIndirectionPolicy(3)); | |
queryManager.addQuery("memoryQueryReturnNotConfirmedQuery", namedQuery); | |
} | |
public void buildMemoryQueryTriggerIndirectionQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(Employee.class); | |
namedQuery.setInMemoryQueryIndirectionPolicy(new InMemoryQueryIndirectionPolicy(1)); | |
queryManager.addQuery("memoryQueryTriggerIndirectionQuery", namedQuery); | |
} | |
public void buildCacheQueryResultsQuery(DescriptorQueryManager queryManager) { | |
ReadObjectQuery namedQuery = new ReadObjectQuery(Employee.class); | |
namedQuery.setQueryResultsCachePolicy(new QueryResultsCachePolicy()); | |
queryManager.addQuery("cacheQueryResultsQuery", namedQuery); | |
} | |
public void buildRefreshIdentityMapResultsQuery(DescriptorQueryManager queryManager) { | |
ReadObjectQuery namedQuery = new ReadObjectQuery(Employee.class); | |
namedQuery.setShouldRefreshIdentityMapResult(true); | |
queryManager.addQuery("refreshIdentityMapResultsQuery", namedQuery); | |
} | |
public void buildReadOnlyQuery(DescriptorQueryManager queryManager) { | |
ReadObjectQuery namedQuery = new ReadObjectQuery(Employee.class); | |
namedQuery.setIsReadOnly(true); | |
queryManager.addQuery("readOnlyQuery", namedQuery); | |
} | |
public void buildJoinSubclassesQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(org.eclipse.persistence.testing.models.employee.domain.Project.class); | |
namedQuery.useCursoredStream(); | |
namedQuery.setShouldOuterJoinSubclasses(true); | |
queryManager.addQuery("joinSubclassesQuery", namedQuery); | |
} | |
public void buildMaxRowsQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(Employee.class); | |
namedQuery.setMaxRows(4); | |
queryManager.addQuery("maxRowsQuery", namedQuery); | |
} | |
public void buildFirstResultQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(Employee.class); | |
namedQuery.setFirstResult(2); | |
queryManager.addQuery("firstResultQuery", namedQuery); | |
} | |
public void buildQueryTimeOutQuery(DescriptorQueryManager queryManager) { | |
DataReadQuery namedQuery = new DataReadQuery(); | |
namedQuery.setSQLString("SELECT SUM(e.EMP_ID) from EMPLOYEE e , EMPLOYEE b, EMPLOYEE c, EMPLOYEE d, EMPLOYEE f, EMPLOYEE g, EMPLOYEE h"); | |
namedQuery.setQueryTimeout(1); | |
queryManager.addQuery("queryTimeOutQuery", namedQuery); | |
} | |
public void buildUseDistinctQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(Employee.class); | |
namedQuery.setDistinctState((short)1); | |
queryManager.addQuery("useDistinctQuery", namedQuery); | |
} | |
public void buildDoNotUseDistinctQuery(DescriptorQueryManager queryManager) { | |
ReadAllQuery namedQuery = new ReadAllQuery(Employee.class); | |
namedQuery.setDistinctState((short)2); | |
queryManager.addQuery("doNotUseDistinctQuery", namedQuery); | |
} | |
public void buildShouldPrepareQuery(DescriptorQueryManager queryManager) { | |
ReadObjectQuery namedQuery = new ReadObjectQuery(Employee.class); | |
queryManager.addQuery("shouldPrepareQuery", namedQuery); | |
} | |
} |