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

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

```
public final class ConnectionManager
extends java.lang.Object
```
Manages information about connected databases in the current context. This includes the existence of connections and their status, and the various aliases and logical names assigned to physical databases. This information is managed to support converted Progress logic, which relies upon the state of this information to make logic decisions. It also is used to determine which physical database is associated with each record buffer and its backing Persistence service object.
A connection in the sense of this class is not a database-level connection, such as a JDBC connection. Database-level connections are managed by the Persistence class transparently. A connection to this class is a logical construct inherited from converted Progress code. Connecting and disconnecting from a database at this level does not create or destroy a JDBC-level connection resource. However, for transient databases at least, it may affect the loading and unloading of database configurations at the DatabaseManager level. That is, the first time any client context connects to a transient database (i.e., one that is not always loaded by the server by default), that database's configuration is loaded temporarily by the server. The last time a client context disconnects from a transient database, that database's configuration is unloaded.
Connections register a physical database name to a logical database name, which can be different or the same as the physical name. A database may not be connected more than once without first disconnecting. Once disconnected, it may be connected again. Only one physical database may be registered to a given logical name at a time. Methods are provided to connect and disconnect, as well as to query information about connected databases, such as their physical and logical names, how many are connected, their types and restrictions.
Any number of aliases may be assigned to a given logical name. Aliases may only be created for connected databases, though they survive database disconnect. They may be explicitly deleted, however.
Whenever a new record buffer scope is opened, it is registered with its context's connection manager. References from buffers to their backing, physical databases are tracked, to enable the correct processing of database disconnect requests. Disconnects can only occur immediately if all procedures which reference the target database are complete. This translates to a state where no record buffers reference the database. Furthermore, even if no buffers reference a database, it may not be disconnected if the active code point currently is within a transaction. At the end of the transaction, all disconnects which were deferred are processed.
A single instance of this class is created for each client context. The constructor is not called directly by client code; rather, access is provided through the static get() method.
Currently, the Progress semantic of database-level auto connect lists is not supported.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ConnectionManager.BoolConnectOptionValue` Logical connection option value.
`private static class`	`ConnectionManager.ConnectInfo` Information about a specific database connection (in 4GL terms, not JDBC terms).
`private static class`	`ConnectionManager.ConnectionDispatcher` This class dispatches connect and disconnect events to the listeners which manage related connection and user statistics metadata.
`private static class`	`ConnectionManager.ConnectOption` CONNECT statement options.
`private static class`	`ConnectionManager.ConnectOptionValue` Connection option value - base class
`static class`	`ConnectionManager.IntConnectOptionValue` Numeric connection option value.
`private static class`	`ConnectionManager.OptionsParser` CONNNECT statement options' parser
`static class`	`ConnectionManager.TextConnectOptionValue` Text connection option value.

Field Summary

Fields
Modifier and Type	Field and Description
`private java.util.Map<java.lang.String,java.lang.String>`	`aliases` Map of active aliases to logical database names
`private java.util.Map<java.lang.String,ClientPrincipal>`	`clients` Map of registered CLIENT-PRINCIPAL objects, for each database.
`private static long`	`CONN_RETRY_DELAY` Milliseconds to wait between connection retries
`private java.util.Map<java.lang.String,ConnectionManager.ConnectInfo>`	`connected` Map of logical database names to `ConnectInfo` objects
`private java.util.Map<java.lang.String,java.lang.String>`	`connectTimeUserid` Stores the userid used at connection time whether the database is connected using command-line (directory implementation) or programatically using `CONNECT` with -U/-P parameters.
`private static java.util.Map<java.lang.String,java.lang.String>`	`dbVersionCache` Cache of database versions, indexed by PDB name
`private static int`	`DEFAULT_CONN_RETRIES` Default number of database connection retries
`private static java.lang.String`	`DEFAULT_DBVERSION` Default DBVERSION text
`private static java.lang.String`	`DICTDB` DICTDB alias name
`private ConnectionManager.ConnectionDispatcher`	`dispatcher` Connect/disconnect event dispatcher
`private java.util.Map<Database,java.lang.String>`	`ldbMap` Map of physical database helper objects to logical database names
`private static ContextLocal<ConnectionManager>`	`local` Context local instance of this class
`private java.util.Set<java.lang.String>`	`locked` Set of locked database.
`private static CentralLogger`	`LOG` Logger
`private static ContextLocal<ConnectionManager.ConnectionDispatcher>`	`metaCleaner` Collect all the DB connections so that they are cleaned up before anything else (as these are dependent on persistence and other context-local data.
`private static long`	`nextConnectID` Next available connect ID for metadata updates
`private java.util.Map<Database,java.util.Set<RecordBuffer>>`	`pdbReferences` Map of buffer sets currently referencing databases
`private java.util.Set<Database>`	`pendingDisconn` Databases awaiting disconnect (first level)
`private java.util.Set<Database>`	`pendingTxDisconn` Databases awaiting disconnect (second level)
`private int`	`registerProgress` This flags a registered (completely build) object.
`private java.util.Map<Database,Session>`	`sessions` Map of database info objects to network sessions
`private boolean`	`singleClient` Equivalent of -1 argument in CONNECT statement.
`private java.util.Map<java.lang.String,java.lang.String>`	`tenantIds` Map of tenant ids based on database logical names.
`private java.util.Map<java.lang.String,java.util.Set<TenantChangeListener>>`	`tenantListeners` Map with registered listeners for tenant changing processes based on the database logical name.
`private java.util.Map<java.lang.String,java.lang.String>`	`userIds` Map with the userids for the currently connected databases.

Constructor Summary

Constructors
Modifier Constructor and Description

private ConnectionManager()
Default constructor.

Constructors
Modifier	Constructor and Description
`private`	`ConnectionManager()` Default constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static character`	`alias(int index)` Retrieve the alias at the specified index in the current context.
`static character`	`alias(NumberType index)` Retrieve the alias at the specified index in the current context.
`private character`	`aliasImpl(int index)` Retrieve the alias at the specified index in the current context.
`private static void`	`assertKnownValue(BaseDataType data, java.lang.String description)` Assert that `data` does not represent the unknown value.
`static boolean`	`authenticate(java.lang.String userid, java.lang.String password, java.lang.String dbname)` Authenticates the user for specified DB connection.
`(package private) void`	`closeBufferScope(RecordBuffer buffer)` Called by a record buffer to notify that its scope has been closed, indicating that it no longer has an active reference to its database.
`private static void`	`connect_(boolean isAutoConnect, java.lang.Object... args)` Create a logical connection to a database using the specified parameters.
`static void`	`connect(boolean isAutoConnect, java.lang.Object... args)` Create a logical connection to a database using the specified parameters.
`private void`	`connect(boolean isAutoConnect, java.lang.String pdb, java.lang.String ldb, java.lang.String host, java.lang.String service, java.lang.String user, java.lang.String password, java.lang.Integer port, java.lang.Integer maxRetries)` Establish database connection.
`static void`	`connect(java.lang.Object... args)` Create a logical connection to a database using the specified parameters.
`private void`	`connectDbImpl(boolean isAutoConnect, java.util.List<java.util.Map.Entry<ConnectionManager.ConnectOption,ConnectionManager.ConnectOptionValue>> opts)` Create a logical connection to a database using the specified parameters.
`static logical`	`connected(character name)` Tests whether a logical connection to a database exists in this context, given a logical database name or alias.
`static logical`	`connected(java.lang.String name)` Tests whether a logical connection to a database exists in this context, given a logical database name or alias.
`private logical`	`connectedImpl(character name)` Tests whether a logical connection to a database exists in this context, given a logical database name or alias.
`private void`	`connectImpl(java.util.List<java.lang.Object> args)` Create a logical connection to a database using the specified parameters.
`static void`	`createAlias(character alias, character ldbName)` Create an alias for a logical database name within the current context.
`static void`	`createAlias(character alias, java.lang.String ldbName)` Create an alias for a logical database name within the current context.
`static void`	`createAlias(java.lang.String alias, character ldbName)` Create an alias for a logical database name within the current context.
`static void`	`createAlias(java.lang.String alias, java.lang.String ldbName)` Create an alias for a logical database name within the current context.
`private void`	`createAliasImpl(java.lang.String alias, java.lang.String ldbName)` Create an alias for a logical database name.
`static character`	`dbCodepage(character alias)` Implementation of the DBCODEPAGE function.
`static character`	`dbCodepage(int index)` Implementation of the DBCODEPAGE function.
`static character`	`dbCodepage(NumberType seqNo)` Implementation of the DBCODEPAGE function.
`static character`	`dbCodepage(java.lang.String alias)` Implementation of the DBCODEPAGE function.
`static character`	`dbCollation(character alias)` Implementation of the DBCOLLATION function.
`static character`	`dbCollation(int index)` Implementation of the DBCOLLATION function.
`static character`	`dbCollation(NumberType seqNo)` Implementation of the DBCOLLATION function.
`static character`	`dbCollation(java.lang.String alias)` Implementation of the DBCOLLATION function.
`static character`	`dbName()` Get the name of the connected database in this context.
`static character`	`dbParam(character nameOrAlias)` Implementation of the `DBPARAM()` Progress function.
`static character`	`dbParam(int index)` Implementation of the `DBPARAM()` Progress function.
`private static java.lang.String`	`dbparam(java.util.List<java.util.Map.Entry<ConnectionManager.ConnectOption,ConnectionManager.ConnectOptionValue>> opts)` Convert CONNECT options to a DBPARAM string.
`static character`	`dbParam(NumberType index)` Implementation of the `DBPARAM()` Progress function.
`static character`	`dbParam(java.lang.String nameOrAlias)` Implementation of the `DBPARAM()` Progress function.
`private character`	`dbParamImpl(java.lang.String nameOrAlias, int index)` Implementation of the `DBPARAM()` Progress function.
`static character`	`dbRestrictions(character name)` Get a description of restrictions for the connected database with the specified logical name or alias.
`static character`	`dbRestrictions(character name, character table)` Get a description of restrictions for the connected database with the specified logical name or alias.
`static character`	`dbRestrictions(character name, java.lang.String table)` Get a description of restrictions for the connected database with the specified logical name or alias.
`static character`	`dbRestrictions(int index)` Get a description of restrictions for the connected database at the specified index.
`static character`	`dbRestrictions(int index, character table)` Get a description of restrictions for the connected database at the specified index.
`static character`	`dbRestrictions(int index, java.lang.String table)` Get a description of restrictions for the connected database at the specified index.
`static character`	`dbRestrictions(NumberType index)` Get a description of restrictions for the connected database at the specified index.
`static character`	`dbRestrictions(NumberType index, character table)` Get a description of restrictions for the connected database at the specified index.
`static character`	`dbRestrictions(NumberType index, java.lang.String table)` Get a description of restrictions for the connected database at the specified index.
`static character`	`dbRestrictions(java.lang.String name)` Get a description of restrictions for the connected database with the specified logical name or alias.
`static character`	`dbRestrictions(java.lang.String name, character table)` Get a description of restrictions for the connected database with the specified logical name or alias.
`static character`	`dbRestrictions(java.lang.String name, java.lang.String table)` Get a description of restrictions for the connected database with the specified logical name or alias.
`private character`	`dbRestrictionsImpl(java.lang.String nameOrAlias, int index, java.lang.String table)` Get a description of restrictions for the table in the connected database with a specified alias or at the specified index.
`static integer`	`dbTaskId(character name)` Get the identifier of the current transaction for the given database.
`static integer`	`dbTaskId(int index)` Get the identifier of the current transaction for the given database.
`static integer`	`dbTaskId(NumberType index)` Get the identifier of the current transaction for the given database.
`static integer`	`dbTaskId(java.lang.String name)` Get the identifier of the current transaction for the given database.
`private integer`	`dbTaskIdImpl(java.lang.String name, int index)` Get the version number of the target database.
`static character`	`dbType(character name)` Get a brief descriptor of the database type with the specified logical name or alias.
`static character`	`dbType(int index)` Get a brief descriptor of the database type with the specified connection index.
`static character`	`dbType(NumberType index)` Get a brief descriptor of the database type with the specified connection index.
`static character`	`dbType(java.lang.String name)` Get a brief descriptor of the database type with the specified logical name or alias.
`static character`	`dbVersion(character name)` Get the version number of the target database.
`static character`	`dbVersion(int index)` Get the version number of the target database.
`static character`	`dbVersion(NumberType index)` Get the version number of the target database.
`static character`	`dbVersion(java.lang.String name)` Get the version number of the target database.
`private character`	`dbVersionImpl(java.lang.String name, int index)` Get the version number of the target database.
`static void`	`deleteAlias(character alias)` Delete the specified alias immediately.
`static void`	`deleteAlias(java.lang.String alias)` Delete the specified alias immediately.
`private void`	`deleteAliasImpl(java.lang.String alias)` Delete the specified alias immediately.
`void`	`deregisterTenantListener(TenantChangeListener listener, java.lang.String ldbName)` De-register a `TenantChangeListener`.
`static void`	`disconnect(character ldbName)` Request a disconnect from a logical database.
`static void`	`disconnect(java.lang.String ldbName)` Request a disconnect from a logical database.
`private void`	`disconnectImmediately(Database database, boolean sessionCleanup)` Disconnect the specified database by deregistering it with the `DatabaseManager` and terminating the associated network session.
`private void`	`disconnectImmediately(java.util.Set<Database> pending, boolean sessionCleanup)` Disconnect all databases in the specified set by deregistering them with the `DatabaseManager` and removing them from the set.
`private void`	`disconnectImpl(java.lang.String ldbName)` Request a disconnect from a logical database.
`static ConnectionManager`	`get()` Retrieve the `ConnectionManager` instance for the local context.
`(package private) java.util.ArrayList<Database>`	`getActiveDatabases()` Get a list of active databases, which is meant to include the temp-table database and all connected, persistent databases.
`(package private) java.util.Map<java.lang.String,java.lang.String>`	`getAliasesByLDB()` Get the currently connected aliases by their logical database name.
`static int`	`getAuthLevel(java.lang.String ldbname)` Check the access level for a database based on metadata of that database.
`static int`	`getConnectedDbCount()` Get the number of databases currently connected in this context.
`static java.lang.String`	`getCurrentUserid(java.lang.String ldbName)` Returns a string representing the user ID used for authentication to a database.
`private java.lang.String`	`getCurrentUseridImpl(java.lang.String ldbName)` Returns the current id used by the user to authenticated to a database identified by its logical name.
`(package private) Database`	`getDatabase(java.lang.String name)` Get the database information object for the given database name, which may be a logical name, physical name, or alias.
`static ClientPrincipal`	`getDbClient(java.lang.String dbName)` Get the CLIENT-PRINCIPAL associated with the given database name.
`static java.lang.String`	`getDefaultDatabase()` Return the default logical database.
`java.lang.String`	`getLDBName(Database database)` Get the logical database name for a connected physical database.
`(package private) java.lang.String`	`getLDBName(java.lang.String name)` Get the logical database name for the given logical database name or alias.
`(package private) java.lang.String`	`getPDBName(java.lang.String name, boolean normalize)` Get the physical database name for the given logical database name or alias.
`static Persistence`	`getPersistence(java.lang.String name)` Get the `Persistence` instance associated with the given database name, which may be a physical or logical name, or an alias.
`static Session`	`getSession(Database database)` Retrieve the network session which manages the connection to the remote server which is authoritative for the specified database.
`static Session`	`getSession(java.lang.String name)` Retrieve the network session which manages the connection to the remote server which is authoritative for the specified database name, which may be a logical name, physical name, or alias.
`private static java.lang.Long`	`getSQLResultAsLong(java.lang.Object ufo)` Dynamically analyze (by class type) and convert a value returned by a SQL statement of an unknown type (but assumed to be integer-like) to Long value.
`java.lang.String`	`getTenantId(java.lang.String ldbName)` Get a tenant id based on a database logical name.
`static java.util.List<java.lang.String>`	`getUnlocked()` Get the list of unlocked database connections.
`boolean`	`isBufferScopeLeaking(RecordBuffer buffer)` Very specific method to check if a buffer is still dangling in the `pdbReferences` collection.
`static boolean`	`isLocked(java.lang.String dbName)` Check if database connection is locked.
`private static <X> X`	`iterateToIndex(java.util.Collection<X> coll, int index)` Iterate over the specified collection, returning the element at index `index`.
`static character`	`ldbName(character name)` Get the logical database name for the connected database with the given logical name or alias.
`static character`	`ldbName(int index)` Get the logical database name for the connected database at the given index.
`static character`	`ldbName(NumberType index)` Get the logical database name for the connected database at the given index.
`static character`	`ldbName(java.lang.Object dmo)` Get the logical database name for the record buffer associated with the given DMO.
`static character`	`ldbName(java.lang.String name)` Get the logical database name for the connected database with the given logical name or alias.
`private character`	`ldbNameImpl(java.lang.String name, int index)` Get the logical name for a database, given an alias (which may be the logical name itself), or its index among all connected databases in this context.
`(package private) static java.lang.String`	`ldbNameNative(int index)` Get the logical database name for the connected database at the given index.
`private java.lang.String`	`ldbNameNativeImpl(java.lang.String name, int index)` Get the logical name for a database, given an alias (which may be the logical name itself), or its index among all connected databases in this context.
`private java.lang.String`	`makeConnection(Database database, java.lang.String ldbName, java.lang.String certAlias, boolean isAutoConnect)` Create a logical connection to the database with the specified physical name, creating the specified logical name for it.
`private static character`	`normalizeAliasOrLDB(character name)` Normalize an alias or logical database name by right trimming whitespace and lowercasing.
`(package private) static java.lang.String`	`normalizeFilename(java.lang.String name)` Normalize the given filename by extracting the root name (removing the file path and the filename extension).
`static integer`	`numAliases()` Get the number of aliases currently defined in this context.
`static integer`	`numDBs()` Get the number of databases currently connected in this context.
`(package private) void`	`openBufferScope(RecordBuffer buffer)` Register that a reference from a record buffer to its database has become active.
`static java.util.List<java.util.List<java.util.Map.Entry<ConnectionManager.ConnectOption,ConnectionManager.ConnectOptionValue>>>`	`parse(java.util.List<java.lang.Object> args)` Parse CONNECT statement options.
`static character`	`pdbName(character name)` Get the physical database name for the connected database with the given logical name or alias.
`static character`	`pdbName(int index)` Get the physical database name for the connected database at the given index.
`static character`	`pdbName(NumberType index)` Get the physical database name for the connected database at the given index.
`static character`	`pdbName(java.lang.String name)` Get the physical database name for the connected database with the given logical name or alias.
`private character`	`pdbNameImpl(java.lang.String name, int index)` Get the physical name for a database, given its logical name or alias, or its index among all connected databases in this context.
`private void`	`putConnected(java.lang.String ldbName, Database database, java.lang.String userId, java.lang.String tenantId)` Update the various housekeeping data structures to reflect a successful connection event, and update connection metadata if it is in use.
`static void`	`putTenantDatabaseConnected(ClientPrincipal client, java.lang.String ldbName)` Mark the given database of a tenant as connected.
`static void`	`readQueryResults(java.lang.String sql, Persistence persistence, java.util.function.Consumer<ScrollableResults<?>> consumer)` Read query results.
`static void`	`readUserTable(Persistence persistence, java.util.function.Consumer<java.lang.String[]> consumer)` Read _User table from the database supplying String array: {userid, domain-name, password} to a consumer.
`private void`	`register()` Registers with the transaction manager for master and global finish notifications.
`void`	`registerTenantListener(TenantChangeListener listener, java.lang.String ldbName)` Register a `TenantChangeListener` for actions that involve tenant id changes.
`private Database`	`removeConnected(java.lang.String ldbName, boolean sessionCleanup)` Update the various housekeeping data structures to reflect a disconnection event, and update connection metadata if it is in use.
`void`	`removeTenantId(java.lang.String ldbName)` Remove a tenant that is tied to a database.
`static character`	`sdbName(character name)` Get the logical database name for the connected database with the given logical name or alias.
`static character`	`sdbName(int index)` Get the logical database name for the connected database at the given index.
`static character`	`sdbName(NumberType index)` Get the logical database name for the connected database at the given index.
`static character`	`sdbName(java.lang.String name)` Get the logical database name for the connected database with the given logical name or alias.
`private void`	`sessionClosed()` Perform end of session cleanup; disconnects all connected databases without regard to transaction state or buffer reference status.
`static void`	`setAuthenticatedUserid(java.lang.String dbName, java.lang.String userid, boolean lock, boolean byConnect)` Set the currently authenticated userid for a database.
`private void`	`setConnectUserImpl(java.lang.String ldbName)` Mark the current user for the database as the connection parameter.
`private void`	`setCurrentUseridImpl(java.lang.String ldbName, java.lang.String newUserId, boolean lock)` Sets the currently authenticated `userid` for a database.
`static void`	`setDbClient(ClientPrincipal client, java.lang.String dbName, ClientPrincipalResource.SealCallee callee)` Associate the specified CLIENT-PRINCIPAL with the given database logical name.
`(package private) void`	`transactionEnded()` This method is invoked after a master transaction commit/rollback; any databases awaiting the end of the current transaction to disconnect are now deregistered with the database manager.
`(package private) void`	`transactionEnded(Database database)` This method is invoked after a master transaction commit/rollback; if the specified database is waiting for the end of the current transaction to disconnect, it will be deregistered with the database manager.
`static void`	`unlock(java.lang.String dbName)` Unlock the database connection.

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
  - local
