From 85f2bd9d365aa275cd211332c4f3682ae20cc9df Mon Sep 17 00:00:00 2001 From: Nico Dreessen Date: Fri, 20 Nov 2026 10:24:38 +0100 Subject: [PATCH 1/5] Add DataSourceConnection interface. --- .../datasource/DataSourceConnection.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java diff --git a/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java b/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java new file mode 100644 index 00000000..d00b70f9 --- /dev/null +++ b/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java @@ -0,0 +1,21 @@ +package io.ebean.datasource; + +import java.sql.Connection; + +/** + * Interface for connection objects returned from the ebean-datasource connection pool + * + * @author Roland Praml, Foconis Analytics GmbH + */ +public interface DataSourceConnection extends Connection { + + /** + * Returns the affinity-ID, this connection was assigned to. + */ + Object affinityId(); + + /** + * Clears the prepared statement cache. + */ + void clearPreparedStatementCache(); +} From c93da2c5befe0b02804ddc611d111f5deb000cc0 Mon Sep 17 00:00:00 2001 From: Nico Dreessen Date: Fri, 20 Nov 2026 10:25:58 +0100 Subject: [PATCH 2/5] Clear prepared-statements-cache. --- .../io/ebean/datasource/pool/PooledConnection.java | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java index 050c98fd..bd3125ce 100644 --- a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java +++ b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java @@ -1,6 +1,13 @@ package io.ebean.datasource.pool; -import java.sql.*; +import java.sql.CallableStatement; +import java.sql.Connection; +import java.sql.DatabaseMetaData; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.SQLWarning; +import java.sql.Savepoint; +import java.sql.Statement; import java.util.ArrayList; import java.util.Map; import java.util.concurrent.TimeUnit; @@ -303,6 +310,7 @@ void clearPreparedStatementCache() throws SQLException { } } finally { + pstmtCache.clear(); lock.unlock(); } } From 5be64412b77dae6099deeba5c61c6be262271aab Mon Sep 17 00:00:00 2001 From: Nico Dreessen Date: Fri, 20 Nov 2026 10:36:06 +0100 Subject: [PATCH 3/5] Restore imports to old state. --- .../java/io/ebean/datasource/pool/PooledConnection.java | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java index bd3125ce..d71c86f8 100644 --- a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java +++ b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java @@ -1,13 +1,6 @@ package io.ebean.datasource.pool; -import java.sql.CallableStatement; -import java.sql.Connection; -import java.sql.DatabaseMetaData; -import java.sql.PreparedStatement; -import java.sql.SQLException; -import java.sql.SQLWarning; -import java.sql.Savepoint; -import java.sql.Statement; +import java.sql.*; import java.util.ArrayList; import java.util.Map; import java.util.concurrent.TimeUnit; From 35218fdd9ee7ca388cb6068668fb5f7c8d5ef8b1 Mon Sep 17 00:00:00 2001 From: Nico Dreessen Date: Fri, 20 Nov 2026 16:26:13 +0100 Subject: [PATCH 4/5] Add test --- .../datasource/DataSourceConnection.java | 5 - .../datasource/DataSourcePoolListener.java | 17 +++ .../datasource/pool/ConnectionDelegator.java | 4 +- .../ebean/datasource/pool/ConnectionPool.java | 11 +- .../datasource/pool/PooledConnection.java | 31 ++-- .../pool/PreparedStatementCacheTest.java | 144 ++++++++++++++++++ 6 files changed, 191 insertions(+), 21 deletions(-) create mode 100644 ebean-datasource/src/test/java/io/ebean/datasource/pool/PreparedStatementCacheTest.java diff --git a/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java b/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java index d00b70f9..15a4f2a4 100644 --- a/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java +++ b/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConnection.java @@ -9,11 +9,6 @@ */ public interface DataSourceConnection extends Connection { - /** - * Returns the affinity-ID, this connection was assigned to. - */ - Object affinityId(); - /** * Clears the prepared statement cache. */ diff --git a/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourcePoolListener.java b/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourcePoolListener.java index 5471c518..a025588a 100644 --- a/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourcePoolListener.java +++ b/ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourcePoolListener.java @@ -1,6 +1,7 @@ package io.ebean.datasource; import java.sql.Connection; +import java.sql.SQLException; /** @@ -17,11 +18,27 @@ public interface DataSourcePoolListener { /** * Called after a connection has been retrieved from the connection pool */ + default void onAfterBorrowConnection(DataSourcePool pool, DataSourceConnection connection) throws SQLException { + onAfterBorrowConnection(connection); + } + + /** + * @deprecated implement {@link #onAfterBorrowConnection(DataSourcePool, DataSourceConnection)} + */ + @Deprecated default void onAfterBorrowConnection(Connection connection) {} /** * Called before a connection will be put back to the connection pool */ + default void onBeforeReturnConnection(DataSourcePool pool, DataSourceConnection connection) { + onBeforeReturnConnection(connection); + } + + /** + * @deprecated implement {@link #onBeforeReturnConnection(DataSourcePool, DataSourceConnection)} + */ + @Deprecated default void onBeforeReturnConnection(Connection connection) {} diff --git a/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionDelegator.java b/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionDelegator.java index 6fd3a67a..c25fbabb 100644 --- a/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionDelegator.java +++ b/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionDelegator.java @@ -96,7 +96,7 @@ public final Struct createStruct(String typeName, Object[] attributes) throws SQ @SuppressWarnings("unchecked") @Override - public final T unwrap(Class iface) throws SQLException { + public T unwrap(Class iface) throws SQLException { if (iface.equals(java.sql.Connection.class)) { return (T) delegate; } @@ -104,7 +104,7 @@ public final T unwrap(Class iface) throws SQLException { } @Override - public final boolean isWrapperFor(Class iface) throws SQLException { + public boolean isWrapperFor(Class iface) throws SQLException { return delegate.isWrapperFor(iface); } } diff --git a/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionPool.java b/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionPool.java index 2f7c7d81..25dbd9a8 100644 --- a/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionPool.java +++ b/ebean-datasource/src/main/java/io/ebean/datasource/pool/ConnectionPool.java @@ -271,7 +271,7 @@ private void initialiseDatabase() throws SQLException { */ @Override public boolean isWrapperFor(Class arg0) { - return false; + return DataSourcePool.class.isAssignableFrom(arg0); } /** @@ -279,7 +279,10 @@ public boolean isWrapperFor(Class arg0) { */ @Override public T unwrap(Class arg0) throws SQLException { - throw new SQLException("Not Implemented"); + if (DataSourcePool.class.isAssignableFrom(arg0)) { + return (T) this; + } + throw new SQLException("Not a wrapper for " + arg0.getName()); } /** @@ -618,7 +621,7 @@ void removeClosedConnection(PooledConnection pooledConnection) { */ private void returnTheConnection(PooledConnection pooledConnection, boolean forceClose) { if (poolListener != null && !forceClose && !pooledConnection.heartbeat()) { - poolListener.onBeforeReturnConnection(pooledConnection); + poolListener.onBeforeReturnConnection(this, pooledConnection); } queue.returnPooledConnection(pooledConnection, forceClose); } @@ -699,7 +702,7 @@ private PooledConnection getPooledConnection(boolean heartbeat) throws SQLExcept c.setStackTrace(Thread.currentThread().getStackTrace()); } if (poolListener != null) { - poolListener.onAfterBorrowConnection(c); + poolListener.onAfterBorrowConnection(this, c); } return c; } diff --git a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java index d71c86f8..286ab31f 100644 --- a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java +++ b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java @@ -1,5 +1,6 @@ package io.ebean.datasource.pool; +import io.ebean.datasource.DataSourceConnection;import io.ebean.datasource.DataSourcePool; import java.sql.*; import java.util.ArrayList; import java.util.Map; @@ -18,7 +19,7 @@ * It has caching of Statements and PreparedStatements. Remembers the last * statement that was executed. Keeps statistics on how long it is in use. */ -final class PooledConnection extends ConnectionDelegator { +final class PooledConnection extends ConnectionDelegator implements DataSourceConnection { private static final String IDLE_CONNECTION_ACCESSED_ERROR = "Pooled Connection has been accessed whilst idle in the pool, via method: "; @@ -262,13 +263,7 @@ void doCloseConnection(boolean logErrors) { Log.error("Error checking if connection [" + name + "] is closed", ex); } } - try { - clearPreparedStatementCache(); - } catch (SQLException ex) { - if (logErrors) { - Log.warn("Error when closing connection Statements", ex); - } - } + clearPreparedStatementCache(); try { // DB2 (and some other DBMS) may have uncommitted changes and do not allow close // so try to do a rollback. @@ -295,11 +290,15 @@ void doCloseConnection(boolean logErrors) { } } - void clearPreparedStatementCache() throws SQLException { + public void clearPreparedStatementCache() { lock.lock(); try { for (ExtendedPreparedStatement ps : pstmtCache.values()) { - ps.closeDestroy(); + try { + ps.closeDestroy(); + } catch (SQLException ex) { + Log.warn("Error when closing connection Statements", ex); + } } } finally { @@ -1023,4 +1022,16 @@ private String stackTraceAsString(StackTraceElement[] stackTrace) { return filteredList.toString(); } + @Override + public boolean isWrapperFor(Class arg0) throws SQLException { + return DataSourceConnection.class.isAssignableFrom(arg0) || super.isWrapperFor(arg0); + } + + @Override + public T unwrap(Class arg0) throws SQLException { + if (DataSourceConnection.class.isAssignableFrom(arg0)) { + return (T) this; + } + return super.unwrap(arg0); + } } diff --git a/ebean-datasource/src/test/java/io/ebean/datasource/pool/PreparedStatementCacheTest.java b/ebean-datasource/src/test/java/io/ebean/datasource/pool/PreparedStatementCacheTest.java new file mode 100644 index 00000000..49ac7412 --- /dev/null +++ b/ebean-datasource/src/test/java/io/ebean/datasource/pool/PreparedStatementCacheTest.java @@ -0,0 +1,144 @@ +package io.ebean.datasource.pool; + +import io.ebean.datasource.DataSourceConfig; +import io.ebean.datasource.DataSourceConnection; +import io.ebean.datasource.DataSourcePool; +import io.ebean.datasource.DataSourcePoolListener; +import org.checkerframework.checker.nullness.qual.NonNull; +import org.h2.Driver; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Proxy; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.Properties; +import java.util.concurrent.atomic.AtomicReference; + +import static org.assertj.core.api.Assertions.assertThat; + +class PreparedStatementCacheTest { + + private Connection activeConnection; + + private int tenant; + + /** + * Nach dem Austausch der physischen Verbindung muss dieselbe SQL-Abfrage ein neues + * PreparedStatement erhalten und den Wert aus der zweiten Datenbank liefern. + */ + @Test + void queryAfterPhysicalConnectionSwitch() throws SQLException { + try (var first = DriverManager.getConnection("jdbc:h2:mem:preparedStatementCacheFirst"); + var second = DriverManager.getConnection("jdbc:h2:mem:preparedStatementCacheSecond")) { + populate(first, 10); + populate(second, 20); + + tenant = 1; + activeConnection = first; + + var config = new DataSourceConfig() + .setUsername("dummy") + .setPassword("dummy") + .setListener(createSwitchingListener(first, second)) + .setMinConnections(1) + .setMaxConnections(1) + .setAutoCommit(true) + .setPstmtCacheSize(2) + .validateOnHeartbeat(false); + config.driver(createSwitchingDriver()); + var pool = new ConnectionPool("preparedStatementCache", config); + Connection tmp; + try { + try (DataSourceConnection connection = pool.getConnection().unwrap(DataSourceConnection.class)) { + assertThat(query(connection)).isEqualTo(10); + tmp = connection; + } + + try (DataSourceConnection connection = pool.getConnection().unwrap(DataSourceConnection.class)) { + assertThat(query(connection)).isEqualTo(10); + assertThat(connection).isSameAs(tmp); + } + + tenant = 2; + try (Connection connection = pool.getConnection()) { + // If `preparedStatementCache` isn’t cleared here, the query returns `10`, a value from the wrong tenant! + assertThat(query(connection)).isEqualTo(20); + assertThat(connection).isSameAs(tmp); + } + + } finally { + pool.shutdown(); + } + } + } + + private @NonNull DataSourcePoolListener createSwitchingListener(Connection first, Connection second) { + return new DataSourcePoolListener() { + @Override + public void onAfterBorrowConnection(DataSourcePool pool, DataSourceConnection connection) throws SQLException { + switch (tenant) { + case 1: + if (activeConnection != first) { + activeConnection = first; + connection.clearPreparedStatementCache(); + } + break; + case 2: + if (activeConnection != second) { + activeConnection = second; + connection.clearPreparedStatementCache(); + } + break; + default: + throw new IllegalArgumentException(tenant + "is invalid"); + } + } + }; + } + + private @NonNull Driver createSwitchingDriver() { + return new Driver() { + @Override + public Connection connect(String url, Properties info) { + return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class[]{Connection.class}, + (proxy, method, args) -> { + try { + return method.invoke(activeConnection, args); + } catch (InvocationTargetException e) { + throw e.getCause(); + } + }); + } + }; + } + + private static void populate(Connection connection, int value) throws SQLException { + try (var statement = connection.createStatement()) { + statement.execute("create table test (id int primary key, test_value int)"); + statement.execute("insert into test values (1, " + value + ")"); + } + } + + private static int query(Connection connection) throws SQLException { + try (var statement = connection.prepareStatement("select test_value from test where id = ?")) { + statement.setInt(1, 1); + try (var result = statement.executeQuery()) { + assertThat(result.next()).isTrue(); + return result.getInt(1); + } + } + } + + private static Connection forwardingConnection(AtomicReference delegate) { + return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class[]{Connection.class}, + (proxy, method, args) -> { + try { + return method.invoke(delegate.get(), args); + } catch (InvocationTargetException e) { + throw e.getCause(); + } + }); + } +} From 9bfc9d07c975964b9498a5298659e99d374b6ed5 Mon Sep 17 00:00:00 2001 From: Nico Dreessen Date: Fri, 20 Nov 2026 16:36:57 +0100 Subject: [PATCH 5/5] Remove unused import. --- .../main/java/io/ebean/datasource/pool/PooledConnection.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java index 286ab31f..8399426c 100644 --- a/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java +++ b/ebean-datasource/src/main/java/io/ebean/datasource/pool/PooledConnection.java @@ -1,6 +1,6 @@ package io.ebean.datasource.pool; -import io.ebean.datasource.DataSourceConnection;import io.ebean.datasource.DataSourcePool; +import io.ebean.datasource.DataSourceConnection; import java.sql.*; import java.util.ArrayList; import java.util.Map;