/*
 * Copyright (c) 1998, 2020 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 v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// 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);
    }
}