All Classes and Interfaces
Class
Description
Base
CpoData implementation for datastore bindings that are
addressed by a positional index (e.g. a JDBC parameter or column index) in addition to the CpoAttribute they move data for.Base
CpoData implementation that owns the CpoAttribute being bound and handles
the transform half of the contract (AbstractCpoData.transformIn(Object)/AbstractCpoData.transformOut(Object)).Base
CpoMetaAdapter implementation that maintains the in-memory map of loaded CpoClass metadata and the shared logic for loading that metadata from the JAXB-bound Ct*
classes produced by unmarshalling a CPO meta XML document.Base
DataSourceInfo implementation that holds the common name/fetchSize/batchSize
configuration and lazily creates the underlying datasource object on first access, guarding
creation with a lock so concurrent callers cannot race to create it twice.An AbstractJDBCDatasource used for instantiating the DataSource from the database driver
A class used for collecting the properties to instantiate the datasource
Base class for
MetaVisitor implementations that generate Java source (interfaces,
classes) from CpoClass meta model objects.Base for
CpoData implementations backed by a JDBC
Statement subtype, resolving the JdbcMethodMapEntry used to bind/read a bound
attribute's value.FactoryMethod for creating a Cassandra AuthProvider
Default
CpoOrderBy implementation: an immutable, bindable sort clause on a single
attribute, optionally wrapped in a native datastore function and associated with a custom marker
for multi-clause substitution.Default
CpoWhere implementation: a bindable where-clause node that is also a Node, allowing leaf comparisons to be chained into branches via BindableCpoWhere.addWhere(CpoWhere) and
rendered to native SQL/CQL text via BindableCpoWhere.toString(CpoClass).A
NodeVisitor that walks a BindableCpoWhere tree and, as a side effect of the
traversal, accumulates both the rendered native (SQL/CQL) where-clause text and the ordered list
of BindAttribute values that must be bound to its parameter placeholders.BindAttribute pairs a single bind value produced while walking a CpoWhere tree
(see BindableWhereBuilder) with either the resolved CpoAttribute it belongs to,
or, when no matching bean attribute exists, the raw attribute name it was addressed by.ExpressionParser implementation for native expressions that use positional ? bind
markers (the common JDBC/CQL convention).Moves a bound attribute's value to or from a JDBC
CallableStatement IN/OUT parameter,
applying any configured JdbcCpoTransform along the way.Helps manage data transfer between the CPO object and the Cassandra bound statement.
CassandraBoundStatementFactory is the object that encapsulates the creation of the actual
Cassandra
BoundStatement used to execute a CpoFunction against the datastax driver.CassandraCpoAdapter is the Cassandra implementation of
CpoAdapter, a set of routines that
are responsible for managing value beans from a Cassandra datasource.A factory for creating CassandraCpoAdapter
CassandraCpoAttribute.
CassandraCpoConfigProcessor processes the datasource configuration file for cassandra.
CassandraCpoMetaAdapter is the Cassandra-specific
AbstractCpoMetaAdapter.CassandraCpoMetaDescriptor is the Cassandra implementation of
CpoMetaDescriptor.Custom transforms of Java classes to Datasource classes
Exports the Cassandra metadata
CassandraMethodMapEntry is a class that defines the getters and setters for Cassandra-specific
data classes
CassandraMethodMapper defines, for each Java type CPO binds to/from Cassandra, the
Row
getter used to read that type back from a query result.Manages data transfer between the cpo objects and the result set
Exception class acts as a catch all for any condition occurring in with regards to an Element
Collects the info required to instantiate a DataSource from a JDBC Driver Provides the
DataSourceInfo factory method getDataSource which instantiates the DataSource
Represents a Cassandra session
Contains the information needed to connect to a Cassandra cluster
The comparison operators for where clauses
Instantiates the Config file processor
XmlObject exporter for meta objects
CpoAdapter is an interface for a set of routines that are responsible for Creating, Retrieving,
Updating, and Deleting (CRUD) value beans within a datasource.
Process-wide cache of
CpoAdapter instances keyed by adapter name.Creates
CpoAdapter instances (plain, transactional, or XA) for a single named data source
configuration.Process-wide cache of
CpoAdapterFactory instances keyed by config name.CpoAdapterFactoryManager is the static entry point applications use to obtain CpoAdapter, CpoTrxAdapter, and CpoXaResource instances by named configuration
context.Represents a single bound argument of a
CpoFunction: a reference to the CpoAttribute whose value is supplied for one of the function's bind markers.Runtime metadata for a single JavaBean-to-datastore attribute binding: extends
CpoAttributeBean's plain configuration data with the reflectively-resolved getter/setter Methods and, if configured, the CpoTransform instance and its transform methods.Plain-data holder for the fields of a CPO attribute as loaded from meta XML: the Java-side
name/type, the datastore-side name/type, and an optional
CpoTransform class name.The CpoBaseAdapter has common functionality needed by all Adapter implementations
Base
CpoXaResource implementation that tracks per-Xid state for a family of XA
resources and drives the JTA two-phase-commit protocol against a subclass-supplied local resource
of type T (e.g. a JDBC Connection).Runtime metadata for a JavaBean class mapped by CPO: its
CpoAttributes, keyed both by
Java property name and by datastore column name, and its CpoFunctionGroups (one per named
CRUD operation group).Plain-data holder for a name and description, the common base for the CPO metadata bean classes
(
CpoClass, CpoArgument, CpoFunctionGroup) that all identify themselves
primarily by name.CpoClass variant whose datastore-name lookups are case-insensitive: attribute data names
are upper-cased before being used as map keys.CpoClass variant whose datastore-name lookups are case-sensitive: attribute data names
are used as map keys exactly as configured.This is a proxy class designed to handle the different classloaders needed when running in a
container as a skinny war versus running from the console.
The CpoClassSourceGenerator generates java source code to define the cpo classes.
CpoData is the binding between a single bean attribute and the mechanics needed to move
its value into and out of the datastore: invoking the bean's getter/setter reflectively and
applying any configured CpoTransform on the way in or out.A
CpoException is the common superclass for any number of CPO related exceptions
that may occur during the execution of a business task.Runtime metadata for a single CPO function: extends
CpoFunctionBean's name/expression/
description with the ordered list of CpoArguments bound to the function's positional bind
markers.Plain-data holder for the fields of a CPO function as loaded from meta XML: its name, native
expression (SQL/CQL), and description.
Runtime metadata for a named group of
CpoFunctions that together implement one CRUD
operation (e.g. all the INSERT functions named "cpo_default") for a CpoClass.Plain-data holder for the fields of a CPO function group as loaded from meta XML: the group's
name (inherited from
CpoClassBean) and its CRUD type (INSERT, RETRIEVE, UPDATE, DELETE,
EXIST, EXECUTE).The CpoInterfaceSourceGenerator generates java source code to define the cpo interfaces.
The CpoClassSourceGenerator generates java source code to define the cpo classes.
CpoMetaAdapter is the datastore-agnostic view over a loaded CPO metadata source: it
resolves the CpoClass for a given bean, exposes the classes it knows about, and bridges
between the datastore's native data type names/ids and their Java equivalents via the
implementation's DataTypeMapper.CpoMetaDescriptor is the runtime, named handle on a loaded CPO metadata source: it owns
the datastore-specific AbstractCpoMetaAdapter that holds the actual CpoClass
metadata, and delegates the CpoMetaAdapter contract to it.Process-wide cache of
CpoMetaDescriptor instances keyed by descriptor name.CpoMetaExportable is implemented by metadata sources that can serialize their loaded
CpoClass metadata back out to a CPO meta XML document.Represents a native (datastore-specific) function expression bound to a marker, for embedding
SQL/CQL functions like
UPPER(?) into a CPO where/order-by clause.CpoOrderBy is an interface for specifying the sort order in which objects are returned from the
Datasource.
The clauses of a
CpoAdapter operation: the function group to run plus any run-time where
constraints, orderings, and native expressions.CpoReleasable is a class that can be called during a CpoTransform when there are resources that
need to released after the current prepared statement is processed.
CpoStatementFactory is the base class that encapsulates the creation of the native statement for
the target datastore from the meta expression, where clauses, and order-by clauses.
CpoTransform converts an attribute's value between the raw form stored/read at the
datastore and the form exposed on the Java bean, e.g. clob-to-string or gzip compression.CpoTrxAdapter adds commit, rollback, and close functionality to the methods already in
CpoAdapter.
`CpoWhere` is an interface for specifying the where clause to filter objects that are returned
from the Datasource.
The XA error codes used by Cpo, mirroring the
int constants declared on XAException so error codes can be passed around as a type-safe enum instead of a bare
int.A JTA
XAResource that additionally allows the resource for a specific transaction branch
to be closed directly, without waiting for commit/rollback/forget.Mutable state tracked for a single XA transaction branch (
Xid): its association state
with a resource manager, its underlying resource, and its success/prepared flags.Simple holder for a
Xid-to-CpoXaState map, one per family of XA resources.The kinds of operation a CPO function group can perform against a datasource.
Interface that defines the methods needed by CPO for any class that collects DataSource info and
instantiates the DataSource
DataTypeMapEntry is a class that defines the mapping of datasource datatypes to java types
Maps datastore data types, identified by either a
java.sql.Types constant or a native
type name, to their DataTypeMapEntry.Collects the info required to instantiate a DataSource from a JDBC Driver Provides the
DataSourceInfo factory method getDataSource which instantiates the DataSource
Static helpers for extracting readable messages from a
Throwable and for normalizing
arbitrary exceptions into CpoException.ExpressionParser extracts bind-marker information from a native (SQL/CQL) function
expression, letting CPO figure out which bean attribute each positional bind marker in the
expression corresponds to.Used to access methods on the driver
Maven goal (
cpo:generatejavasource) that reads one or more CPO meta XML files and
generates the corresponding Java interface and/or class source files, adding the generated
directory to the project's compile (or test-compile) source roots.Histogram tuning shared by the driver's per-metric latency options (session cql-requests, session
throttling.delay, node cql-messages).
JdbcCallableStatementFactory is the object that encapsulates the creation of the actual
CallableStatement for the JDBC driver.
JdbcCpoAdapter is the JDBC implementation of
CpoAdapter, a set
of routines that are responsible for managing value beans from a jdbc datasource.JDBC implementation of
CpoAdapterFactory, vending JdbcCpoAdapter,
transaction-scoped JdbcCpoTrxAdapter, and JdbcCpoXaAdapter instances backed by a
single underlying JdbcCpoAdapter.JdbcCpoArgument is a class that defines the arguments to a JDBC expression
JdbcCpoAttribute.
Processes the cpoConfig.xml data for Jdbc
Builds and manages the Java to Datasource type mapping
Process the Jdbc specific metadata from the xml metadata
Transforms are used when standard java types to data types do not work.
A transaction adapter that allows the user to control the commits and role backs
JDBC implementation of
BindableCpoWhere, resolving a where clause attribute to its
qualified table.column (or bare column) name using the attribute's JdbcCpoAttribute metadata.A JdbcCpoXaAdapter wraps the XAResource processing around a JdbcCpoTrxAdapter.
XmlObject exporter for jdbc meta objects
MethodMapEntry is a class defines the getters and setters for JDBC specific data classes
MethodMapper is a class defines the getters and setters for all the JDBC specific data classes
The data handler for a prepared statement
JdbcPreparedStatementFactory is the object that encapsulates the creation of the actual
PreparedStatement for the JDBC driver.
Result set data getter helper
Collects the info required to instantiate a DataSource stored as a JNDI Resource.
FactoryMethod for creating the collection of NodeStateListener to register with the Cassandra
session
Logical operators for where clauses
Defines that a implementer of this interface allows visits from a MetaVisitor.
This defines a depth first meta visitor.
XmlObject exporter for meta objects
MethodMapEntry is a class defines the getters and setters for JDBC specific data classes
MethodMapper maps java classes to the datastore-specific getter and setter methods used to bind
them.
This is a general Node class to be used to build different types of trees.
This is the interface for the visitors to the Node Hierarchy
Base
CpoData implementation for reading a bound attribute's
value out of a datastore result row (e.g. a JDBC ResultSet or Cassandra Row).FactoryMethod for creating the collection of SchemaChangeListener to register with the Cassandra
session
FactoryMethod for creating a Cassandra SslEngineFactory
Converts a char[] from a jdbc datasource getString() call and from a char[] to a setString() in a
datasource
Converts a java.sql.Clob from a jdbc datasource to a byte[] and from a byte[] to a java.sql.clob
Converts a compressed byte[] from a jdbc datasource to an uncompressed byte[] and from a byte[]
to a compressed byte[] in a datasource
This is an example of a transform that does nothing.
This is an example of a transform that does nothing.
Converts a String to a byte[]
Converts a String from a jdbc datasource to a char[] and from a char[] to a String in a
datasource
Converts a
java.sql.Timestamp from a jdbc datasource to a java.util.Calendar and
from a java.util.Calendar to a java.sql.Timestamp in a datasource.Servlet that will output the current state of a meta descriptor in the form of xml.
Static helpers for locating and safely unmarshalling CPO's XML configuration and meta data files.