All Classes and Interfaces
Class
Description
Configuration settings for abandoned object removal.
Tracks db connection usage for recovering and reporting abandoned db connections.
Expression handler to invoke the SQL ABS function.
Abstract representation of the backing store for an array.
Abstract representation of a table for a class.
Abstract representation of a store of a Collection.
Implementation of the mapping of a column.
Abstract superclass for ConnectionPool factory.
Mapping for a field that represents a container of objects, such as a List, a Set, a Collection, a Map, or an array.
Abstract representation of an identifier factory for ORM datastores.
Mapping of a large binary (e.g BLOB, LONGVARBINARY) column.
Abstract representation of a backing store for a List.
Abstract representation of the backing store for a Map.
Abstract representation of a QueryResult for RDBMS queries.
Abstract result object factory, taking the ExecutionContext being operated in, and the ResultSet that will be processed.
An abstract base class for RDBMSManager transactions that perform some schema operation on the database.
Abstract generator of SQLStatements.
Abstract representation of the backing store for a Set/Collection.
Abstract implementation of a table in the datastore.
Expression handler to invoke the SQL ACOS function.
Representation of an aggregated expression.
Expression for an aggregate function.
Expression for an aggregate function.
Expression for an aggregate function.
Parameter setter class to deal with application identity.
Mapping of an ARRAY column.
Method for evaluating {arrExpr}.contains(elemExpr).
Representation of array expression.
Method for evaluating {arrExpr1}.isEmpty().
Representation of array literal.
Mapping for an array.
Method for evaluating {arrExpr1}.size().
ArrayStore iterator for RDBMS datastores.
Representation of a join table for an array.
Expression handler to invoke the SQL ASIN function.
Expression handler to invoke the SQL ATAN2 function.
Expression handler to invoke the SQL ATAN function.
Expression handler to invoke the SQL AVG aggregation function.
Some databases will use the same type for the return value as the argument, which can be an issue
when averaging on integral types since it will drop the decimals.
Series of helper methods for use with RDBMS backing stores.
Base class for all mapped container stores (collections, maps, arrays).
Provides methods for adapting SQL language elements to a specific vendor's database.
Base class that provides common functionality for
GenericObjectPool
and GenericKeyedObjectPool.Wrapper for objects under management by the pool.
A base implementation of
KeyedPooledObjectFactory.A base class for common functionality.
A simple base implementation of
ObjectPool.Provides the implementation for the common attributes shared by the
sub-classes.
A base implementation of
PoolableObjectFactory.
Basic implementation of
javax.sql.DataSource that is configured via JavaBeans properties.
JNDI object factory that creates an instance of
BasicDataSource that has been configured based on the
RefAddr values of the specified Reference, which must match the names and data types of the
BasicDataSource bean properties with the following exceptions:Defines the methods that will be made available via JMX.
Mapping for BigDecimal type.
Mapping of a Big Integer column.
Mapping for BigInteger type.
Mapping of a BINARY column.
Representation of a Binary expression in a Query.
Representation of a Binary literal.
Mapping of a BinaryStream column.
Mapping of a BIT column.
Mapping for an array of bytes.
Mapping of a BLOB column.
The representation (mapping) in the Java programming language of an SQL
BLOB value.Mapping of a BOOLEAN column.
Representation of a Boolean expression in a Query.
Representation of a Boolean literal in a Query.
Mapping of Java Boolean object.
Boolean expression to wrap a subquery.
Bulk-Fetch handler to generate the necessary statement for multi-valued field bulk-fetch using EXISTS subquery semantics.
Interface for a handler for "bulk fetch" of a multi-valued field from a query.
Helper class to generate the necessary statement for multi-valued field bulk-fetch, using JOIN semantics.
Base class representing a request to perform a bulk action on the datastore.
Representation of a Byte expression in a Query.
Representation of a Byte literal.
Mapping for Byte type.
Plugin for the creation of a C3P0 connection pool.
Strategy for obtaining and printing the current call stack.
Utility methods for
CallStack.Representation of a Candidate key.
Identifier for a unique index (candidate keys).
Case expression such as
Expression representing the SQL construct
Case expression such as
Case expression such as
Expression handler to invoke the SQL CEIL function.
Representation of a Character expression in a Query
Representation of a Character literal in a Query.
Mapping for Character type.
Mapping of a CHAR column.
A ClassDefinitionException is thrown if the settings of a
persistent class are inconsistent with it's metadata.
Table representing a Java class (or classes) as a first class object (FCO).
Representation of an SQL View for a Class.
Mapping of a Clob column.
The mapping in the Java programming language for the SQL
CLOB type.CloudSpannerAdapter defines the types, features that are supported and also deviate from the
BaseDatastoreAdapter.SQL Type info for Google Cloud Spanner datastore.
Expression handler to invoke the SQL COALESCE function.
Method for evaluating {collExpr1}.contains({elemExpr}).
An expression that represents some collection field in a query candidate class,
or a collection field in an object linked from the candidate class by navigation.
Method for evaluating {collExpr1}.isEmpty().
An SQL expression that will test if a column of a table falls within the given Collection of values.
Mapping for Collection types.
Method for evaluating {collExpr1}.size().
RDBMS-specific implementation of
Iterator for Collections/Sets.Representation of a join table for a Collection.
Interface for a column in an RDBMS datastore.
Helper class to create columns.
A ColumnDefinitionException is thrown if the settings of a
database column are incompatible with the data type of the object field
to which it is mapped.
Representation of a column expression.
Identifier for a Column.
Implementation of a Column in an RDBMS datastore.
Representation of the mapping of a column.
Factory class for creating ColumnMapping instances.
Interface implemented by any ColumnMapping that requires a post-set (insert/update) step.
Representation of a key that has columns with specified ordering (ascending/descending) for each column (if required).
Representation of a component of a collection/map.
Implementation of CONCAT, using SQL CONCAT function.
Implementation of CONCAT, using SQL CONCAT operator.
Abstract factory interface for creating
Connections.ConnectionFactory for RDBMS datastores.
Emulate the two phase protocol for non XA
This class is the
Connection that will be returned from
PooledConnectionImpl.getConnection().Wrapper for a connection pool.
Factory for making ConnectionPools.
Constants for use with JMX.
Class to make correspondence between columns in one side of an association to the mapping at the other side.
Expression handler to invoke the SQL COS function.
Expression handler to invoke the SQL COSH function.
Expression handler to invoke the SQL COT function.
Expression handler to invoke the SQL COUNT aggregation function.
Expression handler to invoke the SQL COUNT(*) aggregation function.
A
PooledObjectFactory that creates PoolableConnections.Expression handler to invoke the SQL CURRENT_DATE function.
Expression handler to invoke the SQL CURRENT_TIME function.
Expression handler to invoke the SQL CURRENT_TIMESTAMP function.
A
DataSource-based implementation of ConnectionFactory.Definition of a datastore adapter, providing all characteristics of the underlying datastore
such as whether it supports FKs, indexes, and what statement syntax to use.
Factory of RDBMS datastore adapters.
Representation of a Java class in a datastore.
Exception thrown when a datastore driver class (e.g JDBC driver) is not found.
Representation of a datastore identifier in an RDBMS datastore.
Implementation of a datastore identifier.
Mapping for datastore identity "field".
Exception thrown when encountering an error creating a data source pool.
ValueGenerator using DB2 datastore-based DatastoreUUID generation.
Mapping of a DATE column.
SCO Mapping for java.util.Date type.
Provides methods for adapting SQL language elements to the DB2 database.
Provides methods for adapting SQL language elements to the DB2/AS400 database.
Mapping of a DB2 "Datalink" column.
SQL Type info for DB2 datastores.
Plugin for the creation of a DBCP2 connection pool, using repackaged DBCP2 classes.
Plugin for the creation of a DBCP2 connection pool.
Mapping of a Decimal column.
Default ConnectionPool factory implementation (no pooling).
Wrapper to the JDBC DataSource class.
Provides the default implementation of
EvictionPolicy used by the
pools.This wrapper is used to track the additional information, such as state, for
the pooled objects.
Implementation of object that is used to provide information on pooled
objects via JMX.
The interface that defines the information about pooled objects that will be
exposed via JMX.
Expression handler to invoke the SQL DEGREES function.
Expression for a field/property that can delegate to an internal expression(s).
A base delegating implementation of
CallableStatement.A base delegating implementation of
Connection.
A base delegating implementation of
DatabaseMetaData.A base delegating implementation of
PreparedStatement.A base delegating implementation of
ResultSet.A base delegating implementation of
Statement.Class to provide a means of deletion of records from an RDBMS.
SQL DELETE Statement representation.
Schema transaction for deleting all known tables/views.
Provides methods for adapting SQL language elements to the Apache Derby database.
Java Functions that are called by the database
SQL Type info for Derby datastores.
Mapping for a discriminator column in a table used in inheritance.
Discriminator using a Long delegate.
Discriminator using a String delegate.
Class to generate a SelectStatement for iterating through instances of a particular type (and
optionally subclasses).
Factory that creates immutable instances of DatastoreIdentifier for mapped datastores.
Factory that creates immutable instances of DatastoreIdentifier for mapped datastores.
Mapping of a DOUBLE column.
Mapping for Double type.
An adapter for JDBC drivers that do not include an implementation of
ConnectionPoolDataSource, but
still include a DriverManager implementation.A
Driver-based implementation of ConnectionFactory.A
DriverManager-based implementation of ConnectionFactory.A DuplicateColumnException is thrown if an attempt is made to
add a column to a table with a name already in-use by an existing column.
Field manager that is used to check the values in fields in order to detect "new" classes
that impact on the datastore schema, hence allowing dynamic schema updates.
Representation of the store of an element-based container.
Representation of a join table for a container of elements.
Representation of the SQLStatement for an iterator of a collection/array of elements.
Mapping for a persistable object stored in an embedded collection within a persistable object.
Mapping for a PC key object stored in an embedded map within a PC object.
Mapping for an embedded PC object.
Mapping for a PC object embedded within another PC object (1-1 relation).
Mapping for a PC key object stored in an embedded map within a PC object.
Expression representing an enum field/property.
Representation of an Enum literal.
Mapping for Enum type.
Expression handler to evaluate {enumExpression}.ordinal().
Expression handler to evaluate {enumExpression}.toString().
This class is used by pool implementations to pass configuration information
to
EvictionPolicy instances.To provide a custom eviction policy (i.e.
Provides a shared idle object eviction timer for all pools.
Thread factory that creates a daemon thread, with the context class loader from this class.
Expression handler to invoke the SQL EXP function.
Utility methods for working with SQL expressions.
Class to retrieve the fields of an object of a specified class from the datastore.
Mapping for a File member.
Provides methods for adapting SQL language elements to the Firebird database.
SQL Type info for Firebird datastores.
Implementation of an FK ArrayStore.
Implementation of a
ListStore using foreign keys.Implementation of an
MapStore where either the value has a FK to the owner (and the key stored in the value),
or whether the key has a FK to the owner (and the value stored in the key).Implementation of an
SetStore using foreign keys.Mapping of a Float column.
Representation of a FloatPoint literal in a query.
Mapping for Float Java type.
Expression handler to invoke the SQL FLOOR function.
Flush process extending the core "ordered flush" to catch particular situations present
in a referential datastore and attempt to optimise them.
Representation of a foreign key to another table.
Enum representing an action on the FK.
Identifier for a FK.
Represents the metadata of a specific foreign key column.
Lazy collection results from a Query with the ResultSet in a forward direction.
A configurable
KeyedObjectPool implementation.A simple "struct" encapsulating the configuration for a
GenericKeyedObjectPool.Defines the methods that will be made available via JMX.
A configurable
ObjectPool implementation.A simple "struct" encapsulating the configuration for a
GenericObjectPool.Defines the methods that will be made available via JMX.
Maps the class fields of a GregorianCalendar to column(s).
Provides methods for adapting SQL language elements to the H2 Database Engine.
SQL Type info for H2 datastores.
Provides methods for adapting SQL language elements to the HSQLDB database.
SQL Type info for HSQLDB datastores.
Factory that creates immutable instances of DatastoreIdentifier.
Enum defining the type of component that the identifier is for.
Exception thrown when trying to perform an illegal/unsupported operation
on an SQL expression.
A IncompatibleDataTypeException is thrown if a column is detected to
have an incompatible type in the database during schema validation.
Representation of an INDEX.
Identifier for an Index.
Represents the metadata of a specific index column.
Expression representing the SQL construct "IN (expr1, expr2, ...)".
Provides methods for adapting SQL language elements to the Informix
database.
SQL Type info for Informix datastores.
Class to provide a means of insertion of records to RDBMS.
SQL INSERT Statement representation.
The base class for
SharedPoolDataSource and PerUserPoolDataSource.A JNDI ObjectFactory which creates
SharedPoolDataSources or PerUserPoolDataSourcesMapping of a INTEGER column.
Representation of an Integer literal.
Mapping for Integer type.
Mapping for Interface fields.
This sub-class was created to expose the waiting threads so that they can be
interrupted when the pool using the queue that uses this lock is closed.
Representation of the SQLStatement for an iterator of a container (map, collection, or array).
Representation of the mapping of a Java type.
Defines bridge methods to JDBC 4.1 (Java 7) methods to allow call sites to operate safely (without
AbstractMethodError) when using a JDBC driver written for JDBC 4.0 (Java 6).Representation of JDBC type information in the datastore.
Convenience helper for JDBC.
Expression handler to evaluate JDOHelper.getObjectId({expression}).
Expression handler to evaluate JDOHelper.getVersion({expression}).
RDBMS representation of a JDOQL query for use by DataNucleus.
Implementation of a Join ArrayStore
Implementation of a
ListStore using join table.RDBMS-specific implementation of a
MapStore using join table.RDBMS implementation of a persistable relation backing store.
Implementation of a
SetStore using join table.Abstract class representing a field that maps to a table in the datastore.
Factory that creates immutable instances of DatastoreIdentifier for mapped datastores with JPA.
Factory that creates immutable instances of DatastoreIdentifier for mapped datastores.
RDBMS representation of a JPQL query for use by DataNucleus.
Abstract representation of a Key to a table.
A
KeyedPooledObjectFactory that creates PoolableConnections.A "keyed" pooling interface.
An interface defining life-cycle methods for
instances to be served by a
KeyedObjectPool.Representation of the SQLStatement for an iterator of a map of keys/values.
Exception thrown when a connection's maximum lifetime has been exceeded.
An optionally-bounded blocking
deque based on linked nodes.
Doubly-linked list node class.
An exception wrapping a list of exceptions.
Method for evaluating {listExpr}.get(idxExpr).
Method for evaluating {listExpr}.indexOf(elemExpr) and JPQL "INDEX(elem)"
Returns a NumericExpression representing the index
ListStore iterator for RDBMS datastores.
Expression handler to invoke the SQL CURRENT_DATE function and return as a LocalDate.
Expression handler to invoke the SQL CURRENT_TIMESTAMP function and return as LocalDateTime.
Expression handler to invoke the SQL CURRENT_TIME function and return as LocalTime.
Request to locate a series of records in the data store (all present in the same table).
Request to locate a record in the data store.
Expression handler to invoke the SQL LOG function.
Expression handler to invoke the SQL (natural) LOG function.
Mapping for Long type.
Mapping of a LONGVARBINARY column.
Mapping of a Long VARCHAR column.
Method for evaluating {mapExpr}.containsEntry(keyExpr, valueExpr).
Method for evaluating {mapExpr}.containsKey(keyExpr).
Method for evaluating {mapExpr}.containsValue(valueExpr).
RDBMS-specific implementation of a SetStore for map entries.
Inner class representing the entry in the map.
Inner class representing an iterator for the Set.
An expression that represents some Map field in a query candidate class, or a Map field in an object linked from the candidate class by navigation.
Method for evaluating {mapExpr}.get(keyExpr).
Method for evaluating {mapExpr}.isEmpty().
Method for evaluating KEY({mapExpr}).
Implementation of a backing SetStore for map keys.
An SQL expression that will test if a column of a table falls within the given Map.
An SQL expression that will test if a column of a table falls within the given Map's keys.
An SQL expression that will test if a column of a table falls within the given Map's values.
SCO Mapping for Map types.
Interface defining a series of callbacks that are called when this mapping goes through certain lifecycle events.
Consumer of mappings.
Helper class for handling mappings.
Representation of a MappingManager, mapping a java mapping type to a column mapping type.
Default Mapping manager implementation.
Definition of a java type that can be "mapped".
Enum defining types of mappings, for use with a MappingConsumer.
Method for evaluating {mapExpr}.size().
Representation of a join table for a Map.
RDBMS-specific implementation of a CollectionStore for map values.
Method for evaluating VALUE({mapExpr}).
Expression handler to evaluate Math.abs({expression}).
Expression handler to evaluate Math.acos({expression}).
Expression handler to evaluate Math.asin({expression}).
Expression handler to evaluate Math.atan({expression}).
Expression handler to evaluate Math.ceil({expression}).
Expression handler to evaluate Math.cos({expression}).
Expression handler to evaluate Math.exp({expression}).
Expression handler to evaluate Math.floor({expression}).
Expression handler to evaluate Math.log({expression}).
Expression handler to evaluate Math.power({expression}).
Expression handler to evaluate Math.sin({expression}).
Expression handler to evaluate Math.sqrt({expression}).
Expression handler to evaluate Math.tan({expression}).
Expression handler to evaluate Math.toDegrees({expression}).
Expression handler to evaluate Math.toRadians({expression}).
Expression handler to invoke the SQL MAX aggregation function.
ValueGenerator for RDBMS that uses the "SELECT MAX(column) FROM TABLE" strategy.
Expression handler to invoke the SQL MIN aggregation function.
A MissingColumnException is thrown if an expected column is
not found in the database during schema validation.
A MissingTableException is thrown if an expected table is
not found in the database during schema validation.
Implementation of MOD, using SQL MOD function.
Implementation of MOD, using SQL MOD function.
Mapping to represent multiple mappings within the single overall java type mapping.
Extension of MultiMapping where the actual mapping represents multiple possible persistable types
such as with an interface/reference field.
Provides methods for adapting SQL language elements to the MySQL database.
SQL Type info for MySQL datastores.
Mapping of a NCHAR column.
SQL Expression for creating a new object (in the result clause of a query).
A NoDatastoreMappingException is thrown if an operation is performed that
assumes that a particular persistent field is stored in a single datastore
field when it is not (such as if the field is a Collection or a Map).
CallStack strategy using no-op implementations of all functionality.
A NoSuchPersistentFieldException is thrown if a reference is made
somewhere, such as in a query filter string, to a field that either doesn't
exist or is not persistent.
A NoTableManagedException is thrown if an attempt is made to perform an
operation using a class that is not backed by an table or view
in the database and the operation is not supported on such classes.
A NotATableException is thrown during schema validation if a
table should be a table but is found not to be in the database.
A NotAViewException is thrown during schema validation if a
table should be a view but is found not to be in the database.
Basic implementation of a DataNucleus datastore sequence for RDBMS.
Expression handler to invoke the SQL NULLIF function.
Representation of a Null literal in a Query.
Simple mapping for a null literal.
A NullValueException is thrown if a null value is encountered
in a database column that should prohibit null values.
Mapping for Number type.
Mapping of a numeric column.
Representation of a Numeric expression in an SQL statement.
Numeric expression to wrap a subquery.
Implementation of a conversion from a NumericExpression to a StringExpression.
Implementation of a conversion from a NumericExpression to a StringExpression.
Implementation of a conversion from a NumericExpression to a StringExpression.
Adapter for NuoDB (http://www.nuodb.com).
Type info for NuoDB.
Mapping of a NVARCHAR column.
Representation of an Object expression in a Query.
Expression handler to evaluate {objectExpression}.getClass().
Representation of an Object literal in a query.
Mapping for Object fields.
Internal wrapper class that allows JMX to be a noop if absent or disabled.
A pooling simple interface.
Parameter setter that uses old values when available.
Expression for java.util.Optional.
Method for evaluating {optionalExpr1}.get().
Method for evaluating {optionalExpr1}.isPresent().
Literal for java.util.Optional.
Mapping for java.util.Optional.
Method for evaluating {optionalExpr1}.orElse().
SQL Type info for Oracle datastores.
Mapping for the ordering of an "indexed" list.
Mapping of an "OTHER" column.
Representation of a literal representing a parameter where we don't know the type of the parameter yet.
Parameter setter implementation of a field manager.
Wrapper for a PreparedStatement, providing access to a String representation of the statement with replaced actual parameters.
Inner class representing a sub-part of the PreparedStatement (to allow for batched statements).
Maps to identity objects of persistable values.
Representation of a join table for the case where we have an N-1 unidirectional relation
stored in a join table.
Maps a field storing a persistable object.
Result-object factory that takes a JDBC ResultSet, a results mapping, and creates a persistable object instance for each row in the ResultSet.
A PersistentSuperclassNotAllowedException is thrown if a
persistence-capable class is declared to have a persistence-capable
superclass when that class is backed by a view.
A pooling
DataSource appropriate for deployment within J2EE environment.A JNDI ObjectFactory which creates
SharedPoolDataSourcesProvides methods for adapting SQL language elements to the Pointbase database.
A
DelegatingCallableStatement that cooperates with PoolingConnection to implement a pool of
CallableStatements.A delegating connection that, rather than closing the underlying connection, returns itself to an
ObjectPool
when closed.A
PooledObjectFactory that creates PoolableConnections.Defines the attributes and methods that will be exposed via JMX for
PoolableConnection instances.A
DelegatingPreparedStatement that cooperates with PoolingConnection to implement a pool of
PreparedStatements.Immutable poolable object holding a PooledConnection along with the user name and password used to create the
connection.
Implementation of PooledConnection that is returned by PooledConnectionDataSource.
Methods to manage PoolableConnections and the connection pools that source them.
Defines the wrapper that is used to track the additional information, such as
state, for the pooled objects.
An interface defining life-cycle methods for instances to be served by an
ObjectPool.Provides the possible states that a
PooledObject may be in.Extension of
DefaultPooledObject to wrap pooled soft references.Implementation specific utilities.
A
DelegatingConnection that pools PreparedStatements.Statement types.
This class consists exclusively of static methods that operate on or return
ObjectPool or KeyedObjectPool related interfaces.
Encapsulate the logic for when the next poolable object should be
discarded.
Decorates a keyed object pool, adding "eroding" behavior.
Decorates an object pool, adding "eroding" behavior.
Extends ErodingKeyedObjectPool to allow erosion to take place on a
per-key basis.
Timer task that adds objects to the pool until the number of idle
instances for the given key reaches the configured minIdle.
Timer task that adds objects to the pool until the number of idle
instances reaches the configured minIdle.
A synchronized (thread-safe) KeyedObjectPool backed by the specified
KeyedObjectPool.
A fully synchronized KeyedPooledObjectFactory that wraps a
KeyedPooledObjectFactory and synchronizes access to the wrapped factory
methods.
A synchronized (thread-safe) ObjectPool backed by the specified
ObjectPool.
A fully synchronized PooledObjectFactory that wraps a
PooledObjectFactory and synchronizes access to the wrapped factory
methods.
Timer used to periodically check pools idle object count.
Provides methods for adapting SQL language elements to the PostgreSQL database.
SQL Type info for PostgreSQL datastores.
Expression handler to invoke the SQL POWER function.
Representation of the primary key of a table.
A PrimaryKeyColumnNotAllowedException is thrown if an attempt is
made to add a primary key column to a view.
Identifier for a PK.
Represents the metadata of a specific primary key column.
Utility class used for detecting database schema existence and provides means of determining the schema name.
A key uniquely identifying
PreparedStatements.Interface for Prepared or Callable Statement.
Deprecated.
Interface for a generator of query statements.
Class which maps a compiled (generic) query to an SQL query for RDBMS datastores.
Expression handler to invoke the SQL RADIANS function.
Representation of column schema information in the datastore.
Handler for persistence for RDBMS datastores.
Utility providing convenience naming of RDBMS persistence properties.
Validator for persistence properties used by RDBMS.
Datastore-specific (RDBMS) compilation information for a java query.
Utilities for use in queries specific to RDBMS.
Handler for RDBMS schema information.
Representation of schema table information in the datastore.
Representation of a class (FCO) / field (SCO) that is persisted to an RDBMS table.
Provides a series of utilities assisting in the datastore management process for RDBMS datastores.
StoreManager for RDBMS datastores.
Representation of FK information for a table in the datastore.
Representation of index information for a table in the datastore.
Representation of table column information in the datastore.
Representation of PK information for a table in the datastore.
Representation of types information in the datastore.
Mapping of a REAL column.
Maps to identity objects of reference values.
Mapping for a "reference" type.
Base class representing a request to perform an action on the datastore.
Representation of a request id.
Enum of possible request types.
Expression for use in an ordering clause representing a result alias.
Take a ResultSet, and for each row retrieves an object of a specified result class type.
Invokes a type-specific getter on given ResultSet
ResultObjectFactory that operates using a QueryResultMetaData and returns objects based on the definition.
An object that reads result set rows and returns corresponding object(s) from them.
ResultSet getter implementation of a field manager, extracting field values from a ResultSet.
Expression handler to evaluate ROUND({expression}[,{decimalPlaces}]).
Provides methods for adapting SQL language elements to the SAPDB/MaxDB database.
Implementation of an Auto-Start Mechanism for DataNucleus.
Class defining DataNucleus schema definition tables.
Lazy collection results from a Query with the ResultSet scrollable.
Secondary datastore class, managing the mapping of some of the fields of the class and dependent on a DatastoreClass.
Representation of a secondary table for a class.
CallStack strategy using a
SecurityManager.A custom security manager.
A snapshot of a class stack.
SQL SELECT Statement representation.
Generator of SQL SELECT Statements.
ValueGenerator utilising datastore (RDBMS) sequences.
Representation of an identifier for a sequence.
Class defining a table for storing generated values for use with TableGenerator.
Mapping for a serialised persistable object being the element of a Collection.
Mapping for a serialised persistable object being the key of a Map.
Mapping where we want to serialise a (Serializable) field to a local file.
Maps a field as serialised.
Mapping for a serialised persistable object.
Mapping for a serialised reference (Interface/Object) field.
Mapping for a serialised persistable object being the value of a Map.
A pooling
DataSource appropriate for deployment within J2EE environment.A JNDI ObjectFactory which creates
SharedPoolDataSourcesMapping for the Short type.
Expression handler to invoke the SQL SIGN function.
Expression handler to invoke an SQL aggregated function.
Expression handler to invoke an SQL numeric function that takes in argument(s).
Expression handler to invoke an SQL aggregated function.
Expression handler to invoke an SQL String function that takes in an expression.
Expression handler to invoke the SQL SIN function.
Cover-all expression to represent "single collection" mapped types.
Cover-all literal to represent "single collection" mapped types.
Maps single collection elements as 1-1 instead of 1-N, by wrapping and reusing the JavaTypeMappings and member metadata of the element types.
Simple mapping for a java field mapping to a single column.
Mapping to represent a field that is mapped to multiple datastore columns.
Expression handler to invoke the SQL SINH function.
Mapping of a SMALLINT column.
A
SoftReference based ObjectPool.Provides methods for adapting SQL language elements to the SQL Anywhere database.
Method to allow inclusion of any SQL code that returns a boolean.
Representation of a column reference in an SQL statement.
Controller for execution of SQL statements to the underlying RDBMS datastore.
State of a connection.
Expression handler to evaluate SQL.cube(args).
SCO Mapping for a java.sql.Date type.
A SQLException based on a list of Throwable causes.
Base expression for SQL.
Factory for creating SQL expressions/literals.
Mapping to represent the return value of an SQL function invocation.
Method to allow inclusion of any SQL function invocation.
Provides methods for adapting SQL language elements to the SQLite database.
SQL Type info for SQLite datastores.
Representation of a join in an SQL statement.
Representation of an SQL Literal in a query.
Interface to implement to wrap an SQL function.
Method to allow inclusion of any SQL code that returns a numeric.
Interface to implement an operation in SQL.
A Query using SQL.
Expression handler to evaluate SQL.rollup(args).
Provides methods for adapting SQL language elements to the Microsoft SQL Server database.
SQL Type info for SQLServer datastores.
Class providing an API for generating SQL statements.
Series of convenience methods to help the process of generating SQLStatements.
Representation of an SQLStatement parameter.
Representation of a table reference in an SQL statement.
SQLTable namer that generates names like A0, B1, C0, ...
Group of tables in an SQL statement.
SQLTable namer that uses the table name as the "alias".
Interface to be implemented by a class providing naming for SQL tables.
SQLTable namer that generates names like T0, T1, T2, etc.
Representation of a snippet of an SQL statement.
SCO Mapping for a java.sql.Time type.
SCO Mapping for a java.sql.Timestamp type.
Representation of SQL type information in the datastore.
Mapping of an SQLXML column.
Expression handler to invoke the SQL SQRT function.
Definition of statement mapping for a particular class.
Holder for the StatementExpressionIndex for the various details in UPDATE/DELETE statements.
Representation of a mapping in a statement (such as JDBC), and its mapping to the associated column(s)
or parameters that the mapping relates to.
Definition of the mapping of a new object definition in the results of a statement.
Definition of the mapping of parameters in a datastore statement.
Definition of the mapping of result expressions in a datastore statement.
Query using a stored procedure.
Spooler for files being streamed from the datastore.
Method for evaluating {strExpr}.charAt(numExpr).
Method for evaluating {strExpr}.charAt(numExpr).
Method for evaluating {strExpr}.concat(strExpr1s).
Method for evaluating {strExpr}.concat(strExpr1s).
Method for evaluating {strExpr1}.endsWith(strExpr2[, numExpr]) for Cloud Spanner.
Method for evaluating {strExpr1}.endsWith(strExpr2[, numExpr]).
Method for evaluating {strExpr1}.equalsIgnoreCase(strExpr2).
Method for evaluating {strExpr1}.equals(strExpr2).
Representation of an expression with a string.
Method for evaluating {strExpr1}.indexOf(strExpr2[,pos]).
Method for evaluating {strExpr1}.indexOf(strExpr2[,pos]).
Method for evaluating {strExpr1}.indexOf(strExpr2[,pos]).
Method for evaluating {strExpr1}.indexOf(strExpr2[,pos]) for PostgreSQL.
Method for evaluating {strExpr1}.indexOf(strExpr2[,pos]).
Expression handler to evaluate {stringExpression}.length() with Firebird.
Expression handler to evaluate {stringExpression}.length().
Expression handler to evaluate {stringExpression}.length().
Expression handler to evaluate {stringExpression}.length().
Representation of a string literal.
Mapping for a String type.
Expression handler to evaluate {stringExpression}.matches(StringExpression) for Derby.
Expression handler to evaluate {stringExpression}.matches(StringExpression).
Expression representing a field/property that can be stored as a String or as a Numeric.
Method for evaluating {strExpr}.replaceAll(strExpr1, strExpr2).
Support for a String.matches like functionality but using Postgresql's "SIMILAR TO" operator.
Method for evaluating {strExpr1}.startsWith(strExpr2).
Method for evaluating {strExpr1}.startsWith(strExpr2[,numExpr]).
Method for evaluating {strExpr1}.startsWith(strExpr2) for cloud spanner.
Method for evaluating {strExpr1}.startsWith(strExpr2[, numExpr]).
String expression to wrap a subquery.
Method for evaluating {strExpr}.substring(numExpr1 [,numExpr2]).
Method for evaluating {strExpr}.substring(numExpr1 [,numExpr2]).
Method for evaluating {strExpr}.substring(numExpr1 [,numExpr2]).
Method for evaluating {strExpr}.substring(numExpr1 [,numExpr2]).
Method for evaluating {strExpr}.substring(numExpr1 [,numExpr2]).
Expression representing a field/property that can be stored as a String or as a Temporal.
Expression handler to invoke the SQL LOWER function.
Expression handler to invoke the SQL UPPER function.
Method for evaluating {strExpr}.translate(strExpr1, strExpr2).
Method for trimming a String expression using LTRIM and RTRIM SQL functions.
Method for evaluating {strExpr1}.trim() or "TRIM(BOTH trimChar FROM strExpr1)".
Method for evaluating {strExpr1}.trimLeft() or "TRIM(LEADING trimChar FROM strExpr1)".
Expression handler to invoke the SQL LTRIM function.
Expression handler to invoke the SQL TRIM function.
Method for evaluating {strExpr1}.trimLeft() or "TRIM(TRAILING trimChar FROM strExpr1)".
Expression handler to invoke the SQL RTRIM function.
Mapping for a field that stores a PC object that uses "subclass-table" inheritance
and where this is mapped in the datastore as a separate FK for each subclass.
Expression containing a subquery.
Interface representing an expression that contains a subquery.
Expression handler to invoke the SQL SUM aggregation function.
Pools that unavoidably swallow exceptions may be configured with an instance
of this listener so the user may receive notification of when this happens.
Class for logging swallowed exceptions.
Provides methods for adapting SQL language elements to the Sybase database.
Representation of a table in an RDBMS.
Identity generator for RDBMS databases that generates ids using a table in the database.
Representation of an identifier for a table.
Class representing a table in a datastore (RDBMS).
Class containing a series of convenience methods for the generation of tables and constraints.
Expression handler to invoke the SQL TAN function.
Expression handler to invoke the SQL TANH function.
Base for all temporal methods.
Method for evaluating DAY({dateExpr}).
Method for evaluating DAY({dateExpr}) using Oracle.
Method for evaluating DAY({dateExpr}) using PostgreSQL.
Method for evaluating {dateExpr}.getDay() using SQLite.
Method for evaluating {dateExpr}.getDay() for Firebird and CloudSpanner.
Method for evaluating DAY_OF_WEEK({dateExpr}) using H2.
Method for evaluating DAY_OF_WEEK({dateExpr}) using PostgreSQL.
Method for evaluating DAY_OF_WEEK({dateExpr}) using MySQL.
Method for evaluating DAY_OF_WEEK({dateExpr}) using SQLServer.
Method for evaluating DAY_OF_WEEK({dateExpr}) using SQLite.
Method for evaluating DAY_OF_WEEK({dateExpr}) for Firebird.
Method for evaluating DAY_OF_WEEK({dateExpr}) for CloudSpanner.
Method for evaluating DAYOFYEAR({dateExpr}) for CloudSpanner.
Representation of temporal objects in java query languages.
Method for evaluating HOUR({dateExpr}).
Method for evaluating HOUR({dateExpr}) using Oracle.
Method for evaluating HOUR({dateExpr}) using PostgreSQL.
Method for evaluating HOUR({dateExpr}) using SQLServer.
Method for evaluating HOUR({dateExpr}) using SQLite.
Method for evaluating HOUR({dateExpr}) for Firebird and CloudSpanner.
Method for evaluating ISOWEEK({dateExpr}) for CloudSpanner.
Method for evaluating ISOYEAR({dateExpr}) for CloudSpanner.
Representation of temporal literal in a Query.
Abstract base mapping for all temporal types.
Method for evaluating MILLISECOND({dateExpr}) for CloudSpanner.
Method for evaluating MINUTE({dateExpr}).
Method for evaluating MINUTE({dateExpr}) using Oracle.
Method for evaluating {dateExpr}.getMinute() using PostgreSQL.
Method for evaluating MINUTE({dateExpr}) using SQLServer.
Method for evaluating MINUTE({dateExpr}) using SQLite.
Method for evaluating MINUTE({dateExpr}) for Firebird and CloudSpanner.
Method for evaluating {dateExpr}.getMonth().
Method for evaluating {dateExpr}.getMonth().
Method for evaluating {dateExpr}.getMonth() using PostgreSQL.
Method for evaluating {dateExpr}.getMonth() using SQLite.
Method for evaluating {dateExpr}.getMonth() for Firebird and CloudSpanner.
Method for evaluating MONTH({dateExpr}).
Method for evaluating MONTH({dateExpr}) using Oracle.
Method for evaluating MONTH({dateExpr}) using PostgreSQL.
Method for evaluating MONTH({dateExpr}) using SQLite.
Method for evaluating MONTH({dateExpr}) for Firebird and CloudSpanner.
Method for evaluating QUARTER({dateExpr}).
Method for evaluating QUARTER({dateExpr}) using Oracle.
Method for evaluating QUARTER({dateExpr}) using PostgreSQL.
Method for evaluating QUARTER({dateExpr}) using SQLServer.
Method for evaluating QUARTER({dateExpr}) for CloudSpanner.
Method for evaluating SECOND({dateExpr}).
Method for evaluating SECOND({dateExpr}) using Oracle.
Method for evaluating SECOND({dateExpr}) using PostgreSQL.
Method for evaluating SECOND({dateExpr}) using SQLServer.
Method for evaluating SECOND({dateExpr}).
Method for evaluating SECOND({dateExpr}) using SQLite.
Method for evaluating SECOND({dateExpr}) for Firebird and CloudSpanner.
Temporal expression to wrap a subquery.
Method for evaluating WEEK({dateExpr}).
Method for evaluating WEEK({dateExpr}) using Sybase.
Method for evaluating WEEK({dateExpr}) using PostgreSQL.
Method for evaluating WEEK({dateExpr}) using SQLServer.
Method for evaluating WEEK({dateExpr}) for Firebird and CloudSpanner.
Method for evaluating WEEK({dateExpr}) using Oracle.
Method for evaluating YEAR({dateExpr}).
Method for evaluating YEAR({dateExpr}) using Oracle.
Method for evaluating YEAR({dateExpr}).
Method for evaluating YEAR({dateExpr}) using SQLite.
Method for evaluating YEAR({dateExpr}) for Firebird and CloudSpanner.
CallStack strategy that uses the stack trace from a
Throwable.A snapshot of a throwable.
Mapping of a TIME column.
Mapping of a TIMESTAMP column.
Provides methods for adapting SQL language elements to the Oracle Times Ten database
Mapping of a VARBINARY column for TimesTen database.
Mapping of a TINYINT column.
Plugin for the creation of a Tomcat JDBC connection pool.
A TooManyForeignKeysException is thrown when trying to add a foreign
key to a table and the table already has the maximum allowed number of
foreign keys.
A TooManyIndicesException is thrown when trying to add an index
to a table and the table already has the maximum allowed number of indices.
This interface allows pooled objects to make information available about when
and how they were used available to the object pool.
Wrapper expression handler for a TypeConverterMapping to avoid the need to have an explicit mapping for something using a TypeConverter.
Wrapper literal handler for a TypeConverterMapping to avoid the need to have an explicit mapping for something using a TypeConverter.
Mapping where the member has its value converted to/from some storable datastore type using a TypeConverter.
Expression representing a TypeConverterMultiMapping where we have a java type mapped to multiple columns.
Literal for an object persisted using TypeConverterMultiMapping.
Mapping where the member has its value converted to/from some storable datastore type using a TypeConverter to multiple columns.
Representation of an expression for an unbound variable.
A UnexpectedColumnException is thrown if an unexpected column is
encountered in the database during schema validation.
Class to generate a SelectStatement for iterating through instances of a particular type (and
optionally subclasses).
A UnsupportedDataTypeException is thrown if an attempt is made
to persist an object field whose data type is not supported by the database
and/or the persistence package.
Class to provide a means of update of particular fields of a particular type in an RDBMS.
SQL UPDATE Statement representation.
This interface may be implemented by an object pool to enable clients
(primarily those clients that wrap pools to provide pools with extended
features) to provide additional information to the pool relating to object
using allowing more informed decisions and reporting to be made regarding
abandoned objects.
Holds a user name and password pair.
Utility methods.
Mapping for fields of type java.util.UUID.
Schema transaction to validate the specified table.
Mapping of a VARBINARY column.
Mapping of a VARCHAR column.
Mapping class for mapping version state/timestamp columns in the database.
Version using a Long delegate.
Version using a Timestamp delegate.
A ViewDefinitionException is thrown if the metadata extension(s)
that define a view are missing or invalid.
Representation of a View in a datastore (RDBMS).
Provides methods for adapting SQL language elements to the Virtuoso database.
SQL Type info for Virtuoso datastores.
A WrongPrecisionException is thrown if a column is detected to have
the wrong precision in the database during schema validation.
A WrongPrimaryKeyException is thrown if a table is detected not to
have the expected primary key in the database during schema validation.
A WrongScaleException is thrown if a column is detected to have
the wrong scale in the database during schema validation.
PStmtKey.