@Override public void close() { closeSession(); }
/** * Closes current session and remove the association from current thread. * @see jodd.db.DbSession#closeSession() */ @Override public void closeSession() { ThreadDbSessionHolder.remove(); super.closeSession(); }
/** * Creates new db session and assigns it to the current thread. * Closes already assigned session, if any exist. * @param connectionProvider connection provider */ public DbThreadSession(final ConnectionProvider connectionProvider) { super(connectionProvider); final DbSession session = ThreadDbSessionHolder.get(); if (session != null) { session.closeSession(); } ThreadDbSessionHolder.set(this); }
/** * {@inheritDoc} */ public void commitTransaction(final DbSession resource) { if (resource.isTransactionActive()) { log.debug("commit jtx"); resource.commitTransaction(); } resource.closeSession(); }
/** * {@inheritDoc} */ public void rollbackTransaction(final DbSession resource) { try { if (resource.isTransactionActive()) { log.debug("rollback tx"); resource.rollbackTransaction(); } } catch (Exception ex) { throw new JtxException(ex); } finally { resource.closeSession(); } }
@Override @AfterEach protected void tearDown() throws Exception { dbSession.closeSession(); super.tearDown(); }
@Override @AfterEach protected void tearDown() { session.closeSession(); DbOom.get().shutdown(); }
@AfterEach @Override protected void tearDown() throws Exception { DbSession session = new DbSession(cp); executeUpdate(session, "drop table GIRL if exists"); executeUpdate(session, "drop table BOY if exists"); executeUpdate(session, "drop table ROOM if exists"); session.closeSession(); super.tearDown(); }
@Test void testEnums() { DbSession session = new DbThreadSession(cp); String sql = "create table ENUMERATOR(ID int, NAME varchar(20), STATUS int)"; DbQuery query = new DbQuery(DbOom.get(), sql); query.executeUpdate(); Enumerator e = new Enumerator(); e.id = 2; e.name = "Ikigami"; e.status = Enumerator.STATUS.ONE; query = DbOomQuery.query(dbOom.entities().insert(e)); query.executeUpdate(); session.closeSession(); }
@BeforeEach protected void setUp() throws Exception { final DbPropsQueryMap queryMap = new DbPropsQueryMap(); if (SystemUtil.info().isJavaVersion(9)) { queryMap.props().load(this.getClass().getClassLoader().getResourceAsStream("queries.sql.props")); } LoggerFactory.setLoggerProvider(new TestLoggerProvider()); if (dbtxm != null) { return; } // create connection pool if not created if (cp == null) { cp = new CoreConnectionPool(); setupPool(cp); cp.init(); } dbtxm = new DbJtxTransactionManager(cp); dbOom = DbOom .create() .withConnectionProvider(cp) .withQueryMap(queryMap) .get() .connect(); // initial data final DbSession session = new DbSession(cp); initDb(session); session.closeSession(); }
@BeforeEach void setUp() { cp = new CoreConnectionPool(); cp.setDriver("org.hsqldb.jdbcDriver"); cp.setUrl("jdbc:hsqldb:mem:test"); cp.setUser("sa"); cp.setPassword(""); cp.init(); dbtxm = new DbJtxTransactionManager(cp); // initial data DbSession session = new DbSession(cp); executeUpdate(session, "drop table BOY if exists"); executeUpdate(session, "drop table GIRL if exists"); String sql = "create table GIRL (" + "ID integer not null," + "NAME varchar(20) not null," + "SPECIALITY varchar(20) null," + "primary key (ID)" + ')'; executeUpdate(session, sql); sql = "create table BOY (" + "ID integer not null," + "GIRL_ID integer null," + "NAME varchar(20) null," + "primary key (ID)," + "FOREIGN KEY (GIRL_ID) REFERENCES GIRL (ID)" + ')'; executeUpdate(session, sql); session.closeSession(); }
/** * Tests if rollback works. */ @Test void testRollback() { // prepare manager JtxTransactionManager manager = new JtxTransactionManager(); manager.registerResourceManager(new DbJtxResourceManager(cp)); // request transaction JtxTransaction tx = manager.requestTransaction(new JtxTransactionMode(JtxPropagationBehavior.PROPAGATION_REQUIRED, false)); DbSession session = tx.requestResource(DbSession.class); assertNotNull(session); // insert two records DbQuery query = DbQuery.query(session, "insert into GIRL values(4, 'Jeniffer', 'fighting')"); assertEquals(1, query.executeUpdate()); query = DbQuery.query(session, "insert into GIRL values(5, 'Annita', 'bartender')"); assertEquals(1, query.executeUpdate()); // rollback tx.rollback(); // check !!! session = new DbSession(cp); DbQuery query2 = DbQuery.query(session, "select count(*) from GIRL"); long count = query2.executeCount(); assertEquals(0, count); session.closeSession(); }
@Test void testSupportsNone() { LeanJtxWorker worker = new LeanJtxWorker(dbtxm); DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager()); // session #1: supports - commit JtxTransaction jtx = worker.maybeRequestTransaction(supports(), CTX_1); assertNotNull(jtx); DbSession session = sessionProvider.getDbSession(); executeUpdate(session, "insert into GIRL values(1, 'Sophia', null)"); assertFalse(jtx.isActive()); assertFalse(jtx.isCommitted()); assertTrue(jtx.isNoTransaction()); assertTrue(worker.maybeCommitTransaction(jtx)); assertFalse(jtx.isActive()); assertTrue(jtx.isCommitted()); // session #2: required - rollback jtx = worker.maybeRequestTransaction(supports(), CTX_2); assertNotNull(jtx); session = sessionProvider.getDbSession(); executeUpdate(session, "insert into GIRL values(2, 'Gloria', null)"); assertTrue(worker.markOrRollbackTransaction(jtx, null)); // test session = new DbSession(cp); assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 1")); assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 2")); session.closeSession(); }
@Test void testRequiredToSupportsCommit() { LeanJtxWorker worker = new LeanJtxWorker(dbtxm); DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager()); // session #1: required JtxTransaction jtx = worker.maybeRequestTransaction(required(), CTX_1); assertNotNull(jtx); DbSession session1 = sessionProvider.getDbSession(); executeUpdate(session1, "insert into GIRL values(1, 'Sophia', null)"); assertTrue(jtx.isActive()); assertFalse(jtx.isCommitted()); assertFalse(jtx.isNoTransaction()); // session #2: inner, supports JtxTransaction jtx2 = worker.maybeRequestTransaction(supports(), CTX_2); assertNull(jtx2); DbSession session2 = sessionProvider.getDbSession(); assertSame(session1, session2); executeUpdate(session2, "insert into GIRL values(2, 'Gloria', null)"); assertFalse(worker.maybeCommitTransaction(jtx2)); assertTrue(jtx.isActive()); // session #1: commit assertTrue(worker.maybeCommitTransaction(jtx)); assertFalse(jtx.isActive()); assertTrue(jtx.isCommitted()); // test session1 = new DbSession(cp); assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 1")); assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 2")); session1.closeSession(); }
@Test void testNotSupported() { LeanJtxWorker worker = new LeanJtxWorker(dbtxm); DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager()); // session #1: not supported - commit JtxTransaction jtx = worker.maybeRequestTransaction(notSupported(), CTX_1); assertNotNull(jtx); DbSession session = sessionProvider.getDbSession(); executeUpdate(session, "insert into GIRL values(1, 'Sophia', null)"); assertFalse(jtx.isActive()); assertTrue(jtx.isNoTransaction()); assertTrue(worker.maybeCommitTransaction(jtx)); assertFalse(jtx.isActive()); assertTrue(jtx.isCommitted()); // session #2: not supported - rollback jtx = worker.maybeRequestTransaction(notSupported(), CTX_2); assertNotNull(jtx); session = sessionProvider.getDbSession(); assertFalse(jtx.isActive()); assertTrue(jtx.isNoTransaction()); executeUpdate(session, "insert into GIRL values(2, 'Gloria', null)"); assertTrue(worker.markOrRollbackTransaction(jtx, null)); // test session = new DbSession(cp); assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 1")); assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 2")); session.closeSession(); }
@Test void testRequiredToRequiredCommit() { LeanJtxWorker worker = new LeanJtxWorker(dbtxm); DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager()); // session #1: required JtxTransaction jtx = worker.maybeRequestTransaction(required(), CTX_1); assertNotNull(jtx); DbSession session1 = sessionProvider.getDbSession(); executeUpdate(session1, "insert into GIRL values(1, 'Sophia', null)"); assertTrue(jtx.isActive()); assertFalse(jtx.isCommitted()); assertFalse(jtx.isNoTransaction()); // session #2: inner, required JtxTransaction jtx2 = worker.maybeRequestTransaction(required(), CTX_2); assertNull(jtx2); DbSession session2 = sessionProvider.getDbSession(); assertSame(session1, session2); executeUpdate(session2, "insert into GIRL values(2, 'Gloria', null)"); assertFalse(worker.maybeCommitTransaction(jtx2)); assertTrue(jtx.isActive()); // session #1: commit assertTrue(worker.maybeCommitTransaction(jtx)); assertFalse(jtx.isActive()); assertTrue(jtx.isCommitted()); // test session1 = new DbSession(cp); assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 1")); assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 2")); session1.closeSession(); }
@Test void testRequiredToMandatoryCommit() { LeanJtxWorker worker = new LeanJtxWorker(dbtxm); DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager()); // session #1: required JtxTransaction jtx = worker.maybeRequestTransaction(required(), CTX_1); assertNotNull(jtx); DbSession session1 = sessionProvider.getDbSession(); executeUpdate(session1, "insert into GIRL values(1, 'Sophia', null)"); assertTrue(jtx.isActive()); assertFalse(jtx.isCommitted()); assertFalse(jtx.isNoTransaction()); // session #2: inner, mandatory JtxTransaction jtx2 = worker.maybeRequestTransaction(mandatory(), CTX_2); assertNull(jtx2); DbSession session2 = sessionProvider.getDbSession(); assertSame(session1, session2); executeUpdate(session2, "insert into GIRL values(2, 'Gloria', null)"); assertFalse(worker.maybeCommitTransaction(jtx2)); assertTrue(jtx.isActive()); // session #1: commit assertTrue(worker.maybeCommitTransaction(jtx)); assertFalse(jtx.isActive()); assertTrue(jtx.isCommitted()); // test session1 = new DbSession(cp); assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 1")); assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 2")); session1.closeSession(); }
@Test void testRequired() { LeanJtxWorker worker = new LeanJtxWorker(dbtxm); DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager()); // session #1: required - commit JtxTransaction jtx = worker.maybeRequestTransaction(required(), CTX_1); assertTrue(jtx.isActive()); assertNotNull(jtx); DbSession session = sessionProvider.getDbSession(); executeUpdate(session, "insert into GIRL values(1, 'Sophia', null)"); assertTrue(jtx.isActive()); assertFalse(jtx.isCommitted()); assertFalse(jtx.isNoTransaction()); assertTrue(worker.maybeCommitTransaction(jtx)); assertFalse(jtx.isActive()); assertTrue(jtx.isCommitted()); assertFalse(jtx.isNoTransaction()); // session #2: required - rollback jtx = worker.maybeRequestTransaction(required(), CTX_1); assertNotNull(jtx); session = sessionProvider.getDbSession(); executeUpdate(session, "insert into GIRL values(2, 'Gloria', null)"); assertTrue(worker.markOrRollbackTransaction(jtx, null)); // test session = new DbSession(cp); assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 1")); assertEquals(0, executeCount(session, "select count(*) from GIRL where id = 2")); session.closeSession(); }
assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 1")); assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 2")); session1.closeSession();
assertEquals(0, executeCount(session1, "select count(*) from GIRL where id = 1")); assertEquals(0, executeCount(session1, "select count(*) from GIRL where id = 2")); session1.closeSession();