All Classes and Interfaces

Class
Description
A persistent low-level database object.
Delegate for the AbstractDbObject class.
Notice: in this class we cut off generics!
Base class for the remote delegate of AbstractDbObject.
All other subclasses of AbstractDbObject should extend AbstractDbObjectRemoteDelegateImpl to reflect the class hierarchy below AbstractDbObject.
A AbstractDbOperation provides methods that are not part of AbstractDbObjects and is associated to a Db-session.
Delegate for the DbOperation class.
Base class for the remote delegate of AbstractDbOperation.
All other subclasses of AbstractDbOperation should extend AbstractDbOperationRemoteDelegateImpl to reflect the class hierarchy below AbstractDbOperation.
Base implementation for IdSources.
A Runnable that gets invoked before a physical commit.
The commit runnable is Serializable and transferred to the server, if registered at a remote client.
Connection Manager for local connections.
JDBC-connections are never used directly.
A provider for a connection manager.
A persistence session.
Maintains batches of prepared statements.
Statement and its data used in a batched transactions.
Factory for class variables.
Utilities for diagnostic purposes with persistence extensions.
Session factory for Db instances.
Modification information per table.
The modification tracker for the tentackle persistence layer.
Remote delegate interface for ModificationTracker.
Remote delegate implementation for DbModificationTracker.
The persistence layer's modification types.
Holds static class variables for classes derived from AbstractDbObject.
This is a "singleton per class".
 
Result used to return the possibly new object-ID, changed serial and a result code for success or failure.
Holds static class variables for classes derived from AbstractDbOperation.
An implementation of a session pool.
It allows min/max sizes, fixed increments and timeouts for unused instances.
SessionPool factory implementation.
Timeout thread to supervise DbPools.
Persisted preferences implementation.
Repository and factory for database backed preferences.
A preferences key/value pair stored in the database.
Preferences Node stored in the database.
Remoting capable operations on persisted preferences.
Holds all nodes and keys for a user- or system-root along with its version.
 
 
Remote delegate interface for Db.
Remote delegate implementation for Db.
The default implementation for a RemoteDelegateLocator.
Default implementation for a remote session factory.
Holder for transaction local data.
Factory for transactions.
Collects duration statistics and monitors transactions.
A unique handle to reference an object within a DbTransaction.
Persistence utility methods.
This singleton is provided mainly to allow a clean separation between the lower- and higher level persistence layer implementations.
It is replaced by PersistenceUtilities from the tentackle-persistence module to make it PDO-aware.
The default implementation of a connection manager.
Each session will get its own physical connection.
The default master serial.
Default implementation of a modification log factory.
An exportable remote object.
Source of ID numbers.
Configurator for an IdSource.
Runtime exception thrown when an IdSource becomes empty.
Runtime exception thrown for id source failures.
A visitor to ignore duplicates within a persistence operation.
Used to avoid duplicate key errors, for example, if components are referenced more than once within the same root entity.
 
 
Holds the old thread-locals during remote delegate method invocation.
A jdbc connection managed by the ConnectionManager.
The connection provides some additional features such as a prepared statement cache and translates SQLExceptions to PersistenceExceptions.
Maintains a set of all open managed connections.
The connections are held by a weak reference and the set is cleaned up once a minute.
Optionally, idle connections with ManagedConnection.isConnectionVerificationNecessary() == true will be verified (via dummy selects) periodically and to prevent premature closing by the database backend.
Logging for object modifications.
Modifications of PDOs can be logged to a so-called modification log.
Such modlogs can be used for asynchronous database coupling, higher level replication, etc...
Replay state shared between consecutive invocations of ModificationLog.replay(org.tentackle.dbms.ModificationLog, org.tentackle.session.Session, boolean).
This is just a DTO.
The ModificationLog factory.
Objects that can be modification-logged.
Remote delegate interface for ModificationLog.
Remote delegate implementation for ModificationLog.
Counter to track modifications for a class/table.
The ModificationTracker maintains a list of ModificationTally-objects, one for each tracked name.
The modification type.
The default types are defined in DbModificationType, which is an enum.
Factory for modification types.
Basically maps character values to modification types.
Multiplexing connection manager.
A connection manager for applications with a large number of session instances, e.g. application servers.
Implementation of a MultiUserSessionPool.
The pool is actually a pool of DbPools, one for each SessionInfo.
An IdSource to create unique object IDs.
An IdSource to create unique object IDs from a database sequence.
 
 
A reflective visitor to add application-specific functionality to persistence operations.
Session managed by the session pool.
A wrapper for prepared statements.
Will catch and report SQLExceptions and keep track of being used only once after Db.getPreparedStatement(org.tentackle.dbms.StatementKey, boolean, int, int, org.tentackle.dbms.SqlSupplier).
A database query.
RMI remote connection.
This is the first remote object passed to the client when it connects to the application server.
Server side RMI-connection implementation.
Application server session.
The session will create all other delegates for the client.
Cleans up dead or crashed sessions.
User session within the application server.
Tag interface for Remote delegates.
The implementation of a RemoteDelegate must provide a constructor as follows:
All remote delegates must extend this class
Invocation handler to capture RMI method invocations.
Finds the remote delegate classes for a given class.
The result.
 
 
Extends UnicastRemoteObject to get the port and socket factories.
Adapter for a remote session.
Hides the RMI stuff.
RMI servers should throw a RemoteSessionClosedException if the remote session is already closed.
Factory for remote sessions.
A section of columns within the result set.
A subset of the columns returned by a ResultSetWrapper.
A wrapper for ResultSets.
A generic RMI server.
The backend properties file is parsed for the following keywords: service=service-URL: defaults to the basename of the RMI-server class instance at the default registry port on localhost, i.e.
A Runnable that gets invoked before a physical rollback.
The rollback runnable is Serializable and transferred to the server, if registered at a remote client.
Backend-specific SQL-code supplier.
History of statement execution.
A statement id.
The statement key.
Statement statistics collector.
Statistics result for SQL statements.
Optionally extends StatisticsResult by fetch duration for the result set and result set size.
A wrapper for sql statements.
Will catch and report SQLExceptions and keep track of being used only once after Db.createStatement().
Keeps a backlog of expiration sets.
Used in RMI-servers to reduce database roundtrips for clients requesting the expiration info for their local caches.
Transaction statistics collector.
Statistics result for transactions.
Extends StatisticsResult by number of statements.