PoolDataSourceTest.java
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (c) 2012-2014 Monty Program Ab
// Copyright (c) 2015-2025 MariaDB Corporation Ab
package org.mariadb.jdbc.integration;
import static org.junit.jupiter.api.Assertions.*;
import java.lang.management.ManagementFactory;
import java.sql.*;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import javax.management.MBeanInfo;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import javax.sql.XAConnection;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.mariadb.jdbc.MariaDbPoolDataSource;
import org.mariadb.jdbc.pool.PoolThreadFactory;
import org.mariadb.jdbc.pool.Pools;
public class PoolDataSourceTest extends Common {
/** Initialisation. */
@BeforeAll
public static void beforeClassDataSourceTest() throws SQLException {
drop();
boolean useOldNotation =
(!isMariaDBServer() || !minVersion(10, 2, 0))
&& (isMariaDBServer() || !minVersion(8, 0, 0));
Statement stmt = sharedConn.createStatement();
if (useOldNotation) {
stmt.execute("CREATE USER 'poolUser'" + getHostSuffix());
stmt.execute(
"GRANT ALL ON *.* TO 'poolUser'" + getHostSuffix() + " IDENTIFIED BY '!Passw0rd3Works'");
} else {
stmt.execute("CREATE USER 'poolUser'" + getHostSuffix() + " IDENTIFIED BY '!Passw0rd3Works'");
stmt.execute("GRANT ALL ON *.* TO 'poolUser'" + getHostSuffix());
}
stmt.execute(
"CREATE TABLE testResetRollback(id int not null primary key auto_increment, test"
+ " varchar(20))");
stmt.execute("FLUSH TABLES");
stmt.execute("FLUSH PRIVILEGES");
}
@AfterAll
public static void drop() throws SQLException {
try (Statement stmt = sharedConn.createStatement()) {
stmt.execute("DROP USER IF EXISTS 'poolUser'" + getHostSuffix());
stmt.execute("DROP TABLE IF EXISTS testResetRollback");
}
}
/**
* List current connections to server.
*
* @return number of thread connected.
*/
public static int getCurrentConnections() {
try {
Statement stmt = sharedConn.createStatement();
ResultSet rs = stmt.executeQuery("show status where `variable_name` = 'Threads_connected'");
if (rs.next()) {
return rs.getInt(2);
}
return -1;
} catch (SQLException e) {
return -1;
}
}
@Test
public void basic() throws SQLException {
MariaDbPoolDataSource ds = new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=2");
testDs(ds);
ds.close();
ds = new MariaDbPoolDataSource();
ds.setUrl(mDefUrl + "&maxPoolSize=2");
testDs(ds);
ds.close();
}
private void testDs(MariaDbPoolDataSource ds) throws SQLException {
try (Connection con1 = ds.getConnection()) {
long threadId;
try (org.mariadb.jdbc.Connection con2 = (org.mariadb.jdbc.Connection) ds.getConnection()) {
threadId = con2.getThreadId();
ResultSet rs1 = con1.createStatement().executeQuery("SELECT 1");
ResultSet rs2 = con2.createStatement().executeQuery("SELECT 2");
while (rs1.next()) {
assertEquals(1, rs1.getInt(1));
}
while (rs2.next()) {
assertEquals(2, rs2.getInt(1));
}
}
try (org.mariadb.jdbc.Connection con2 = (org.mariadb.jdbc.Connection) ds.getConnection()) {
assertEquals(threadId, con2.getThreadId());
}
}
PooledConnection con1 = null;
PooledConnection con2 = null;
try {
con1 = ds.getPooledConnection();
con2 = ds.getPooledConnection();
try (Statement st1 = con1.getConnection().createStatement()) {
try (Statement st2 = con2.getConnection().createStatement()) {
ResultSet rs1 = st1.executeQuery("SELECT 1");
ResultSet rs2 = st2.executeQuery("SELECT 2");
while (rs1.next()) {
assertEquals(1, rs1.getInt(1));
}
while (rs2.next()) {
assertEquals(2, rs2.getInt(1));
}
}
}
long threadId = ((org.mariadb.jdbc.Connection) con2.getConnection()).getThreadId();
con2.getConnection().close();
con2 = ds.getPooledConnection();
assertEquals(threadId, ((org.mariadb.jdbc.Connection) con2.getConnection()).getThreadId());
} finally {
if (con1 != null) con1.getConnection().close();
if (con2 != null) con2.getConnection().close();
}
XAConnection conx1 = null;
XAConnection conx2 = null;
try {
conx1 = ds.getXAConnection();
conx2 = ds.getXAConnection();
try (Statement st1 = conx1.getConnection().createStatement()) {
try (Statement st2 = conx2.getConnection().createStatement()) {
ResultSet rs1 = st1.executeQuery("SELECT 1");
ResultSet rs2 = st2.executeQuery("SELECT 2");
while (rs1.next()) {
assertEquals(1, rs1.getInt(1));
}
while (rs2.next()) {
assertEquals(2, rs2.getInt(1));
}
}
}
} finally {
if (conx1 != null) con1.close();
if (conx2 != null) con2.close();
}
}
@Test
public void basic2() throws SQLException {
MariaDbPoolDataSource ds = new MariaDbPoolDataSource();
assertNull(ds.getUrl());
assertNull(ds.getUser());
assertEquals(30, ds.getLoginTimeout());
DriverManager.setLoginTimeout(40);
assertEquals(40, ds.getLoginTimeout());
DriverManager.setLoginTimeout(0);
ds.setLoginTimeout(50);
assertEquals(50, ds.getLoginTimeout());
assertThrows(SQLException.class, ds::getConnection);
assertThrows(SQLException.class, () -> ds.getConnection("user", "password"));
assertThrows(SQLException.class, ds::getPooledConnection);
assertThrows(SQLException.class, () -> ds.getPooledConnection("user", "password"));
assertThrows(SQLException.class, ds::getXAConnection);
assertThrows(SQLException.class, () -> ds.getXAConnection("user", "password"));
ds.setUser("dd");
assertEquals("dd", ds.getUser());
ds.setPassword("pwd");
assertThrows(SQLException.class, ds::getConnection);
assertThrows(SQLException.class, ds::getPooledConnection);
assertThrows(SQLException.class, () -> ds.setUrl("jdbc:wrong://d"));
ds.setUrl("jdbc:mariadb://myhost:5500/db?someOption=val");
assertEquals(
"jdbc:mariadb://myhost:5500/db?user=dd&password=***&someOption=val&connectTimeout=50000",
ds.getUrl());
ds.close();
}
@Test
public void testDataSource() throws SQLException {
try (MariaDbPoolDataSource ds =
new MariaDbPoolDataSource(mDefUrl + "&allowPublicKeyRetrieval")) {
try (Connection connection = ds.getConnection()) {
assertTrue(connection.isValid(0));
}
try (Connection connection = ds.getConnection("poolUser", "!Passw0rd3Works")) {
assertTrue(connection.isValid(0));
}
PooledConnection poolCon = ds.getPooledConnection();
assertTrue(poolCon.getConnection().isValid(0));
poolCon.close();
poolCon = ds.getPooledConnection("poolUser", "!Passw0rd3Works");
assertTrue(poolCon.getConnection().isValid(0));
poolCon.close();
}
}
@Test
public void testResetDatabase() throws SQLException {
try (MariaDbPoolDataSource pool = new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1")) {
try (Connection connection = pool.getConnection()) {
Statement statement = connection.createStatement();
statement.execute("CREATE DATABASE IF NOT EXISTS testingReset");
connection.setCatalog("testingReset");
}
try (Connection connection = pool.getConnection()) {
assertEquals(sharedConn.getCatalog(), connection.getCatalog());
Statement statement = connection.createStatement();
statement.execute("DROP DATABASE testingReset");
}
}
}
@Test
public void testResetSessionVariable() throws SQLException {
testResetSessionVariable(false);
if (isMariaDBServer() && minVersion(10, 2, 0)) {
testResetSessionVariable(true);
}
}
private void testResetSessionVariable(boolean useResetConnection) throws SQLException {
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
mDefUrl + "&maxPoolSize=1&useResetConnection=" + useResetConnection)) {
long nowMillis;
int initialWaitTimeout;
try (Connection connection = pool.getConnection()) {
Statement statement = connection.createStatement();
nowMillis = getNowTime(statement);
initialWaitTimeout = getWaitTimeout(statement);
statement.execute(
"SET @@timestamp=UNIX_TIMESTAMP('1970-10-01 01:00:00'), @@wait_timeout=2000");
long newNowMillis = getNowTime(statement);
int waitTimeout = getWaitTimeout(statement);
assertTrue(nowMillis - newNowMillis > 23_587_200_000L);
assertEquals(2_000, waitTimeout);
}
try (Connection connection = pool.getConnection()) {
Statement statement = connection.createStatement();
long newNowMillis = getNowTime(statement);
int waitTimeout = getWaitTimeout(statement);
if (useResetConnection) {
assertTrue(nowMillis - newNowMillis < 10L);
assertEquals(initialWaitTimeout, waitTimeout);
} else {
assertTrue(nowMillis - newNowMillis > 23_587_200_000L);
assertEquals(2_000, waitTimeout);
}
}
}
}
private long getNowTime(Statement statement) throws SQLException {
ResultSet rs = statement.executeQuery("SELECT NOW()");
assertTrue(rs.next());
return rs.getTimestamp(1).getTime();
}
private int getWaitTimeout(Statement statement) throws SQLException {
ResultSet rs = statement.executeQuery("SELECT @@wait_timeout");
assertTrue(rs.next());
return rs.getInt(1);
}
@Test
public void testResetUserVariable() throws SQLException {
testResetUserVariable(false);
testResetUserVariable(false);
if (isMariaDBServer() && minVersion(10, 2, 0)) {
testResetUserVariable(true);
testResetUserVariable(true);
}
}
private void testResetUserVariable(boolean useResetConnection) throws SQLException {
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
mDefUrl
+ "&maxPoolSize=1&useResetConnection="
+ useResetConnection
+ "&allowPublicKeyRetrieval")) {
try (Connection connection = pool.getConnection()) {
Statement statement = connection.createStatement();
assertNull(getUserVariableStr(statement));
statement.execute("SET @str = '123'");
assertEquals("123", getUserVariableStr(statement));
}
try (Connection connection = pool.getConnection()) {
Statement statement = connection.createStatement();
if (useResetConnection) {
assertNull(getUserVariableStr(statement));
} else {
assertEquals("123", getUserVariableStr(statement));
}
}
}
}
private String getUserVariableStr(Statement statement) throws SQLException {
ResultSet rs = statement.executeQuery("SELECT @str");
assertTrue(rs.next());
return rs.getString(1);
}
@Test
public void testNetworkTimeout() throws SQLException {
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1&socketTimeout=10000")) {
try (Connection connection = pool.getConnection()) {
assertEquals(10_000, connection.getNetworkTimeout());
connection.setNetworkTimeout(null, 5_000);
}
try (Connection connection = pool.getConnection()) {
assertEquals(10_000, connection.getNetworkTimeout());
}
}
}
@Test
public void testResetReadOnly() throws SQLException {
try (MariaDbPoolDataSource pool = new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1")) {
try (Connection connection = pool.getConnection()) {
assertFalse(connection.isReadOnly());
connection.setReadOnly(true);
assertTrue(connection.isReadOnly());
}
try (Connection connection = pool.getConnection()) {
assertFalse(connection.isReadOnly());
}
}
}
@Test
public void testResetAutoCommit() throws SQLException {
try (MariaDbPoolDataSource pool = new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1")) {
try (Connection connection = pool.getConnection()) {
assertTrue(connection.getAutoCommit());
connection.setAutoCommit(false);
assertFalse(connection.getAutoCommit());
}
try (Connection connection = pool.getConnection()) {
assertTrue(connection.getAutoCommit());
}
}
}
@Test
public void testResetAutoCommitOption() throws SQLException {
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1&autocommit=false&poolName=PoolTest")) {
assertTrue(pool.getPoolName().startsWith("PoolTest-"));
try (Connection connection = pool.getConnection()) {
assertFalse(connection.getAutoCommit());
connection.setAutoCommit(true);
assertTrue(connection.getAutoCommit());
}
try (Connection connection = pool.getConnection()) {
assertFalse(connection.getAutoCommit());
}
}
}
@Test
public void testResetTransactionIsolation() throws SQLException {
try (MariaDbPoolDataSource pool = new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1")) {
try (Connection connection = pool.getConnection()) {
assertEquals(Connection.TRANSACTION_REPEATABLE_READ, connection.getTransactionIsolation());
connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
assertEquals(Connection.TRANSACTION_SERIALIZABLE, connection.getTransactionIsolation());
}
try (Connection connection = pool.getConnection()) {
assertEquals(Connection.TRANSACTION_REPEATABLE_READ, connection.getTransactionIsolation());
}
}
}
@Test
public void testJmx() throws Exception {
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
ObjectName filter = new ObjectName("org.mariadb.jdbc.pool:type=PoolTestJmx-*");
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=5&minPoolSize=0&poolName=PoolTestJmx")) {
try (Connection connection = pool.getConnection()) {
connection.isValid(1);
Set<ObjectName> objectNames = server.queryNames(filter, null);
assertEquals(1, objectNames.size());
ObjectName name = objectNames.iterator().next();
MBeanInfo info = server.getMBeanInfo(name);
assertEquals(4, info.getAttributes().length);
checkJmxInfo(server, name, 1, 1, 0);
try (Connection connection2 = pool.getConnection()) {
connection2.isValid(1);
checkJmxInfo(server, name, 2, 2, 0);
}
checkJmxInfo(server, name, 1, 2, 1);
}
}
}
@Test
public void testNoMinConnection() throws Exception {
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
ObjectName filter = new ObjectName("org.mariadb.jdbc.pool:type=testNoMinConnection-*");
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=5&poolName=testNoMinConnection")) {
try (Connection connection = pool.getConnection()) {
connection.isValid(1);
Set<ObjectName> objectNames = server.queryNames(filter, null);
assertEquals(1, objectNames.size());
ObjectName name = objectNames.iterator().next();
MBeanInfo info = server.getMBeanInfo(name);
assertEquals(4, info.getAttributes().length);
// wait to ensure pool has time to create 5 connections
try {
Thread.sleep(500);
} catch (InterruptedException interruptEx) {
// eat
}
checkJmxInfo(server, name, 1, 5, 4);
try (Connection connection2 = pool.getConnection()) {
connection2.isValid(1);
checkJmxInfo(server, name, 2, 5, 3);
}
checkJmxInfo(server, name, 1, 5, 4);
}
}
}
@Test
public void testIdleTimeout() throws Throwable {
// appveyor is so slow wait time are not relevant.
Assumptions.assumeTrue(System.getenv("APPVEYOR_BUILD_WORKER_IMAGE") == null);
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
ObjectName filter = new ObjectName("org.mariadb.jdbc.pool:type=testIdleTimeout-*");
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
mDefUrl
+ "&maxPoolSize=5&minPoolSize=3&poolName=testIdleTimeout&testMinRemovalDelay=50&maxIdleTime=100")) {
// wait to ensure pool has time to create 3 connections
Thread.sleep(1_000);
Set<ObjectName> objectNames = server.queryNames(filter, null);
ObjectName name = objectNames.iterator().next();
checkJmxInfo(server, name, 0, 3, 3);
pool.testGetConnectionIdleThreadIds();
Thread.sleep(200);
// must still have 3 connections, but must be other ones
checkJmxInfo(server, name, 0, 3, 3);
}
}
@Test
public void testMinConnection() throws Throwable {
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
ObjectName filter = new ObjectName("org.mariadb.jdbc.pool:type=testMinConnection-*");
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
mDefUrl
+ "&maxPoolSize=5&minPoolSize=3&poolName=testMinConnection&testMinRemovalDelay=30&maxIdleTime=100")) {
try (Connection connection = pool.getConnection()) {
connection.isValid(1);
Set<ObjectName> objectNames = server.queryNames(filter, null);
assertEquals(1, objectNames.size());
ObjectName name = objectNames.iterator().next();
MBeanInfo info = server.getMBeanInfo(name);
assertEquals(4, info.getAttributes().length);
// to ensure pool has time to create minimal connection number
Thread.sleep(200);
checkJmxInfo(server, name, 1, 3, 2);
try (Connection connection2 = pool.getConnection()) {
connection2.isValid(1);
checkJmxInfo(server, name, 2, 3, 1);
}
checkJmxInfo(server, name, 1, 3, 2);
}
}
}
private void checkJmxInfo(
MBeanServer server,
ObjectName name,
long expectedActive,
long expectedTotal,
long expectedIdle)
throws Exception {
assertEquals(
expectedActive, ((Long) server.getAttribute(name, "ActiveConnections")).longValue());
assertEquals(expectedTotal, ((Long) server.getAttribute(name, "TotalConnections")).longValue());
assertEquals(expectedIdle, ((Long) server.getAttribute(name, "IdleConnections")).longValue());
assertEquals(0, ((Long) server.getAttribute(name, "ConnectionRequests")).longValue());
}
@Test
public void testJmxDisable() throws Exception {
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
ObjectName filter = new ObjectName("org.mariadb.jdbc.pool:type=PoolTest-*");
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
mDefUrl + "&maxPoolSize=2®isterJmxPool=false&poolName=PoolTest")) {
try (Connection connection = pool.getConnection()) {
connection.isValid(1);
Set<ObjectName> objectNames = server.queryNames(filter, null);
assertEquals(0, objectNames.size());
}
}
}
@Test
public void testResetRollback() throws SQLException {
sharedConn.createStatement().execute("FLUSH TABLES");
try (MariaDbPoolDataSource pool = new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1")) {
try (Connection connection = pool.getConnection()) {
Statement stmt = connection.createStatement();
stmt.executeUpdate("INSERT INTO testResetRollback (test) VALUES ('heja')");
connection.setAutoCommit(false);
stmt.executeUpdate("INSERT INTO testResetRollback (test) VALUES ('japp')");
}
try (Connection connection = pool.getConnection()) {
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery("SELECT count(*) FROM testResetRollback");
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
}
}
}
@Test
public void ensureUsingPool() throws Exception {
ThreadPoolExecutor connectionAppender =
new ThreadPoolExecutor(
50,
5000,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(5000),
new PoolThreadFactory("testPool"));
Set<Integer> threadIds = new HashSet<>();
for (int i = 0; i < 500; i++) {
connectionAppender.execute(
() -> {
try (Connection connection =
DriverManager.getConnection(
mDefUrl + "&pool&staticGlobal&poolName=PoolEnsureUsingPool&log=true")) {
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery("SELECT CONNECTION_ID()");
rs.next();
Integer connectionId = rs.getInt(1);
threadIds.add(connectionId);
stmt.execute("SELECT 1");
} catch (SQLException e) {
// e.printStackTrace();
}
});
}
connectionAppender.shutdown();
connectionAppender.awaitTermination(30, TimeUnit.SECONDS);
assertTrue(threadIds.size() <= 9, "connection ids must be less than 9 : " + threadIds.size());
Pools.close("PoolTest");
}
@Test
public void wrongUrlHandling() throws SQLException {
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
"jdbc:mariadb://unknownHost/db?user=wrong&maxPoolSize=10&connectTimeout=500")) {
long start = System.currentTimeMillis();
try {
pool.getConnection();
fail();
} catch (SQLException sqle) {
// ensure more time for windows
assertTrue(
(System.currentTimeMillis() - start) >= 500
&& (System.currentTimeMillis() - start)
< (System.getProperty("os.name").toLowerCase(Locale.ROOT).contains("win")
? 1050
: 800),
"timeout does not correspond to option. Elapsed time:"
+ (System.currentTimeMillis() - start));
assertTrue(
sqle.getMessage()
.contains(
"No connection available within the specified time (option 'connectTimeout':"
+ " 500 ms)"));
}
}
}
@Test
public void testPrepareReset() throws SQLException {
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
mDefUrl + "&maxPoolSize=1&useServerPrepStmts=true&useResetConnection")) {
try (Connection connection = pool.getConnection()) {
PreparedStatement preparedStatement = connection.prepareStatement("SELECT ?");
preparedStatement.setString(1, "1");
preparedStatement.execute();
}
try (Connection connection = pool.getConnection()) {
// must re-prepare
PreparedStatement preparedStatement = connection.prepareStatement("SELECT ?");
preparedStatement.setString(1, "1");
preparedStatement.execute();
}
}
}
@Test
public void poolWithUser() throws SQLException {
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(
mDefUrl + "&maxPoolSize=1&poolName=myPool&allowPublicKeyRetrieval")) {
long threadId;
try (Connection conn = pool.getConnection()) {
conn.isValid(1);
threadId = ((org.mariadb.jdbc.Connection) conn).getThreadId();
}
try (Connection conn = pool.getConnection(user, password)) {
conn.isValid(1);
assertEquals(threadId, ((org.mariadb.jdbc.Connection) conn).getThreadId());
}
try (Connection conn = pool.getConnection("poolUser", "!Passw0rd3Works")) {
conn.isValid(1);
assertNotEquals(threadId, ((org.mariadb.jdbc.Connection) conn).getThreadId());
}
}
}
@Test
@SuppressWarnings("try")
public void various() throws SQLException {
Common.assertThrowsContains(
SQLException.class,
() -> new MariaDbPoolDataSource("jdbc:notMariadb"),
"Wrong mariaDB url");
try (MariaDbPoolDataSource pool =
new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1&poolName=myPool&connectTimeout=2000")) {
assertNotNull(pool.unwrap(org.mariadb.jdbc.MariaDbPoolDataSource.class));
assertNotNull(pool.unwrap(ConnectionPoolDataSource.class));
Common.assertThrowsContains(
SQLException.class,
() -> pool.unwrap(String.class),
"Datasource is not a wrapper for java.lang.String");
assertTrue(pool.isWrapperFor(org.mariadb.jdbc.MariaDbPoolDataSource.class));
assertTrue(pool.isWrapperFor(ConnectionPoolDataSource.class));
assertFalse(pool.isWrapperFor(String.class));
pool.setLogWriter(null);
assertNull(pool.getLogWriter());
assertNull(pool.getParentLogger());
assertEquals(2, pool.getLoginTimeout());
pool.setLoginTimeout(4);
assertEquals(4, pool.getLoginTimeout());
}
}
@Test
@SuppressWarnings("try")
public void pools() throws SQLException {
// ensure all are closed
Pools.close();
Pools.close(null);
new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1&poolName=myPool");
Pools.close("myPool");
new MariaDbPoolDataSource(mDefUrl + "&maxPoolSize=1&poolName=myPool");
Pools.close();
}
@Test
public void ensureConnectionClose() throws Exception {
MariaDbPoolDataSource datasource = new MariaDbPoolDataSource(mDefUrl);
Connection c = datasource.getConnection();
assertFalse(c.isClosed());
c.close();
assertFalse(c.isClosed());
PooledConnection pc = datasource.getPooledConnection();
assertFalse(pc.getConnection().isClosed());
pc.getConnection().close();
assertFalse(pc.getConnection().isClosed());
pc.close();
XAConnection xac = datasource.getXAConnection();
assertFalse(xac.getConnection().isClosed());
xac.getConnection().close();
assertFalse(xac.getConnection().isClosed());
xac.close();
}
@Timeout(value = 5, unit = TimeUnit.SECONDS)
@Test
public void testConcurrentCreationForDifferentHosts() throws Exception {
CountDownLatch ready = new CountDownLatch(5);
CountDownLatch start = new CountDownLatch(1);
ExecutorService executor = Executors.newCachedThreadPool();
try {
// When many pools are created concurrently
List<Future<MariaDbPoolDataSource>> futures =
IntStream.rangeClosed(1, 5)
.mapToObj(
hostIndex ->
executor.submit(
() -> {
ready.countDown();
start.await();
MariaDbPoolDataSource ds = new MariaDbPoolDataSource();
ds.setUrl(
"jdbc:mariadb://myhost" + hostIndex + ":5500/db?someOption=val");
return ds;
}))
.collect(Collectors.toList());
ready.await();
start.countDown();
// Then they should all be created in a timely manner
for (Future<MariaDbPoolDataSource> future : futures) {
future.get().close();
}
} finally {
executor.shutdown();
}
}
}