001: /**
002: *
003: * Licensed to the Apache Software Foundation (ASF) under one or more
004: * contributor license agreements. See the NOTICE file distributed with
005: * this work for additional information regarding copyright ownership.
006: * The ASF licenses this file to You under the Apache License, Version 2.0
007: * (the "License"); you may not use this file except in compliance with
008: * the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing, software
013: * distributed under the License is distributed on an "AS IS" BASIS,
014: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015: * See the License for the specific language governing permissions and
016: * limitations under the License.
017: */package org.apache.openejb.core.cmp.jpa;
018:
019: import org.apache.openejb.test.entity.cmp.ComplexCmpBean;
020: import org.apache.openejb.test.entity.cmp.UnknownCmpBean;
021: import org.apache.openejb.test.entity.cmp.BasicCmpBean;
022:
023: import javax.persistence.EntityManager;
024: import javax.persistence.EntityManagerFactory;
025: import javax.persistence.EntityTransaction;
026: import javax.sql.DataSource;
027: import javax.transaction.Status;
028: import javax.transaction.TransactionManager;
029: import java.sql.Connection;
030: import java.sql.ResultSet;
031: import java.sql.ResultSetMetaData;
032: import java.sql.SQLException;
033: import java.sql.Statement;
034: import java.util.Set;
035:
036: public class JpaTestObject extends junit.framework.Assert {
037: private EntityManagerFactory entityManagerFactory;
038: private TransactionManager transactionManager;
039: private DataSource nonJtaDs;
040:
041: private EntityManager entityManager;
042: private EntityTransaction transaction;
043: private static final String MCLAUGHLIN = "Brett McLaughlin";
044: private static final String FLANAGAN = "David Flanagan";
045: private static final String TIGER = "Java 5.0 Tiger";
046: private static final String JAVASCRIPT = "JavaScript";
047: private static final String ENTERPRISE_APPS = "Building Java Enterprise Applications";
048:
049: public EntityManagerFactory getEntityManagerFactory() {
050: return entityManagerFactory;
051: }
052:
053: public void setEntityManagerFactory(
054: EntityManagerFactory entityManagerFactory) {
055: this .entityManagerFactory = entityManagerFactory;
056: }
057:
058: public TransactionManager getTransactionManager() {
059: return transactionManager;
060: }
061:
062: public void setTransactionManager(
063: TransactionManager transactionManager) {
064: this .transactionManager = transactionManager;
065: }
066:
067: public DataSource getNonJtaDs() {
068: return nonJtaDs;
069: }
070:
071: public void setNonJtaDs(DataSource nonJtaDs) {
072: this .nonJtaDs = nonJtaDs;
073: }
074:
075: public void setUp() throws Exception {
076: }
077:
078: public void tearDown() throws Exception {
079: if (entityManager != null && entityManager.isOpen()) {
080: if (transactionManager == null) {
081: try {
082: if (entityManager.getTransaction()
083: .getRollbackOnly()) {
084: entityManager.getTransaction().rollback();
085: } else {
086: entityManager.getTransaction().commit();
087: }
088: } catch (Exception e) {
089: e.printStackTrace();
090: }
091: } else {
092: try {
093: if (transactionManager.getStatus() != Status.STATUS_NO_TRANSACTION) {
094: transactionManager.rollback();
095: }
096: } catch (Exception e) {
097: e.printStackTrace();
098: }
099: }
100: entityManager.close();
101: }
102:
103: nonJtaDs = null;
104: entityManager = null;
105: entityManagerFactory = null;
106: transactionManager = null;
107: }
108:
109: public void jpaLifecycle() throws Exception {
110: newDeleteNew();
111: employeeTest();
112: billTest();
113: cmpText();
114: complexCmpText();
115: unknownCmpText();
116: manytoMany();
117:
118: // beginTx();
119: // ABean_ABean a = new ABean_ABean();
120: // a.setField1(2);
121: // entityManager.persist(a);
122: // BBean_BBean b = new BBean_BBean();
123: // b.setField1(22);
124: // entityManager.persist(b);
125: // commitTx();
126: //
127: // beginTx();
128: // b = entityManager.find(BBean_BBean.class, 22);
129: // a = entityManager.find(ABean_ABean.class, 2);
130: // a.OpenEJB_addCmr("b", b);
131: // b.OpenEJB_addCmr("a", a);
132: // commitTx();
133: //
134: //// dump();
135: //
136: // beginTx();
137: // b = entityManager.find(BBean_BBean.class, 22);
138: // assertNotNull(b);
139: // assertEquals(new Integer(22), b.getField1());
140: //// a = (ABean_ABean) b.OpenEJB_getCmr("a");
141: //// assertNotNull(a);
142: //// assertEquals(new Integer(2), a.getField1());
143: // commitTx();
144: }
145:
146: private void newDeleteNew() throws Exception {
147: beginTx();
148:
149: // Create new
150: Person dain = new Person();
151: dain.setName("dain");
152: assertFalse(entityManager.contains(dain));
153: entityManager.persist(dain);
154: entityManager.flush();
155: dain = entityManager.merge(dain);
156: assertTrue(entityManager.contains(dain));
157:
158: // Find and verify
159: dain = entityManager.find(Person.class, "dain");
160: assertNotNull(dain);
161: assertEquals("dain", dain.getName());
162:
163: // Delete
164: entityManager.remove(dain);
165: assertFalse(entityManager.contains(dain));
166:
167: // Recreate
168: dain = new Person();
169: dain.setName("dain");
170: assertFalse(entityManager.contains(dain));
171: entityManager.persist(dain);
172: entityManager.flush();
173: dain = entityManager.merge(dain);
174: assertTrue(entityManager.contains(dain));
175:
176: // Find and verify
177: dain = entityManager.find(Person.class, "dain");
178: // assertNotNull(dain); // <<<<<<< FAILS
179: // assertEquals("dain", dain.getName());
180:
181: commitTx();
182: }
183:
184: private void employeeTest() throws Exception {
185: // get the pk for the inserted row
186: int davidPk = -1;
187: {
188: Connection connection = null;
189: Statement statement = null;
190: try {
191: connection = nonJtaDs.getConnection();
192: statement = connection.createStatement();
193: ResultSet resultSet = statement
194: .executeQuery("select * from employee");
195: resultSet.next();
196: davidPk = resultSet.getInt("id");
197: } finally {
198: close(statement);
199: close(connection);
200: }
201: }
202:
203: beginTx();
204: assertTrue(entityManager.isOpen());
205:
206: Employee david = entityManager.find(Employee.class, davidPk);
207: assertTrue(entityManager.contains(david));
208:
209: assertEquals(david.getId(), davidPk);
210: assertEquals(david.getFirstName(), "David");
211: assertEquals(david.getLastName(), "Blevins");
212: commitTx();
213:
214: beginTx();
215:
216: david = entityManager.find(Employee.class, davidPk);
217: assertTrue(entityManager.contains(david));
218:
219: assertEquals(david.getId(), davidPk);
220: assertEquals(david.getFirstName(), "David");
221: assertEquals(david.getLastName(), "Blevins");
222:
223: commitTx();
224: beginTx();
225:
226: david = (Employee) entityManager.createQuery(
227: "select e from Employee e where e.firstName='David'")
228: .getSingleResult();
229: assertTrue(entityManager.contains(david));
230:
231: assertEquals(david.getId(), davidPk);
232: assertEquals(david.getFirstName(), "David");
233: assertEquals(david.getLastName(), "Blevins");
234:
235: commitTx();
236: beginTx();
237:
238: david = entityManager.find(Employee.class, davidPk);
239: entityManager.remove(david);
240: assertFalse(entityManager.contains(david));
241: david = entityManager.find(Employee.class, davidPk);
242: assertNull(david);
243:
244: commitTx();
245: beginTx();
246:
247: Employee dain = new Employee();
248: dain.setFirstName("Dain");
249: dain.setLastName("Sundstrom");
250: assertFalse(entityManager.contains(dain));
251:
252: entityManager.persist(dain);
253:
254: // extract primary key seems to require a flush followed by a merge
255: entityManager.flush();
256: dain = entityManager.merge(dain);
257: int dainId = dain.getId();
258:
259: assertTrue(entityManager.contains(dain));
260:
261: commitTx();
262:
263: beginTx();
264:
265: dain = entityManager.find(Employee.class, dainId);
266: assertTrue(entityManager.contains(dain));
267:
268: assertEquals(dain.getId(), dainId);
269: assertEquals(dain.getFirstName(), "Dain");
270: assertEquals(dain.getLastName(), "Sundstrom");
271:
272: commitTx();
273: beginTx();
274:
275: dain = (Employee) entityManager.createQuery(
276: "select e from Employee e").getSingleResult();
277: assertTrue(entityManager.contains(dain));
278:
279: assertEquals(dain.getId(), dainId);
280: assertEquals(dain.getFirstName(), "Dain");
281: assertEquals(dain.getLastName(), "Sundstrom");
282:
283: commitTx();
284: }
285:
286: public void billTest() throws Exception {
287: // get the pk for the inserted row
288: BillPk basicPk;
289:
290: {
291: Connection connection = null;
292: Statement statement = null;
293: try {
294: connection = nonJtaDs.getConnection();
295: statement = connection.createStatement();
296: ResultSet resultSet = statement
297: .executeQuery("select * from bill");
298: resultSet.next();
299:
300: basicPk = new BillPk(resultSet.getLong("billNumber"),
301: resultSet.getLong("billVersion"), resultSet
302: .getLong("billRevision"));
303: } finally {
304: close(statement);
305: close(connection);
306: }
307: }
308:
309: beginTx();
310: assertTrue(entityManager.isOpen());
311:
312: Bill basic = entityManager.find(Bill.class, basicPk);
313: assertTrue(entityManager.contains(basic));
314:
315: assertTrue(basicPk.equals(new BillPk(1, 0, 0)));
316:
317: assertEquals(basic.getBillNumber(), 1);
318: assertEquals(basic.getBillVersion(), 0);
319: assertEquals(basic.getBillRevision(), 0);
320: assertEquals(basic.getBillDescription(), "Basic Model");
321:
322: commitTx();
323: beginTx();
324:
325: basic = (Bill) entityManager
326: .createQuery(
327: "select e from Bill e where e.billDescription='Basic Model'")
328: .getSingleResult();
329: assertTrue(entityManager.contains(basic));
330:
331: assertTrue(basicPk.equals(new BillPk(1, 0, 0)));
332:
333: assertEquals(basic.getBillNumber(), 1);
334: assertEquals(basic.getBillVersion(), 0);
335: assertEquals(basic.getBillRevision(), 0);
336: assertEquals(basic.getBillDescription(), "Basic Model");
337:
338: commitTx();
339: beginTx();
340:
341: basic = entityManager.find(Bill.class, basicPk);
342: entityManager.remove(basic);
343: assertFalse(entityManager.contains(basic));
344: basic = entityManager.find(Bill.class, basicPk);
345: assertNull(basic);
346:
347: commitTx();
348: beginTx();
349:
350: Bill advanced = new Bill();
351: advanced.setBillNumber(1000);
352: advanced.setBillVersion(2000);
353: advanced.setBillRevision(3000);
354: advanced.setBillDescription("This is so advanced!!");
355: assertFalse(entityManager.contains(advanced));
356:
357: entityManager.persist(advanced);
358:
359: // extract primary key seems to require a flush followed by a merge
360: entityManager.flush();
361: advanced = entityManager.merge(advanced);
362:
363: BillPk advancedPk = new BillPk(advanced.getBillNumber(),
364: advanced.getBillVersion(), advanced.getBillRevision());
365:
366: assertTrue(entityManager.contains(advanced));
367:
368: commitTx();
369: beginTx();
370:
371: advanced = entityManager.find(Bill.class, advancedPk);
372: assertTrue(entityManager.contains(advanced));
373:
374: assertTrue(advancedPk.equals(new BillPk(1000, 2000, 3000)));
375: assertEquals(advanced.getBillNumber(), 1000);
376: assertEquals(advanced.getBillVersion(), 2000);
377: assertEquals(advanced.getBillRevision(), 3000);
378: assertEquals(advanced.getBillDescription(),
379: "This is so advanced!!");
380:
381: commitTx();
382: beginTx();
383:
384: advanced = (Bill) entityManager.createQuery(
385: "select e from Bill e").getSingleResult();
386: assertTrue(entityManager.contains(advanced));
387:
388: assertTrue(advancedPk.equals(new BillPk(1000, 2000, 3000)));
389: assertEquals(advanced.getBillNumber(), 1000);
390: assertEquals(advanced.getBillVersion(), 2000);
391: assertEquals(advanced.getBillRevision(), 3000);
392: assertEquals(advanced.getBillDescription(),
393: "This is so advanced!!");
394:
395: commitTx();
396: }
397:
398: private void cmpText() throws Exception {
399: beginTx();
400:
401: BasicCmpBean basicCmpBean = new BasicCmpBean_Subclass();
402: basicCmpBean.ejbCreateObject("Joe Blow");
403: assertFalse(entityManager.contains(basicCmpBean));
404:
405: entityManager.persist(basicCmpBean);
406:
407: // extract primary key seems to require a flush followed by a merge
408: entityManager.flush();
409: basicCmpBean = entityManager.merge(basicCmpBean);
410: int joeId = basicCmpBean.getPrimaryKey();
411:
412: assertTrue(entityManager.contains(basicCmpBean));
413:
414: commitTx();
415: beginTx();
416:
417: basicCmpBean = new BasicCmpBean_Subclass();
418: basicCmpBean.ejbCreateObject("Lloyd Dobler");
419: assertFalse(entityManager.contains(basicCmpBean));
420:
421: entityManager.persist(basicCmpBean);
422:
423: // extract primary key seems to require a flush followed by a merge
424: entityManager.flush();
425: basicCmpBean = entityManager.merge(basicCmpBean);
426: int lloydId = basicCmpBean.getPrimaryKey();
427:
428: assertTrue(entityManager.contains(basicCmpBean));
429: commitTx();
430:
431: beginTx();
432:
433: BasicCmpBean joe = (BasicCmpBean) entityManager.createQuery(
434: "select e from BasicCmpBean_Subclass e where e.primaryKey="
435: + joeId).getSingleResult();
436: assertTrue(entityManager.contains(joe));
437:
438: assertEquals(joe.getPrimaryKey(), joeId);
439: assertEquals(joe.getFirstName(), "Joe");
440: assertEquals(joe.getLastName(), "Blow");
441:
442: BasicCmpBean lloyd = (BasicCmpBean) entityManager.createQuery(
443: "select e from BasicCmpBean_Subclass e where e.primaryKey="
444: + lloydId).getSingleResult();
445: assertTrue(entityManager.contains(lloyd));
446:
447: assertEquals(lloyd.getPrimaryKey(), lloydId);
448: assertEquals(lloyd.getFirstName(), "Lloyd");
449: assertEquals(lloyd.getLastName(), "Dobler");
450:
451: commitTx();
452: }
453:
454: private void complexCmpText() throws Exception {
455: beginTx();
456:
457: ComplexCmpBean complexCmpBean = new ComplexCmpBean_Subclass();
458: complexCmpBean.ejbCreateObject("Joe Blow");
459: assertFalse(entityManager.contains(complexCmpBean));
460:
461: entityManager.persist(complexCmpBean);
462:
463: // extract primary key seems to require a flush followed by a merge
464: entityManager.flush();
465: complexCmpBean = entityManager.merge(complexCmpBean);
466:
467: assertTrue(entityManager.contains(complexCmpBean));
468:
469: commitTx();
470: beginTx();
471:
472: complexCmpBean = new ComplexCmpBean_Subclass();
473: complexCmpBean.ejbCreateObject("Lloyd Dobler");
474: assertFalse(entityManager.contains(complexCmpBean));
475:
476: entityManager.persist(complexCmpBean);
477:
478: // extract primary key seems to require a flush followed by a merge
479: entityManager.flush();
480: complexCmpBean = entityManager.merge(complexCmpBean);
481:
482: assertTrue(entityManager.contains(complexCmpBean));
483: commitTx();
484:
485: beginTx();
486:
487: ComplexCmpBean joe = (ComplexCmpBean) entityManager
488: .createQuery(
489: "select e from ComplexCmpBean_Subclass e where e.firstName='Joe'")
490: .getSingleResult();
491: assertTrue(entityManager.contains(joe));
492:
493: assertEquals(joe.getFirstName(), "Joe");
494: assertEquals(joe.getLastName(), "Blow");
495:
496: ComplexCmpBean lloyd = (ComplexCmpBean) entityManager
497: .createQuery(
498: "select e from ComplexCmpBean_Subclass e where e.firstName='Lloyd'")
499: .getSingleResult();
500: assertTrue(entityManager.contains(lloyd));
501:
502: assertEquals(lloyd.getFirstName(), "Lloyd");
503: assertEquals(lloyd.getLastName(), "Dobler");
504:
505: commitTx();
506: }
507:
508: private void unknownCmpText() throws Exception {
509: beginTx();
510:
511: UnknownCmpBean unknownCmpBean = new UnknownCmpBean_Subclass();
512: unknownCmpBean.ejbCreateObject("Joe Blow");
513: assertFalse(entityManager.contains(unknownCmpBean));
514:
515: entityManager.persist(unknownCmpBean);
516:
517: // extract primary key seems to require a flush followed by a merge
518: entityManager.flush();
519: unknownCmpBean = entityManager.merge(unknownCmpBean);
520: Object joeId = unknownCmpBean.getPrimaryKey();
521:
522: assertTrue(entityManager.contains(unknownCmpBean));
523:
524: commitTx();
525: beginTx();
526:
527: unknownCmpBean = new UnknownCmpBean_Subclass();
528: unknownCmpBean.ejbCreateObject("Lloyd Dobler");
529: assertFalse(entityManager.contains(unknownCmpBean));
530:
531: entityManager.persist(unknownCmpBean);
532:
533: // extract primary key seems to require a flush followed by a merge
534: entityManager.flush();
535: unknownCmpBean = entityManager.merge(unknownCmpBean);
536: Object lloydId = unknownCmpBean.getPrimaryKey();
537:
538: assertTrue(entityManager.contains(unknownCmpBean));
539: commitTx();
540:
541: beginTx();
542:
543: UnknownCmpBean joe = (UnknownCmpBean) entityManager
544: .createQuery(
545: "select e from UnknownCmpBean_Subclass e where e.firstName='Joe'")
546: .getSingleResult();
547: assertTrue(entityManager.contains(joe));
548:
549: assertEquals(joe.getPrimaryKey(), joeId);
550: assertEquals(joe.getFirstName(), "Joe");
551: assertEquals(joe.getLastName(), "Blow");
552:
553: UnknownCmpBean lloyd = (UnknownCmpBean) entityManager
554: .createQuery(
555: "select e from UnknownCmpBean_Subclass e where e.firstName='Lloyd'")
556: .getSingleResult();
557: assertTrue(entityManager.contains(lloyd));
558:
559: assertEquals(lloyd.getPrimaryKey(), lloydId);
560: assertEquals(lloyd.getFirstName(), "Lloyd");
561: assertEquals(lloyd.getLastName(), "Dobler");
562:
563: commitTx();
564: }
565:
566: private void manytoMany() throws Exception {
567: beginTx();
568:
569: AuthorBean mcLaughlin = new AuthorBean(MCLAUGHLIN);
570: AuthorBean flanagan = new AuthorBean(FLANAGAN);
571:
572: BookBean tiger = new BookBean(TIGER);
573: BookBean javaScript = new BookBean(JAVASCRIPT);
574:
575: BookBean enterpriseApps = new BookBean(ENTERPRISE_APPS);
576:
577: entityManager.persist(mcLaughlin);
578: entityManager.persist(flanagan);
579: entityManager.persist(tiger);
580: entityManager.persist(javaScript);
581: entityManager.persist(enterpriseApps);
582:
583: commitTx();
584:
585: link(MCLAUGHLIN, TIGER);
586: link(MCLAUGHLIN, ENTERPRISE_APPS);
587: link(FLANAGAN, TIGER);
588: link(FLANAGAN, JAVASCRIPT);
589:
590: beginTx();
591:
592: BookBean book = entityManager.find(BookBean.class, TIGER);
593: assertTrue(entityManager.contains(book));
594:
595: assertEquals(book.getTitle(), TIGER);
596: Set<AuthorBean> authors = book.getAuthors();
597: assertEquals(authors.size(), 2);
598:
599: commitTx();
600: }
601:
602: private void link(String authorName, String title) throws Exception {
603: beginTx();
604: AuthorBean author = entityManager.find(AuthorBean.class,
605: authorName);
606: assertNotNull("Author not found " + authorName, author);
607:
608: BookBean book = entityManager.find(BookBean.class, title);
609: assertNotNull("Book not found " + title, book);
610:
611: book.OpenEJB_addCmr("authors", author);
612: author.OpenEJB_addCmr("books", book);
613: commitTx();
614: }
615:
616: private void createEntityManager() {
617: entityManager = entityManagerFactory.createEntityManager();
618:
619: // OpenJPAEntityManager openjpaEM = (OpenJPAEntityManager) entityManager;
620: // openjpaEM.addLifecycleListener(new JpaTestObject.OpenJPALifecycleListener(), (Class[])null);
621: }
622:
623: private void beginTx() throws Exception {
624: createEntityManager();
625:
626: String msg = "BEGIN_TX";
627: log(msg);
628: if (transactionManager != null) {
629: transactionManager.begin();
630: entityManager.joinTransaction();
631: } else {
632: transaction = entityManager.getTransaction();
633: transaction.begin();
634: }
635: }
636:
637: public void log(String msg) {
638: // System.out.println(msg);
639: }
640:
641: private void commitTx() throws Exception {
642: log(" BEFORE_COMMIT_TX");
643: try {
644: if (transactionManager != null) {
645: transactionManager.commit();
646: } else {
647: transaction.commit();
648: }
649: } finally {
650: if (entityManager != null && entityManager.isOpen()) {
651: entityManager.close();
652: }
653: entityManager = null;
654: log("AFTER_COMMIT_TX");
655: }
656: }
657:
658: // private class OpenJPALifecycleListener extends AbstractLifecycleListener {
659: // protected void eventOccurred(LifecycleEvent event) {
660: // int type = event.getType();
661: // switch (type) {
662: // case LifecycleEvent.BEFORE_PERSIST:
663: // log(" BEFORE_PERSIST");
664: // break;
665: // case LifecycleEvent.AFTER_PERSIST:
666: // log(" AFTER_PERSIST");
667: // break;
668: // case LifecycleEvent.AFTER_LOAD:
669: // log(" AFTER_LOAD");
670: // break;
671: // case LifecycleEvent.BEFORE_STORE:
672: // log(" BEFORE_STORE");
673: // break;
674: // case LifecycleEvent.AFTER_STORE:
675: // log(" AFTER_STORE");
676: // break;
677: // case LifecycleEvent.BEFORE_CLEAR:
678: // log(" BEFORE_CLEAR");
679: // break;
680: // case LifecycleEvent.AFTER_CLEAR:
681: // log(" AFTER_CLEAR");
682: // break;
683: // case LifecycleEvent.BEFORE_DELETE:
684: // log(" BEFORE_DELETE");
685: // break;
686: // case LifecycleEvent.AFTER_DELETE:
687: // log(" AFTER_DELETE");
688: // break;
689: // case LifecycleEvent.BEFORE_DIRTY:
690: // log(" BEFORE_DIRTY");
691: // break;
692: // case LifecycleEvent.AFTER_DIRTY:
693: // log(" AFTER_DIRTY");
694: // break;
695: // case LifecycleEvent.BEFORE_DIRTY_FLUSHED:
696: // log(" BEFORE_DIRTY_FLUSHED");
697: // break;
698: // case LifecycleEvent.AFTER_DIRTY_FLUSHED:
699: // log(" AFTER_DIRTY_FLUSHED");
700: // break;
701: // case LifecycleEvent.BEFORE_DETACH:
702: // log(" BEFORE_DETACH");
703: // break;
704: // case LifecycleEvent.AFTER_DETACH:
705: // log(" AFTER_DETACH");
706: // break;
707: // case LifecycleEvent.BEFORE_ATTACH:
708: // log(" BEFORE_ATTACH");
709: // break;
710: // case LifecycleEvent.AFTER_ATTACH:
711: // log(" AFTER_ATTACH");
712: // break;
713: // case LifecycleEvent.AFTER_REFRESH:
714: // log(" AFTER_REFRESH");
715: // break;
716: // default:
717: // log(" default");
718: // break;
719: // }
720: // super.eventOccurred(event);
721: // }
722: //
723: // public void beforePersist(LifecycleEvent event) {
724: // eventOccurred(event);
725: // }
726: //
727: // public void afterRefresh(LifecycleEvent event) {
728: // eventOccurred(event);
729: // }
730: //
731: // public void beforeDetach(LifecycleEvent event) {
732: // eventOccurred(event);
733: // }
734: //
735: // public void afterDetach(LifecycleEvent event) {
736: // eventOccurred(event);
737: // }
738: //
739: // public void beforeAttach(LifecycleEvent event) {
740: // eventOccurred(event);
741: // }
742: //
743: // public void afterAttach(LifecycleEvent event) {
744: // eventOccurred(event);
745: // }
746: // }
747:
748: protected void dump() throws SQLException {
749: JpaTestObject.dumpTable(nonJtaDs, "employee");
750: JpaTestObject.dumpTable(nonJtaDs, "OneToOneA");
751: JpaTestObject.dumpTable(nonJtaDs, "OneToOneB");
752: }
753:
754: public static void dumpTable(DataSource ds, String table)
755: throws SQLException {
756: Connection connection = null;
757: Statement statement = null;
758: ResultSet resultSet = null;
759: try {
760: connection = ds.getConnection();
761: statement = connection.createStatement();
762: resultSet = statement
763: .executeQuery("SELECT * FROM " + table);
764: ResultSetMetaData setMetaData = resultSet.getMetaData();
765: int columnCount = setMetaData.getColumnCount();
766: while (resultSet.next()) {
767: StringBuilder row = new StringBuilder();
768: for (int i = 1; i <= columnCount; i++) {
769: if (i > 1) {
770: row.append(", ");
771: }
772: String name = setMetaData.getColumnName(i);
773: Object value = resultSet.getObject(i);
774: row.append(name).append("=").append(value);
775: }
776: System.out.println(row);
777: }
778: } finally {
779: JpaTestObject.close(resultSet);
780: JpaTestObject.close(statement);
781: JpaTestObject.close(connection);
782: }
783: }
784:
785: private static void close(ResultSet resultSet) {
786: if (resultSet == null)
787: return;
788: try {
789: resultSet.close();
790: } catch (SQLException e) {
791: }
792: }
793:
794: private static void close(Statement statement) {
795: if (statement == null)
796: return;
797: try {
798: statement.close();
799: } catch (SQLException e) {
800: }
801: }
802:
803: private static void close(Connection connection) {
804: if (connection == null)
805: return;
806: try {
807: connection.close();
808: } catch (SQLException e) {
809: }
810: }
811: }
|