| /* |
| * Copyright (c) 2010, 2021 Oracle and/or its affiliates. All rights reserved. |
| * Copyright (c) 2010, 2019 SAP. All rights reserved. |
| * Copyright (c) 2019 IBM Corporation. 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 |
| // SAP - tests rewritten |
| package org.eclipse.persistence.testing.tests.jpa.advanced; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import jakarta.persistence.EntityManager; |
| import jakarta.persistence.LockModeType; |
| import jakarta.persistence.PessimisticLockScope; |
| import jakarta.persistence.Query; |
| |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| |
| import org.eclipse.persistence.config.QueryHints; |
| import org.eclipse.persistence.descriptors.ClassDescriptor; |
| import org.eclipse.persistence.sessions.server.ServerSession; |
| import org.eclipse.persistence.testing.framework.junit.JUnitTestCase; |
| import org.eclipse.persistence.testing.models.jpa.advanced.Address; |
| import org.eclipse.persistence.testing.models.jpa.advanced.AdvancedTableCreator; |
| import org.eclipse.persistence.testing.models.jpa.advanced.Dealer; |
| import org.eclipse.persistence.testing.models.jpa.advanced.Employee; |
| import org.eclipse.persistence.testing.models.jpa.advanced.Equipment; |
| import org.eclipse.persistence.testing.models.jpa.advanced.EquipmentCode; |
| import org.eclipse.persistence.testing.models.jpa.advanced.LargeProject; |
| import org.eclipse.persistence.testing.models.jpa.advanced.SmallProject; |
| import org.eclipse.persistence.testing.models.jpa.advanced.entities.EntyA; |
| import org.eclipse.persistence.testing.models.jpa.advanced.entities.EntyB; |
| import org.eclipse.persistence.testing.models.jpa.advanced.entities.EntyC; |
| import org.eclipse.persistence.testing.models.jpa.advanced.entities.EntyD; |
| import org.eclipse.persistence.testing.models.jpa.advanced.entities.EntyE; |
| |
| /** |
| * <p> |
| * <b>Purpose</b>: Test Pessimistic Locking Extended Scope functionality. |
| * <p> |
| * <b>Description</b>: Test the relationship will be locked or unlocked under different situations |
| * |
| */ |
| public class PessimisticLockingExtendedScopeTestSuite extends JUnitTestCase { |
| |
| public PessimisticLockingExtendedScopeTestSuite() { |
| super(); |
| } |
| |
| public PessimisticLockingExtendedScopeTestSuite(String name) { |
| super(name); |
| } |
| |
| public static Test suite() { |
| TestSuite suite = new TestSuite("PessimisticLocking ExtendedScope TestSuite"); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testSetup")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES1")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES2")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES3")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES4")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES5")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES6")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES7")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES8")); |
| suite.addTest(new PessimisticLockingExtendedScopeTestSuite("testPESSMISTIC_ES9")); |
| return suite; |
| } |
| |
| public void testSetup() { |
| ServerSession session = JUnitTestCase.getServerSession(); |
| new AdvancedTableCreator().replaceTables(session); |
| //make the entity EquipmentCode read-write for the following tests |
| ClassDescriptor descriptor = session.getDescriptor(EquipmentCode.class); |
| boolean shouldBeReadOnly = descriptor.shouldBeReadOnly(); |
| descriptor.setShouldBeReadOnly(false); |
| clearCache(); |
| } |
| |
| interface Actor<X> { |
| void setup(EntityManager em); |
| |
| X getEntityToLock(EntityManager em); |
| |
| void modify(EntityManager em); |
| |
| void check(EntityManager em, X lockedEntity); |
| } |
| |
| // Entity relationships for which the locked entity contains the foreign key |
| // will be locked with bidirectional one-to-one mapping without mappedBy |
| // (Scenario 1.1) |
| public void testPESSMISTIC_ES1() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| final EntyA a = new EntyA(); |
| |
| final Actor actor = new Actor<EntyA>() { |
| |
| @Override |
| public void setup(EntityManager em) { |
| EntyC c = new EntyC(); |
| em.persist(c); |
| a.setName("test"); |
| a.setEntyC(c); |
| em.persist(a); |
| } |
| |
| @Override |
| public EntyA getEntityToLock(EntityManager em) { |
| return em.find(EntyA.class, a.getId()); |
| } |
| |
| @Override |
| public void modify(EntityManager em) { |
| EntyA a2 = em.find(EntyA.class, a.getId()); |
| a2.setEntyC(null); |
| } |
| |
| @Override |
| public void check(EntityManager em, EntyA lockedEntity) { |
| em.refresh(lockedEntity); |
| assertNotNull("other transaction modified row concurrently", lockedEntity.getEntyC()); |
| } |
| |
| }; |
| |
| testNonrepeatableRead(actor); |
| } |
| |
| // Entity relationships for which the locked entity contains the foreign key |
| // will be locked with unidirectional one-to-one mapping(Scenario 1.2) |
| public void testPESSMISTIC_ES2() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| final EntyA a = new EntyA(); |
| |
| final Actor actor = new Actor<EntyA>() { |
| |
| @Override |
| public void setup(EntityManager em) { |
| EntyB b = new EntyB(); |
| a.setEntyB(b); |
| em.persist(a); |
| } |
| |
| @Override |
| public EntyA getEntityToLock(EntityManager em1) { |
| return em1.find(EntyA.class, a.getId()); |
| } |
| |
| @Override |
| public void modify(EntityManager em2) { |
| EntyA a2 = em2.find(EntyA.class, a.getId()); |
| a2.setEntyB(null); |
| } |
| |
| @Override |
| public void check(EntityManager em1, EntyA lockedEntity) { |
| em1.refresh(lockedEntity); |
| assertNotNull("other transaction modified row concurrently", lockedEntity.getEntyB()); |
| } |
| |
| }; |
| |
| testNonrepeatableRead(actor); |
| } |
| |
| |
| // Entity relationships for which the locked entity contains the foreign key |
| // will be locked with unidirectional many-to-one mapping(Scenario 1.3) |
| public void testPESSMISTIC_ES3() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| final Equipment eq = new Equipment(); |
| |
| final Actor actor = new Actor<Equipment>() { |
| |
| @Override |
| public void setup(EntityManager em) { |
| EquipmentCode eqCode = new EquipmentCode(); |
| eqCode.setCode("A"); |
| em.persist(eqCode); |
| eq.setEquipmentCode(eqCode); |
| em.persist(eq); |
| } |
| |
| @Override |
| public Equipment getEntityToLock(EntityManager em1) { |
| return em1.find(Equipment.class, eq.getId()); |
| } |
| |
| @Override |
| public void modify(EntityManager em2) { |
| Equipment eq2 = em2.find(Equipment.class, eq.getId()); |
| eq2.setEquipmentCode(null); |
| } |
| |
| @Override |
| public void check(EntityManager em1, Equipment lockedEntity) { |
| em1.refresh(lockedEntity); |
| assertNotNull("other transaction modified row concurrently", lockedEntity.getEquipmentCode()); |
| } |
| |
| }; |
| |
| testNonrepeatableRead(actor); |
| } |
| |
| |
| // Entity relationships for which the locked entity contains the foreign key |
| // will be locked with bidirectional many-to-one mapping(Scenario 1.4) |
| public void testPESSMISTIC_ES4() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| if ((JUnitTestCase.getServerSession()).getPlatform().isHANA()) { |
| // HANA currently doesn't support pessimistic locking with queries on multiple tables |
| // feature is under development (see bug 384129), but test should be skipped for the time being |
| return; |
| } |
| final Employee emp = new Employee(); |
| |
| final Actor actor = new Actor<Employee>() { |
| |
| @Override |
| public void setup(EntityManager em) { |
| Address ads = new Address("SomeStreet", "somecity", "province", "country", "postalcode"); |
| emp.setAddress(ads); |
| em.persist(emp); |
| } |
| |
| @Override |
| public Employee getEntityToLock(EntityManager em1) { |
| return em1.find(Employee.class, emp.getId()); |
| } |
| |
| @Override |
| public void modify(EntityManager em2) { |
| Employee emp2 = em2.find(Employee.class, emp.getId()); |
| emp2.setAddress((Address)null); |
| } |
| |
| @Override |
| public void check(EntityManager em1, Employee lockedEntity) { |
| em1.refresh(lockedEntity); |
| assertNotNull("other transaction modified row concurrently", lockedEntity.getAddress()); |
| } |
| |
| }; |
| |
| testNonrepeatableRead(actor); |
| } |
| |
| |
| // Relationships owned by the entity that are contained in join tables will |
| // be locked with Unidirectional OneToMany mapping (Scenario 2.2) |
| public void testPESSMISTIC_ES5() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| final EntyA entyA = new EntyA(); |
| |
| final Actor actor = new Actor<EntyA>() { |
| |
| @Override |
| public void setup(EntityManager em) { |
| em.persist(entyA); |
| entyA.getEntyDs().add(new EntyD()); |
| } |
| |
| @Override |
| public EntyA getEntityToLock(EntityManager em1) { |
| return em1.find(EntyA.class, entyA.getId()); |
| } |
| |
| @Override |
| public void modify(EntityManager em2) { |
| EntyA entyA2 = em2.find(EntyA.class, entyA.getId()); |
| entyA2.setEntyDs(null); |
| } |
| |
| @Override |
| public void check(EntityManager em1, EntyA lockedEntity) { |
| em1.refresh(lockedEntity); |
| assertNotNull("other transaction modified row concurrently", lockedEntity.getEntyDs()); |
| |
| final Collection collection; |
| if (getServerSession().getPlatform().isMaxDB()) { |
| // avoid accessing EntyD's table as this would lead to a dead lock |
| Query query = em1.createNativeQuery("SELECT t2.entyDs_ID FROM ADV_ENTYA_ADV_ENTYD t2, ADV_ENTYA t1 WHERE ((? = t1.ID) AND ((t2.EntyA_ID = t1.ID)))"); |
| query.setParameter(1, lockedEntity.getId()); |
| collection = query.getResultList(); |
| } else { |
| collection = lockedEntity.getEntyDs(); |
| } |
| |
| assertFalse("other transaction modified row concurrently", collection.isEmpty()); |
| } |
| |
| }; |
| |
| testNonrepeatableRead(actor); |
| } |
| |
| |
| //Relationships owned by the entity that are contained in join tables will be locked with Unidirectional ManyToMany mapping (Scenario 2.3) |
| public void testPESSMISTIC_ES6() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| final EntyA entyA = new EntyA(); |
| |
| final Actor actor = new Actor<EntyA>() { |
| |
| @Override |
| public void setup(EntityManager em) { |
| Collection entyEs = new ArrayList(); |
| EntyE entyE1 = new EntyE(); |
| EntyE entyE2 = new EntyE(); |
| entyEs.add(entyE1); |
| entyEs.add(entyE2); |
| entyA.setEntyEs(entyEs); |
| em.persist(entyA); |
| } |
| |
| @Override |
| public EntyA getEntityToLock(EntityManager em1) { |
| return em1.find(EntyA.class, entyA.getId()); |
| } |
| |
| @Override |
| public void modify(EntityManager em2) { |
| EntyA entyA2 = em2.find(EntyA.class, entyA.getId()); |
| entyA2.setEntyEs(null); |
| } |
| |
| @Override |
| public void check(EntityManager em1, EntyA lockedEntity) { |
| em1.refresh(lockedEntity); |
| assertNotNull("other transaction modified row concurrently", lockedEntity.getEntyEs()); |
| assertFalse("other transaction modified row concurrently", lockedEntity.getEntyEs().isEmpty()); |
| } |
| |
| }; |
| |
| testNonrepeatableRead(actor); |
| } |
| |
| |
| |
| /* |
| * The test should assert that the following phenomenon does not occur |
| * after a row has been locked by T1: |
| * |
| * - P2 (Non-repeatable read): Transaction T1 reads a row. Another |
| * transaction T2 then modifies or deletes that row, before T1 has |
| * committed or rolled back. |
| */ |
| private <X> void testNonrepeatableRead(final Actor<X> actor) throws InterruptedException { |
| // Cannot create parallel entity managers in the server. |
| if (isOnServer() || !isSelectForUpateSupported()) { |
| return; |
| } |
| |
| EntityManager em = createEntityManager(); |
| EntyC c = null; |
| try { |
| beginTransaction(em); |
| actor.setup(em); |
| commitTransaction(em); |
| } catch (RuntimeException ex) { |
| throw ex; |
| } finally { |
| if (isTransactionActive(em)) { |
| rollbackTransaction(em); |
| } |
| closeEntityManager(em); |
| } |
| |
| Exception lockTimeOutException = null; |
| LockModeType lockMode = LockModeType.PESSIMISTIC_WRITE; |
| Map<String, Object> properties = new HashMap(); |
| properties.put(QueryHints.PESSIMISTIC_LOCK_SCOPE, PessimisticLockScope.EXTENDED); |
| properties.put(QueryHints.PESSIMISTIC_LOCK_TIMEOUT, 10000); |
| |
| EntityManager em1 = createEntityManager(); |
| try { |
| beginTransaction(em1); |
| X locked = actor.getEntityToLock(em1); |
| em1.lock(locked, lockMode, properties); |
| |
| final EntityManager em2 = createEntityManager(); |
| try { |
| // P2 (Non-repeatable read) |
| Runnable runnable = new Runnable() { |
| @Override |
| public void run() { |
| try { |
| beginTransaction(em2); |
| actor.modify(em2); |
| commitTransaction(em2); // might wait for lock to be released |
| } catch (jakarta.persistence.RollbackException ex) { |
| if (ex.getMessage().indexOf("org.eclipse.persistence.exceptions.DatabaseException") == -1) { |
| ex.printStackTrace(); |
| fail("it's not the right exception"); |
| } |
| } |
| } |
| }; |
| |
| Thread t2 = new Thread(runnable); |
| t2.start(); |
| Thread.sleep(1000); // allow t2 to atempt update |
| actor.check(em1, locked); // assert repeatable read |
| rollbackTransaction(em1); // release lock |
| t2.join(); // wait until t2 finished |
| } finally { |
| if (isTransactionActive(em2)) { |
| rollbackTransaction(em2); |
| } |
| closeEntityManager(em2); |
| } |
| } finally { |
| if (isTransactionActive(em1)) { |
| rollbackTransaction(em1); |
| } |
| closeEntityManager(em1); |
| } |
| } |
| |
| |
| |
| //Bidirectional OneToOne Relationship with target entity has foreign key, entity does not contain the foreign key will not be locked (Scenario 3.1) |
| public void testPESSMISTIC_ES7() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| // Cannot create parallel entity managers in the server. |
| if (! isOnServer() && isSelectForUpateSupported()) { |
| EntityManager em = createEntityManager(); |
| EntyA a = null; |
| EntyC c = null; |
| try{ |
| beginTransaction(em); |
| a = new EntyA(); |
| c = new EntyC(); |
| em.persist(c); |
| a.setEntyC(c); |
| em.persist(a); |
| commitTransaction(em); |
| }catch (RuntimeException ex){ |
| throw ex; |
| }finally{ |
| if (isTransactionActive(em)){ |
| rollbackTransaction(em); |
| } |
| closeEntityManager(em); |
| } |
| |
| Exception lockTimeOutException = null; |
| LockModeType lockMode = LockModeType.PESSIMISTIC_WRITE; |
| Map<String, Object> properties = new HashMap(); |
| properties.put(QueryHints.PESSIMISTIC_LOCK_SCOPE, PessimisticLockScope.NORMAL); |
| EntityManager em1= createEntityManager(); |
| |
| try{ |
| beginTransaction(em1); |
| c = em1.find(EntyC.class, c.getId()); |
| em1.lock(c, lockMode, properties); |
| EntityManager em2 = createEntityManager(); |
| try{ |
| beginTransaction(em2); |
| c = em2.find(EntyC.class, c.getId()); |
| c.setEntyA(null); |
| commitTransaction(em2); |
| } catch(jakarta.persistence.RollbackException ex){ |
| fail("it should not throw the exception!!!"); |
| }finally{ |
| if (isTransactionActive(em2)){ |
| rollbackTransaction(em2); |
| } |
| closeEntityManager(em2); |
| } |
| }catch (Exception ex){ |
| throw ex; |
| }finally{ |
| if (isTransactionActive(em1)){ |
| rollbackTransaction(em1); |
| } |
| closeEntityManager(em1); |
| } |
| } |
| } |
| |
| //Unidirectional OneToMany Relationship, in which entity does not contain the foreign key will not be locked (Scenario 3.2) |
| public void testPESSMISTIC_ES8() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| if ((JUnitTestCase.getServerSession()).getPlatform().isHANA()) { |
| // HANA currently doesn't support pessimistic locking with queries on multiple tables |
| // feature is under development (see bug 384129), but test should be skipped for the time being |
| return; |
| } |
| // Cannot create parallel entity managers in the server. |
| if (! isOnServer() && isSelectForUpateSupported()) { |
| EntityManager em = createEntityManager(); |
| Employee emp = null; |
| try{ |
| beginTransaction(em); |
| emp = new Employee(); |
| emp.getDealers().add(new Dealer("Honda", "Kanata")); |
| em.persist(emp); |
| commitTransaction(em); |
| }catch (RuntimeException ex){ |
| throw ex; |
| }finally{ |
| if (isTransactionActive(em)){ |
| rollbackTransaction(em); |
| } |
| closeEntityManager(em); |
| } |
| |
| Exception lockTimeOutException = null; |
| LockModeType lockMode = LockModeType.PESSIMISTIC_WRITE; |
| Map<String, Object> properties = new HashMap(); |
| properties.put(QueryHints.PESSIMISTIC_LOCK_SCOPE, PessimisticLockScope.NORMAL); |
| EntityManager em1= createEntityManager(); |
| |
| try { |
| beginTransaction(em1); |
| emp = em1.find(Employee.class, emp.getId()); |
| em1.lock(emp, lockMode, properties); |
| EntityManager em2 = createEntityManager(); |
| try { |
| beginTransaction(em2); |
| emp = em1.find(Employee.class, emp.getId()); |
| emp.setDealers(null); |
| commitTransaction(em2); |
| } catch (jakarta.persistence.RollbackException ex){ |
| fail("it should not throw the exception!!!"); |
| } finally { |
| if (isTransactionActive(em2)) { |
| rollbackTransaction(em2); |
| } |
| closeEntityManager(em2); |
| } |
| } catch (Exception ex){ |
| fail("it should not throw the exception!!!"); |
| throw ex; |
| } finally { |
| if (isTransactionActive(em1)){ |
| rollbackTransaction(em1); |
| } |
| closeEntityManager(em1); |
| } |
| } |
| } |
| |
| //Bidirectional ManyToMany Relationship, in which entity does not contain the foreign key will not be locked by default (Scenario 3.3) |
| public void testPESSMISTIC_ES9() throws Exception { |
| if (getPlatform().isSQLServer()) { |
| warning("This test deadlocks on SQL Server"); |
| return; |
| } |
| if ((JUnitTestCase.getServerSession()).getPlatform().isHANA()) { |
| // HANA currently doesn't support pessimistic locking with queries on multiple tables |
| // feature is under development (see bug 384129), but test should be skipped for the time being |
| return; |
| } |
| // Cannot create parallel entity managers in the server. |
| if (! isOnServer() && isSelectForUpateSupported()) { |
| EntityManager em = createEntityManager(); |
| Employee emp = null; |
| try{ |
| beginTransaction(em); |
| emp = new Employee(); |
| SmallProject smallProject = new SmallProject(); |
| smallProject.setName("New High School Set Up"); |
| emp.addProject(smallProject); |
| LargeProject largeProject = new LargeProject(); |
| largeProject.setName("Downtown Light Rail"); |
| largeProject.setBudget(5000); |
| emp.addProject(largeProject); |
| em.persist(emp); |
| commitTransaction(em); |
| }catch (RuntimeException ex){ |
| throw ex; |
| }finally{ |
| if (isTransactionActive(em)){ |
| rollbackTransaction(em); |
| } |
| closeEntityManager(em); |
| } |
| |
| Exception lockTimeOutException = null; |
| LockModeType lockMode = LockModeType.PESSIMISTIC_WRITE; |
| Map<String, Object> properties = new HashMap(); |
| properties.put(QueryHints.PESSIMISTIC_LOCK_SCOPE, PessimisticLockScope.NORMAL); |
| EntityManager em1= createEntityManager(); |
| |
| try{ |
| beginTransaction(em1); |
| emp = em1.find(Employee.class, emp.getId()); |
| em1.lock(emp, lockMode, properties); |
| EntityManager em2 = createEntityManager(); |
| try{ |
| beginTransaction(em2); |
| emp = em1.find(Employee.class, emp.getId()); |
| emp.setProjects(null); |
| commitTransaction(em2); |
| }catch(jakarta.persistence.RollbackException ex){ |
| fail("it should not throw the exception!!!"); |
| }finally{ |
| if (isTransactionActive(em2)){ |
| rollbackTransaction(em2); |
| } |
| closeEntityManager(em2); |
| } |
| }catch (Exception ex){ |
| fail("it should not throw the exception!!!"); |
| throw ex; |
| }finally{ |
| if (isTransactionActive(em1)){ |
| rollbackTransaction(em1); |
| } |
| closeEntityManager(em1); |
| } |
| } |
| } |
| } |
