| /* |
| * Copyright (c) 1998, 2021 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.performance; |
| |
| import java.util.*; |
| |
| import org.eclipse.persistence.sessions.*; |
| import org.eclipse.persistence.testing.framework.*; |
| |
| /** |
| * Performance test that allows cache and parameterizedSQL to be configured. |
| * Its purpose is to compare the test result with previous release/label results. |
| * It also provides a useful test for profiling performance. |
| */ |
| public abstract class PerformanceTest extends PerformanceRegressionTestCase { |
| protected boolean shouldUseParameterizedSQL; |
| protected boolean shouldCache; |
| protected boolean shouldBatch; |
| protected boolean shouldUseEmulatedDB; |
| |
| // Can be used to ensure cached objects do not garbage collect. |
| protected List allObjects; |
| |
| public PerformanceTest() { |
| this.shouldCache = false; |
| this.shouldUseParameterizedSQL = false; |
| this.shouldBatch = false; |
| this.shouldUseEmulatedDB = false; |
| } |
| |
| @Override |
| public String getName() { |
| String name = super.getName(); |
| if (shouldCache) { |
| name = name + "Cached"; |
| } |
| if (shouldUseParameterizedSQL) { |
| name = name + "ParameterizedSQL"; |
| } |
| if (shouldBatch) { |
| name = name + "Batched"; |
| } |
| if (shouldUseEmulatedDB) { |
| name = name + "EmulatedDB"; |
| } |
| return name; |
| } |
| |
| public boolean shouldCache() { |
| return shouldCache; |
| } |
| |
| public boolean shouldUseEmulatedDB() { |
| return shouldUseEmulatedDB; |
| } |
| |
| public void setShouldUseEmulatedDB(boolean shouldUseEmulatedDB) { |
| this.shouldUseEmulatedDB = shouldUseEmulatedDB; |
| } |
| |
| public boolean shouldBatch() { |
| return shouldBatch; |
| } |
| |
| public void setShouldBatch(boolean shouldBatch) { |
| this.shouldBatch = shouldBatch; |
| } |
| |
| public void setShouldCache(boolean shouldCache) { |
| this.shouldCache = shouldCache; |
| } |
| |
| public boolean shouldUseParameterizedSQL() { |
| return shouldUseParameterizedSQL; |
| } |
| |
| public void setShouldUseParameterizedSQL(boolean shouldUseParameterizedSQL) { |
| this.shouldUseParameterizedSQL = shouldUseParameterizedSQL; |
| } |
| |
| /** |
| * Configure parameterized SQL. |
| */ |
| @Override |
| public void setup() { |
| if (shouldUseParameterizedSQL()) { |
| getSession().getLogin().cacheAllStatements(); |
| } |
| if (shouldBatch()) { |
| getSession().getLogin().useBatchWriting(); |
| if (shouldUseParameterizedSQL()) { |
| getSession().getLogin().setMaxBatchWritingSize(20); |
| } else { |
| getSession().getLogin().setMaxBatchWritingSize(32000); |
| } |
| } |
| if (shouldUseEmulatedDB()) { |
| setupEmulatedDB(); |
| } |
| } |
| |
| /** |
| * Swap the session to use an emulated session. |
| * Load the employee data into the emulated DB. |
| */ |
| public void setupEmulatedDB() { |
| Session session = buildEmulatedSession(); |
| /* |
| EmulatedConnection connection = (EmulatedConnection)((org.eclipse.persistence.internal.sessions.AbstractSession)session).getAccessor().getConnection(); |
| |
| String sql; |
| Vector rows; |
| ComplexQueryResult result; |
| |
| // Load read all employees. |
| ReadAllQuery readAllQuery = new ReadAllQuery(Employee.class); |
| readAllQuery.setShouldIncludeData(true); |
| result = (ComplexQueryResult)getSession().executeQuery(readAllQuery); |
| List employees = (List)result.getResult(); |
| rows = (Vector)result.getData(); |
| sql = readAllQuery.getSQLString(); |
| connection.putRows(sql, rows); |
| |
| // Load Bob query. |
| Expression expression = new ExpressionBuilder().get("firstName").equal("Bob"); |
| ReadObjectQuery bobQuery = new ReadObjectQuery(Employee.class, expression); |
| bobQuery.setShouldIncludeData(true); |
| result = (ComplexQueryResult)getSession().executeQuery(bobQuery); |
| rows = new Vector(); |
| rows.add(result.getData()); |
| sql = bobQuery.getSQLString(); |
| connection.putRows(sql, rows); |
| |
| // Load read pk. |
| Iterator iterator = employees.iterator(); |
| Employee employee = (Employee)iterator.next(); |
| ReadObjectQuery readObjectQuery = new ReadObjectQuery(employee); |
| readObjectQuery.setShouldIncludeData(true); |
| readObjectQuery.setShouldRefreshIdentityMapResult(true); |
| DatabaseRecord record = new DatabaseRecord(); |
| record.put("EMP_ID", employee.getId()); |
| readObjectQuery.prepareCall(getSession(), record); |
| sql = readObjectQuery.getSQLString(); |
| rows = new Vector(); |
| rows.add(((ComplexQueryResult)getSession().executeQuery(readObjectQuery)).getData()); |
| connection.putRows(sql, rows); |
| |
| // Load sequence query. |
| rows = new Vector(); |
| record = new DatabaseRecord(); |
| record.put("NEXTVAL", Long.valueOf(12345)); |
| rows.add(record); |
| connection.putRows("SELECT EMP_SEQ.NEXTVAL FROM DUAL", rows); |
| connection.putRows("SELECT ADDRESS_SEQ.NEXTVAL FROM DUAL", rows);*/ |
| |
| getExecutor().swapSession(session); |
| } |
| |
| /** |
| * Clear cache. |
| */ |
| @Override |
| public void test() throws Exception { |
| if (!shouldCache()) { |
| getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); |
| } |
| } |
| |
| /** |
| * Reset parameterized SQL. |
| */ |
| @Override |
| public void reset() { |
| if (shouldUseParameterizedSQL()) { |
| getSession().getLogin().dontCacheAllStatements(); |
| } |
| if (shouldBatch()) { |
| getSession().getLogin().dontUseBatchWriting(); |
| } |
| if (shouldUseEmulatedDB()) { |
| getExecutor().resetSession(); |
| } |
| } |
| } |