diff --git a/hibernate-agroal/src/main/java/org/hibernate/agroal/internal/AgroalConnectionProvider.java b/hibernate-agroal/src/main/java/org/hibernate/agroal/internal/AgroalConnectionProvider.java index 6374f9a643..e0da779265 100644 --- a/hibernate-agroal/src/main/java/org/hibernate/agroal/internal/AgroalConnectionProvider.java +++ b/hibernate-agroal/src/main/java/org/hibernate/agroal/internal/AgroalConnectionProvider.java @@ -9,6 +9,7 @@ package org.hibernate.agroal.internal; import io.agroal.api.AgroalDataSource; import io.agroal.api.configuration.AgroalConnectionFactoryConfiguration; +import io.agroal.api.configuration.AgroalConnectionPoolConfiguration; import io.agroal.api.configuration.supplier.AgroalConnectionFactoryConfigurationSupplier; import io.agroal.api.configuration.supplier.AgroalPropertiesReader; import io.agroal.api.security.NamePrincipal; @@ -17,11 +18,12 @@ import org.hibernate.HibernateException; import org.hibernate.cfg.AgroalSettings; import org.hibernate.cfg.AvailableSettings; import org.hibernate.engine.jdbc.connections.internal.ConnectionProviderInitiator; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.service.UnknownUnwrapTypeException; import org.hibernate.service.spi.Configurable; import org.hibernate.service.spi.Stoppable; -import org.jboss.logging.Logger; import javax.sql.DataSource; import java.sql.Connection; @@ -30,6 +32,10 @@ import java.util.Map; import java.util.function.Consumer; import java.util.function.Function; +import org.jboss.logging.Logger; + +import static org.hibernate.cfg.AgroalSettings.AGROAL_CONFIG_PREFIX; + /** * ConnectionProvider based on Agroal connection pool * To use this ConnectionProvider set: 
 hibernate.connection.provider_class AgroalConnectionProvider
@@ -54,18 +60,26 @@ import java.util.function.Function; */ public class AgroalConnectionProvider implements ConnectionProvider, Configurable, Stoppable { - public static final String CONFIG_PREFIX = AgroalSettings.AGROAL_CONFIG_PREFIX + "."; + public static final String CONFIG_PREFIX = AGROAL_CONFIG_PREFIX + "."; private static final long serialVersionUID = 1L; private static final Logger LOGGER = Logger.getLogger( AgroalConnectionProvider.class ); private AgroalDataSource agroalDataSource = null; + private DatabaseConnectionInfo dbInfo; // --- Configurable - private static void resolveIsolationSetting(Map properties, AgroalConnectionFactoryConfigurationSupplier cf) { + private static String extractIsolationAsString(Map properties) { Integer isolation = ConnectionProviderInitiator.extractIsolation( properties ); if ( isolation != null ) { // Agroal resolves transaction isolation from the 'nice' name - String isolationString = ConnectionProviderInitiator.toIsolationNiceName( isolation ); + return ConnectionProviderInitiator.toIsolationNiceName( isolation ); + } + return null; + } + + private static void resolveIsolationSetting(Map properties, AgroalConnectionFactoryConfigurationSupplier cf) { + String isolationString = extractIsolationAsString( properties ); + if ( isolationString != null ) { cf.jdbcTransactionIsolation( AgroalConnectionFactoryConfiguration.TransactionIsolation.valueOf( isolationString ) ); } } @@ -94,6 +108,18 @@ public class AgroalConnectionProvider implements ConnectionProvider, Configurabl } ) ); agroalDataSource = AgroalDataSource.from( agroalProperties ); + + // For logging purposes + AgroalConnectionPoolConfiguration acpc = agroalDataSource.getConfiguration().connectionPoolConfiguration(); + AgroalConnectionFactoryConfiguration acfc = acpc.connectionFactoryConfiguration(); + dbInfo = new DatabaseConnectionInfoImpl() + .setDBUrl( acfc.jdbcUrl() ) + .setDBDriverName( acfc.connectionProviderClass().toString() ) + .setDBAutoCommitMode( Boolean.toString(acfc.autoCommit()) ) + .setDBIsolationLevel( acfc.jdbcTransactionIsolation() != null ? + ConnectionProviderInitiator.toIsolationNiceName( acfc.jdbcTransactionIsolation().level() ) : null ) + .setDBMinPoolSize( String.valueOf(acpc.minSize()) ) + .setDBMaxPoolSize( String.valueOf(acpc.maxSize()) ); } catch ( Exception e ) { throw new HibernateException( e ); @@ -121,6 +147,11 @@ public class AgroalConnectionProvider implements ConnectionProvider, Configurabl return false; } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbInfo; + } + @Override public boolean isUnwrappableAs(Class unwrapType) { return ConnectionProvider.class.equals( unwrapType ) diff --git a/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0ConnectionProvider.java b/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0ConnectionProvider.java index 49b1e41aca..093965ea4e 100644 --- a/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0ConnectionProvider.java +++ b/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0ConnectionProvider.java @@ -21,7 +21,9 @@ import org.hibernate.boot.registry.classloading.spi.ClassLoadingException; import org.hibernate.cfg.C3p0Settings; import org.hibernate.cfg.JdbcSettings; import org.hibernate.engine.jdbc.connections.internal.ConnectionProviderInitiator; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.internal.util.PropertiesHelper; import org.hibernate.internal.util.config.ConfigurationHelper; import org.hibernate.service.UnknownUnwrapTypeException; @@ -61,7 +63,7 @@ public class C3P0ConnectionProvider // hibernate sensibly lets default to minPoolSize, but we'll let users // override it with the c3p0-style property if they want. private static final String C3P0_STYLE_INITIAL_POOL_SIZE = "c3p0.initialPoolSize"; - + private DatabaseConnectionInfo dbInfo; private DataSource ds; private Integer isolation; private boolean autocommit; @@ -121,13 +123,12 @@ public class C3P0ConnectionProvider JdbcSettings.URL, JdbcSettings.JPA_JDBC_URL ); + final Properties connectionProps = ConnectionProviderInitiator.getConnectionProperties( props ); - C3P0_MSG_LOGGER.c3p0UsingDriver( jdbcDriverClass, jdbcUrl ); C3P0_MSG_LOGGER.connectionProperties( ConfigurationHelper.maskOut( connectionProps, "password" ) ); autocommit = getBoolean( JdbcSettings.AUTOCOMMIT, props ); - C3P0_MSG_LOGGER.autoCommitMode( autocommit ); if ( jdbcDriverClass == null ) { C3P0_MSG_LOGGER.jdbcDriverNotSpecified(); @@ -141,11 +142,13 @@ public class C3P0ConnectionProvider } } + Integer minPoolSize = null; + Integer maxPoolSize = null; try { //swaldman 2004-02-07: modify to allow null values to signify fall through to c3p0 PoolConfig defaults - final Integer minPoolSize = getInteger( C3p0Settings.C3P0_MIN_SIZE, props ); - final Integer maxPoolSize = getInteger( C3p0Settings.C3P0_MAX_SIZE, props ); + minPoolSize = getInteger( C3p0Settings.C3P0_MIN_SIZE, props ); + maxPoolSize = getInteger( C3p0Settings.C3P0_MAX_SIZE, props ); final Integer maxIdleTime = getInteger( C3p0Settings.C3P0_TIMEOUT, props ); final Integer maxStatements = getInteger( C3p0Settings.C3P0_MAX_STATEMENTS, props ); final Integer acquireIncrement = getInteger( C3p0Settings.C3P0_ACQUIRE_INCREMENT, props ); @@ -187,19 +190,26 @@ public class C3P0ConnectionProvider final DataSource unpooled = DataSources.unpooledDataSource( jdbcUrl, connectionProps ); - final Map allProps = new HashMap<>(); + final Map allProps = new HashMap<>(); allProps.putAll( props ); allProps.putAll( PropertiesHelper.map(c3props) ); ds = DataSources.pooledDataSource( unpooled, allProps ); } catch (Exception e) { - C3P0_LOGGER.error( C3P0_MSG_LOGGER.unableToInstantiateC3p0ConnectionPool(), e ); + C3P0_LOGGER.error( C3P0_MSG_LOGGER.unableToInstantiateC3p0ConnectionPool(), e );; throw new HibernateException( C3P0_MSG_LOGGER.unableToInstantiateC3p0ConnectionPool(), e ); } isolation = ConnectionProviderInitiator.extractIsolation( props ); - C3P0_MSG_LOGGER.jdbcIsolationLevel( ConnectionProviderInitiator.toIsolationNiceName( isolation ) ); + + dbInfo = new DatabaseConnectionInfoImpl() + .setDBUrl( jdbcUrl ) + .setDBDriverName( jdbcDriverClass ) + .setDBAutoCommitMode( Boolean.toString( autocommit ) ) + .setDBIsolationLevel( isolation != null ? ConnectionProviderInitiator.toIsolationNiceName( isolation ) : null ) + .setDBMinPoolSize( String.valueOf(minPoolSize) ) + .setDBMaxPoolSize( String.valueOf(maxPoolSize) ); } @Override @@ -207,6 +217,11 @@ public class C3P0ConnectionProvider return false; } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbInfo; + } + private void setOverwriteProperty( String hibernateStyleKey, String c3p0StyleKey, @@ -237,6 +252,7 @@ public class C3P0ConnectionProvider } catch (SQLException sqle) { C3P0_MSG_LOGGER.unableToDestroyC3p0ConnectionPool( sqle ); + throw new HibernateException( "Unable to destroy the connection pool", sqle ); } } diff --git a/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0MessageLogger.java b/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0MessageLogger.java index b3c8b2e3d2..4fabc20f22 100644 --- a/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0MessageLogger.java +++ b/hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0MessageLogger.java @@ -50,16 +50,6 @@ public interface C3P0MessageLogger extends ConnectionPoolingLogger { + "properties. Hibernate-style property '%1$s' will be used and c3p0-style property '%2$s' will be ignored!", id = 10001) void bothHibernateAndC3p0StylesSet(String hibernateStyle,String c3p0Style); - /** - * Log a message (INFO) about which Driver class is being used. - * - * @param jdbcDriverClass The JDBC Driver class - * @param jdbcUrl The JDBC URL - */ - @LogMessage(level = INFO) - @Message(value = "C3P0 using driver: %s at URL: %s", id = 10002) - void c3p0UsingDriver(String jdbcDriverClass, String jdbcUrl); - /** * Build a message about not being able to find the JDBC driver class * diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DatabaseConnectionInfoImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DatabaseConnectionInfoImpl.java new file mode 100644 index 0000000000..f595320a97 --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DatabaseConnectionInfoImpl.java @@ -0,0 +1,115 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later + * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html + */ +package org.hibernate.engine.jdbc.connections.internal; + +import org.hibernate.dialect.DatabaseVersion; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; +import org.hibernate.internal.util.StringHelper; + +import static org.hibernate.dialect.SimpleDatabaseVersion.ZERO_VERSION; +import static org.hibernate.dialect.SimpleDatabaseVersion.NO_VERSION; + +/** + * @author Jan Schatteman + */ +public class DatabaseConnectionInfoImpl implements DatabaseConnectionInfo { + + public static final String DEFAULT = "undefined/unknown"; + + protected String dbUrl = DEFAULT; + protected String dbDriverName = DEFAULT; + protected DatabaseVersion dbVersion = ZERO_VERSION; + protected String dbAutoCommitMode = DEFAULT; + protected String dbIsolationLevel = DEFAULT; + protected String dbMinPoolSize = DEFAULT; + protected String dbMaxPoolSize = DEFAULT; + + public DatabaseConnectionInfoImpl() { + } + + @Override + public DatabaseConnectionInfo setDBUrl(String dbUrl) { + this.dbUrl = dbUrl; + return this; + } + + @Override + public DatabaseConnectionInfo setDBDriverName(String dbDriverName) { + if ( checkValidString(dbDriverName) && isDefaultStringValue(this.dbDriverName) ) { + this.dbDriverName = dbDriverName; + } + return this; + } + + @Override + public DatabaseConnectionInfo setDBVersion(DatabaseVersion dbVersion) { + if ( checkValidVersion(dbVersion) && ZERO_VERSION.equals(this.dbVersion) ) { + this.dbVersion = dbVersion; + } + return this; + } + + @Override + public DatabaseConnectionInfo setDBAutoCommitMode(String dbAutoCommitMode) { + if ( checkValidString(dbAutoCommitMode) && isDefaultStringValue(this.dbAutoCommitMode) ) { + this.dbAutoCommitMode = dbAutoCommitMode; + } + return this; + } + + @Override + public DatabaseConnectionInfo setDBIsolationLevel(String dbIsolationLevel) { + if ( checkValidString(dbIsolationLevel) && isDefaultStringValue(this.dbIsolationLevel) ) { + this.dbIsolationLevel = dbIsolationLevel; + } + return this; + } + + @Override + public DatabaseConnectionInfo setDBMinPoolSize(String minPoolSize) { + if ( checkValidInteger(minPoolSize) ) { + this.dbMinPoolSize = minPoolSize; + } + return this; + } + + @Override + public DatabaseConnectionInfo setDBMaxPoolSize(String maxPoolSize) { + if ( checkValidInteger(maxPoolSize) ) { + this.dbMaxPoolSize = maxPoolSize; + } + return this; + } + + private boolean checkValidInteger(String integerString) { + return checkValidString( integerString ) && Integer.parseInt( integerString, 10 ) >= 0; + } + + private boolean checkValidString(String value) { + return !( StringHelper.isBlank( value ) || "null".equalsIgnoreCase( value ) ); + } + + private boolean checkValidVersion(DatabaseVersion version) { + return version != null && !( version.isSame(ZERO_VERSION) || version.isSame(NO_VERSION) ); + } + + private boolean isDefaultStringValue(String value) { + return DEFAULT.equalsIgnoreCase( value ); + } + + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append( "\tDatabase JDBC URL [" ).append( dbUrl ).append(']'); + sb.append(sb.length() > 0 ? "\n\t" : "" ).append( "Database driver: " ).append( dbDriverName ); + sb.append(sb.length() > 0 ? "\n\t" : "" ).append( "Database version: " ).append( dbVersion ); + sb.append(sb.length() > 0 ? "\n\t" : "" ).append( "Autocommit mode: " ).append( dbAutoCommitMode ); + sb.append(sb.length() > 0 ? "\n\t" : "" ).append( "Isolation level: " ).append( dbIsolationLevel ); + sb.append(sb.length() > 0 ? "\n\t" : "" ).append( "Minimum pool size: " ).append( dbMinPoolSize ); + sb.append(sb.length() > 0 ? "\n\t" : "" ).append( "Maximum pool size: " ).append( dbMaxPoolSize ); + return sb.toString(); + } +} diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DatasourceConnectionProviderImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DatasourceConnectionProviderImpl.java index 9df9807409..d1ce7d9323 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DatasourceConnectionProviderImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DatasourceConnectionProviderImpl.java @@ -14,6 +14,7 @@ import javax.sql.DataSource; import org.hibernate.HibernateException; import org.hibernate.cfg.Environment; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.engine.jndi.spi.JndiService; import org.hibernate.service.UnknownUnwrapTypeException; import org.hibernate.service.spi.Configurable; @@ -38,6 +39,7 @@ public class DatasourceConnectionProviderImpl implements ConnectionProvider, Con private String pass; private boolean useCredentials; private JndiService jndiService; + private String dataSourceJndiName; private boolean available; @@ -92,6 +94,7 @@ public class DatasourceConnectionProviderImpl implements ConnectionProvider, Con + "] configuration property" ); } + this.dataSourceJndiName = dataSourceJndiName; if ( jndiService == null ) { throw new HibernateException( "Unable to locate JndiService to lookup Datasource" ); } @@ -131,4 +134,9 @@ public class DatasourceConnectionProviderImpl implements ConnectionProvider, Con public boolean supportsAggressiveRelease() { return true; } + + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return new DatabaseConnectionInfoImpl().setDBUrl( "Connecting through datasource" + dataSourceJndiName ); + } } diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DriverManagerConnectionProviderImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DriverManagerConnectionProviderImpl.java index bc6e8a8683..960e77f916 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DriverManagerConnectionProviderImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DriverManagerConnectionProviderImpl.java @@ -28,8 +28,10 @@ import org.hibernate.HibernateException; import org.hibernate.Internal; import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; import org.hibernate.cfg.AvailableSettings; +import org.hibernate.cfg.JdbcSettings; import org.hibernate.dialect.Database; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.internal.util.config.ConfigurationHelper; import org.hibernate.internal.util.securitymanager.SystemSecurityManager; import org.hibernate.service.UnknownUnwrapTypeException; @@ -67,6 +69,8 @@ public class DriverManagerConnectionProviderImpl private volatile PoolState state; + private static DatabaseConnectionInfo dbInfo; + // create the pool ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ private volatile ServiceRegistryImplementor serviceRegistry; @@ -132,13 +136,10 @@ public class DriverManagerConnectionProviderImpl } } - if ( success ) { - CONNECTIONS_MESSAGE_LOGGER.loadedDriver( driverClassName ); - } - else { + StringBuilder list = new StringBuilder(); + if ( !success ) { //we're hoping that the driver is already loaded CONNECTIONS_MESSAGE_LOGGER.noDriver( AvailableSettings.DRIVER ); - StringBuilder list = new StringBuilder(); Enumeration drivers = DriverManager.getDrivers(); while ( drivers.hasMoreElements() ) { if ( list.length() != 0) { @@ -146,7 +147,6 @@ public class DriverManagerConnectionProviderImpl } list.append( drivers.nextElement().getClass().getName() ); } - CONNECTIONS_MESSAGE_LOGGER.loadedDrivers( list.toString() ); } if ( url == null ) { @@ -155,8 +155,6 @@ public class DriverManagerConnectionProviderImpl throw new HibernateException( msg ); } - CONNECTIONS_MESSAGE_LOGGER.usingUrl( url ); - final Properties connectionProps = ConnectionProviderInitiator.getConnectionProperties( configurationValues ); // if debug level is enabled, then log the password, otherwise mask it @@ -168,13 +166,7 @@ public class DriverManagerConnectionProviderImpl } final boolean autoCommit = ConfigurationHelper.getBoolean( AvailableSettings.AUTOCOMMIT, configurationValues ); - CONNECTIONS_MESSAGE_LOGGER.autoCommitMode( autoCommit ); - final Integer isolation = ConnectionProviderInitiator.extractIsolation( configurationValues ); - if ( isolation != null ) { - CONNECTIONS_MESSAGE_LOGGER.jdbcIsolationLevel( ConnectionProviderInitiator.toIsolationNiceName( isolation ) ); - } - final String initSql = (String) configurationValues.get( INIT_SQL ); final Object connectionCreatorFactory = configurationValues.get( CONNECTION_CREATOR_FACTORY ); @@ -188,7 +180,17 @@ public class DriverManagerConnectionProviderImpl if ( factory == null ) { factory = ConnectionCreatorFactoryImpl.INSTANCE; } + + dbInfo = new DatabaseConnectionInfoImpl() + .setDBUrl( url ) + .setDBDriverName( success ? driverClassName : list.toString() ) + .setDBAutoCommitMode( Boolean.toString( autoCommit ) ) + .setDBIsolationLevel( isolation != null ? ConnectionProviderInitiator.toIsolationNiceName(isolation) : null ) + // no standard setting for minimum size? + .setDBMaxPoolSize( ConfigurationHelper.getString(JdbcSettings.POOL_SIZE, configurationValues) ); + return factory.create( + driver, serviceRegistry, url, @@ -275,6 +277,11 @@ public class DriverManagerConnectionProviderImpl return false; } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbInfo; + } + @Override public boolean isUnwrappableAs(Class unwrapType) { return ConnectionProvider.class.equals( unwrapType ) || diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/ConnectionProvider.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/ConnectionProvider.java index bc566d82f8..f1ce9617d1 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/ConnectionProvider.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/ConnectionProvider.java @@ -8,6 +8,7 @@ package org.hibernate.engine.jdbc.connections.spi; import java.sql.Connection; import java.sql.SQLException; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.service.Service; import org.hibernate.service.spi.Wrapped; @@ -69,4 +70,9 @@ public interface ConnectionProvider extends Service, Wrapped { * @return {@code true} if aggressive releasing is supported; {@code false} otherwise. */ boolean supportsAggressiveRelease(); + + default DatabaseConnectionInfo getDatabaseConnectionInfo() { + return new DatabaseConnectionInfoImpl(); + } + } diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/DataSourceBasedMultiTenantConnectionProviderImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/DataSourceBasedMultiTenantConnectionProviderImpl.java index db373bbb9e..415d08e12b 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/DataSourceBasedMultiTenantConnectionProviderImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/DataSourceBasedMultiTenantConnectionProviderImpl.java @@ -15,6 +15,7 @@ import org.hibernate.HibernateException; import org.hibernate.cfg.AvailableSettings; import org.hibernate.cfg.MultiTenancySettings; import org.hibernate.engine.config.spi.ConfigurationService; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jndi.spi.JndiService; import org.hibernate.service.spi.ServiceRegistryAwareService; import org.hibernate.service.spi.ServiceRegistryImplementor; @@ -47,6 +48,8 @@ public class DataSourceBasedMultiTenantConnectionProviderImpl private T tenantIdentifierForAny; private String baseJndiNamespace; + private DatabaseConnectionInfo dbInfo; + @Override protected DataSource selectAnyDataSource() { return selectDataSource( tenantIdentifierForAny ); @@ -59,6 +62,7 @@ public class DataSourceBasedMultiTenantConnectionProviderImpl dataSource = (DataSource) jndiService.locate( baseJndiNamespace + '/' + tenantIdentifier ); dataSourceMap().put( tenantIdentifier, dataSource ); } + dbInfo = new DatabaseConnectionInfoImpl().setDBUrl( "Connecting through datasource" + baseJndiNamespace + '/' + tenantIdentifier ); return dataSource; } @@ -119,4 +123,10 @@ public class DataSourceBasedMultiTenantConnectionProviderImpl dataSourceMap = null; } } + + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbInfo; + } + } diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/DatabaseConnectionInfo.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/DatabaseConnectionInfo.java new file mode 100644 index 0000000000..5537a301b3 --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/DatabaseConnectionInfo.java @@ -0,0 +1,30 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later + * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html + */ +package org.hibernate.engine.jdbc.connections.spi; + +import org.hibernate.dialect.DatabaseVersion; + +/** + * @author Jan Schatteman + */ +public interface DatabaseConnectionInfo { + DatabaseConnectionInfo setDBUrl(String dbUrl); + + DatabaseConnectionInfo setDBDriverName(String dbDriverName); + + DatabaseConnectionInfo setDBVersion(DatabaseVersion dbVersion); + + DatabaseConnectionInfo setDBAutoCommitMode(String dbAutoCommitMode); + + DatabaseConnectionInfo setDBIsolationLevel(String dbIsolationLevel); + + DatabaseConnectionInfo setDBMinPoolSize(String minPoolSize); + + DatabaseConnectionInfo setDBMaxPoolSize(String maxPoolSize); + + String toString(); +} diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/MultiTenantConnectionProvider.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/MultiTenantConnectionProvider.java index 3305fde364..debb3045b7 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/MultiTenantConnectionProvider.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/MultiTenantConnectionProvider.java @@ -9,6 +9,7 @@ package org.hibernate.engine.jdbc.connections.spi; import java.sql.Connection; import java.sql.SQLException; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.service.Service; import org.hibernate.service.spi.Wrapped; @@ -89,4 +90,9 @@ public interface MultiTenantConnectionProvider extends Service, Wrapped { * @return {@code true} if aggressive releasing is supported; {@code false} otherwise. */ boolean supportsAggressiveRelease(); + + default DatabaseConnectionInfo getDatabaseConnectionInfo() { + return new DatabaseConnectionInfoImpl(); + } + } diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/JdbcEnvironmentInitiator.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/JdbcEnvironmentInitiator.java index 0cc9afb633..ebb1332e63 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/JdbcEnvironmentInitiator.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/JdbcEnvironmentInitiator.java @@ -17,9 +17,12 @@ import org.hibernate.boot.registry.StandardServiceInitiator; import org.hibernate.cfg.JdbcSettings; import org.hibernate.dialect.DatabaseVersion; import org.hibernate.dialect.Dialect; +import org.hibernate.dialect.SimpleDatabaseVersion; import org.hibernate.engine.config.spi.ConfigurationService; import org.hibernate.engine.jdbc.batch.spi.BatchBuilder; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess; import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider; import org.hibernate.engine.jdbc.dialect.spi.DialectFactory; @@ -33,6 +36,7 @@ import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.event.internal.EmptyEventManager; import org.hibernate.event.spi.EventManager; import org.hibernate.internal.CoreMessageLogger; +import org.hibernate.internal.log.ConnectionProviderLogger; import org.hibernate.jdbc.AbstractReturningWork; import org.hibernate.jpa.internal.MutableJpaComplianceImpl; import org.hibernate.jpa.spi.JpaCompliance; @@ -120,8 +124,9 @@ public class JdbcEnvironmentInitiator implements StandardServiceInitiator mcp = registry.getService( MultiTenantConnectionProvider.class ); + databaseConnectionInfo = mcp.getDatabaseConnectionInfo(); + } + // most likely, the version hasn't been set yet, at least not for the ConnectionProviders that we currently maintain + databaseConnectionInfo.setDBVersion( jdbcEnvironment.getDialect().getVersion() ); + + ConnectionProviderLogger.INSTANCE.logConnectionDetails( databaseConnectionInfo ); } private static JdbcEnvironmentImpl getJdbcEnvironmentWithDefaults( diff --git a/hibernate-core/src/main/java/org/hibernate/internal/log/ConnectionPoolingLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/log/ConnectionPoolingLogger.java index e700e12440..d7d8b5b53a 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/log/ConnectionPoolingLogger.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/log/ConnectionPoolingLogger.java @@ -47,37 +47,17 @@ public interface ConnectionPoolingLogger extends BasicLogger { @Message(value = "Using built-in connection pool (not intended for production use)", id = 10001002) void usingHibernateBuiltInConnectionPool(); - @LogMessage(level = INFO) - @Message(value = "Autocommit mode: %s", id = 10001003) - void autoCommitMode(boolean autocommit); - @Message(value = "No JDBC URL specified by property %s", id = 10001004) String jdbcUrlNotSpecified(String property); - @LogMessage(level = INFO) - @Message(value = "Loaded JDBC driver class: %s", id = 10001005) - void loadedDriver(String driverClassName); - @LogMessage(level = INFO) @Message(value = "No JDBC driver class specified by %s", id = 10001010) void noDriver(String property); - @LogMessage(level = INFO) - @Message(value = "Loaded JDBC drivers: %s", id = 10001011) - void loadedDrivers(String loadedDrivers); - - @LogMessage(level = INFO) - @Message(value = "Connecting with JDBC URL [%s]", id = 10001012) - void usingUrl(String url); - @LogMessage(level = WARN) @Message(id = 10001006, value = "No JDBC Driver class was specified by property `jakarta.persistence.jdbc.driver`, `hibernate.driver` or `javax.persistence.jdbc.driver`") void jdbcDriverNotSpecified(); - @LogMessage(level = INFO) - @Message(value = "JDBC isolation level: %s", id = 10001007) - void jdbcIsolationLevel(String isolationLevelToString); - @LogMessage(level = INFO) @Message(value = "Cleaning up connection pool [%s]", id = 10001008) void cleaningUpConnectionPool(String url); diff --git a/hibernate-core/src/main/java/org/hibernate/internal/log/ConnectionProviderLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/log/ConnectionProviderLogger.java new file mode 100644 index 0000000000..8f5c17b928 --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/internal/log/ConnectionProviderLogger.java @@ -0,0 +1,44 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later. + * See the lgpl.txt file in the root directory or . + */ +package org.hibernate.internal.log; + +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; + +import org.jboss.logging.BasicLogger; +import org.jboss.logging.Logger; +import org.jboss.logging.annotations.LogMessage; +import org.jboss.logging.annotations.Message; +import org.jboss.logging.annotations.MessageLogger; +import org.jboss.logging.annotations.ValidIdRange; + +import static org.jboss.logging.Logger.Level.INFO; + +@MessageLogger( projectCode = "HHH" ) +@ValidIdRange( min = 10002001, max = 10002100 ) +@SubSystemLogging( + name = ConnectionProviderLogger.LOGGER_NAME, + description = "Used to log details of database access through `ConnectionProvider`" +) +public interface ConnectionProviderLogger extends BasicLogger { + String LOGGER_NAME = SubSystemLogging.BASE + ".connections.provider"; + + /** + * Static access to the logging instance + */ + ConnectionProviderLogger INSTANCE = Logger.getMessageLogger( + ConnectionProviderLogger.class, + LOGGER_NAME + ); + + + @LogMessage(level = INFO) + @Message( + value = "Database info:\n%s", + id = 10002001 + ) + void logConnectionDetails(DatabaseConnectionInfo databaseConnectionInfo); +} diff --git a/hibernate-hikaricp/src/main/java/org/hibernate/hikaricp/internal/HikariCPConnectionProvider.java b/hibernate-hikaricp/src/main/java/org/hibernate/hikaricp/internal/HikariCPConnectionProvider.java index 6d38b26de4..3047ce1276 100644 --- a/hibernate-hikaricp/src/main/java/org/hibernate/hikaricp/internal/HikariCPConnectionProvider.java +++ b/hibernate-hikaricp/src/main/java/org/hibernate/hikaricp/internal/HikariCPConnectionProvider.java @@ -13,7 +13,9 @@ import java.util.Map; import javax.sql.DataSource; import org.hibernate.HibernateException; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.service.UnknownUnwrapTypeException; import org.hibernate.service.spi.Configurable; import org.hibernate.service.spi.Stoppable; @@ -45,6 +47,8 @@ public class HikariCPConnectionProvider implements ConnectionProvider, Configura */ private HikariDataSource hds = null; + private DatabaseConnectionInfo dbinfo; + // ************************************************************************* // Configurable // ************************************************************************* @@ -57,6 +61,13 @@ public class HikariCPConnectionProvider implements ConnectionProvider, Configura hcfg = HikariConfigurationUtil.loadConfiguration( props ); hds = new HikariDataSource( hcfg ); + dbinfo = new DatabaseConnectionInfoImpl() + .setDBUrl( hcfg.getJdbcUrl() ) + .setDBDriverName( hcfg.getDriverClassName() ) + .setDBAutoCommitMode( Boolean.toString( hcfg.isAutoCommit() ) ) + .setDBIsolationLevel( hcfg.getTransactionIsolation() ) + .setDBMinPoolSize( String.valueOf(hcfg.getMinimumIdle()) ) + .setDBMaxPoolSize( String.valueOf(hcfg.getMaximumPoolSize()) ); } catch (Exception e) { throw new HibernateException( e ); @@ -84,6 +95,11 @@ public class HikariCPConnectionProvider implements ConnectionProvider, Configura return false; } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbinfo; + } + @Override public boolean isUnwrappableAs(Class unwrapType) { return ConnectionProvider.class.equals( unwrapType ) diff --git a/hibernate-proxool/src/main/java/org/hibernate/proxool/internal/ProxoolConnectionProvider.java b/hibernate-proxool/src/main/java/org/hibernate/proxool/internal/ProxoolConnectionProvider.java index 0c87ee6cac..1b96f14be5 100644 --- a/hibernate-proxool/src/main/java/org/hibernate/proxool/internal/ProxoolConnectionProvider.java +++ b/hibernate-proxool/src/main/java/org/hibernate/proxool/internal/ProxoolConnectionProvider.java @@ -20,13 +20,16 @@ import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; import org.hibernate.cfg.JdbcSettings; import org.hibernate.cfg.ProxoolSettings; import org.hibernate.engine.jdbc.connections.internal.ConnectionProviderInitiator; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.service.UnknownUnwrapTypeException; import org.hibernate.service.spi.Configurable; import org.hibernate.service.spi.ServiceRegistryAwareService; import org.hibernate.service.spi.ServiceRegistryImplementor; import org.hibernate.service.spi.Stoppable; +import org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF; import org.logicalcobwebs.proxool.ProxoolException; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.configuration.JAXPConfigurator; @@ -61,6 +64,8 @@ public class ProxoolConnectionProvider private ClassLoaderService classLoaderService; + private DatabaseConnectionInfo dbInfo; + @Override public Connection getConnection() throws SQLException { // get a connection from the pool (through DriverManager, cfr. Proxool doc) @@ -115,8 +120,9 @@ public class ProxoolConnectionProvider final String propFile = (String) props.get( ProxoolSettings.PROXOOL_PROPERTIES ); final String externalConfig = (String) props.get( ProxoolSettings.PROXOOL_EXISTING_POOL ); + String proxoolPoolAlias; // Default the Proxool alias setting - proxoolAlias = (String) props.get( ProxoolSettings.PROXOOL_POOL_ALIAS ); + proxoolAlias = proxoolPoolAlias = (String) props.get( ProxoolSettings.PROXOOL_POOL_ALIAS ); // Configured outside of Hibernate (i.e. Servlet container, or Java Bean Container // already has Proxool pools running, and this provider is to just borrow one of these @@ -188,10 +194,22 @@ public class ProxoolConnectionProvider // Remember Isolation level isolation = ConnectionProviderInitiator.extractIsolation( props ); - PROXOOL_MESSAGE_LOGGER.jdbcIsolationLevel( ConnectionProviderInitiator.toIsolationNiceName( isolation ) ); - autocommit = getBoolean( JdbcSettings.AUTOCOMMIT, props ); - PROXOOL_MESSAGE_LOGGER.autoCommitMode( autocommit ); + + try { + ConnectionPoolDefinitionIF cpd = ProxoolFacade.getConnectionPoolDefinition( proxoolPoolAlias ); + dbInfo = new DatabaseConnectionInfoImpl() + .setDBUrl( cpd.getUrl() ) + .setDBDriverName( cpd.getDriver() ) + .setDBIsolationLevel( ConnectionProviderInitiator.toIsolationNiceName(isolation) ) + .setDBAutoCommitMode( Boolean.toString(autocommit) ) + .setDBMinPoolSize( String.valueOf(cpd.getMinimumConnectionCount()) ) + .setDBMaxPoolSize( String.valueOf(cpd.getMaximumConnectionCount()) ); + } + catch (ProxoolException e) { + PROXOOL_MESSAGE_LOGGER.warn( "Error while obtaining the database pool information", e ); + } + } private Reader getConfigStreamReader(String resource) { @@ -240,6 +258,11 @@ public class ProxoolConnectionProvider } } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbInfo; + } + /** * Release all resources held by this provider. * diff --git a/hibernate-testing/src/main/java/org/hibernate/testing/jdbc/ConnectionProviderDelegate.java b/hibernate-testing/src/main/java/org/hibernate/testing/jdbc/ConnectionProviderDelegate.java index 390a52790c..3f50a01844 100644 --- a/hibernate-testing/src/main/java/org/hibernate/testing/jdbc/ConnectionProviderDelegate.java +++ b/hibernate-testing/src/main/java/org/hibernate/testing/jdbc/ConnectionProviderDelegate.java @@ -14,6 +14,7 @@ import java.util.Map; import org.hibernate.cfg.AvailableSettings; import org.hibernate.engine.jdbc.connections.internal.ConnectionProviderInitiator; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.service.spi.Configurable; import org.hibernate.service.spi.ServiceRegistryAwareService; import org.hibernate.service.spi.ServiceRegistryImplementor; @@ -103,6 +104,11 @@ public class ConnectionProviderDelegate implements return connectionProvider.supportsAggressiveRelease(); } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return connectionProvider.getDatabaseConnectionInfo(); + } + @Override public boolean isUnwrappableAs(Class unwrapType) { return connectionProvider.isUnwrappableAs( unwrapType ); diff --git a/hibernate-testing/src/main/java/org/hibernate/testing/jta/JtaAwareConnectionProviderImpl.java b/hibernate-testing/src/main/java/org/hibernate/testing/jta/JtaAwareConnectionProviderImpl.java index 6804acb93b..d500726c31 100644 --- a/hibernate-testing/src/main/java/org/hibernate/testing/jta/JtaAwareConnectionProviderImpl.java +++ b/hibernate-testing/src/main/java/org/hibernate/testing/jta/JtaAwareConnectionProviderImpl.java @@ -56,6 +56,7 @@ import org.hibernate.cfg.Environment; import org.hibernate.engine.jdbc.connections.internal.ConnectionProviderInitiator; import org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.internal.build.AllowSysOut; import org.hibernate.service.spi.Configurable; import org.hibernate.service.spi.ServiceRegistryAwareService; @@ -178,6 +179,11 @@ public class JtaAwareConnectionProviderImpl implements ConnectionProvider, Confi return true; } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return delegate.getDatabaseConnectionInfo(); + } + protected Transaction findCurrentTransaction() { try { return TestingJtaPlatformImpl.transactionManager().getTransaction(); diff --git a/hibernate-ucp/src/main/java/org/hibernate/oracleucp/internal/UCPConnectionProvider.java b/hibernate-ucp/src/main/java/org/hibernate/oracleucp/internal/UCPConnectionProvider.java index 4efdccbb96..b6be90c800 100644 --- a/hibernate-ucp/src/main/java/org/hibernate/oracleucp/internal/UCPConnectionProvider.java +++ b/hibernate-ucp/src/main/java/org/hibernate/oracleucp/internal/UCPConnectionProvider.java @@ -20,7 +20,9 @@ import javax.sql.DataSource; import org.hibernate.HibernateException; import org.hibernate.engine.jdbc.connections.internal.ConnectionProviderInitiator; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.internal.util.config.ConfigurationHelper; import org.hibernate.service.UnknownUnwrapTypeException; import org.hibernate.service.spi.Configurable; @@ -46,6 +48,8 @@ public class UCPConnectionProvider implements ConnectionProvider, Configurable, private boolean autoCommit; private Integer isolation; + private DatabaseConnectionInfo dbInfo; + @SuppressWarnings("rawtypes") @Override public void configure(Map props) throws HibernateException { @@ -60,6 +64,14 @@ public class UCPConnectionProvider implements ConnectionProvider, Configurable, ucpDS = PoolDataSourceFactory.getPoolDataSource(); Properties ucpProps = getConfiguration(props); configureDataSource(ucpDS, ucpProps); + + dbInfo = new DatabaseConnectionInfoImpl() + .setDBUrl( ucpDS.getURL() ) + .setDBDriverName( ucpDS.getConnectionFactoryClassName() ) + .setDBAutoCommitMode( Boolean.toString( autoCommit ) ) + .setDBIsolationLevel( isolation != null ? ConnectionProviderInitiator.toIsolationConnectionConstantName( isolation ) : null ) + .setDBMinPoolSize( String.valueOf(ucpDS.getMinPoolSize()) ) + .setDBMaxPoolSize( String.valueOf(ucpDS.getMaxPoolSize()) ); } catch (Exception e) { LOGGER.debug( "oracle UCP Configuration failed" ); @@ -183,6 +195,11 @@ public class UCPConnectionProvider implements ConnectionProvider, Configurable, return false; } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbInfo; + } + @Override @SuppressWarnings("rawtypes") public boolean isUnwrappableAs(Class unwrapType) { diff --git a/hibernate-vibur/src/main/java/org/hibernate/vibur/internal/ViburDBCPConnectionProvider.java b/hibernate-vibur/src/main/java/org/hibernate/vibur/internal/ViburDBCPConnectionProvider.java index 19da5bca44..519b2fe2ae 100644 --- a/hibernate-vibur/src/main/java/org/hibernate/vibur/internal/ViburDBCPConnectionProvider.java +++ b/hibernate-vibur/src/main/java/org/hibernate/vibur/internal/ViburDBCPConnectionProvider.java @@ -7,7 +7,9 @@ package org.hibernate.vibur.internal; +import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.engine.jdbc.connections.spi.DatabaseConnectionInfo; import org.hibernate.service.UnknownUnwrapTypeException; import org.hibernate.service.spi.Configurable; import org.hibernate.service.spi.Stoppable; @@ -50,10 +52,20 @@ public class ViburDBCPConnectionProvider implements ConnectionProvider, Configur private ViburDBCPDataSource dataSource = null; + private DatabaseConnectionInfo dbInfo; + @Override public void configure(Map configurationValues) { dataSource = new ViburDBCPDataSource( transform( configurationValues ) ); dataSource.start(); + + dbInfo = new DatabaseConnectionInfoImpl() + .setDBUrl( dataSource.getJdbcUrl() ) + .setDBDriverName( dataSource.getDriverClassName() ) + .setDBAutoCommitMode( String.valueOf(dataSource.getDefaultAutoCommit()) ) + .setDBIsolationLevel( dataSource.getDefaultTransactionIsolation() ) + .setDBMinPoolSize( String.valueOf(dataSource.getPoolInitialSize()) ) + .setDBMaxPoolSize( String.valueOf(dataSource.getPoolMaxSize()) ); } @Override @@ -79,6 +91,11 @@ public class ViburDBCPConnectionProvider implements ConnectionProvider, Configur return false; } + @Override + public DatabaseConnectionInfo getDatabaseConnectionInfo() { + return dbInfo; + } + @Override public boolean isUnwrappableAs(Class unwrapType) { return ConnectionProvider.class.equals( unwrapType ) @@ -103,6 +120,7 @@ public class ViburDBCPConnectionProvider implements ConnectionProvider, Configur if ( driverClassName != null ) { result.setProperty( "driverClassName", driverClassName ); } + String jdbcUrl = (String) configurationValues.get( URL ); if ( jdbcUrl != null ) { result.setProperty( "jdbcUrl", jdbcUrl ); @@ -133,7 +151,6 @@ public class ViburDBCPConnectionProvider implements ConnectionProvider, Configur result.setProperty( key, (String) entry.getValue() ); } } - return result; }