```
private static final ContextLocal<ConnectionManager> local
```
    Context local instance of this class
  - metaCleaner
```
private static final ContextLocal<ConnectionManager.ConnectionDispatcher> metaCleaner
```
    Collect all the DB connections so that they are cleaned up before anything else (as these are dependent on persistence and other context-local data.
  - DICTDB
```
private static final java.lang.String DICTDB
```
    DICTDB alias name
    
    See Also:
    
    Constant Field Values
  - DEFAULT_DBVERSION
```
private static final java.lang.String DEFAULT_DBVERSION
```
    Default DBVERSION text
    
    See Also:
    
    Constant Field Values
  - DEFAULT_CONN_RETRIES
```
private static final int DEFAULT_CONN_RETRIES
```
    Default number of database connection retries
    
    See Also:
    
    Constant Field Values
  - CONN_RETRY_DELAY
```
private static final long CONN_RETRY_DELAY
```
    Milliseconds to wait between connection retries
    
    See Also:
    
    Constant Field Values
  - dbVersionCache
```
private static final java.util.Map<java.lang.String,java.lang.String> dbVersionCache
```
    Cache of database versions, indexed by PDB name
  - nextConnectID
```
private static long nextConnectID
```
    Next available connect ID for metadata updates
  - locked
```
private final java.util.Set<java.lang.String> locked
```
    Set of locked database.
  - clients
```
private final java.util.Map<java.lang.String,ClientPrincipal> clients
```
    Map of registered CLIENT-PRINCIPAL objects, for each database.
  - userIds
```
private final java.util.Map<java.lang.String,java.lang.String> userIds
```
    Map with the userids for the currently connected databases. This map must be kept in sync with the connected map of the databases.
  - connectTimeUserid
```
private final java.util.Map<java.lang.String,java.lang.String> connectTimeUserid
```
    Stores the userid used at connection time whether the database is connected using command-line (directory implementation) or programatically using CONNECT with -U/-P parameters. This list is not affected by later SETUSERID calls.
  - connected
```
private final java.util.Map<java.lang.String,ConnectionManager.ConnectInfo> connected
```
    Map of logical database names to ConnectInfo objects
  - ldbMap
```
private final java.util.Map<Database,java.lang.String> ldbMap
```
    Map of physical database helper objects to logical database names
  - pendingDisconn
```
private final java.util.Set<Database> pendingDisconn
```
    Databases awaiting disconnect (first level)
  - pendingTxDisconn
```
private final java.util.Set<Database> pendingTxDisconn
```
    Databases awaiting disconnect (second level)
  - aliases
```
private final java.util.Map<java.lang.String,java.lang.String> aliases
```
    Map of active aliases to logical database names
  - pdbReferences
```
private final java.util.Map<Database,java.util.Set<RecordBuffer>> pdbReferences
```
    Map of buffer sets currently referencing databases
  - sessions
```
private final java.util.Map<Database,Session> sessions
```
    Map of database info objects to network sessions
  - tenantIds
```
private final java.util.Map<java.lang.String,java.lang.String> tenantIds
```
    Map of tenant ids based on database logical names.
  - tenantListeners
```
private final java.util.Map<java.lang.String,java.util.Set<TenantChangeListener>> tenantListeners
```
    Map with registered listeners for tenant changing processes based on the database logical name.
  - dispatcher
```
private final ConnectionManager.ConnectionDispatcher dispatcher
```
    Connect/disconnect event dispatcher
  - singleClient
```
private boolean singleClient
```
    Equivalent of -1 argument in CONNECT statement. At this moment it is not used except for computing DBPARAM function result. TODO: Future implementation will address this flag.
  - registerProgress
```
private int registerProgress
```
    This flags a registered (completely build) object. It is set after calling register().
- Constructor Detail
  - ConnectionManager
```
private ConnectionManager()
```
    Default constructor.
    Call register() ASAP to actually connects to all permanent databases and register with the transaction manager for master and global finish notifications.
- Method Detail
  - register
```
private void register()
```
    Registers with the transaction manager for master and global finish notifications. Connects to all permanent databases.
    WARNING: Only call this method once!
  - get
```
public static ConnectionManager get()
```
    Retrieve the ConnectionManager instance for the local context.
    
    Returns:
    
    Context local connection manager.
  - connect
```
public static void connect(java.lang.Object... args)
```
    Create a logical connection to a database using the specified parameters.
    Parameters:
    args - One or more connection parameters. This may take one of several forms:
    
    an ordered list of the following:
    
    physical database name (required)
    logical database name (optional)
    P2J server host name/address (optional)
    P2J server port number or service name (optional, unless host name/address is supplied)
    userid (optional)
    password (optional, required if userid is specified)
    
    a string with the above listed components, prefaced by the following identifiers, respectively:
    
    -db
    -ld
    -H
    -S
    -U
    -P
    -ct
    For example: -db mydb -ld logical_name -H 192.168.1.12 -S 3333. After -db, parameters can be in any order, so long as each is preceded by the specified option identifier.
    any combination of string fragments, which, if concatenated together in the order supplied, would create a string matching the requirements of the previous item.
    Throws:
    
    ErrorConditionException - if any parameter is null or represents the unknown value; if any parameter is neither a text value nor an integral value; if there is an error registering the database with the database manager.
  - connect
```
public static void connect(boolean isAutoConnect,
                           java.lang.Object... args)
```
    Create a logical connection to a database using the specified parameters.
    Parameters:
    
    isAutoConnect - flag indication that is is an implicit auto-connect operation
    args - One or more connection parameters. This may take one of several forms:
    
    an ordered list of the following:
    
    physical database name (required)
    logical database name (optional)
    P2J server host name/address (optional)
    P2J server port number or service name (optional, unless host name/address is supplied)
    userid (optional)
    password (optional, required if userid is specified)
    
    a string with the above listed components, prefaced by the following identifiers, respectively:
    
    -db
    -ld
    -H
    -S
    -U
    -P
    -ct
    For example: -db mydb -ld logical_name -H 192.168.1.12 -S 3333. After -db, parameters can be in any order, so long as each is preceded by the specified option identifier.
    any combination of string fragments, which, if concatenated together in the order supplied, would create a string matching the requirements of the previous item.
    Throws:
    
    ErrorConditionException - if any parameter is null or represents the unknown value; if any parameter is neither a text value nor an integral value; if there is an error registering the database with the database manager.
  - connect_
```
private static void connect_(boolean isAutoConnect,
                             java.lang.Object... args)
```
    Create a logical connection to a database using the specified parameters.
    
    Parameters:
    
    isAutoConnect - flag indication that is is an implicit auto-connect operation
    
    args - One or more connection parameters. This may take one of several forms:
    
    Throws:
    
    ErrorConditionException - see above
  - parse
```
public static java.util.List<java.util.List<java.util.Map.Entry<ConnectionManager.ConnectOption,ConnectionManager.ConnectOptionValue>>> parse(java.util.List<java.lang.Object> args)
                                                                                                                                       throws PersistenceException
```
    Parse CONNECT statement options.
    
    Parameters:
    
    args - statement arguments.
    
    Returns:
    
    The parsed options (separately for all databases).
    
    Throws:
    
    PersistenceException - if a fatal error was encountered
  - disconnect
```
public static void disconnect(character ldbName)
```
    Request a disconnect from a logical database. This does not actually perform the disconnect immediately, but registers ldbName for disconnect at the appropriate time: once no buffers reference the database, and at the end of the current transaction (if any).
    
    Parameters:
    
    ldbName - Logical name of the database to disconnect.
    
    Throws:
    
    ErrorConditionException - if the specified database has not been opened.
  - disconnect
```
public static void disconnect(java.lang.String ldbName)
```
    Request a disconnect from a logical database. This does not actually perform the disconnect immediately, but registers ldbName for disconnect at the appropriate time: once no buffers reference the database, and at the end of the current transaction (if any).
    
    Parameters:
    
    ldbName - Logical name of the database to disconnect.
    
    Throws:
    
    ErrorConditionException - if the specified database has not been opened.
  - connected
```
public static logical connected(character name)
```
    Tests whether a logical connection to a database exists in this context, given a logical database name or alias.
    
    Parameters:
    
    name - Logical database name or alias.
    
    Returns:
    
    true if a logical connection exists; else false.
  - connected
```
public static logical connected(java.lang.String name)
```
    Tests whether a logical connection to a database exists in this context, given a logical database name or alias.
    
    Parameters:
    
    name - Logical database name or alias.
    
    Returns:
    
    true if a logical connection exists; else false.
  - numAliases
```
public static integer numAliases()
```
    Get the number of aliases currently defined in this context.
    
    Returns:
    
    Number of aliases in this context.
  - getConnectedDbCount
```
public static int getConnectedDbCount()
```
    Get the number of databases currently connected in this context.
    
    Returns:
    
    Number of logical connections in this context.
  - numDBs
```
public static integer numDBs()
```
    Get the number of databases currently connected in this context.
    
    Returns:
    
    Number of logical connections in this context.
  - dbCodepage
```
public static character dbCodepage(NumberType seqNo)
```
    Implementation of the DBCODEPAGE function.
    
    Parameters:
    
    seqNo - The sequence number of the connected database.
    
    Returns:
    
    The CP of the specified database.
  - dbCodepage
```
public static character dbCodepage(int index)
```
    Implementation of the DBCODEPAGE function.
    
    Parameters:
    
    index - The sequence number of the connected database.
    
    Returns:
    
    The CP of the specified database.
  - dbCodepage
```
public static character dbCodepage(character alias)
```
    Implementation of the DBCODEPAGE function.
    
    Parameters:
    
    alias - The logical name or alias of the connected database.
    
    Returns:
    
    The CP of the specified database.
  - dbCodepage
```
public static character dbCodepage(java.lang.String alias)
```
    Implementation of the DBCODEPAGE function.
    
    Parameters:
    
    alias - The logical name or alias of the connected database.
    
    Returns:
    
    The CP of the specified database.
  - dbCollation
```
public static character dbCollation(NumberType seqNo)
```
    Implementation of the DBCOLLATION function.
    
    Parameters:
    
    seqNo - The sequence number of the connected database.
    
    Returns:
    
    The collation of the specified database.
  - dbCollation
```
public static character dbCollation(int index)
```
    Implementation of the DBCOLLATION function.
    
    Parameters:
    
    index - The sequence number of the connected database.
    
    Returns:
    
    The collation of the specified database.
  - dbCollation
```
public static character dbCollation(character alias)
```
    Implementation of the DBCOLLATION function.
    
    Parameters:
    
    alias - The logical name or alias of the connected database.
    
    Returns:
    
    The collation of the specified database.
  - dbCollation
```
public static character dbCollation(java.lang.String alias)
```
    Implementation of the DBCOLLATION function.
    
    Parameters:
    
    alias - The logical name or alias of the connected database.
    
    Returns:
    
    The collation of the specified database.
  - dbName
```
public static character dbName()
```
    Get the name of the connected database in this context. If more than one, return the first.
    
    Returns:
    
    First or only connected database, or unknown value if none.
  - dbParam
```
public static character dbParam(int index)
```
    Implementation of the DBPARAM() Progress function. Returns, as a character string, a comma-separated list of the parameters used to connect to the database.
    The sequence number of a database the Progress session is connected to. For example, DBPARAM(1) returns information on the first database the Progress session is connected to, DBPARAM(2) returns information on the second database the Progress session is connected to, etc. If you specify a sequence number that does not correspond to a database the Progress session is connected to, the DBPARAM function returns the unknown value (?).
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    A comma-separated list of the parameters used to connect to the database
  - dbParam
```
public static character dbParam(NumberType index)
```
    Implementation of the DBPARAM() Progress function. Returns, as a character string, a comma-separated list of the parameters used to connect to the database.
    The sequence number of a database the Progress session is connected to. For example, DBPARAM(1) returns information on the first database the Progress session is connected to, DBPARAM(2) returns information on the second database the Progress session is connected to, etc. If you specify a sequence number that does not correspond to a database the Progress session is connected to, the DBPARAM function returns the unknown value (?).
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    A comma-separated list of the parameters used to connect to the database
  - dbParam
```
public static character dbParam(java.lang.String nameOrAlias)
```
    Implementation of the DBPARAM() Progress function. Returns, as a character string, a comma-separated list of the parameters used to connect to the database.
    This forms of the DBPARAM() function require a character expression as a parameter. If the parameter is an alias or the logical name of a connected database, then Progress returns the comma-separated parameter list. Otherwise, it returns the unknown value (?).
    
    Parameters:
    
    nameOrAlias - The logical-name or alias of a connected database
    
    Returns:
    
    A comma-separated list of the parameters used to connect to the database
  - dbParam
```
public static character dbParam(character nameOrAlias)
```
    Implementation of the DBPARAM() Progress function. Returns, as a character string, a comma-separated list of the parameters used to connect to the database.
    This forms of the DBPARAM() function require a character expression as a parameter. If the parameter is an alias or the logical name of a connected database, then Progress returns the comma-separated parameter list. Otherwise, it returns the unknown value (?).
    
    Parameters:
    
    nameOrAlias - The logical-name or alias of a connected database
    
    Returns:
    
    A comma-separated list of the parameters used to connect to the database
  - dbType
```
public static character dbType(NumberType index)
```
    Get a brief descriptor of the database type with the specified connection index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The string "PROGRESS" or unknown value if index represents the unknown value or is outside of the range of connected databases.
  - dbType
```
public static character dbType(int index)
```
    Get a brief descriptor of the database type with the specified connection index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The string "PROGRESS" or unknown value if index represents the unknown value or is outside of the range of connected databases.
  - dbType
```
public static character dbType(character name)
```
    Get a brief descriptor of the database type with the specified logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The string "PROGRESS" or unknown value if name is not a recognized logical name or alias.
  - dbType
```
public static character dbType(java.lang.String name)
```
    Get a brief descriptor of the database type with the specified logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The string "PROGRESS" or unknown value if name is not a recognized logical name or alias.
  - dbTaskId
```
public static integer dbTaskId(character name)
```
    Get the identifier of the current transaction for the given database.
    
    Parameters:
    
    name - Logical name or alias of a connected database.
    
    Returns:
    
    Current transaction identifier, or unknown value if name is not the name or an alias for a connected database, or if there is no active transaction.
  - dbTaskId
```
public static integer dbTaskId(java.lang.String name)
```
    Get the identifier of the current transaction for the given database.
    
    Parameters:
    
    name - Logical name or alias of a connected database.
    
    Returns:
    
    Current transaction identifier, or unknown value if name is not the name or an alias for a connected database, or if there is no active transaction.
  - dbTaskId
```
public static integer dbTaskId(NumberType index)
```
    Get the identifier of the current transaction for the given database.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    Current transaction identifier, or unknown value if index is not an index of a connected database, or if there is no active transaction.
  - dbTaskId
```
public static integer dbTaskId(int index)
```
    Get the identifier of the current transaction for the given database.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    Current transaction identifier, or unknown value if index is not an index of a connected database, or if there is no active transaction.
  - dbVersion
```
public static character dbVersion(NumberType index)
```
    Get the version number of the target database.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The database's version, as extracted from runtime configuration, or unknown value if index represents the unknown value or is outside of the range of connected databases.
  - dbVersion
```
public static character dbVersion(int index)
```
    Get the version number of the target database.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The database's version, as extracted from runtime configuration, or unknown value if index is outside of the range of connected databases.
  - dbVersion
```
public static character dbVersion(character name)
```
    Get the version number of the target database.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The database's version, as extracted from runtime configuration, or unknown value if name represents the unknown value or is not a recognized logical name or alias.
  - dbVersion
```
public static character dbVersion(java.lang.String name)
```
    Get the version number of the target database.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The database's version, as extracted from runtime configuration, or unknown value if name is not a recognized logical name or alias.
  - dbRestrictions
```
public static character dbRestrictions(NumberType index)
```
    Get a description of restrictions for the connected database at the specified index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The empty string, or unknown value if index represents the unknown value or is outside of the range of connected databases.
  - dbRestrictions
```
public static character dbRestrictions(int index)
```
    Get a description of restrictions for the connected database at the specified index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The empty string, or unknown value if index is invalid.
  - dbRestrictions
```
public static character dbRestrictions(NumberType index,
                                       character table)
```
    Get a description of restrictions for the connected database at the specified index. Currently, table is ignored.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if index is invalid.
  - dbRestrictions
```
public static character dbRestrictions(NumberType index,
                                       java.lang.String table)
```
    Get a description of restrictions for the connected database at the specified index. Currently, table is ignored.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if index is invalid.
  - dbRestrictions
```
public static character dbRestrictions(int index,
                                       character table)
```
    Get a description of restrictions for the connected database at the specified index. Currently, table is ignored.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if index is invalid.
  - dbRestrictions
```
public static character dbRestrictions(int index,
                                       java.lang.String table)
```
    Get a description of restrictions for the connected database at the specified index. Currently, table is ignored.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if index is invalid.
  - dbRestrictions
```
public static character dbRestrictions(character name)
```
    Get a description of restrictions for the connected database with the specified logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The empty string, or unknown value if name is not a recognized logical name or alias.
  - dbRestrictions
```
public static character dbRestrictions(java.lang.String name)
```
    Get a description of restrictions for the connected database with the specified logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The empty string, or unknown value if name is not a recognized logical name or alias.
  - dbRestrictions
```
public static character dbRestrictions(character name,
                                       character table)
```
    Get a description of restrictions for the connected database with the specified logical name or alias. Currently, table is ignored.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if name is not a recognized logical name or alias.
  - dbRestrictions
```
public static character dbRestrictions(character name,
                                       java.lang.String table)
```
    Get a description of restrictions for the connected database with the specified logical name or alias. Currently, table is ignored.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if name is not a recognized logical name or alias.
  - dbRestrictions
```
public static character dbRestrictions(java.lang.String name,
                                       character table)
```
    Get a description of restrictions for the connected database with the specified logical name or alias. Currently, table is ignored.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if name is not a recognized logical name or alias.
  - dbRestrictions
```
public static character dbRestrictions(java.lang.String name,
                                       java.lang.String table)
```
    Get a description of restrictions for the connected database with the specified logical name or alias. Currently, table is ignored.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    table - Name of a table within the target database. Ignored.
    
    Returns:
    
    The empty string, or unknown value if name is not a recognized logical name or alias.
  - createAlias
```
public static void createAlias(character alias,
                               character ldbName)
```
    Create an alias for a logical database name within the current context. The alias may not conflict with an existing logical database name (except for that of the database which it aliases). The alias will be created regardless of whether the target database currently is connected; however, an error will be raised (or silently registered) in the event it is not, after the alias has been created. The alias persists until explicitly deleted with one of the variants of the deleteAlias method, or until the current session ends.
    Parameters:
    
    alias - Alias to be created.
    
    ldbName - Logical name of the database to which the alias is assigned.
    
    Throws:
    ErrorConditionException - if silent error mode is disabled and any of the following:
    
    alias represents the unknown value;
    ldbName represents the unknown value;
    the target database is not connected;
    the alias conflicts with an existing logical database name, other than ldbName.
  - createAlias
```
public static void createAlias(java.lang.String alias,
                               character ldbName)
```
    Create an alias for a logical database name within the current context. The alias may not conflict with an existing logical database name (except for that of the database which it aliases). The alias will be created regardless of whether the target database currently is connected; however, an error will be raised (or silently registered) in the event it is not, after the alias has been created. The alias persists until explicitly deleted with one of the variants of the deleteAlias method, or until the current session ends.
    Parameters:
    
    alias - Alias to be created.
    
    ldbName - Logical name of the database to which the alias is assigned.
    
    Throws:
    ErrorConditionException - if silent error mode is disabled and any of the following:
    
    ldbName represents the unknown value;
    the target database is not connected;
    the alias conflicts with an existing logical database name, other than ldbName.
  - createAlias
```
public static void createAlias(character alias,
                               java.lang.String ldbName)
```
    Create an alias for a logical database name within the current context. The alias may not conflict with an existing logical database name (except for that of the database which it aliases). The alias will be created regardless of whether the target database currently is connected; however, an error will be raised (or silently registered) in the event it is not, after the alias has been created. The alias persists until explicitly deleted with one of the variants of the deleteAlias method, or until the current session ends.
    Parameters:
    
    alias - Alias to be created.
    
    ldbName - Logical name of the database to which the alias is assigned.
    
    Throws:
    ErrorConditionException - if silent error mode is disabled and any of the following:
    
    alias represents the unknown value;
    the target database is not connected;
    the alias conflicts with an existing logical database name, other than ldbName.
  - createAlias
```
public static void createAlias(java.lang.String alias,
                               java.lang.String ldbName)
```
    Create an alias for a logical database name within the current context. The alias may not conflict with an existing logical database name (except for that of the database which it aliases). The alias will be created regardless of whether the target database currently is connected; however, an error will be raised (or silently registered) in the event it is not, after the alias has been created. The alias persists until explicitly deleted with one of the variants of the deleteAlias method, or until the current session ends.
    Parameters:
    
    alias - Alias to be created.
    
    ldbName - Logical name of the database to which the alias is assigned.
    
    Throws:
    ErrorConditionException - if silent error mode is disabled and any of the following:
    
    the target database is not connected;
    the alias conflicts with an existing logical database name, other than ldbName.
  - deleteAlias
```
public static void deleteAlias(character alias)
```
    Delete the specified alias immediately.
    
    Parameters:
    
    alias - Alias to be deleted.
  - deleteAlias
```
public static void deleteAlias(java.lang.String alias)
```
    Delete the specified alias immediately.
    
    Parameters:
    
    alias - Alias to be deleted.
  - alias
```
public static character alias(NumberType index)
```
    Retrieve the alias at the specified index in the current context.
    
    Parameters:
    
    index - One-based index of the alias (aliases are stored in the order in which they were created).
    
    Returns:
    
    The target alias, or unknown value if index is invalid.
  - alias
```
public static character alias(int index)
```
    Retrieve the alias at the specified index in the current context.
    
    Parameters:
    
    index - One-based index of the alias (aliases are stored in the order in which they were created).
    
    Returns:
    
    The target alias, or unknown value if index is invalid.
  - ldbName
```
public static character ldbName(NumberType index)
```
    Get the logical database name for the connected database at the given index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The logical name, or unknown value if index is invalid.
  - ldbName
```
public static character ldbName(int index)
```
    Get the logical database name for the connected database at the given index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The logical name, or unknown value if index is invalid.
  - ldbName
```
public static character ldbName(character name)
```
    Get the logical database name for the connected database with the given logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The logical name, or unknown value if name is invalid.
  - ldbName
```
public static character ldbName(java.lang.String name)
```
    Get the logical database name for the connected database with the given logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The logical name, or unknown value if name is invalid.
  - ldbName
```
public static character ldbName(java.lang.Object dmo)
```
    Get the logical database name for the record buffer associated with the given DMO.
    
    Parameters:
    
    dmo - Data model object returned by a previous call to RecordBuffer.define(java.lang.Class<T>, java.lang.String, java.lang.String).
    
    Returns:
    
    The logical database name for the DMO.
  - pdbName
```
public static character pdbName(NumberType index)
```
    Get the physical database name for the connected database at the given index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The physical name, or unknown value if index is invalid.
  - pdbName
```
public static character pdbName(int index)
```
    Get the physical database name for the connected database at the given index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The physical name, or unknown value if index is invalid.
  - pdbName
```
public static character pdbName(character name)
```
    Get the physical database name for the connected database with the given logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The physical name, or unknown value if name is invalid.
  - pdbName
```
public static character pdbName(java.lang.String name)
```
    Get the physical database name for the connected database with the given logical name or alias.
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The physical name, or unknown value if name is invalid.
  - sdbName
```
public static character sdbName(NumberType index)
```
    Get the logical database name for the connected database at the given index.
    The current implementation delegates to ldbName(NumberType).
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The logical name, or unknown value if index is invalid.
  - sdbName
```
public static character sdbName(int index)
```
    Get the logical database name for the connected database at the given index.
    The current implementation delegates to ldbName(int).
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The logical name, or unknown value if index is invalid.
  - sdbName
```
public static character sdbName(character name)
```
    Get the logical database name for the connected database with the given logical name or alias.
    The current implementation delegates to ldbName(character).
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The logical name, or unknown value if name is invalid.
  - sdbName
```
public static character sdbName(java.lang.String name)
```
    Get the logical database name for the connected database with the given logical name or alias.
    The current implementation delegates to ldbName(String).
    
    Parameters:
    
    name - Logical name or alias of the target database.
    
    Returns:
    
    The logical name, or unknown value if name is invalid.
  - getSession
```
public static Session getSession(Database database)
```
    Retrieve the network session which manages the connection to the remote server which is authoritative for the specified database.
    
    Parameters:
    
    database - Database to which the target session is mapped.
    
    Returns:
    
    Network session for the given database, or null if there is no current connection.
  - getSession
```
public static Session getSession(java.lang.String name)
```
    Retrieve the network session which manages the connection to the remote server which is authoritative for the specified database name, which may be a logical name, physical name, or alias. It is assumed that the database currently is connected.
    
    Parameters:
    
    name - Logical name, physical name, or alias for database.
    
    Returns:
    
    Network session for the given database, or null if there is no current connection.
  - getPersistence
```
public static Persistence getPersistence(java.lang.String name)
```
    Get the Persistence instance associated with the given database name, which may be a physical or logical name, or an alias.
    
    Parameters:
    
    name - Physical or logical database name, or alias.
    
    Returns:
    
    Persistence object associated with the given database, which may be locally or remotely connected or null if no database with such name is connected
  - getCurrentUserid
```
public static java.lang.String getCurrentUserid(java.lang.String ldbName)
```
    Returns a string representing the user ID used for authentication to a database. The database is identified by its logical name.
    
    Parameters:
    
    ldbName - The logical name of the database for which the userid is requested.
    
    Returns:
    
    current userid that was authenticated to specified database
  - getDefaultDatabase
```
public static java.lang.String getDefaultDatabase()
```
    Return the default logical database. It is used only with setuserid and userid with default (missing argument) for database parameter.
    
    Returns:
    
    The logical database name if only one (permanent) database is connected. Otherwise it raise an error condition and abends.
  - authenticate
```
public static boolean authenticate(java.lang.String userid,
                                   java.lang.String password,
                                   java.lang.String dbname)
```
    Authenticates the user for specified DB connection. Checks if the user login account match the corresponding record of the _User table of the database. If the specified database is not connected, an error is issued. The user/password comparing operation is done as 4GL:
    - user: is case-insensitive, trailing spaces are ignored (in upper(rtrim()) mode)
    - password: must be an exact match: after applying ENCODE to password string it is compared to existing record from database in case sensitive, taking into consideration trailing spaces
    Parameters:
    
    userid - The name of the user to set as UserID.
    
    password - The users password.
    
    dbname - Logical database name.
    
    Returns:
    
    The true in case of valid user match false otherwise.
  - getAuthLevel
```
public static int getAuthLevel(java.lang.String ldbname)
```
    Check the access level for a database based on metadata of that database. This will query if _User table and return SecurityOps.FREE_ACCESS if the meta table is not populated and SecurityOps.BLANK_ALLOWED otherwise.
    
    Parameters:
    
    ldbname - The logical database name to query.
    
    Returns:
    
    The access level to specified database.
  - putTenantDatabaseConnected
```
public static void putTenantDatabaseConnected(ClientPrincipal client,
                                              java.lang.String ldbName)
```
    Mark the given database of a tenant as connected. This method makes use of the ConnectionManager.putConnected method, and it will fail if the database with the given name cannot be found.
    
    Parameters:
    
    client - The client/tenant for which to mark the database.
    
    ldbName - The logical name of the database.
  - setDbClient
```
public static void setDbClient(ClientPrincipal client,
                               java.lang.String dbName,
                               ClientPrincipalResource.SealCallee callee)
```
    Associate the specified CLIENT-PRINCIPAL with the given database logical name. If not specified, use the default connected database.
    A copy of the CLIENT-PRINCIPAL object is saved in the clients map.
    
    Parameters:
    
    client - The CLIENT-PRINCIPAL object.
    
    dbName - A valid database name.
    
    callee - where the method is called from
    
    Throws:
    
    java.lang.IllegalArgumentException - If the database name is not valid.
  - getUnlocked
```
public static java.util.List<java.lang.String> getUnlocked()
```
    Get the list of unlocked database connections.
    
    Returns:
    
    the list of unlocked database connections.
  - isLocked
```
public static boolean isLocked(java.lang.String dbName)
```
    Check if database connection is locked.
    
    Parameters:
    
    dbName - A valid database name.
    
    Returns:
    
    true if the database connection is locked.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the database name is not valid.
  - unlock
```
public static void unlock(java.lang.String dbName)
```
    Unlock the database connection.
    
    Parameters:
    
    dbName - A valid database name.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the database name is not valid.
  - getDbClient
```
public static ClientPrincipal getDbClient(java.lang.String dbName)
```
    Get the CLIENT-PRINCIPAL associated with the given database name.
    
    Parameters:
    
    dbName - A valid database name.
    
    Returns:
    
    The CLIENT-PRINCIPAL object or null if none associated.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the database name is not valid.
  - setAuthenticatedUserid
```
public static void setAuthenticatedUserid(java.lang.String dbName,
                                          java.lang.String userid,
                                          boolean lock,
                                          boolean byConnect)
```
    Set the currently authenticated userid for a database. This method assumes that the userid has already been authenticated in this context using authenticate() method. If byConnect then the userid is stored and will be reported by dbparam function with -U tag.
    
    Parameters:
    
    dbName - A valid database name.
    
    userid - The name of the user to set as UserID.
    
    lock - Flag indicationg that the database should be locked
    
    byConnect - trueif the authentication was done from a connect (at startup time or later) or false if the authentication was done using the setuserid function.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the database name is not valid.
  - readUserTable
```
public static void readUserTable(Persistence persistence,
                                 java.util.function.Consumer<java.lang.String[]> consumer)
```
    Read _User table from the database supplying String array: {userid, domain-name, password} to a consumer.
    
    Parameters:
    
    persistence - Persistence instance for the database
    
    consumer - Consumer<String[]> instance
  - readQueryResults
```
public static void readQueryResults(java.lang.String sql,
                                    Persistence persistence,
                                    java.util.function.Consumer<ScrollableResults<?>> consumer)
```
    Read query results.
    
    Parameters:
    
    sql - SQL statement to be executed
    
    persistence - Persistence instance for the database
    
    consumer - Result set consumer
  - ldbNameNative
```
static java.lang.String ldbNameNative(int index)
```
    Get the logical database name for the connected database at the given index.
    
    Parameters:
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The logical name, or unknown value if index is invalid.
  - normalizeFilename
```
static java.lang.String normalizeFilename(java.lang.String name)
```
    Normalize the given filename by extracting the root name (removing the file path and the filename extension).
    
    Parameters:
    
    name - File name.
    
    Returns:
    
    "Normalized" root file name.
  - assertKnownValue
```
private static void assertKnownValue(BaseDataType data,
                                     java.lang.String description)
                              throws PersistenceException
```
    Assert that data does not represent the unknown value. If the assertion fails, an exception is thrown.
    
    Parameters:
    
    data - The data value to be checked.
    
    description - A brief description of data's purpose; this will be used in an error message if the assertion fails.
    
    Throws:
    
    PersistenceException - if the assertion fails.
  - iterateToIndex
```
private static <X> X iterateToIndex(java.util.Collection<X> coll,
                                    int index)
```
    Iterate over the specified collection, returning the element at index index.
    
    Parameters:
    
    coll - Collection over which to iterate.
    
    index - The 1-based index of the target element in the collection.
    
    Returns:
    
    The element at the specified index, or null if index was never reached.
  - normalizeAliasOrLDB
```
private static character normalizeAliasOrLDB(character name)
```
    Normalize an alias or logical database name by right trimming whitespace and lowercasing.
    
    Parameters:
    
    name - Alias or LDB name to be normalized.
    
    Returns:
    
    Normalized result.
  - registerTenantListener
```
public void registerTenantListener(TenantChangeListener listener,
                                   java.lang.String ldbName)
```
    Register a TenantChangeListener for actions that involve tenant id changes.
    
    Parameters:
    
    listener - The listener to be notified when a tenant changes.
    
    ldbName - The logical database name for which the listener should be registered.
  - deregisterTenantListener
```
public void deregisterTenantListener(TenantChangeListener listener,
                                     java.lang.String ldbName)
```
    De-register a TenantChangeListener.
    
    Parameters:
    
    listener - The listener to be de-registered.
    
    ldbName - The logical database name for which the listener should be de-registered.
  - getTenantId
```
public java.lang.String getTenantId(java.lang.String ldbName)
```
    Get a tenant id based on a database logical name.
    
    Parameters:
    
    ldbName - The database logical name.
    
    Returns:
    
    The id of the tenant.
  - removeTenantId
```
public void removeTenantId(java.lang.String ldbName)
```
    Remove a tenant that is tied to a database.
    
    Parameters:
    
    ldbName - The database logical name for which to remove the tenant.
  - getLDBName
```
public java.lang.String getLDBName(Database database)
```
    Get the logical database name for a connected physical database.
    
    Parameters:
    
    database - Physical database helper object.
    
    Returns:
    
    Logical database name, if database is connected, else null.
  - transactionEnded
```
void transactionEnded()
```
    This method is invoked after a master transaction commit/rollback; any databases awaiting the end of the current transaction to disconnect are now deregistered with the database manager.
  - transactionEnded
```
void transactionEnded(Database database)
```
    This method is invoked after a master transaction commit/rollback; if the specified database is waiting for the end of the current transaction to disconnect, it will be deregistered with the database manager.
    
    Parameters:
    
    database - The database for which to process the transaction end - as this will be executed for every database which was used in this transaction block.
  - openBufferScope
```
void openBufferScope(RecordBuffer buffer)
```
    Register that a reference from a record buffer to its database has become active. We will be notified when this reference is no longer active, which is used to resolve pending disconnect requests.
    
    Parameters:
    
    buffer - Record buffer whose scope has been opened.
    
    See Also:
    
    closeBufferScope(com.goldencode.p2j.persist.RecordBuffer), disconnect(com.goldencode.p2j.util.character)
  - isBufferScopeLeaking
```
public boolean isBufferScopeLeaking(RecordBuffer buffer)
```
    Very specific method to check if a buffer is still dangling in the pdbReferences collection. This should be called only in extra-ordinary execution paths that may involve native Java integrations outside the persist framework. This should be called in case of fail-safes to avoid memory leaks.
    DON'T use this method for trivial checks on whether the buffer has its scope opened or not. This should be used only to detect unexpected leaks inside pdbReferences that can't be solved by the normal lifecycle of TransactionManager or BufferManager.
    For example, invoking generic triggers that do not properly manage the buffer lifecycle may result in memory leaks. Therefore, attempt to detect this case and improve the fault tolerance on persistence layer side.
    
    Parameters:
    
    buffer - The buffer that should be checked for leakage.
    
    Returns:
    
    true if this buffer still resides in pdbReferences due to a bad handling of the buffer from native Java integrations like generic triggers.
  - closeBufferScope
```
void closeBufferScope(RecordBuffer buffer)
```
    Called by a record buffer to notify that its scope has been closed, indicating that it no longer has an active reference to its database. This may result in the current context disconnecting from the database, if and only if:
    1. there is a (first level) disconnect request pending for the database; AND
    2. no record buffers currently have active references to it; AND
    3. no transaction currently is active.
    If all three conditions are met, the database is disconnected immediately, and removed from the first level pending disconnect list. If the first two conditions are met, but the third is not, the database is moved from the first level to the second level disconnect list, where it will await the end of the transaction for disconnect.
    Parameters:
    
    buffer - Record buffer whose scope has been closed.
    
    See Also:
    
    openBufferScope(com.goldencode.p2j.persist.RecordBuffer), disconnect(com.goldencode.p2j.util.character)
  - getLDBName
```
java.lang.String getLDBName(java.lang.String name)
```
    Get the logical database name for the given logical database name or alias. The database does not necessarily have to be connected, if name represents an alias.
    
    Parameters:
    
    name - Logical database name or alias.
    
    Returns:
    
    Logical database name or null if name is not recognized.
  - getPDBName
```
java.lang.String getPDBName(java.lang.String name,
                            boolean normalize)
```
    Get the physical database name for the given logical database name or alias. The database must be connected. The resulting name may optionally be normalized, which excludes any filename path and extension.
    
    Parameters:
    
    name - Logical database name or alias.
    
    normalize - true to return the normalized name; else false to return the unaltered (possibly fully qualified name), as provided by the caller of the connect(java.lang.Object...) method.
    
    Returns:
    
    Physical database name or null if name is not recognized.
  - getDatabase
```
Database getDatabase(java.lang.String name)
```
    Get the database information object for the given database name, which may be a logical name, physical name, or alias. It is assumed that the database currently is connected.
    
    Parameters:
    
    name - Logical name, physical name, or alias for database.
    
    Returns:
    
    Database information object associated with name, or null if no such database currently is connected.
  - getActiveDatabases
```
java.util.ArrayList<Database> getActiveDatabases()
```
    Get a list of active databases, which is meant to include the temp-table database and all connected, persistent databases. The term "active" is used instead of "connected" because the inclusion of the temp table database is an implementation-specific requirement, which is not consistent with the 4GL's notion of "connected" databases. Thus, this API is meant for internal use only and should not be exposed as a legacy API.
    
    Returns:
    
    List of all connected, persistent databases, plus the temp-table database.
  - getAliasesByLDB
```
java.util.Map<java.lang.String,java.lang.String> getAliasesByLDB()
```
    Get the currently connected aliases by their logical database name.
    
    Returns:
    
    See above.
  - getSQLResultAsLong
```
private static java.lang.Long getSQLResultAsLong(java.lang.Object ufo)
```
    Dynamically analyze (by class type) and convert a value returned by a SQL statement of an unknown type (but assumed to be integer-like) to Long value. If the type cannot be detected, null is returned.
    
    Parameters:
    
    ufo - The value from a SQL result. It is assumed to be some kind of integer/long.
    
    Returns:
    
    The long value of the unknown object or null if its type could not be detected.
  - getCurrentUseridImpl
```
private java.lang.String getCurrentUseridImpl(java.lang.String ldbName)
```
    Returns the current id used by the user to authenticated to a database identified by its logical name.
    
    Parameters:
    
    ldbName - The logical name of the database for which the userid is requested.
    
    Returns:
    
    current userid
  - setCurrentUseridImpl
```
private void setCurrentUseridImpl(java.lang.String ldbName,
                                  java.lang.String newUserId,
                                  boolean lock)
```
    Sets the currently authenticated userid for a database.
    The only authority to set this is an instance of MetadataSecurityOps and only after checking the user/password combination against the _User meta-table.
    Notes:
    - The CONNECT statement with -U and -P parameters will have to call SecurityOps to verify if the user/password combination if correct.
      (At this moment the ConnectionManager does not support these parameters, yet).
    - The command-line parameters should be investigated.
    Parameters:
    
    ldbName - The logical database name for which the userid is set/updated.
    
    newUserId - The newly newUserId for this database context.
    
    lock - Flag indicationg that the database should be locked
  - setConnectUserImpl
```
private void setConnectUserImpl(java.lang.String ldbName)
```
    Mark the current user for the database as the connection parameter. The user currently authenticated will be reported by dbparam function with -U tag.
    
    Parameters:
    
    ldbName - The logical database name for which the userid is marked as connection parameter.
  - sessionClosed
```
private void sessionClosed()
```
    Perform end of session cleanup; disconnects all connected databases without regard to transaction state or buffer reference status. This ensures DatabaseManager's transient database reference counts are not corrupted when client sessions end.
  - disconnectImmediately
```
private void disconnectImmediately(java.util.Set<Database> pending,
                                   boolean sessionCleanup)
```
    Disconnect all databases in the specified set by deregistering them with the DatabaseManager and removing them from the set. Network sessions associated with the databases in the set are terminated accordingly. If being called at the end of a user's session, clean up internal data structures and update _connect metadata as well.
    
    Parameters:
    
    pending - Set of databases to disconnect.
    
    sessionCleanup - true if this action is being taken as part of cleanup for a session that is terminating; false if a normal disconnect.
  - disconnectImmediately
```
private void disconnectImmediately(Database database,
                                   boolean sessionCleanup)
```
    Disconnect the specified database by deregistering it with the DatabaseManager and terminating the associated network session.
    
    Parameters:
    
    database - Database to disconnect.
    
    sessionCleanup - true if this action is being taken as part of cleanup for a session that is terminating; false if a normal disconnect.
  - ldbNameImpl
```
private character ldbNameImpl(java.lang.String name,
                              int index)
```
    Get the logical name for a database, given an alias (which may be the logical name itself), or its index among all connected databases in this context.
    
    Parameters:
    
    name - Logical database name or alias. May be null, but only if index is non-null.
    
    index - Index of the database among connected databases. May be null, but only if name is non-null. This is a one-based index.
    
    Returns:
    
    Logical database name, or unknown value if name is not recognized.
  - ldbNameNativeImpl
```
private java.lang.String ldbNameNativeImpl(java.lang.String name,
                                           int index)
```
    Get the logical name for a database, given an alias (which may be the logical name itself), or its index among all connected databases in this context.
    
    Parameters:
    
    name - Logical database name or alias. May be null, but only if index is non-null.
    
    index - Index of the database among connected databases. May be null, but only if name is non-null. This is a one-based index.
    
    Returns:
    
    Logical database name, or unknown value if name is not recognized.
  - pdbNameImpl
```
private character pdbNameImpl(java.lang.String name,
                              int index)
```
    Get the physical name for a database, given its logical name or alias, or its index among all connected databases in this context.
    
    Parameters:
    
    name - Logical database name or alias. May be null, but only if index is non-null.
    
    index - One-based index of the database among connected databases.
    
    Returns:
    
    Physical database name, or unknown value if name is not recognized.
  - connectDbImpl
```
private void connectDbImpl(boolean isAutoConnect,
                           java.util.List<java.util.Map.Entry<ConnectionManager.ConnectOption,ConnectionManager.ConnectOptionValue>> opts)
                    throws PersistenceException
```
    Create a logical connection to a database using the specified parameters.
    
    Parameters:
    
    isAutoConnect - flag indication that is is an implicit auto-connect operation
    
    opts - A list of one or more connection parameters.
    
    Throws:
    
    PersistenceException - if any parameter is null; if any parameter is neither a text value nor an integral value; if there is an error registering the database with the database manager.
  - connectImpl
```
private void connectImpl(java.util.List<java.lang.Object> args)
                  throws PersistenceException
```
    Create a logical connection to a database using the specified parameters.
    Parameters:
    args - A list of one or more connection parameters. This may take one of several forms:
    
    an ordered list of the following:
    
    physical database name (required)
    logical database name (optional)
    P2J server host name/address (optional)
    P2J server port number or service name (optional, unless host name/address is supplied)
    userid (optional)
    password (optional, required if userid is present)
    
    the following parameter pairs:
    
    physical database name key/value pair...
    
    "-db" (optional identifier for physical database name option to follow)
    physical database name (required)
    
    ...followed by an unordered list of the following options. Note that the order of these parameter key/value pairs is not important; however, the pairing of key string (e.g., "-ld"), with the associated value must be preserved:
    
    "-ld" (required only if next element is provided)
    logical database name (optional)
    "-H" (required only if next element is provided)
    P2J server host name/address (optional)
    "-S" (required only if next element is provided)
    P2J server port number or service name (optional, unless host name/address is supplied)
    "-U" (required only if next element is provided)
    userid used to authenticate to database (optional)
    "-P" (required only if next element is provided)
    password used for authentication (optional)
    Throws:
    
    PersistenceException - if any parameter is null; if any parameter is neither a text value nor an integral value; if there is an error registering the database with the database manager.
  - connect
```
private void connect(boolean isAutoConnect,
                     java.lang.String pdb,
                     java.lang.String ldb,
                     java.lang.String host,
                     java.lang.String service,
                     java.lang.String user,
                     java.lang.String password,
                     java.lang.Integer port,
                     java.lang.Integer maxRetries)
              throws PersistenceException
```
    Establish database connection.
    
    Parameters:
    
    isAutoConnect - flag indication that is is an implicit auto-connect operation
    
    pdb - database physical name.
    
    ldb - database logical name.
    
    host - remote host name.
    
    service - remote service name.
    
    user - used id.
    
    password - user password.
    
    port - remote port number.
    
    maxRetries - max connection attempts.
    
    Throws:
    
    PersistenceException - if any parameter is null; if any parameter is neither a text value nor an integral value; if there is an error registering the database with the database manager.
  - makeConnection
```
private java.lang.String makeConnection(Database database,
                                        java.lang.String ldbName,
                                        java.lang.String certAlias,
                                        boolean isAutoConnect)
                                 throws PersistenceException
```
    Create a logical connection to the database with the specified physical name, creating the specified logical name for it.
    
    Parameters:
    
    database - Database information object.
    
    ldbName - Logical database name. If null, root name of physical database name will be used.
    
    certAlias - Alias of certificate to be read from trust store to enable certificate-based, server-to-server authentication. This should match the server ID of the remote node.
    
    isAutoConnect - flag indication that is is an implicit auto-connect operation
    
    Returns:
    
    the logical database name on success (the ldbName input parameter may be null, but a new logical name will be computed and returned) and null otherwise.
    
    Throws:
    
    ErrorConditionException - if the given database already is connected.
    
    PersistenceException - if there is an error registering the database with the database manager or establishing a network session with the remote server.
  - disconnectImpl
```
private void disconnectImpl(java.lang.String ldbName)
                     throws PersistenceException
```
    Request a disconnect from a logical database. This does not actually perform the disconnect immediately, but registers ldbName for disconnect at the appropriate time: once no buffers reference the database, and at the end of the current transaction (if any).
    
    Parameters:
    
    ldbName - Logical name of the database to disconnect.
    
    Throws:
    
    PersistenceException - if the specified database has not been opened.
  - connectedImpl
```
private logical connectedImpl(character name)
```
    Tests whether a logical connection to a database exists in this context, given a logical database name or alias.
    
    Parameters:
    
    name - Logical database name or alias.
    
    Returns:
    
    true if a logical connection exists; else false.
  - createAliasImpl
```
private void createAliasImpl(java.lang.String alias,
                             java.lang.String ldbName)
                      throws PersistenceException
```
    Create an alias for a logical database name. The alias may not conflict with an existing logical database name (except for that of the database which it aliases). The alias will be created regardless of whether the target database currently is connected; however, an error will be raised (or silently registered) in the event it is not, after the alias has been created. The alias persists until explicitly deleted with one of the variants of the deleteAlias method, or until the current session ends.
    
    Parameters:
    
    alias - Alias to be created.
    
    ldbName - Logical name of the database to which the alias is assigned.
    
    Throws:
    
    PersistenceException - if the alias conflicts with an existing logical database name, other than ldbName.
    
    ErrorConditionException - if the target database is not connected, and we are not in silent error mode.
  - deleteAliasImpl
```
private void deleteAliasImpl(java.lang.String alias)
```
    Delete the specified alias immediately.
    
    Parameters:
    
    alias - Alias to be deleted.
  - aliasImpl
```
private character aliasImpl(int index)
```
    Retrieve the alias at the specified index in the current context.
    
    Parameters:
    
    index - One-based index of the alias (aliases are stored in the order in which they were created).
    
    Returns:
    
    The target alias, or unknown value if index is invalid.
  - dbParamImpl
```
private character dbParamImpl(java.lang.String nameOrAlias,
                              int index)
```
    Implementation of the DBPARAM() Progress function. Returns, as a character string, a comma-separated list of the parameters used to connect to the database.
    The method does a lookup on the database's name, or id it is null, the alias will extracted using the index.
    Parameters returned by this method generally will not match those returned by the original 4GL implementation, since we don't support any others than those handled by ConnectionManager.connect().
    
    Parameters:
    
    nameOrAlias - Logical database name or alias.
    
    index - One-based index of the alias (aliases are stored in the order in which they were created).
    
    Returns:
    
    A comma-separated list of the parameters used to connect to the database, or unknown value if nameOrAlias or index cannot be resolved to a database.
  - dbRestrictionsImpl
```
private character dbRestrictionsImpl(java.lang.String nameOrAlias,
                                     int index,
                                     java.lang.String table)
```
    Get a description of restrictions for the table in the connected database with a specified alias or at the specified index. Currently, table is ignored.
    
    Parameters:
    
    nameOrAlias - Logical database name or alias.
    
    index - One-based index of the alias (aliases are stored in the order in which they were created).
    
    table - table name (currently ignored)
    
    Returns:
    
    a description of restrictions for the table in the connected database
  - dbparam
```
private static java.lang.String dbparam(java.util.List<java.util.Map.Entry<ConnectionManager.ConnectOption,ConnectionManager.ConnectOptionValue>> opts)
```
    Convert CONNECT options to a DBPARAM string.
    
    Parameters:
    
    opts - CONNECT options.
    
    Returns:
    
    DBPARAM string.
  - dbVersionImpl
```
private character dbVersionImpl(java.lang.String name,
                                int index)
```
    Get the version number of the target database.
    
    Parameters:
    
    name - Logical name or alias of the target database. If null, then index is used instead.
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The database's version, as extracted from runtime configuration, or unknown value if index represents the unknown value or is outside of the range of connected databases.
    
    Throws:
    
    java.lang.RuntimeException - if there is an error binding to the directory service to retrieve runtime configuration information.
  - putConnected
```
private void putConnected(java.lang.String ldbName,
                          Database database,
                          java.lang.String userId,
                          java.lang.String tenantId)
```
    Update the various housekeeping data structures to reflect a successful connection event, and update connection metadata if it is in use.
    
    Parameters:
    
    ldbName - Logical name of connected database.
    
    database - Object describing physical database.
    
    userId - Current user's ID.
    
    tenantId - The id of the tenant.
  - removeConnected
```
private Database removeConnected(java.lang.String ldbName,
                                 boolean sessionCleanup)
```
    Update the various housekeeping data structures to reflect a disconnection event, and update connection metadata if it is in use.
    
    Parameters:
    
    ldbName - Logical name of disconnected database.
    
    sessionCleanup - true if this action is being taken as part of cleanup for a session that is terminating; false if a normal disconnect.
    
    Returns:
    
    database being removed
  - dbTaskIdImpl
```
private integer dbTaskIdImpl(java.lang.String name,
                             int index)
```
    Get the version number of the target database.
    
    Parameters:
    
    name - Logical name or alias of the target database. If null, then index is used instead.
    
    index - One-based index of the target database among all databases currently connected in this context.
    
    Returns:
    
    The database's transaction id, or unknown value if name is not a valid database name or index is outside of the range of connected databases.
    
    Throws:
    
    java.lang.RuntimeException - if there is an error binding to the directory service to retrieve runtime configuration information.

Class ConnectionManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

local

metaCleaner

DICTDB

DEFAULT_DBVERSION

DEFAULT_CONN_RETRIES

CONN_RETRY_DELAY

dbVersionCache

nextConnectID

locked

clients

userIds

connectTimeUserid

connected

ldbMap

pendingDisconn

pendingTxDisconn

aliases

pdbReferences

sessions

tenantIds

tenantListeners

dispatcher

singleClient

registerProgress

Constructor Detail

ConnectionManager

Method Detail

register

get

connect

connect

connect_

parse

disconnect

disconnect

connected

connected

numAliases

getConnectedDbCount

numDBs

dbCodepage

dbCodepage

dbCodepage

dbCodepage

dbCollation

dbCollation

dbCollation

dbCollation

dbName

dbParam

dbParam

dbParam

dbParam

dbType

dbType

dbType

dbType

dbTaskId

dbTaskId

dbTaskId

dbTaskId

dbVersion

dbVersion

dbVersion

dbVersion

dbRestrictions

dbRestrictions

dbRestrictions

dbRestrictions

dbRestrictions

dbRestrictions

dbRestrictions