DatabaseManager (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.persist.DatabaseManager

```
public final class DatabaseManager
extends java.lang.Object
```
Manages configuration for all databases accessed by the current server, and provides access to Hibernate session factories to create new sessions. This class is a helper for the Persistence class, but since it contains generally useful methods, it has been made public.
During server bootstrap, this class reads configuration data from the directory service. This information includes the names of databases which must be configured and be permanently accessible, as well as those which are considered "transient". A transient database is one which can be connected to and disconnected from (in the Progress sense) on demand, from application code.
When a database is initialized for use via Hibernate, whether permanent or transient, additional configuration data, including Hibernate's configuration properties, is read from the directory service. This is assembled into a Properties object and passed to Hibernate's configuration subsystem.
Each database is represented by a Hibernate SessionFactory object, which is the object which the Persistence class uses to create database Sessions lazily. In addition to the configuration options read from the directory, each session factory requires the list of ORM mapping classes which will be used to represent database tables in any session established with that database.
SessionFactory objects for transient databases are created on demand, which can be an expensive process. A session factory for a transient database is required when at least one client session connects dynamically to that database. A reference count is maintained across client sessions for each transient database, such that a session factory need not be created for one client context, if another is already using it. Session factory objects for transient databases thus are not discarded while any context is connected to the associated database.
This class can both register remote databases for local use, as well as serve requests from remote servers to provide access to local databases. Whether a database is remote or local is transparent to users of this class. Both are registered using the registerDatabase(Database) method.
Implementation Note: several methods of this class synchronizes on two objects:
- configLock
- sessionFactories
configLock is the less granular of these. It is important that any code path which requires access to both locks simultaneously always acquire configLock first, then sessionFactories, to avoid deadlock.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static interface`	`DatabaseManager.Activator` Database activator.
`private static class`	`DatabaseManager.AutoConnected` The guarded set of auto-connected sessions for the local database
`private static class`	`DatabaseManager.Context` A class containing context-specific data.
`static interface`	`DatabaseManager.DatabaseConfigFetcher` Interface for a remote object whose purpose is to fetch a local `DatabaseConfig` object and deliver it to the remote caller.
`static class`	`DatabaseManager.DatabaseConfigFetcherImpl` Concrete implementation of the `DatabaseConfigFetcher` interface.

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.lang.String`	`CFG_AUTO_CONNECT` session auto-connection registry key
`private static java.lang.Object`	`configLock` Object upon which configuration routines synchronize
`private static ContextLocal<DatabaseManager.Context>`	`context` Context local data
`static java.lang.String`	`CP_ACQUIRE_INCREMENT` Connection pool acquire increment key name
`static java.lang.String`	`CP_INIT_POOL_SIZE` Initial connection pool size key name
`static java.lang.String`	`CP_MAX_POOL_SIZE` Maximum connection pool size key name
`static java.lang.String`	`CP_MIN_POOL_SIZE` Minimum connection pool size key name
`private static java.util.Map<Database,DatabaseConfig>`	`dbConfigs` Map of local DatabaseConfig objects, keyed by database info objects
`private static java.util.Map<Database,DatabaseManager.AutoConnected>`	`dbSessions` Map of session auto-connected databases to the guarded sets of connected sessions.
`private static java.util.Map<Database,Dialect>`	`dialects` Map of databases to database `Dialect` objects
`private static java.util.Set<Database>`	`dirtyDBs` Registered dirty databases
`private static boolean`	`forceNoUndoTempTables` Flag indicating temp-tables must be NO-UNDO application-wide
`private static boolean`	`initialized` Flag indicating persistence has been initialized
`private static java.util.List<java.lang.String>`	`loadedOnStartupDBs` Local databases configured as 'load_at_statup'
`private static java.util.Map<Database,LockTableUpdater>`	`lockTableUpdaters` Map of LockTableUpdater instances, keyed by database
`private static CentralLogger`	`log` Logger.
`private static java.util.Set<Database>`	`managed` Set of all databases managed by the local P2J server instance
`static int`	`MIXED_MODE_SSL_PORT` Port for mixed mode, remote, SSL connections to embedded databases
`static java.lang.String`	`PRIMARY_KEY` Reserved name of primary key identifier column/property
`private static java.util.Set<java.lang.String>`	`readOnly` Set of DMO entity names which correspond to read-only tables
`private static java.util.concurrent.ScheduledExecutorService`	`scheduler` Auto-connections' cleanup executor
`private static java.util.Map<Database,java.lang.String>`	`schemaByDatabase` Map of schema names, keyed by database
`static Database`	`TEMP_TABLE_DB` Temp table database information object
`static java.lang.String`	`TEMP_TABLE_SCHEMA` Reserved name of temp table schema
`private static java.util.Map<java.lang.String,java.util.Map<java.lang.String,DatabaseConfig>>`	`tenantDbConfigs` Map that stores the database configurations per tenant.
`private static java.util.Map<Database,java.lang.Integer>`	`transientDatabases` Map of transient databases to reference counts of registrations
`private static boolean`	`useMeta` Flag indicating that the metadata manager was initialized

Constructor Summary

Constructors
Modifier Constructor and Description

private DatabaseManager()
This class cannot be instantiated; all methods are static.

Constructors
Modifier	Constructor and Description
`private`	`DatabaseManager()` This class cannot be instantiated; all methods are static.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`activate(java.lang.String pdb)` Activate local primary database.
`private static void`	`activateAndRegister(java.lang.Integer sessionId, Database db, DatabaseManager.Activator activator)` Activate and register the database for the user session.
`private static void`	`activateDb(DatabaseConfig cfg, Database database)` Activate database - register the database with the persistence framework.
`private static void`	`activateMetaDb(Database primaryDB, Database metaDB)` Activate meta database.
`static boolean`	`activateTenantDatabase(TenantManager.Tenant tenant, java.lang.String pdbName)` Create, register and activate a given database for a given tenant.
`static boolean`	`activateTenantDatabases(TenantManager.Tenant tenant)` Create, register and activate the databases for the given tenant.
`static void`	`autoConnect()` Auto-connect databases configured to be auto-connected on session start
`private static void`	`bootstrap()` Method called at server bootstrap that initializes values from the directory configuration.
`private static void`	`checkRemoteConnectURL(Database database, Settings settings)` Validate and possibly modify the remote connection URL.
`static void`	`createDatabase(Text name, boolean replace)` Implementation of the CREATE DATABASE language statement.
`static void`	`createDatabase(Text name, Text source, boolean newInstance, boolean replace)` Implementation of the CREATE DATABASE language statement.
`private static Settings`	`createDefaultTempSettings()` This method returns the ORM settings which should be used when connecting to the primary temp-table database.
`private static Settings`	`createEmbeddedSettings(Database database)` This method returns the Hibernate properties which should be used when connecting to a secondary (e.g., dirty or metadata) database associated with a normal database.
`static DatabaseConfig`	`createSettings(TenantManager.Tenant tenant, Database db, TenantDatabaseDescriptor credentials)` Create a database configuration based on the given tenant and database.
`private static void`	`deactivate(Database db, long deactivateIfNotUsedSec)` Deactivate session auto-connected database.
`static void`	`deactivate(java.lang.Integer sessionId, Database db, boolean cleanup)` Deactivate session auto-connected database.
`(package private) static boolean`	`deregisterDatabase(Database database)` Deregister the specified, transient database, if and only if all other contexts using the database have deregistered it.
`static RecordLockInfo[]`	`getAllRecordLockInfo()` Gather snapshots of all record locks for all, non-temporary, permanently connected databases which are authoritatively managed by this P2J server instance.
`static java.lang.String`	`getBackingTableName(java.lang.Class<? extends Record> dmoClass)` Retrieve the database table name for a given DMO implementation class.
`static java.util.Map<java.lang.String,java.lang.String>`	`getColumnToPropertyMap(Database database, java.lang.Class<? extends Record> dmoClass, java.util.Set<java.lang.String> columnNames, boolean includePK)` Get a mapping of column names to property names for the given DMO in the given database.
`static DatabaseConfig`	`getConfiguration(Database database)` Get the database configuration.
`(package private) static DatabaseConfig`	`getDatabaseConfig(Database database)` Get the local or remote configuration for the given database.
`static java.util.List<java.lang.String>`	`getDatabaseDMOs(Database database)` Get the table DMO names of the given database.
`static java.util.List<java.lang.String>`	`getDatabaseTables(Database database)` Get the tables of the given database.
`static Dialect`	`getDialect(Database database)` Report the database dialect in use for the given database.
`static java.lang.String`	`getEntityNameByTableName(Database database, java.lang.String table)` Get the entity name which corresponds the given table of the given database.
`(package private) static java.lang.Boolean`	`getIgnoreCase(java.lang.Class<? extends Record> dmoClass, java.lang.String property)` For a given DMO property which may represent an indexed text column, indicate whether that column is set to ignore case.
`private static DatabaseConfig`	`getLocalConfiguration(Database database)` Get all data necessary to configure a database managed by the current P2J server instance.
`static LockTableUpdater`	`getLockTableUpdater(Database database)` Return the lock table updater associated with the given database, if any.
`static java.util.List<Database>`	`getManagedDatabases()` Get a list of all configured databases managed by this P2J server instance.
`static Database`	`getMutableDatabase(java.lang.String ldbName)` Return the database object for the given logical database name, if the database is mutable and currently connected.
`private static DatabaseConfig`	`getRemoteConfiguration(Database database)` Get all data necessary to configure a database managed by a remote P2J server instance.
`static java.lang.String`	`getSchema(Database database)` Lookup the schema name associated with the given physical database name.
`static character`	`getTenantName()` Implementation of the TENANT-NAME() builtin function.
`static character`	`getTenantName(character db)` Implementation of the TENANT-NAME() builtin function.
`static character`	`getTenantName(java.lang.String db)` Implementation of the TENANT-NAME() builtin function.
`private static Database`	`initDb(DatabaseConfig cfg, Database primaryDB)` Initialize local database based on its configuration.
`private static void`	`initDb(java.lang.String pdb, java.lang.String ldb)` Initialize local database.
`(package private) static void`	`initialize()` Initialize the persistence framework.
`private static void`	`initMetaDb(Database primaryDB, Database metaDB)` Initialize meta database.
`private static void`	`initTempDb()` Initialize _temp database.
`(package private) static boolean`	`isAuthoritative(Database database)` Indicate whether this P2J server instance is authoritative for the given database.
`static logical`	`isDbMultiTenant()` Implementation of the IS-DB-MULTITENANT() builtin function.
`static logical`	`isDbMultiTenant(character db)` Implementation of the IS-DB-MULTITENANT() builtin function.
`static logical`	`isDbMultiTenant(java.lang.String db)` Implementation of the IS-DB-MULTITENANT() builtin function.
`static boolean`	`isForceNoUndoTempTables()` Returns the value of the flag that indicates if temp-tables must be NO-UNDO.
`static boolean`	`isInitializing()` Indicate whether the database manager is currently initializing.
`(package private) static boolean`	`isMutable(Database database)` Determine whether a database's schema is programmatically mutable, which is set by configuration.
`(package private) static boolean`	`isPermamentDB(Database database)` Check if the specified database is a permanent database.
`static boolean`	`isReadOnly(java.lang.String entity)` Check if the DMO class corresponds to the read-only table
`(package private) static boolean`	`isTempTable(java.lang.Class<?> dmoClass)` Helper method to determine whether the specified class or interface represents the DMO front-end for temp table records.
`static java.util.List<java.lang.String>`	`loadedOnStartup()` Get list of local databases loaded on startup.
`private static Settings`	`loadSettings(Database database)` Load configuration from the P2J directory service and return it as a `Settings` object.
`private static DatabaseConfig`	`readDatabaseConfig(Database database)` Read and create the database configuration for the given database.
`private static DatabaseConfig`	`readDatabaseConfig(Database database, DatabaseConfig config)` Read from the directory all data necessary to configure a database managed by the current P2J server instance.
`private static void`	`readOrmSettings(DirectoryService ds, java.lang.String id, java.lang.String prefix, Settings settings)` Read ORM configuration properties from the directory and populate a properties file which will be passed to the ORM subsystem to configure database access.
`(package private) static boolean`	`registerDatabase(Database database)` Register an individual database with the persistence framework.
`private static boolean`	`registerDatabase(DatabaseConfig dbConfig, Database database, boolean bootstrap, boolean updateRefCount)` Register an individual database with the persistence framework.
`private static void`	`registerDb(Database database)` Register the database.
`private static void`	`registerDb(Database database, DatabaseConfig cfg)` Register database.
`(package private) static boolean`	`registerDirtyDatabase(Database database)` Given a normal database, this method will register its associated dirty database with the persistence framework.
`private static boolean`	`registerDirtyDatabase(DatabaseConfig dbConfig, Database database, boolean bootstrap)` Given a normal database, this method will register its associated dirty database; the created dirty database will have the same name as the original database.
`static void`	`removeTenantDbConfig(java.lang.String tenantName, java.lang.String pdbName)` Remove the stored database configuration of the given tenant.
`static void`	`removeTenantDbConfigs(java.lang.String tenantName)` Remove all the database configurations of a certain tenant.
`static void`	`removeTenantDbFromLockTable(Database db)` Remove the given tenant database from the map of `LockTableUpdater` instances.
`private static int`	`updateTransientRefCount(Database database, boolean increment)` Update the reference count of registrations of the specified database across all contexts.
`private static int`	`updateTransientRefCountWorker(Database database, int delta)` Update the reference count of registrations of the specified database.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - log
```
private static final CentralLogger log
```
    Logger.
  - CFG_AUTO_CONNECT
```
private static final java.lang.String CFG_AUTO_CONNECT
```
    session auto-connection registry key
    
    See Also:
    
    Constant Field Values
  - TEMP_TABLE_SCHEMA
```
public static final java.lang.String TEMP_TABLE_SCHEMA
```
    Reserved name of temp table schema
    
    See Also:
    
    Constant Field Values
  - TEMP_TABLE_DB
```
public static final Database TEMP_TABLE_DB
```
    Temp table database information object
  - PRIMARY_KEY
```
public static final java.lang.String PRIMARY_KEY
```
    Reserved name of primary key identifier column/property
  - MIXED_MODE_SSL_PORT
```
public static final int MIXED_MODE_SSL_PORT
```
    Port for mixed mode, remote, SSL connections to embedded databases
    
    See Also:
    
    Constant Field Values
  - CP_INIT_POOL_SIZE
```
public static final java.lang.String CP_INIT_POOL_SIZE
```
    Initial connection pool size key name
    
    See Also:
    
    Constant Field Values
  - CP_MIN_POOL_SIZE
```
public static final java.lang.String CP_MIN_POOL_SIZE
```
    Minimum connection pool size key name
    
    See Also:
    
    Constant Field Values
  - CP_MAX_POOL_SIZE
```
public static final java.lang.String CP_MAX_POOL_SIZE
```
    Maximum connection pool size key name
    
    See Also:
    
    Constant Field Values
  - CP_ACQUIRE_INCREMENT
```
public static final java.lang.String CP_ACQUIRE_INCREMENT
```
    Connection pool acquire increment key name
    
    See Also:
    
    Constant Field Values
  - dbConfigs
```
private static final java.util.Map<Database,DatabaseConfig> dbConfigs
```
    Map of local DatabaseConfig objects, keyed by database info objects
  - tenantDbConfigs
```
private static final java.util.Map<java.lang.String,java.util.Map<java.lang.String,DatabaseConfig>> tenantDbConfigs
```
    Map that stores the database configurations per tenant.
  - schemaByDatabase
```
private static final java.util.Map<Database,java.lang.String> schemaByDatabase
```
    Map of schema names, keyed by database
  - loadedOnStartupDBs
```
private static final java.util.List<java.lang.String> loadedOnStartupDBs
```
    Local databases configured as 'load_at_statup'
  - dbSessions
```
private static final java.util.Map<Database,DatabaseManager.AutoConnected> dbSessions
```
    Map of session auto-connected databases to the guarded sets of connected sessions.
  - scheduler
```
private static final java.util.concurrent.ScheduledExecutorService scheduler
```
    Auto-connections' cleanup executor
  - dirtyDBs
```
private static java.util.Set<Database> dirtyDBs
```
    Registered dirty databases
  - dialects
```
private static final java.util.Map<Database,Dialect> dialects
```
    Map of databases to database Dialect objects
  - transientDatabases
```
private static final java.util.Map<Database,java.lang.Integer> transientDatabases
```
    Map of transient databases to reference counts of registrations
  - managed
```
private static final java.util.Set<Database> managed
```
    Set of all databases managed by the local P2J server instance
  - readOnly
```
private static final java.util.Set<java.lang.String> readOnly
```
    Set of DMO entity names which correspond to read-only tables
  - forceNoUndoTempTables
```
private static boolean forceNoUndoTempTables
```
    Flag indicating temp-tables must be NO-UNDO application-wide
  - useMeta
```
private static boolean useMeta
```
    Flag indicating that the metadata manager was initialized
  - context
```
private static final ContextLocal<DatabaseManager.Context> context
```
    Context local data
  - configLock
```
private static final java.lang.Object configLock
```
    Object upon which configuration routines synchronize
  - lockTableUpdaters
```
private static java.util.Map<Database,LockTableUpdater> lockTableUpdaters
```
    Map of LockTableUpdater instances, keyed by database
  - initialized
```
private static volatile boolean initialized
```
    Flag indicating persistence has been initialized
- Constructor Detail
  - DatabaseManager
```
private DatabaseManager()
```
    This class cannot be instantiated; all methods are static.
- Method Detail
  - createDatabase
```
public static void createDatabase(Text name,
                                  boolean replace)
```
    Implementation of the CREATE DATABASE language statement. Just a stub at this time.
    
    Parameters:
    
    name - The database name.
    
    replace - Flag indicating the REPLACE option is used.
  - createDatabase
```
public static void createDatabase(Text name,
                                  Text source,
                                  boolean newInstance,
                                  boolean replace)
```
    Implementation of the CREATE DATABASE language statement. Just a stub at this time.
    
    Parameters:
    
    name - The new database name.
    
    source - The source database name.
    
    newInstance - Flag indicating the NEW-INSTANCE option is used.
    
    replace - Flag indicating the REPLACE option is used.
  - loadedOnStartup
```
public static java.util.List<java.lang.String> loadedOnStartup()
```
    Get list of local databases loaded on startup.
    
    Returns:
    
    list of local databases loaded on startup.
  - getDialect
```
public static Dialect getDialect(Database database)
```
    Report the database dialect in use for the given database.
    
    Parameters:
    
    database - Database information object.
    
    Returns:
    
    Dialect in use for database.
  - getSchema
```
public static java.lang.String getSchema(Database database)
```
    Lookup the schema name associated with the given physical database name.
    
    Parameters:
    
    database - Database information object. May be null if dmoClass represents a temporary table.
    
    Returns:
    
    Schema name for the given database.
  - getBackingTableName
```
public static java.lang.String getBackingTableName(java.lang.Class<? extends Record> dmoClass)
```
    Retrieve the database table name for a given DMO implementation class.
    
    Parameters:
    
    dmoClass - DMO implementation class to which the table is mapped.
    
    Returns:
    
    Name of the database table.
  - getManagedDatabases
```
public static java.util.List<Database> getManagedDatabases()
```
    Get a list of all configured databases managed by this P2J server instance.
    
    Returns:
    
    List of database information objects managed by this server instance.
  - getAllRecordLockInfo
```
public static RecordLockInfo[] getAllRecordLockInfo()
```
    Gather snapshots of all record locks for all, non-temporary, permanently connected databases which are authoritatively managed by this P2J server instance. Note that this data is for informational, reporting purposes only. It is guaranteed to be consistent (per database) at the moment it is collected, but it is possible (likely) for this information to become stale quickly.
    
    Returns:
    
    Record lock information for all non-temporary databases managed by this server.
  - getEntityNameByTableName
```
public static java.lang.String getEntityNameByTableName(Database database,
                                                        java.lang.String table)
```
    Get the entity name which corresponds the given table of the given database.
    
    Parameters:
    
    database - Database which contains the target table.
    
    table - Target table
    
    Returns:
    
    Entity name which corresponds the given table.
  - getDatabaseTables
```
public static java.util.List<java.lang.String> getDatabaseTables(Database database)
```
    Get the tables of the given database.
    
    Parameters:
    
    database - Target database.
    
    Returns:
    
    the tables of the given database.
  - getDatabaseDMOs
```
public static java.util.List<java.lang.String> getDatabaseDMOs(Database database)
```
    Get the table DMO names of the given database. For a given database, searches through the package corresponding to that databases name and that contains DMO interface classes. Out of all the classes found in that package, all implementations of those interfaces and all Buffer interfaces need to be excluded.
    
    Parameters:
    
    database - Target database.
    
    Returns:
    
    List of DMO table names/classes names, prefixed with the package thay are located in.
  - getColumnToPropertyMap
```
public static java.util.Map<java.lang.String,java.lang.String> getColumnToPropertyMap(Database database,
                                                                                      java.lang.Class<? extends Record> dmoClass,
                                                                                      java.util.Set<java.lang.String> columnNames,
                                                                                      boolean includePK)
```
    Get a mapping of column names to property names for the given DMO in the given database.
    
    Parameters:
    
    database - Target database.
    
    dmoClass - Target DMO implementation class.
    
    columnNames - Set of column names to be mapped to properties. If null, all of the table's columns will be mapped to DMO property names.
    
    includePK - true to include the reserved mapping of primary "recid" to reserved property name "recid"; false to omit this mapping.
    
    Returns:
    
    A map whose keys are the given set of column names, and whose values are the corresponding DMO property names.
  - getMutableDatabase
```
public static Database getMutableDatabase(java.lang.String ldbName)
                                   throws PersistenceException
```
    Return the database object for the given logical database name, if the database is mutable and currently connected. Otherwise, raise an exception.
    
    Parameters:
    
    ldbName - Logical database name (or alias).
    
    Returns:
    
    Database object.
    
    Throws:
    
    PersistenceException - if the database does not exist, is not connected, or its schema is not mutable by the application.
  - isReadOnly
```
public static boolean isReadOnly(java.lang.String entity)
```
    Check if the DMO class corresponds to the read-only table
    
    Parameters:
    
    entity - DMO entity name.
    
    Returns:
    
    true if the DMO entity corresponds to a read-only table.
  - isDbMultiTenant
```
public static logical isDbMultiTenant()
```
    Implementation of the IS-DB-MULTITENANT() builtin function.
    
    Returns:
    
    n/a
  - isDbMultiTenant
```
public static logical isDbMultiTenant(java.lang.String db)
```
    Implementation of the IS-DB-MULTITENANT() builtin function.
    
    Parameters:
    
    db - The db name.
    
    Returns:
    
    n/a
  - isDbMultiTenant
```
public static logical isDbMultiTenant(character db)
```
    Implementation of the IS-DB-MULTITENANT() builtin function.
    
    Parameters:
    
    db - The db name.
    
    Returns:
    
    n/a
  - getTenantName
```
public static character getTenantName()
```
    Implementation of the TENANT-NAME() builtin function.
    
    Returns:
    
    n/a
  - getTenantName
```
public static character getTenantName(java.lang.String db)
```
    Implementation of the TENANT-NAME() builtin function.
    
    Parameters:
    
    db - The db name.
    
    Returns:
    
    n/a
  - getTenantName
```
public static character getTenantName(character db)
```
    Implementation of the TENANT-NAME() builtin function.
    
    Parameters:
    
    db - The db name.
    
    Returns:
    
    n/a
  - getConfiguration
```
public static DatabaseConfig getConfiguration(Database database)
                                       throws PersistenceException
```
    Get the database configuration.
    
    Parameters:
    
    database - The database whose configuration is requested.
    
    Returns:
    
    the database configuration.
    
    Throws:
    
    PersistenceException - if an error occurs accessing configuration data.
  - autoConnect
```
public static void autoConnect()
```
    Auto-connect databases configured to be auto-connected on session start
  - deactivate
```
public static void deactivate(java.lang.Integer sessionId,
                              Database db,
                              boolean cleanup)
```
    Deactivate session auto-connected database.
    1. Detach database from the session.
    2. If there are no other session connected to the database and the the database is configured for the de-activation schedule the de-activation after a configured time.
    Parameters:
    
    sessionId - User session Id, if null get from the SecurityManager.
    
    db - Database to be deactivated.
    
    cleanup - Flag indicating that session cleanup is in progress.
  - isForceNoUndoTempTables
```
public static boolean isForceNoUndoTempTables()
```
    Returns the value of the flag that indicates if temp-tables must be NO-UNDO.
    
    Returns:
    
    true if temp-tables must be NO-UNDO, false otherwise.
  - createSettings
```
public static DatabaseConfig createSettings(TenantManager.Tenant tenant,
                                            Database db,
                                            TenantDatabaseDescriptor credentials)
```
    Create a database configuration based on the given tenant and database.
    
    Parameters:
    
    tenant - The tenant.
    
    db - The database for which the configuration is created.
    
    credentials - The credentials (URL, username, password) of the given database.
    
    Returns:
    
    The created/retrieved database configuration.
  - removeTenantDbConfigs
```
public static void removeTenantDbConfigs(java.lang.String tenantName)
```
    Remove all the database configurations of a certain tenant.
    
    Parameters:
    
    tenantName - The tenant for which to remove the configurations.
  - removeTenantDbConfig
```
public static void removeTenantDbConfig(java.lang.String tenantName,
                                        java.lang.String pdbName)
```
    Remove the stored database configuration of the given tenant. This operation can have two roots. Either the database instance has been unassigned from the tenant and a database configuration is no longer required, or the tenant has been updated, which means that this stored configuration is out-dated.
    
    Parameters:
    
    tenantName - The tenant id for which to remove the database configuration.
    
    pdbName - The physical name of the database for which to remove the configuration.
  - removeTenantDbFromLockTable
```
public static void removeTenantDbFromLockTable(Database db)
```
    Remove the given tenant database from the map of LockTableUpdater instances.
    
    Parameters:
    
    db - The database for which to remove the LockTableUpdater.
  - activateTenantDatabase
```
public static boolean activateTenantDatabase(TenantManager.Tenant tenant,
                                             java.lang.String pdbName)
                                      throws PersistenceException
```
    Create, register and activate a given database for a given tenant.
    
    Parameters:
    
    tenant - The tenant for which to perform these operations.
    
    pdbName - The physical name of the database for which to perform these operations.
    
    Returns:
    
    true if the operation was successful, false otherwise.
    
    Throws:
    
    PersistenceException
  - activateTenantDatabases
```
public static boolean activateTenantDatabases(TenantManager.Tenant tenant)
                                       throws PersistenceException
```
    Create, register and activate the databases for the given tenant.
    
    Parameters:
    
    tenant - The tenant to work with.
    
    Returns:
    
    true if all database configurations have been created successfully, false if at least one configuration failed.
    
    Throws:
    
    PersistenceException
  - isTempTable
```
static boolean isTempTable(java.lang.Class<?> dmoClass)
```
    Helper method to determine whether the specified class or interface represents the DMO front-end for temp table records.
    
    Parameters:
    
    dmoClass - A DMO interface or implementation class.
    
    Returns:
    
    true if dmoClass is assignable from the Temporary marker interface; else false.
  - isPermamentDB
```
static boolean isPermamentDB(Database database)
```
    Check if the specified database is a permanent database. This is true only if the database is neither a dirty database nor the temporary database.
    
    Parameters:
    
    database - The database to be checked.
    
    Returns:
    
    true if this database object is configured for a permanent DB.
  - initialize
```
static void initialize()
                throws PersistenceException
```
    Initialize the persistence framework. This entails configuring and storing a Hibernate session factory for each database to be supported. This may be done immediately (for databases flagged as "auto-connect"), or may be deferred for databases which are dynamically connected and disconnected at runtime. This information will be retrieved from the P2J directory.
    Remote database service provider exports are registered at this time as well. This includes services to fetch database configurations for remote requesters, record locking services, and the tracking of dirty records within uncommitted transactions.
    Databases and the DMO classes associated with them are determined by reading the DMO index configuration file. The location of this file is read from the P2J directory. Hibernate configuration properties for each session factory are read from the directory as well.
    The logic flow is:
    1. read from the directory the location of the DMO index document;
    2. parse the DMO index document and compile a list of fully qualified class names for each schema node in the document; store these in a map, keyed by schema name.
    3. read from the directory the list of physical database names of those databases supported by the current server;
    4. for each database:
      
      get the name of its schema, which should match one of the names mapped to a DMOIndex instance;
      determine whether it must be auto-connected.
    5. if a database is to be auto-connected:
      
      create a Hibernate Configuration;
      retrieve all Hibernate properties for that database from the directory and add them to the configuration;
      add to the configuration each DMO class which corresponds to that database's schema name, as read from the DMO index;
      build a Hibernate SessionFactory from the configuration and store it in a map, keyed by the database name (not the schema name, which may be different)
      add the database name to the set of permanent databases which have been configured.
    6. if a database is not to be auto-connected:
      
      defer session factory configuration until such time as a dynamic configuration request is processed (i.e., do nothing at this time).
    Throws:
    
    java.lang.IllegalStateException - if invoked more than once.
    
    PersistenceException - if any error is encountered initializing the persistence framework.
  - bootstrap
```
private static void bootstrap()
```
    Method called at server bootstrap that initializes values from the directory configuration. Until this method is called, default values are used.
  - deactivate
```
private static void deactivate(Database db,
                               long deactivateIfNotUsedSec)
```
    Deactivate session auto-connected database.
    
    Parameters:
    
    db - Database to be deactivated.
    
    deactivateIfNotUsedSec - Idle period threshold for deactivation in sec.
  - initDb
```
private static void initDb(java.lang.String pdb,
                           java.lang.String ldb)
                    throws PersistenceException
```
    Initialize local database.
    
    Parameters:
    
    pdb - The physical name of the database.
    
    ldb - The logical name of the database.
    
    Throws:
    
    PersistenceException - on initialization failure.
  - initDb
```
private static Database initDb(DatabaseConfig cfg,
                               Database primaryDB)
                        throws PersistenceException
```
    Initialize local database based on its configuration.
    
    Parameters:
    
    cfg - The database configuration.
    
    primaryDB - The database to be initialized.
    
    Returns:
    
    The meta database instance that was created.
    
    Throws:
    
    PersistenceException
  - activateMetaDb
```
private static void activateMetaDb(Database primaryDB,
                                   Database metaDB)
                            throws PersistenceException
```
    Activate meta database.
    
    Parameters:
    
    primaryDB - Primary database.
    
    metaDB - Meta database.
    
    Throws:
    
    PersistenceException - on initialization failure.
  - activateDb
```
private static void activateDb(DatabaseConfig cfg,
                               Database database)
                        throws PersistenceException
```
    Activate database - register the database with the persistence framework. For the primary database register its dirty database as well.
    
    Parameters:
    
    cfg - Database configuration.
    
    database - Database to be activated.
    
    Throws:
    
    PersistenceException - on initialization failure.
  - activate
```
public static void activate(java.lang.String pdb)
                     throws PersistenceException
```
    Activate local primary database. Register the database and its meta database with the persistence framework
    
    Parameters:
    
    pdb - Database name.
    
    Throws:
    
    PersistenceException - on initialization failure.
  - activateAndRegister
```
private static void activateAndRegister(java.lang.Integer sessionId,
                                        Database db,
                                        DatabaseManager.Activator activator)
                                 throws PersistenceException
```
    Activate and register the database for the user session.
    
    Parameters:
    
    sessionId - The user session Id.
    
    db - Database to be activated and registered.
    
    activator - Database DatabaseManager.Activator
    
    Throws:
    
    PersistenceException - on activation failure.
  - initMetaDb
```
private static void initMetaDb(Database primaryDB,
                               Database metaDB)
                        throws PersistenceException
```
    Initialize meta database. The _File, _Field, _Index, _Index_Field tables are populated with information extracted from DMO annotations of the primary database.
    
    Parameters:
    
    primaryDB - Primary database.
    
    metaDB - Meta database.
    
    Throws:
    
    PersistenceException - on initialization failure.
  - registerDb
```
private static void registerDb(Database database)
                        throws PersistenceException
```
    Register the database.
    
    Parameters:
    
    database - The database to be registered.
    
    Throws:
    
    PersistenceException
  - registerDb
```
private static void registerDb(Database database,
                               DatabaseConfig cfg)
                        throws PersistenceException
```
    Register database.
    
    Parameters:
    
    database - Database to be registered.
    
    cfg - The configuration of the given database.
    
    Throws:
    
    PersistenceException - on initialization failure.
  - initTempDb
```
private static void initTempDb()
                        throws PersistenceException
```
    Initialize _temp database. This should ONLY be called from initialize().
    
    Throws:
    
    PersistenceException - on initialization failure.
  - isInitializing
```
public static boolean isInitializing()
```
    Indicate whether the database manager is currently initializing.
    
    Returns:
    
    true if database manager is initializing, else false if initialization is complete.
  - isMutable
```
static boolean isMutable(Database database)
                  throws PersistenceException
```
    Determine whether a database's schema is programmatically mutable, which is set by configuration.
    
    Parameters:
    
    database - Database identifier.
    
    Returns:
    
    true if the schema is mutable, else false.
    
    Throws:
    
    PersistenceException
  - registerDatabase
```
static boolean registerDatabase(Database database)
                         throws PersistenceException
```
    Register an individual database with the persistence framework. This configures the database to allow the framework to access it.
    
    Parameters:
    
    database - Database to be configured.
    
    Returns:
    
    true if the database was newly registered; false if the database already was registered, and only the reference count was incremented, or if this registration attempt was redundant in the local context.
    
    Throws:
    
    PersistenceException - if database is not recognized, based upon configuration information in the directory.
  - registerDirtyDatabase
```
static boolean registerDirtyDatabase(Database database)
                              throws PersistenceException
```
    Given a normal database, this method will register its associated dirty database with the persistence framework. This configures the database to allow the framework to access it. The created dirty database will have the same name as the original database.
    
    Parameters:
    
    database - Database to be configured.
    
    Returns:
    
    true if the database was newly registered; false if the database already was registered, and only the reference count was incremented, or if this registration attempt was redundant in the local context.
    
    Throws:
    
    PersistenceException - if database is not recognized, based upon configuration information in the directory.
  - getLockTableUpdater
```
public static LockTableUpdater getLockTableUpdater(Database database)
```
    Return the lock table updater associated with the given database, if any.
    
    Parameters:
    
    database - A primary database for which the lock table updater is needed.
    
    Returns:
    
    Lock table updater, or null if lock metadata is not used by the current application.
    
    Throws:
    
    java.lang.IllegalArgumentException - if lock metadata is used by the current application, but no lock table updater is found for the given database.
  - getDatabaseConfig
```
static DatabaseConfig getDatabaseConfig(Database database)
                                 throws PersistenceException
```
    Get the local or remote configuration for the given database.
    
    Parameters:
    
    database - The database instance.
    
    Returns:
    
    See above.
    
    Throws:
    
    PersistenceException
  - getLocalConfiguration
```
private static DatabaseConfig getLocalConfiguration(Database database)
                                             throws PersistenceException
```
    Get all data necessary to configure a database managed by the current P2J server instance. This information is read from the directory the first time it is needed and then cached for future accesses.
    
    Parameters:
    
    database - A locally managed database.
    
    Returns:
    
    A configuration object which provides all information needed to connect to a physical database.
    
    Throws:
    
    PersistenceException - if an error occurs accessing configuration data.
  - getRemoteConfiguration
```
private static DatabaseConfig getRemoteConfiguration(Database database)
                                              throws PersistenceException
```
    Get all data necessary to configure a database managed by a remote P2J server instance.
    
    Parameters:
    
    database - A remotely managed database.
    
    Returns:
    
    A configuration object which provides all information needed to connect to a physical database.
    
    Throws:
    
    PersistenceException - if the specified database is not managed by the remote server.
  - checkRemoteConnectURL
```
private static void checkRemoteConnectURL(Database database,
                                          Settings settings)
                                   throws PersistenceException
```
    Validate and possibly modify the remote connection URL. Validation consists of confirming the existence of the appropriate property in the settings object and confirming it begins with the necessary jdbc: prefix.
    The URL setting is modified in the event it specifies a localhost/loopback address. Such an address specification is relative to the remote server and is most likely invalid for the requesting server. The host in such a case is replaced the host name specified in database, and the modified URL is set back into settings under the appropriate key.
    NOTE: this approach assumes the local and remote servers share a DNS which will resolve the given connection URL to the same physical address.
    
    Parameters:
    
    database - Object containing address information for the remotely managed database.
    
    settings - ORM configuration as reported by the remote server. This is a local copy of the remote settings; it is modified by this method.
    
    Throws:
    
    PersistenceException - if the connection URL specified in settings is missing or invalid.
  - readDatabaseConfig
```
private static DatabaseConfig readDatabaseConfig(Database database)
                                          throws PersistenceException
```
    Read and create the database configuration for the given database.
    
    Parameters:
    
    database - The given database.
    
    Returns:
    
    The created configuration for the given database.
    
    Throws:
    
    PersistenceException
  - readDatabaseConfig
```
private static DatabaseConfig readDatabaseConfig(Database database,
                                                 DatabaseConfig config)
                                          throws PersistenceException
```
    Read from the directory all data necessary to configure a database managed by the current P2J server instance.
    
    Parameters:
    
    database - A locally managed database.
    
    config - The database configuration, if one already exists.
    
    Returns:
    
    A configuration object which provides all information needed to connect to a physical database.
    
    Throws:
    
    PersistenceException - if an error occurs accessing configuration data.
  - deregisterDatabase
```
static boolean deregisterDatabase(Database database)
```
    Deregister the specified, transient database, if and only if all other contexts using the database have deregistered it. After deregistration, sessions can no longer be opened for database, without first building a new session factory (an expensive process).
    
    Parameters:
    
    database - Database to be deregistered.
    
    Returns:
    
    true if database was deregistered; else false. Note that the latter does not represent an error condition, but rather indicates that the database could not be deregistered because other contexts still referenced it, or because it is a permanent database.
    
    Throws:
    
    java.lang.IllegalArgumentException - if database is not currently registered.
  - isAuthoritative
```
static boolean isAuthoritative(Database database)
```
    Indicate whether this P2J server instance is authoritative for the given database. Remote P2J servers must connect to the authoritative server instance for a given database, in order to access that database and its supporting resources, such as a lock manager, dirty read manager, etc.
    
    Parameters:
    
    database - Database information object.
    
    Returns:
    
    true if this server instance is authoritative for the specified database.
  - getIgnoreCase
```
static java.lang.Boolean getIgnoreCase(java.lang.Class<? extends Record> dmoClass,
                                       java.lang.String property)
```
    For a given DMO property which may represent an indexed text column, indicate whether that column is set to ignore case.
    
    Parameters:
    
    dmoClass - DMO implementation class.
    
    property - DMO property name.
    
    Returns:
    
    true to ignore case, false to preserve case sensitivity, null if the property does not represent an indexed text column.
  - registerDirtyDatabase
```
private static boolean registerDirtyDatabase(DatabaseConfig dbConfig,
                                             Database database,
                                             boolean bootstrap)
                                      throws PersistenceException
```
    Given a normal database, this method will register its associated dirty database; the created dirty database will have the same name as the original database.
    The dirty database is hard-coded to be an in-memory H2 database. See createEmbeddedSettings(Database) method for the Hibernate settings used.
    
    Parameters:
    
    dbConfig - Configuration properties for the given database.
    
    database - Database to be configured.
    
    bootstrap - true if this method is invoked during bootstrap initialization at server start-up; false if invoked otherwise. If false, it is assumed that database represents a transient database.
    
    Returns:
    
    true if the dirty database was newly registered; false if the database was already registered, and only the reference count was incremented (transient only), or if this registration attempt was redundant in the local context.
    
    Throws:
    
    PersistenceException - If there is an error configuring the Hibernate framework.
    
    java.lang.IllegalStateException - if database is permanent and already has been registered.
    
    java.lang.IllegalArgumentException - if database is not recognized, based upon configuration information in the directory.
  - registerDatabase
```
private static boolean registerDatabase(DatabaseConfig dbConfig,
                                        Database database,
                                        boolean bootstrap,
                                        boolean updateRefCount)
                                 throws PersistenceException
```
    Register an individual database with the persistence framework. This configures the database to allow the framework to access it. This method ensures that a permanent database is never registered more than once. Registration involves the following:
    - create a Hibernate Configuration;
    - retrieve all Hibernate properties for that database from the directory and add them to the configuration;
    - add to the configuration each DMO class which corresponds to that database's schema name, as read from the DMO index;
    - build a Hibernate SessionFactory from the configuration and store it in a map, keyed by the database name (not the schema name, which may be different)
    - if the database is transient (i.e., not configured immediately during bootstrap), update its configuration reference count; otherwise, add the database name to the set of permanent databases which have been configured.
    This method may be invoked during bootstrap initialization, to register a permanent database, or after initialization, to dynamically register a transient database.
    Parameters:
    
    dbConfig - Configuration properties for the given database.
    
    database - Database to be configured.
    
    bootstrap - true if this method is invoked during bootstrap initialization at server start-up; false if invoked otherwise. If false, it is assumed that database represents a transient database.
    
    updateRefCount - true if the transient reference count should be updated; else false.
    
    Returns:
    
    true if the (permanent or transient) database was newly registered; false if the database was already registered, and only the reference count was incremented (transient only), or if this registration attempt was redundant in the local context.
    
    Throws:
    
    PersistenceException - If there is an error configuring the Hibernate framework.
    
    java.lang.IllegalStateException - if database is permanent and already has been registered.
  - updateTransientRefCount
```
private static int updateTransientRefCount(Database database,
                                           boolean increment)
```
    Update the reference count of registrations of the specified database across all contexts. The reference count for each database is global across the system. Its value determines when a database configuration may be safely dropped by the server.
    The reference count is either incremented by 1, decremented by 1, or left unchanged, based upon the following rules:
    - if increment is true:
      
      if database is already registered in the local context, no change is made;
      otherwise, the count is incremented by 1.
    - if increment is false:
      
      if database is not registered in the local context, no change is made;
      otherwise, the count is decremented by 1.
    This logic ensures that attempts to register and deregister the same database, if not properly bracketed, will not corrupt the global reference count.
    Parameters:
    
    database - A transient database.
    
    increment - true to increment reference count by 1; false to decrement reference count by 1; See above for the implications of this.
    
    Returns:
    
    A non-negative number indicating the reference count for database after the update; or -1 if database was not recognized.
  - updateTransientRefCountWorker
```
private static int updateTransientRefCountWorker(Database database,
                                                 int delta)
```
    Update the reference count of registrations of the specified database. This method must be called from a point where the delta have been correctly computed, respectively updateTransientRefCount() where the current context is inspected to see if incrementation is needed, or from context clean when all databases from context should be de-ref counted (and delta is -1).
    
    Parameters:
    
    database - A transient database.
    
    delta - Specifies the direction of change (1 = increment, -1 decrement, 0 = no change); See updateTransientRefCount() for details.
    
    Returns:
    
    A non-negative number indicating the reference count for database after the update; or -1 if database was not recognized.
  - loadSettings
```
private static Settings loadSettings(Database database)
                              throws PersistenceException
```
    Load configuration from the P2J directory service and return it as a Settings object. The contents of this object must match the properties expected by the ORM framework.
    
    Parameters:
    
    database - Database for which properties are to be loaded. This differentiates the directory key by database name.
    
    Returns:
    
    ORM settings for the given database.
    
    Throws:
    
    PersistenceException - if no configuration properties for the specified database were found, or if the directory service is unavailable.
  - createEmbeddedSettings
```
private static Settings createEmbeddedSettings(Database database)
```
    This method returns the Hibernate properties which should be used when connecting to a secondary (e.g., dirty or metadata) database associated with a normal database. A random username and password are generated. Hibernate second level caching is disabled.
    
    Parameters:
    
    database - The database information object for the embedded database.
    
    Returns:
    
    The created Hibernate properties.
  - createDefaultTempSettings
```
private static Settings createDefaultTempSettings()
```
    This method returns the ORM settings which should be used when connecting to the primary temp-table database. A random username and password are generated.
    
    Returns:
    
    The created ORM settings.
  - readOrmSettings
```
private static void readOrmSettings(DirectoryService ds,
                                    java.lang.String id,
                                    java.lang.String prefix,
                                    Settings settings)
```
    Read ORM configuration properties from the directory and populate a properties file which will be passed to the ORM subsystem to configure database access.
    Properties are organized hierarchically in the directory. This method recursively walks the tree and adds a new property entry when it reaches any directory entry terminus. Keys are qualified with the given prefix, if any.
    This method does not know or care about the names of individual properties; it simply performs a depth-first enumeration of a directory subtree and composes the property names from the directory entry names it encounters. Error checking of property names and values is left to the ORM configuration subsystem.
    
    Parameters:
    
    ds - Directory service instance.
    
    id - Directory entry key for the node currently being visited.
    
    prefix - Prefix to prepend to key (may be empty string, but not null.
    
    settings - Object to which settings are added.

Class DatabaseManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

log

CFG_AUTO_CONNECT

TEMP_TABLE_SCHEMA

TEMP_TABLE_DB

PRIMARY_KEY

MIXED_MODE_SSL_PORT

CP_INIT_POOL_SIZE

CP_MIN_POOL_SIZE

CP_MAX_POOL_SIZE

CP_ACQUIRE_INCREMENT

dbConfigs

tenantDbConfigs

schemaByDatabase

loadedOnStartupDBs

dbSessions

scheduler

dirtyDBs

dialects

transientDatabases

managed

readOnly

forceNoUndoTempTables

useMeta

context

configLock

lockTableUpdaters

initialized

Constructor Detail

DatabaseManager

Method Detail

createDatabase

createDatabase

loadedOnStartup

getDialect

getSchema

getBackingTableName

getManagedDatabases

getAllRecordLockInfo

getEntityNameByTableName

getDatabaseTables

getDatabaseDMOs

getColumnToPropertyMap

getMutableDatabase

isReadOnly

isDbMultiTenant

isDbMultiTenant

isDbMultiTenant

getTenantName

getTenantName

getTenantName

getConfiguration

autoConnect

deactivate

isForceNoUndoTempTables

createSettings

removeTenantDbConfigs

removeTenantDbConfig

removeTenantDbFromLockTable

activateTenantDatabase

activateTenantDatabases

isTempTable

isPermamentDB

initialize

bootstrap

deactivate

initDb

initDb

activateMetaDb

activateDb

activate

activateAndRegister

initMetaDb

registerDb