| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.openjpa.persistence.lock.extended; |
| |
| import javax.persistence.EntityManager; |
| |
| /** |
| * LockScopeTestCase subclass to test entity with: |
| * - Uni-1x1 - eager fetch (default) |
| * - Uni-1x1 - lazy fetch |
| * - Uni-1x1 use join table - eager fetch (default) |
| * - Uni-1x1 use join table - lazy fetch |
| */ |
| public class Test1x1LockScope extends LockScopeTestCase { |
| |
| public void setUp() { |
| setSupportedDatabases( |
| org.apache.openjpa.jdbc.sql.DerbyDictionary.class, |
| org.apache.openjpa.jdbc.sql.OracleDictionary.class, |
| org.apache.openjpa.jdbc.sql.DB2Dictionary.class); |
| if (isTestsDisabled()) { |
| return; |
| } |
| |
| setUp(LSE1x1Lf.class |
| , LSE1x1LfLzy.class |
| , LSE1x1LfJT.class |
| , LSE1x1LfJTLzy.class |
| , LSE1x1Rt.class |
| , "openjpa.LockManager", "mixed" |
| , "openjpa.jdbc.SynchronizeMappings", "buildSchema(ForeignKeys=true)" |
| ); |
| commonSetUp(LSE1x1Lf.class |
| , LSE1x1LfLzy.class |
| , LSE1x1LfJT.class |
| , LSE1x1LfJTLzy.class |
| , LSE1x1Rt.class |
| ); |
| } |
| |
| public void testNormalUni1x1Lock() { |
| common1x1Lock("testNormalUni1x1Lock", 1111201, false); |
| } |
| |
| public void testExtendedUni1x1Lock() { |
| common1x1Lock("testExtendedUni1x1Lock", 1111211, true); |
| } |
| |
| private void common1x1Lock(String testName, int idLf0, boolean extended) { |
| final String tableLfName = "LSE1x1Lf"; |
| final String tableRtName = "LSE1x1Rt"; |
| final String joinTables = tableLfName + ".*JOIN.*" + tableRtName; |
| getLog().info("** " + testName + "()"); |
| String scope = extended ? "Extended" : "Normal"; |
| int idRt0 = idLf0 + 10000; // right table |
| int idLf1 = idLf0 + 1; |
| int idRt1 = idRt0 + 1; |
| |
| // create test entity. |
| LSE1x1Lf eLf0 = new LSE1x1Lf(); |
| LSE1x1Rt eRt0 = new LSE1x1Rt(); |
| eLf0.setId(idLf0); |
| eLf0.setFirstName("firstName " + idLf0); |
| eLf0.setUniRight(eRt0); |
| eRt0.setId(idRt0); |
| eRt0.setLastName("lastName " + idRt0); |
| LSE1x1Lf eLf1 = new LSE1x1Lf(); |
| LSE1x1Rt eRt1 = new LSE1x1Rt(); |
| eLf1.setId(idLf1); |
| eLf1.setFirstName("firstName " + idLf1); |
| eLf1.setUniRight(eRt1); |
| eRt1.setId(idRt1); |
| eRt1.setLastName("lastName " + idRt1); |
| |
| EntityManager em = null; |
| try { |
| em = emf.createEntityManager(); |
| em.getTransaction().begin(); |
| em.persist(eLf0); |
| em.persist(eRt0); |
| em.persist(eLf1); |
| em.persist(eRt1); |
| em.getTransaction().commit(); |
| } finally { |
| em = null; |
| eLf0 = eLf1 = null; |
| eRt0 = eRt1 = null; |
| if (em != null && em.isOpen()) { |
| em.close(); |
| } |
| } |
| |
| commonLockTest(testName, LSE1x1Lf.class, idLf0, extended, |
| "SELECT c FROM LSE1x1Lf c WHERE c.firstName LIKE :firstName", "findLSE1x1Lf" + scope, |
| new AssertCallback() { |
| public void findNoLockDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1111201] |
| assertLockTestSQLs(Select + joinTables + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName |
| // FROM LSE1x1Lf t0, LSE1x1Rt t1 WHERE t0.id = ? AND t0.UNIRIGHT_ID = t1.id(+) |
| // [params=(int) 1111201] |
| assertLockTestSQLs(Select + tableLfName + Any + tableRtName + Where + "\\(\\+\\).*" |
| + NoForUpdate); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // [params=(int) 1111201] |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate); |
| } |
| } |
| |
| public void findPessimisticForcIncDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // optimize for 1 row FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS |
| // [params=(int) 1111202] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? |
| // -FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS- [params=(int) 1121202] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? |
| // -FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS- [params=(int) 1111202] |
| assertLockTestSQLs(Select + joinTables + Where + DB2Lock, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| case oracle: // TODO: if jpa2, DO NOT lock LSE1x1RT using "FOR UPDATE OF col" |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName |
| // FROM LSE1x1Lf t0, LSE1x1Rt t1 WHERE t0.id = ? AND t0.UNIRIGHT_ID = t1.id(+) |
| // FOR UPDATE [params=(int) 1111202] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE [params=(int) 1121202] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? FOR UPDATE [params=(int) 1111202] |
| assertLockTestSQLs(Select + tableLfName + Any + tableRtName + Where + "\\(\\+\\).*" |
| + ForUpdate); |
| break; |
| case derby: //-TODO: **Non-atomic lock. |
| // The database is unable to lock this query. Each object matching the query will be |
| // locked individually after it is loaded; however, it is technically possible that |
| // another transaction could modify the data before the lock is obtained. |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // [params=(int) 1111202] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? -FOR UPDATE WITH RR- |
| // [params=(int) 1121202] |
| // SELECT t0.id FROM LSE1x1Lf t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1111202] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? -FOR UPDATE WITH RR- |
| // [params=(int) 1111202] |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate, |
| Select + NoJoin + Any + tableLfName + Any + NoJoin + Where + ForUpdate, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| //-SELECT t0.id FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1121202]- |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + ForUpdate); |
| } |
| } |
| |
| public void queryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.id, t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RS USE AND KEEP UPDATE LOCKS [params=(String) firstName%1111201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1121201] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? [params=(int) 1111201] |
| assertLockTestSQLs(Select + joinTables + Where + DB2Lock, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| case oracle: // TODO: if jpa2, DO NOT lock LSE1x1RT using "FOR UPDATE OF col" |
| // SELECT t0.id, t0.version, t0.firstName, t1.id, t1.version, t1.lastName |
| // FROM LSE1x1Lf t0, LSE1x1Rt t1 |
| // WHERE (t0.firstName LIKE ?) AND t0.UNIRIGHT_ID = t1.id(+) |
| // FOR UPDATE [params=(String) firstName%1111201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1121201] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? [params=(int) 1111201] |
| assertLockTestSQLs(Select + tableLfName + Any + tableRtName + Where + "\\(\\+\\).*" |
| + ForUpdate); |
| break; |
| case derby: //-TODO: **Non-atomic lock. |
| // The database is unable to lock this query. Each object matching the query will be |
| // locked individually after it is loaded; however, it is technically possible that |
| // another transaction could modify the data before the lock is obtained. |
| // SELECT t0.id, t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') [params=(String) firstName%1111201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1121201] |
| // SELECT t0.id FROM LSE1x1Lf t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1111201] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? [params=(int) 1111201] |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate, |
| Select + NoJoin + Any + tableLfName + Any + NoJoin + Where + ForUpdate, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| //-SELECT t0.id FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1121201]- |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterQueryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1111202] |
| assertLockTestSQLs(Select + joinTables + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName |
| // FROM LSE1x1Lf t0, LSE1x1Rt t1 WHERE t0.id = ? AND t0.UNIRIGHT_ID = t1.id(+) |
| // [params=(int) 1111202] |
| assertLockTestSQLs(Select + tableLfName + Any + tableRtName + Where + "\\(\\+\\).*" |
| + NoForUpdate); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // [params=(int) 1111202] |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate); |
| } |
| } |
| |
| public void namedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.id, t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(String) firstName%1111201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1121201] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? [params=(int) 1111201] |
| assertLockTestSQLs(Select + joinTables + Where + DB2Lock, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| case oracle: // TODO: if jpa2, DO NOT lock LSE1x1RT using "FOR UPDATE OF col" |
| // SELECT t0.id, t0.version, t0.firstName, t1.id, t1.version, t1.lastName |
| // FROM LSE1x1Lf t0, LSE1x1Rt t1 |
| // WHERE (t0.firstName LIKE ?) AND t0.UNIRIGHT_ID = t1.id(+) |
| // FOR UPDATE [params=(String) firstName%1111201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1121201] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? [params=(int) 1111201] |
| assertLockTestSQLs(Select + tableLfName + Any + tableRtName + Where + "\\(\\+\\).*" |
| + ForUpdate); |
| break; |
| case derby: //-TODO: **Non-atomic lock. |
| // The database is unable to lock this query. Each object matching the query will be |
| // locked individually after it is loaded; however, it is technically possible that |
| // another transaction could modify the data before the lock is obtained. |
| // SELECT t0.id, t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') [params=(String) firstName%1111201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1121201] |
| // SELECT t0.id FROM LSE1x1Lf t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1111201] |
| // SELECT t0.version FROM LSE1x1Lf t0 WHERE t0.id = ? [params=(int) 1111201] |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate, |
| Select + NoJoin + Any + tableLfName + Any + NoJoin + Where + ForUpdate, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| //-SELECT t0.id FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1121201]- |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterNamedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1111202] |
| assertLockTestSQLs(Select + joinTables + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName |
| // FROM LSE1x1Lf t0, LSE1x1Rt t1 WHERE t0.id = ? AND t0.UNIRIGHT_ID = t1.id(+) |
| // [params=(int) 1111202] |
| assertLockTestSQLs(Select + tableLfName + Any + tableRtName + Where + "\\(\\+\\).*" |
| + NoForUpdate); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName, t1.id, t1.version, t1.lastName FROM LSE1x1Lf t0 |
| // LEFT OUTER JOIN LSE1x1Rt t1 ON t0.UNIRIGHT_ID = t1.id WHERE t0.id = ? |
| // [params=(int) 1111202] |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate); |
| } |
| } |
| }); |
| } |
| |
| public void testNormalUni1x1LazyLock() { |
| common1x1LazyLock("testNormalUni1x1LazyLock", 1111101, false); |
| } |
| |
| public void testExtendedUni1x1LazyLock() { |
| common1x1LazyLock("testExtendedUni1x1LazyLock", 1111111, true); |
| } |
| |
| private void common1x1LazyLock(String testName, int idLf0, boolean extended) { |
| final String tableLfName = "LSE1x1LfLzy"; |
| // final String tableRtName = "LockSEUni1x1RT"; |
| getLog().info("** " + testName + "()"); |
| String scope = extended ? "Extended" : "Normal"; |
| int idRt0 = idLf0 + 10000; // right table |
| int idLf1 = idLf0 + 1; |
| int idRt1 = idRt0 + 1; |
| |
| // create test entity. |
| LSE1x1LfLzy eLf0 = new LSE1x1LfLzy(); |
| LSE1x1Rt eRt0 = new LSE1x1Rt(); |
| eLf0.setId(idLf0); |
| eLf0.setFirstName("firstName " + idLf0); |
| eLf0.setUniRight(eRt0); |
| eRt0.setId(idRt0); |
| eRt0.setLastName("lastName " + idRt0); |
| LSE1x1LfLzy eLf1 = new LSE1x1LfLzy(); |
| LSE1x1Rt eRt1 = new LSE1x1Rt(); |
| eLf1.setId(idLf1); |
| eLf1.setFirstName("firstName " + idLf1); |
| eLf1.setUniRight(eRt1); |
| eRt1.setId(idRt1); |
| eRt1.setLastName("lastName " + idRt1); |
| |
| EntityManager em = null; |
| try { |
| em = emf.createEntityManager(); |
| em.getTransaction().begin(); |
| em.persist(eLf0); |
| em.persist(eRt0); |
| em.persist(eLf1); |
| em.persist(eRt1); |
| em.getTransaction().commit(); |
| } finally { |
| em = null; |
| eLf0 = eLf1 = null; |
| eRt0 = eRt1 = null; |
| if (em != null && em.isOpen()) { |
| em.close(); |
| } |
| } |
| |
| commonLockTest(testName, LSE1x1LfLzy.class, idLf0, extended, |
| "SELECT c FROM LSE1x1LfLzy c WHERE c.firstName LIKE :firstName", "findLSE1x1LfLzy" + scope, |
| new AssertCallback() { |
| public void findNoLockDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1111101] |
| assertLockTestSQLs(Select + tableLfName + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // [params=(int) 1111101] |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // [params=(int) 1111101] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + NoForUpdate); |
| } |
| } |
| |
| public void findPessimisticForcIncDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // optimize for 1 row FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS |
| // [params=(int) 1111102] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(int) 1111102] |
| assertLockTestSQLs(Select + tableLfName + Where + DB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // FOR UPDATE [params=(int) 1111102] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? FOR UPDATE [params=(int) 1111102] |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? FOR UPDATE WITH RR |
| // [params=(int) 1111102] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? FOR UPDATE WITH RR |
| // [params=(int) 1111102] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + ForUpdate); |
| } |
| } |
| |
| public void queryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RS USE AND KEEP UPDATE LOCKS [params=(String) firstName%1111101] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? [params=(int) 1111101] |
| assertLockTestSQLs(Select + tableLfName + Where + DB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE (t0.firstName LIKE ?) |
| // FOR UPDATE [params=(String) firstName%1111101] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? [params=(int) 1111101] |
| case derby: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') FOR UPDATE WITH RR |
| // [params=(String) firstName%1111101] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? [params=(int) 1111101] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterQueryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1111102] |
| assertLockTestSQLs(Select + tableLfName + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // [params=(int) 1111102] |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // [params=(int) 1111102] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + NoForUpdate); |
| } |
| } |
| |
| public void namedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(String) firstName%1111101] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? [params=(int) 1111101] |
| assertLockTestSQLs(Select + tableLfName + Where + DB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE (t0.firstName LIKE ?) |
| // FOR UPDATE [params=(String) firstName%1111101] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? [params=(int) 1111101] |
| case derby: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') FOR UPDATE WITH RR |
| // [params=(String) firstName%1111101] |
| // SELECT t0.version FROM LSE1x1LfLzy t0 WHERE t0.id = ? [params=(int) 1111101] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterNamedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1111102] |
| assertLockTestSQLs(Select + tableLfName + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // [params=(int) 1111102] |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfLzy t0 WHERE t0.id = ? |
| // [params=(int) 1111102] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + NoForUpdate); |
| } |
| } |
| }); |
| } |
| |
| public void testNormalUni1x1JTLock() { |
| common1x1JTLock("testNormalUni1x1JTLock", 1112201, false); |
| } |
| |
| public void testExtendedUni1x1JTLock() { |
| common1x1JTLock("testExtendedUni1x1JTLock", 1112211, true); |
| } |
| |
| private void common1x1JTLock(String testName, int idLf0, boolean extended) { |
| final String tableLfName = "LSE1x1LfJT"; |
| final String tableJTName = "Uni1x1LfJT_Uni1x1RT"; |
| final String tableRtName = "LSE1x1Rt"; |
| final String joinTables = tableLfName + ".*JOIN.*" + tableJTName + ".*JOIN.*" + tableRtName; |
| |
| getLog().info("** " + testName + "()"); |
| String scope = extended ? "Extended" : "Normal"; |
| int idRt0 = idLf0 + 10000; // right table |
| int idLf1 = idLf0 + 1; |
| int idRt1 = idRt0 + 1; |
| |
| // create test entity. |
| LSE1x1LfJT eLf0 = new LSE1x1LfJT(); |
| LSE1x1Rt eRt0 = new LSE1x1Rt(); |
| eLf0.setId(idLf0); |
| eLf0.setFirstName("firstName " + idLf0); |
| eLf0.setUniRightJT(eRt0); |
| eRt0.setId(idRt0); |
| eRt0.setLastName("lastName " + idRt0); |
| LSE1x1LfJT eLf1 = new LSE1x1LfJT(); |
| LSE1x1Rt eRt1 = new LSE1x1Rt(); |
| eLf1.setId(idLf1); |
| eLf1.setFirstName("firstName " + idLf1); |
| eLf1.setUniRightJT(eRt1); |
| eRt1.setId(idRt1); |
| eRt1.setLastName("lastName " + idRt1); |
| |
| EntityManager em = null; |
| try { |
| em = emf.createEntityManager(); |
| em.getTransaction().begin(); |
| em.persist(eLf0); |
| em.persist(eRt0); |
| em.persist(eLf1); |
| em.persist(eRt1); |
| em.getTransaction().commit(); |
| } finally { |
| em = null; |
| eLf0 = eLf1 = null; |
| eRt0 = eRt1 = null; |
| if (em != null && em.isOpen()) { |
| em.close(); |
| } |
| } |
| |
| commonLockTest(testName, LSE1x1LfJT.class, idLf0, extended, |
| "SELECT c FROM LSE1x1LfJT c WHERE c.firstName LIKE :firstName", "findLSE1x1LfJT" + scope, |
| new AssertCallback() { |
| public void findNoLockDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1112201] |
| assertLockTestSQLs(Select + joinTables + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName |
| // FROM LSE1x1LfJT t0, Uni1x1LfJT_Uni1x1RT t1, LSE1x1Rt t2 |
| // WHERE t0.id = ? AND t0.id = t1.LSE1X1LFJT_ID AND t1.UNIRIGHTJT_ID = t2.id(+) |
| // [params=(int) 1112201] |
| assertLockTestSQLs(Select + tableLfName + Any + tableJTName + Any + tableRtName + Where |
| + "\\(\\+\\).*" + NoForUpdate); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id WHERE t0.id = ? |
| // [params=(int) 1112201] |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate); |
| } |
| } |
| |
| public void findPessimisticForcIncDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id WHERE t0.id = ? |
| // optimize for 1 row FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS |
| // [params=(int) 1112202] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(int) 1122202] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(int) 1112202] |
| assertLockTestSQLs(Select + joinTables + Where + DB2Lock, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| case oracle: // TODO: If jpa2, DO NOT lock LSE1x1RT using "FOR UDPATE OF col" |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName |
| // FROM LSE1x1LfJT t0, Uni1x1LfJT_Uni1x1RT t1, LSE1x1Rt t2 |
| // WHERE t0.id = ? AND t0.id = t1.LSE1X1LFJT_ID AND t1.UNIRIGHTJT_ID = t2.id(+) |
| // FOR UPDATE [params=(int) 1112202] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE [params=(int) 1122202] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? FOR UPDATE [params=(int) 1112202] |
| assertLockTestSQLs(Select + tableLfName + Any + tableJTName + Any + tableRtName + Where |
| + "\\(\\+\\).*" + ForUpdate); |
| break; |
| case derby: //-TODO: **Non-atomic lock, if jpa2/extended scope, LOCK Uni1x1LfJT_Uni1x1RT |
| // DO NOT lock LSE1x1Rt |
| // The database is unable to lock this query. Each object matching the query will be |
| // locked individually after it is loaded; however, it is technically possible that |
| // another transaction could modify the data before the lock is obtained. |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id WHERE t0.id = ? |
| // [params=(int) 1112202] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? -FOR UPDATE WITH RR- |
| // [params=(int) 1122202] |
| // SELECT t0.id FROM LSE1x1LfJT t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1112202] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? -FOR UPDATE WITH RR- |
| // [params=(int) 1112202] |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate, |
| Select + NoJoin + Any + tableLfName + Any + NoJoin + Where + ForUpdate, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| //-SELECT t0.id FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1122202]- |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + ForUpdate); |
| } |
| } |
| |
| public void queryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.id, t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RS USE AND KEEP UPDATE LOCKS [params=(String) firstName%1112201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1122201] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? [params=(int) 1112201] |
| assertLockTestSQLs(Select + joinTables + Where + DB2Lock, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| case oracle: // TODO: If jpa2, DO NOT lock LSE1x1RT using "FOR UDPATE OF col" |
| // SELECT t0.id, t0.version, t0.firstName, t2.id, t2.version, t2.lastName |
| // FROM LSE1x1LfJT t0, Uni1x1LfJT_Uni1x1RT t1, LSE1x1Rt t2 |
| // WHERE (t0.firstName LIKE ?) AND t0.id = t1.LSE1X1LFJT_ID |
| // AND t1.UNIRIGHTJT_ID = t2.id(+) FOR UPDATE [params=(String) firstName%1112201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1122201] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? [params=(int) 1112201] |
| assertLockTestSQLs(Select + tableLfName + Any + tableJTName + Any + tableRtName + Where |
| + "\\(\\+\\).*" + ForUpdate); |
| break; |
| case derby: //-TODO: **Non-atomic lock, if jpa2/extended scope, LOCK Uni1x1LfJT_Uni1x1RT |
| // DO NOT lock LSE1x1Rt |
| // The database is unable to lock this query. Each object matching the query will be |
| // locked individually after it is loaded; however, it is technically possible that |
| // another transaction could modify the data before the lock is obtained. |
| // SELECT t0.id, t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') [params=(String) firstName%1112201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1122201] |
| // SELECT t0.id FROM LSE1x1LfJT t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1112201] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? [params=(int) 1112201] |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate, |
| Select + NoJoin + Any + tableLfName + Any + NoJoin + Where + ForUpdate, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| //-SELECT t0.id FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1122201]- |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterQueryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1112202] |
| assertLockTestSQLs(Select + joinTables + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName |
| // FROM LSE1x1LfJT t0, Uni1x1LfJT_Uni1x1RT t1, LSE1x1Rt t2 |
| // WHERE t0.id = ? AND t0.id = t1.LSE1X1LFJT_ID AND t1.UNIRIGHTJT_ID = t2.id(+) |
| // [params=(int) 1112202] |
| assertLockTestSQLs(Select + tableLfName + Any + tableJTName + Any + tableRtName + Where |
| + "\\(\\+\\).*" + NoForUpdate); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id WHERE t0.id = ? |
| // [params=(int) 1112202] |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate); |
| } |
| } |
| |
| public void namedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { |
| case db2: |
| //SELECT t0.id, t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(String) firstName%1112201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1122201] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? [params=(int) 1112201] |
| assertLockTestSQLs(Select + joinTables + Where + DB2Lock, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| case oracle: // TODO: If jpa2, DO NOT lock LSE1x1RT using "FOR UDPATE OF col" |
| // SELECT t0.id, t0.version, t0.firstName, t2.id, t2.version, t2.lastName |
| // FROM LSE1x1LfJT t0, Uni1x1LfJT_Uni1x1RT t1, LSE1x1Rt t2 |
| // WHERE (t0.firstName LIKE ?) AND t0.id = t1.LSE1X1LFJT_ID |
| // AND t1.UNIRIGHTJT_ID = t2.id(+) FOR UPDATE [params=(String) firstName%1112201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1122201] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? [params=(int) 1112201] |
| assertLockTestSQLs(Select + tableLfName + Any + tableJTName + Any + tableRtName + Where |
| + "\\(\\+\\).*" + ForUpdate); |
| break; |
| case derby: //-TODO: **Non-atomic lock, if jpa2/extended scope, LOCK Uni1x1LfJT_Uni1x1RT |
| // DO NOT lock LSE1x1Rt |
| // The database is unable to lock this query. Each object matching the query will be |
| // locked individually after it is loaded; however, it is technically possible that |
| // another transaction could modify the data before the lock is obtained. |
| // SELECT t0.id, t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') [params=(String) firstName%1112201] |
| // SELECT t0.version FROM LSE1x1Rt t0 WHERE t0.id = ? [params=(int) 1122201] |
| // SELECT t0.id FROM LSE1x1LfJT t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1112201] |
| // SELECT t0.version FROM LSE1x1LfJT t0 WHERE t0.id = ? [params=(int) 1112201] |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate, |
| Select + NoJoin + Any + tableLfName + Any + NoJoin + Where + ForUpdate, |
| SelectVersion + NoJoin + Any + tableLfName + Any + NoJoin + Where + NoForUpdate, |
| SelectVersion + NoJoin + Any + tableRtName + Any + NoJoin + Where + NoForUpdate |
| ); |
| //-SELECT t0.id FROM LSE1x1Rt t0 WHERE t0.id = ? FOR UPDATE WITH RR [params=(int) 1122201] |
| assertLockTestNoSQLs(Select + NoJoin + Any + tableRtName + Any + NoJoin + Where + ForUpdate |
| ); |
| break; |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterNamedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1112202] |
| assertLockTestSQLs(Select + joinTables + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName |
| // FROM LSE1x1LfJT t0, Uni1x1LfJT_Uni1x1RT t1, LSE1x1Rt t2 |
| // WHERE t0.id = ? AND t0.id = t1.LSE1X1LFJT_ID AND t1.UNIRIGHTJT_ID = t2.id(+) |
| // [params=(int) 1112202] |
| assertLockTestSQLs(Select + tableLfName + Any + tableJTName + Any + tableRtName + Where |
| + "\\(\\+\\).*" + NoForUpdate); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName, t2.id, t2.version, t2.lastName FROM LSE1x1LfJT t0 |
| // INNER JOIN Uni1x1LfJT_Uni1x1RT t1 ON t0.id = t1.LSE1X1LFJT_ID |
| // LEFT OUTER JOIN LSE1x1Rt t2 ON t1.UNIRIGHTJT_ID = t2.id |
| // WHERE t0.id = ? [params=(int) 1112202] |
| default: |
| assertLockTestSQLs(Select + joinTables + Where + NoForUpdate); |
| } |
| } |
| }); |
| } |
| |
| public void testNormalUni1x1JTLazyLock() { |
| common1x1JTLazyLock("testNormalUni1x1JTLazyLock", 1112101, false); |
| } |
| |
| public void testExtendedUni1x1JTLazyLock() { |
| common1x1JTLazyLock("testExtendedUni1x1JTLazyLock", 1112111, true); |
| } |
| |
| private void common1x1JTLazyLock(String testName, int idLf0, boolean extended) { |
| final String tableLfName = "LSE1x1LfJTLzy"; |
| // final String tableRtName = "LockSEUni1x1RT"; |
| getLog().info("** " + testName + "()"); |
| String scope = extended ? "Extended" : "Normal"; |
| int idRt0 = idLf0 + 10000; // right table |
| int idLf1 = idLf0 + 1; |
| int idRt1 = idRt0 + 1; |
| |
| // create test entity. |
| LSE1x1LfJTLzy eLf0 = new LSE1x1LfJTLzy(); |
| LSE1x1Rt eRt0 = new LSE1x1Rt(); |
| eLf0.setId(idLf0); |
| eLf0.setFirstName("firstName " + idLf0); |
| eLf0.setUniRightJT(eRt0); |
| eRt0.setId(idRt0); |
| eRt0.setLastName("lastName " + idRt0); |
| LSE1x1LfJTLzy eLf1 = new LSE1x1LfJTLzy(); |
| LSE1x1Rt eRt1 = new LSE1x1Rt(); |
| eLf1.setId(idLf1); |
| eLf1.setFirstName("firstName " + idLf1); |
| eLf1.setUniRightJT(eRt1); |
| eRt1.setId(idRt1); |
| eRt1.setLastName("lasttName " + idRt1); |
| |
| EntityManager em = null; |
| try { |
| em = emf.createEntityManager(); |
| em.getTransaction().begin(); |
| em.persist(eLf0); |
| em.persist(eRt0); |
| em.persist(eLf1); |
| em.persist(eRt1); |
| em.getTransaction().commit(); |
| } finally { |
| em = null; |
| eLf0 = eLf1 = null; |
| eRt0 = eRt1 = null; |
| if (em != null && em.isOpen()) { |
| em.close(); |
| } |
| } |
| |
| commonLockTest(testName, LSE1x1LfJTLzy.class, idLf0, extended, |
| "SELECT c FROM LSE1x1LfJTLzy c WHERE c.firstName LIKE :firstName", "findLSE1x1LfJTLzy" + scope, |
| new AssertCallback() { |
| public void findNoLockDbSQL(EntityManager em) { |
| switch (getDBType(em)) { |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1112101] |
| assertLockTestSQLs(Select + tableLfName + Where + NoDB2Lock); |
| break; |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // [params=(int) 1112101] |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // [params=(int) 1112101] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + NoForUpdate); |
| } |
| } |
| |
| public void findPessimisticForcIncDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // optimize for 1 row FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS |
| // [params=(int) 1112102] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(int) 1112102] |
| assertLockTestSQLs(Select + tableLfName + Where + DB2Lock); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? FOR UPDATE WITH RR |
| // [params=(int) 1112102] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? FOR UPDATE WITH RR |
| // [params=(int) 1112102] |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? FOR UPDATE |
| // [params=(int) 1112102] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? FOR UPDATE [params=(int) 1112102] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + ForUpdate); |
| } |
| } |
| |
| public void queryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RS USE AND KEEP UPDATE LOCKS [params=(String) firstName%1112101] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? [params=(int) 1112101] |
| assertLockTestSQLs(Select + tableLfName + Where + DB2Lock); |
| break; |
| case derby: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') FOR UPDATE WITH RR |
| // [params=(String) firstName%1112101] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? [params=(int) 1112101] |
| case oracle: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 |
| // WHERE (t0.firstName LIKE ?) FOR UPDATE [params=(String) firstName%1112101] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? [params=(int) 1112101] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterQueryPessimisticReadDbSQL(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1112102] |
| assertLockTestSQLs(Select + tableLfName + Where + NoDB2Lock); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // [params=(int) 1112102] |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // [params=(int) 1112102] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + NoForUpdate); |
| } |
| } |
| |
| public void namedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') |
| // FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS [params=(String) firstName%1112101] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? [params=(int) 1112101] |
| assertLockTestSQLs(Select + tableLfName + Where + DB2Lock); |
| break; |
| case derby: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 |
| // WHERE (t0.firstName LIKE ? ESCAPE '\') FOR UPDATE WITH RR |
| // [params=(String) firstName%1112101] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? [params=(int) 1112101] |
| case oracle: |
| // SELECT t0.id, t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 |
| // WHERE (t0.firstName LIKE ?) FOR UPDATE [params=(String) firstName%1112101] |
| // SELECT t0.version FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? [params=(int) 1112101] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + ForUpdate); |
| } |
| } |
| |
| public void findNoLockAfterNamedQueryPessimisticWriteDbSql(EntityManager em) { |
| switch (getDBType(em)) { // **Check |
| case db2: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // optimize for 1 row [params=(int) 1112102] |
| assertLockTestSQLs(Select + tableLfName + Where + NoDB2Lock); |
| break; |
| case derby: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // [params=(int) 1112102] |
| case oracle: |
| // SELECT t0.version, t0.firstName FROM LSE1x1LfJTLzy t0 WHERE t0.id = ? |
| // [params=(int) 1112102] |
| default: |
| assertLockTestSQLs(Select + tableLfName + Where + NoForUpdate); |
| } |
| } |
| }); |
| } |
| } |
