## org.hibernate.service.jdbc.connections.spi
Interface MultiTenantConnectionProvider

All Superinterfaces:
  Serializable, Service, Wrapped

All Known Implementing Classes:
  AbstractDataSourceBasedMultiTenantConnectionProviderImpl, AbstractMultiTenantConnectionProvider, DataSourceBasedMultiTenantConnectionProviderImpl

    public interface MultiTenantConnectionProvider

extends Service, Wrapped

Method Summary
`Connection` `getAnyConnection()` Allows access to the database metadata of the underlying database(s) in situations where we do not have a tenant id (like startup processing, for example).
`Connection` `getConnection(String tenantIdentifier)` Obtains a connection for Hibernate use according to the underlying strategy of this provider.
`void` `releaseAnyConnection(Connection connection)` Release a connection obtained from `getAnyConnection()`
`void` `releaseConnection(String tenantIdentifier, Connection connection)` Release a connection from Hibernate use.
`boolean` `supportsAggressiveRelease()` Does this connection provider support aggressive release of JDBC connections and re-acquisition of those connections (if need be) later? This is used in conjunction with `AvailableSettings.RELEASE_CONNECTIONS` to aggressively release JDBC connections.

Methods inherited from interface org.hibernate.service.spi.Wrapped
`isUnwrappableAs, unwrap`

Method Detail

### getAnyConnection

    Connection getAnyConnection()
                                throws SQLException

  Allows access to the database metadata of the underlying database(s) in situations where we do not have a tenant id (like startup processing, for example).

  Returns:
    The database metadata.
  Throws:
    `SQLException` - Indicates a problem opening a connection

### releaseAnyConnection

    void releaseAnyConnection(Connection connection)
                              throws SQLException

  Release a connection obtained from `getAnyConnection()`

  Parameters:
    `connection` - The JDBC connection to release
  Throws:
    `SQLException` - Indicates a problem closing the connection

### getConnection

    Connection getConnection(String tenantIdentifier)
                             throws SQLException

  Obtains a connection for Hibernate use according to the underlying strategy of this provider.

  Parameters:
    `tenantIdentifier` - The identifier of the tenant for which to get a connection
  Returns:
    The obtained JDBC connection
  Throws:
    `SQLException` - Indicates a problem opening a connection
    `HibernateException` - Indicates a problem otherwise obtaining a connection.

### releaseConnection

    void releaseConnection(String tenantIdentifier,
                           Connection connection)
                           throws SQLException

  Release a connection from Hibernate use.

  Parameters:
    `connection` - The JDBC connection to release
    `tenantIdentifier` - The identifier of the tenant.
  Throws:
    `SQLException` - Indicates a problem closing the connection
    `HibernateException` - Indicates a problem otherwise releasing a connection.

### supportsAggressiveRelease

    boolean supportsAggressiveRelease()

  Does this connection provider support aggressive release of JDBC connections and re-acquisition of those connections (if need be) later?

  This is used in conjunction with `AvailableSettings.RELEASE_CONNECTIONS` to aggressively release JDBC connections. However, the configured ConnectionProvider must support re-acquisition of the same underlying connection for that semantic to work.

  Typically, this is only true in managed environments where a container tracks connections by transaction or thread. Note that JTA semantic depends on the fact that the underlying connection provider does support aggressive release.

  Returns:
    `true` if aggressive releasing is supported; `false` otherwise.

Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.