All Classes and Interfaces
Class
Description
A common superclass of Cayenne queries.
An accessor of a property value.
A descriptor for an additional DB entity attached to the main one.
Creates objects for user-provided String class names, injecting dependencies
 into them.
Superclass of aggregated conditional nodes such as NOT, AND, OR.
Superclass of aggregated conditional nodes such as NOT, AND, OR.
Object that represents Arc identifier.
A Property that represents an "arc" connecting source node to the target node
 in the graph.
Implements dependency sorting algorithms for ObjEntities, DbEntities and
 Persistent objects.
"Add" Expression.
Base class for all aggregation functions expressions
 It's more like marker interface for now.
"And" expression.
Asterisk operator for COUNT(*) expression.
"Between" expression.
Bitwise conjunction (AND or '&') expression
Bitwise left shift '<<' operation.
Bitwise negation (NOT i.e.
Bitwise disjunction (OR or '|') expression.
Bitwise right shift '>>' operation.
Bitwise exclusive disjunction (XOR or '^') operation.
This is a root node of parsed template.
"CASE-WHEN" expression root node.
Class for custom aggregation functions expressions.
Path expression traversing DB relationships and attributes.
"Divide" expression.
"ELSE" part of the case-when expression.
Scalar node that represents constant enumeration value.
"Equal To" expression.
Available components of date/time.
Boolean false expression element
 
 Notice that there is one ASTTrue and one ASTFalse instead of a ASTBoolean
 with a Boolean value.
"Greater Than" expression.
"Greater Than Or Equal To" expression.
"In" expression.
"Less Then" expression.
"Less than or equal to" expression.
"Like" expression.
"Case insensitive like" expression.
A leaf expression representing an immutable collection of values.
"Multiply" expression.
A named expression parameter.
"Negate" expression.
"Not" expression.
"Not Between" expression.
"Not equal to" expression.
"Not In" expression.
"Not Like" expression.
"Not like, ignore case" expression.
"Or" expression.
Generic path expression.
A scalar value wrapper expression.
"Subtract" expression.
"THEN" part of the case-when expression.
Boolean true expression element Notice that there is one ASTTrue and one
 ASTFalse instead of a ASTBoolean with a Boolean value.
"WHEN" part of the case-when expression.
Defines a property descriptor that is a part of an Entity.
Represents events resulted from Attribute changes 
 in CayenneModeler.
Represents a simple object property.
A DbAdapter that automatically detects the kind of database it is running on
 and instantiates an appropriate DB-specific adapter, delegating all
 subsequent method calls to this adapter.
Thrown when the pool fails to validate a fresh connection that is known to be
 in a good state.
A base implementation of the 
ArcProperty.A 
ConfigurationNodeVisitor that does nothing, used as a convenience superclass
 for partial visitors.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.0, use 
PersistentObject directlyProperty that represents non-numeric PK
Property that represents generic attribute.
An abstract property descriptor that delegates property access to an 
Accessor.A convenience superclass for SQLAction implementations.
A generic superclass of CollectionProperty implementations.
A convenience base superclass for 
ToOneProperty implementors.A Cayenne transaction.
BatchQuery and its descendants allow to group similar data for the batch
 database modifications, including inserts, updates and deletes.
Represents a single row of values in a BatchQuery.
Superclass of batch query translators.
Factory which creates BatchQueryBuilders for different types of queries,
 which, in their turn, create SQL strings for batch queries.
A property accessor that uses set/get methods following JavaBean naming
 conventions.
ValidationFailure implementation that described a failure of a single named property of
 a Java Bean object.
An annotation used by objects that want to receive scope ending events from the DI
 registry.
An object passed to a 
Module by the DI container during initialization, that
 provides the API for the module to bind its services to the container.A binding builder that helps with fluent binding creation.
Handles 
java.lang.Boolean mapping.Handles 
byte[], mapping it as either of JDBC types - BLOB or
 (VAR)BINARY.Handles 
java.lang.Byte type mapping.Shared functionality for cacheable queries.
ExtendedType that handles 
Calendar fields.A mapping descriptor of a single callback event.
A generic descriptor of a set of standard lifecycle callbacks.
Defines forced capitalization of the result column names in the DataRow.
Various utils for processing persistent objects and their properties
Common superclass for events passed from the EventManager to Listeners; encapsulates
 optional event information.
Defining a double-linked named entry in CayenneMap.
 This interface represents some path in the Cayenne model.
Value object representing segment of a 
CayennePathObject representing Cayenne stack.
A convenience class to assemble custom 
CayenneRuntime.A generic unchecked exception that may be thrown by Cayenne framework.
This interface implementations will be used by 
CayenneRuntimeBuilder to auto-load runtime modules.Represents a Cayenne-managed local Transaction.
This is char and Character type mapped to zero or one char String.
Handles 
java.lang.String, mapping it as either of JDBC types -
 CLOB or (VAR)CHAR.A GraphChangeHandler that loads child ObjectContext diffs into a parent
 ObjectContext.
A runtime descriptor of an persistent class.
A factory of 
ClassDescriptor instances.An object that holds class descriptors for mapped entities, compiling new
 descriptors on demand using an internal chain of descriptor factories.
Maps ClassLoaders to resources.
A 
ResourceLocator that looks up resources is the application
 classpath based on the current thread ClassLoader.Base class for 
ListProperty and SetPropertyA descriptor of a ResultSet column.
A helper builder for queries selecting individual properties based on the root object.
Interface (or "Trait") that provides basic functionality for comparable properties.
Assists in implementing 
Comparable.compareTo(Object) methods.Decorates a collection of other collections to provide a single unified view.
A GraphDiff that is a list of other GraphDiffs.
A hash table supporting full concurrency of retrievals, adjustable expected concurrency
 for updates, and a maximum capacity to bound the map by.
A builder that creates 
ConcurrentLinkedHashMap instances.Superclass of conditional expressions.
A runtime exception thrown on failures in Cayenne configuration.
A service that maps the names of configuration objects to the resource names.
Implemented by the "nodes" on the Cayenne configuration tree.
A visitor interface for implementing operations on different types of
 
ConfigurationNode objects.A tree of configuration nodes that contains extra information about the nodes, such
 as load errors.
A 
ResultIterator wrapper that handles closing a connection.Defines the names of runtime properties and named collections used in DI modules.
A collection of static conversion utility methods.
A helper class to do property type conversions.
A factory of property type converters.
A DI module containing all Cayenne runtime configuration.
A builder of extensions for 
CoreModule.CoreModule auto-loading facility.
DataChannel is an abstraction used by ObjectContexts to obtain mapping metadata and
 access a persistent store.
A descriptor of a DataChannel normally loaded from XML configuration.
An object that can load a named 
DataChannelDescriptor from some configuration
 source.Merges multiple descriptors into a single runtime descriptor.
A listener of 
DataChannel lifecycle events.
 Storage for all kind of meta data that is not required for runtime.
An interface of a filter that allows to intercept DataChannel query operations.
Interface for chain of query filters
An interface of a filter that allows to intercept DataChannel sync operations.
Interface for chain of sync filters
The most common implementation of 
ObjectContext.Defines API for a DataContext "delegate" - an object that is temporarily passed control
 by DataContext at some critical points in the normal flow of execution.
DataDomain performs query routing functions in Cayenne.
A stateful commit handler used by DataContext to perform commit operation.
Factory that produces 
DataDomainFlushActionA 
DataChannel provider that provides a single instance of DataDomain
 configured per configuration supplied via injected
 DataChannelDescriptorLoader.Stores a collection of related mapping objects that describe database and
 object layers of an application.
A loader of DataMaps.
An abstraction of a single physical data storage.
A descriptor of 
DataNode configuration.A factory for creating DataNodes from descriptors.
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.0, use 
Persistent interface directlyDataRow a map that holds values retrieved from the database for a given query row.
A fixed size cache of DataRows keyed by ObjectId.
A factory for creating 
DataRowStoreA builder class that allows to build a 
DataSource with optional
 pooling.Helper JavaBean class that holds DataSource information for the Cayenne-managed DataSource.
Property that represents date/time attribute.
DbAdapter implementation for the  DB2 RDBMS .
A sequence-based PK generator used by 
DB2Adapter.A Cayenne extension point that abstracts the differences between specifics of
 JDBC interfaces to various databases.
A factory interface providing DbAdapter based on JDBC metadata.
A DbAttribute defines a descriptor for a single database table column.
Describes a PreparedStatement parameter binding mapped to a DbAttribute.
For managing the changes in the DbAttribute.
A DbEntity is a mapping descriptor that defines a structure of a database
 table.
Defines a listener for DbEntity modification events.
Utility class that generates database schema based on Cayenne mapping.
Defines a join between two attributes of a given relationship.
DbKeyGenerator is an abstraction of a primary key generator It configures the primary
 key generation per DbEntity in a RDBMS independent manner.
A DbRelationship is a descriptor of a database inter-table relationship based
 on one or more primary key/foreign key pairs.
For managing the changes in the DbRelationship.
Object that represents some change on DB level.
BiFunction that merges two 
DbRowOp changing same object.Sorter of 
DbRowOp operations.An operation that merges changes from an object graph, whose objects are registered in
 some ObjectContext, to peer objects in an ObjectConext that is a child of that context.
A default implementation of 
AdhocObjectFactory that creates objects
 using default no-arg constructor and injects dependencies into annotated
 fields.Deprecated.
since 4.2
Default implementation of 
BatchTranslatorFactory.A 
ClassLoaderManager thatA default implementation of 
DataChannelDescriptorMerger.
     Default implementation of 
DataChannelMetaData that stores data in Map.Default implementation of 
DataDomainFlushAction.Factory that produces 
DefaultDataDomainFlushAction.A default implementation of 
DataRowStoreFactoryA factory of DbAdapters that either loads user-provided adapter or guesses
 the adapter type from the database metadata.
A default implementation of 
EventManager.A default Cayenne implementations of a DI injector.
Default implementation of 
ObjectMapRetainStrategy.A default implementation of 
ObjectStoreFactory which makes decision to
 turn ObjectStore's syncing with parent DataRowStore on or off 
 basing on RuntimeProperties.Simple implementation of OperationObserver interface.
An implementation of 
RuntimeProperties that returns properties that
 were injected via a map in constructor.An implementation of a DI scopes with support scope events.
A provider that provides scoping for other providers.
Default translator of select queries 
FluentSelect.A 
SelectTranslator factory that delegates translator creation to
 DbAdapter.Default implementation of 
ValueObjectTypeRegistryA 
DataSourceFactory that delegates DataSource creation to another factory,
 which is determined dynamically per DataNodeDescriptor.Batched delete query.
An exception thrown during an attempt to delete an object that has a relationship to a
 non-null related object, that has a DENY delete rule.
Special case op, that describes delete/insert sequence of different objects
 that have same ObjectId (known example: meaningful PK set to same value as used before).
Defines constants for the possible values of ObjRelationship delete rules.
DeleteRuleUpdater is responsible for auto-setting delete rules for object relationships
DbAdapter implementation for the  Derby RDBMS
 .
PK generator for Derby that uses sequences.
Creates a DerbyAdapter if Apache Derby database is detected.
A class that bootstraps the Cayenne DI container.
A superclass of DI List and Map builders.
A runtime exception thrown on DI misconfiguration.
A ResultIterator that does in-memory filtering of rows to return only
 distinct rows.
This is a default implementation of a DataChannel provider that simply returns a
 DataDomain for a given runtime.
An exception thrown on attempts to access a DataDomain after it was explicitly shut
 down by the user.
A very simple observer that does nothing with provided data, and rethrows any
 reported exceptions.
A non-pooling DataSource implementation wrapping a JDBC driver.
Helper value-object class that used to compare operations by "effective" id (i.e.
Parses an EJBQL statement, converting it to SQL.
An aggregate column expression.
A noop implementation of the EJBQL visitor that returns same preset boolean value from
 all methods.
Represents an EJB QL expression "compiled" in the context of a certain mapping.
Token literal values and constants.
A translator of EJBQL DELETE statements into SQL.
An exception thrown on errors during parsing EJBQL statements.
An abstract EJBQL expression interface.
A visitor interface to inspect the EJBQL expression tree.
Handles appending joins to the content buffer at a marked position.
A holder of multi-column match condition operand.
An abstract definition of EJBQL query parser.
Creates 
EJBQLParser based on the system settings.A translator that walks the relationship/attribute path, appending joins to
 the query.
An EJBQL query representation in Cayenne.
Translator of the EJBQL select clause.
A translator of EJBQL SELECT statements into SQL.
Token Manager.
A context used for translating of EJBQL to SQL.
Defines a factory for translation visitors of EJBQL.
A mapping descriptor of an embeddable class.
A persistent attribute of an embeddable object.
Property that represents object attribute mapped on 
Embeddable object.An attribute of the ObjEntity that maps to an embeddable class.
An accessor for fields storing embedded objects.
A metadata object that provides mapping of a set of result columns to an Embeddable object.
An Entity is an abstract descriptor for an entity mapping concept.
Represents events resulted from Entity changes 
 in CayenneModeler.
A tree structure representing inheritance hierarchy of an ObjEntity and its
 subentities.
EntityMergeListener interface defines API useful for listening to
 EntityMergeSupport processing.
Property that represents to-one relationships.
Represents a virtual shared namespace for zero or more DataMaps.
A metadata object that provides mapping of a set of result columns to an
 ObjEntity.
A "compiled" version of a 
EntityResult descriptor.Defines API for sorting of Cayenne entities based on their mutual dependencies.
An ExtendedType that handles an enum class.
ExtendedTypeFactory for handling Enum types.
Assists in implementing 
Object.equals(Object) methods.An object that passes events between a local EventManager and some other event dispatch
 mechanism.
Defines a factory to dynamically create EventBridge instances.
This class acts as bridge between an Object that wants to inform others about its
 current state or a change thereof (Publisher) and a list of objects interested in the
 Subject (Listeners).
This class encapsulates the String that is used to identify the subject that
 a listener is interested in.
Contains access stack events related utility methods.
Superclass of Cayenne expressions that defines basic API for expressions use.
RuntimeException thrown on errors during expressions creation/parsing.
Helper class to build expressions.
Named parameter for parameterized expressions.
Parser of Cayenne Expressions.
Token literal values and constants.
Token Manager.
An interface that Enum classes may implement to map enum instances to arbitrary DB
 values that do not match the enum names or positions.
An ExtendedType that handles a Java Enum based upon the Cayenne ExtendedEnumeration
 interface.
Defines methods to read Java objects from JDBC ResultSets and write as parameters of PreparedStatements.
ExtendedType factory interface.
Stores ExtendedTypes, implementing an algorithm to determine the right type
 for a given Java class.
Represents a container-managed transaction.
Represents a placeholder for an unresolved relationship from a source object.
A runtime exception thrown when during lazy object initialization Cayenne finds that no
 matching row exists in the database for a given ObjectId.
A PropertyAccessor that performs direct Field access.
A default POJO embeddable descriptor.
DbAdapter implementation for FirebirdSQL
 RDBMS .
SUBSTRING function for Firebird
 It has following format:
 SUBSTRING (string FROM CAST(? AS INTEGER) FOR CAST(? AS INTEGER))
Base class for 
ObjectSelect and ColumnSelectA 
Slf4jJdbcEventLogger extension that provides pretty formatting of the logged SQL messages.An action builder for FrontBaseActionBuilder.
DbAdapter implementation for FrontBase
 RDBMS.
Collection of factory methods to create function call expressions.
Implementation of 
Persistent that uses Map to store object fields.Generic implementation of QueryResult using List as QueryResultItem storage.
A simple serializable implementation of QueryResponse.
A Cayenne-supported values object that holds GeoJson string.
Db operation sorted that builds dependency graph and uses topological sort to get final order.
Defines callback API that can be used by object graph nodes to notify of their state
 changes.
Represents a change in an object graph.
A utility class that removes redundant and mutually exclusive graph changes from the
 graph diff.
An event indicating a change in the object graph.
Represents a generic "managed" graph with nodes mapped by their ids.
A base implementation of GraphManager that stores graph nodes keyed by their ids.
DbAdapter implementation for H2
 RDBMS .
H2 specific char type handling - used to handle the correct setting of clobs
Default PK generator for H2 that uses sequences for PK generation.
Factory that creates handlers for unparsed elements.
Assists in implementing 
Object.hashCode() methods.DbAdapter implementation for the 
 HSQLDB RDBMS .
A flavor of HSQLDBAdapter that implements workarounds for some old driver limitations.
Works around HSQLDB's pickiness about stored procedure syntax.
Detects HSQLDB database from JDBC metadata.
This data object like 
GenericPersistentObject uses Map to store generic attributes,
 only difference is that this Map will be created lazily at first write, thus reducing memory penalty if possible.A stateless read-only accessor of the map key value that is based on the Persistent
 object id.
Base class for properties mapped to PK
helper class to generate pseudo-GUID sequences.
A synchronized list that serves as a container of Persistent objects.
A QueryResponse that contains a sublist of the query result.
A List implementation that would maintain its internal ordering based on some object
 numeric "index" property.
A base superclass for queries that resolve into some other queries during the
 routing phase.
DbAdapter implementation for Ingres.
Ingres-specific sequence based PK generator.
Detects Ingres database from JDBC metadata.
A facade to the Cayenne DI container.
Batched INSERT query.
Extended type factory that produces types for Cayenne internal value types that could potentially make it to the DB.
Marker interface, that should be used by any internal value types, that could potentially get to the SQL
Invocation represents a dynamic method invocation bound to a specific target.
A simple decorator for an iterated query.
OperationObserver that is used to track the execution of SelectQueries with
 results returned as ResultIterator.
An implementation of interface CharStream, where the stream is assumed to
 contain only ASCII characters (with java-like unicode escape processing).
An implementation of interface CharStream, where the stream is assumed to
 contain only ASCII characters (with java-like unicode escape processing).
An implementation of interface CharStream, where the stream is assumed to
 contain only ASCII characters (with java-like unicode escape processing).
A factory of default SQLActions.
A generic DbAdapter implementation.
A default EJBQLTranslatorFactory.
A logging service used by Cayenne to output database interactions.
Default primary key generator implementation.
A ResultIterator over the underlying JDBC ResultSet.
Deprecated.
since 5.0, unused by Cayenne
Enumerates supported JOIN types.
A Cayenne-supported values object that holds Json string.
Simple utils to process JSON.
An object that encapsulates a key used to store and lookup DI bindings.
A ClassDescriptor wrapper that compiles decorated descriptor lazily on first access.
A registry of lifecycle callbacks for all callback event types.
Defines possible entity object lifecycle events.
A callback interface to listen to persistent object lifecycle events.
expressions: LIKE, ILIKE, NOT LIKE, NOT ILIKE + ESCAPE
A binding builder for list configurations.
Property that represents to-many relationship mapped on 
List.A QueryResponse optimized to hold a single object or data row list.
Provides access to various modeler resources (mainly strings) obtained via a
 ResourceBundle.
A wrapper for 
UnmanagedPoolingDataSource that automatically manages
 the underlying connection pool size.A binding builder for map configurations.
Superclass of CayenneModeler events.
A query that represents a named parameterized non selecting query stored in the mapping.
A query that represents a named parameterized selecting query stored in the mapping.
Defines API of a container of DbEntities, ObjEntities, Procedures, Queries
 and other mapping objects.
Property that represents to-many relationship mapped on 
Map.A default implementation of the 
QueryCache interface that stores data in a
 non-expiring LRUMap.A Blob implementation that stores content in memory.
A Clob implementation that stores contents in memory.
Represents a unit of configuration of the Cayenne DI container.
Auto-loads DI modules using ServiceLoader.
 Provider of modules used by module auto-loading mechanism to identify and load modules.
DbAdapter implementation for MySQL RDBMS.
Detects MySQL database from JDBC metadata.
Base class for handlers that can delegate execution of unknown tags to
 handlers produced by factory.
A 
QueryCache wrapper that introduces a key namespace on top of a
 delegate shared cache.A JJTree-compliant tree node interface.
Provides basic machinery for constructing the parent and child relationships 
 between nodes.
All AST nodes must implement this interface.
An abstract superclass of operations on individual nodes and arcs in a
 digraph.
A GraphDiff representing a change in node ID.
Noop implementation of 
DataChannelMetaData.Noop implementation of JdbcEventLogger
An 
ObjectStore which doesn't receive notifications 
 on parent's DataRowStore events.Property that represents numeric PK
Property that represents attributes mapped on numeric types
An ObjAttribute is a mapping descriptor of a Java class property.
Listener for ObjAttribute events.
A Cayenne object facade to a persistent store.
A factory for regular and nested contexts.
A base implementation of a helper class to handle
 
ObjectContext.propertyChanged(org.apache.cayenne.Persistent, String, Object, Object)
 processing on behalf of an ObjectContext.A helper class that implements
 
DataChannel.onQuery(ObjectContext, Query) logic on behalf of
 an ObjectContext.A dynamic GraphDiff that represents a delta between object simple properties
 at diff creation time and its current state.
 A portable global identifier for persistent objects.
A query that matches zero or one object or data row corresponding to the ObjectId.
A strategy for retaining objects in 
ObjectStore.A selecting query providing chainable API.
ObjectStore stores objects using their ObjectId as a key.
A factory for creating 
ObjectStores.A GraphDiff facade for the ObjectStore changes.
This is a default ExtendedType that relies on JDBC driver to determine the result type.
ObjEntity is a mapping descriptor for a Persistent Java class.
For managing the changes in the ObjEntity
Describes an association between two Java classes mapped as source and target
 ObjEntity.
Defines a listener for ObjRelationship modification events.
Defines API that allows QueryEngine to obtain information about query execution
 strategy.
Defines a set of callback methods that allow 
QueryEngine to pass back query
 results and notify caller about exceptions.Factory that wraps provided ID to be suitable for the better processing in the flush operation.
An exception thrown on optimistic lock failure.
A flavor of OracleAdapter that implements workarounds for some old driver
 limitations.
DbAdapter implementation for Oracle RDBMS
 .
Oracle specific CHAR type handling.
Sequence-based primary key generator implementation for Oracle.
Defines object sorting criteria, used either for in-memory sorting of object
 lists or as a specification for building ORDER BY clause of a
 SelectQuery query.
Orderings is provided so that you can chain Ordering together and then use 
 the result to pass into methods that require List<Ordering>
Describes a PreparedStatement parameter generic binding.
Defines a query that can serve as a template for other queries.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
A component in a path chain.
Property that represents path segment (relationship or embeddable).
Superclass of pattern matching nodes.
An injectable provider that returns a given service in a context of a specific 
DbAdapter.Defines a set of object states from the point of view of persistence.
Defines minimal API of an object that can be persisted via Cayenne.
A default ClassDescriptor implementation for persistent objects.
A convenience superclass for 
ClassDescriptorFactory implementors.Base implementation of 
Persistent, have no assumption about how data is actually stored.Simple interface to unify PersistentObject* collections in way of
 setting properties directly
A 
ClassDescriptorFactory that creates descriptors for classes implementing Persistent.A ValueHolder implementation that holds a single Persistent object related to an object
 used to initialize PersistentObjectHolder.
A list of persistent objects lazily resolved on the first access.
Defines methods to support automatic primary key generation.
Per-adapter provider of PkGenerators
Simple mapper of Object[] to a POJO class.
A 
Connection wrapper that interacts with the
 UnmanagedPoolingDataSource, allowing to recycle connections and track
 failures.A 
DataSource that pools connections and requires to be explicitly
 closed.Turns unpooled DataSource to a connection pool.
A collection of pooling parameters used by 
UnmanagedPoolingDataSource.An annotation to place on the entity event listener method to receive
 
LifecycleEvent.POST_ADD events.DbAdapter implementation for PostgreSQL
 RDBMS .
Default PK generator for PostgreSQL that uses sequences for PK generation.
An annotation to place on the entity event listener method to receive
 
LifecycleEvent.POST_LOAD events.An annotation to place on the entity event listener method to receive
 
LifecycleEvent.POST_PERSIST events.An annotation to place on the entity event listener method to receive
 
LifecycleEvent.POST_REMOVE events.An annotation to place on the entity event listener method to receive
 
LifecycleEvent.POST_UPDATE events.A hierarchical visitor interface for traversing a tree of PrefetchTreeNodes.
A SelectQuery to perform a prefetch based on another query.
Defines a node in a prefetch tree.
An annotation to place on the entity event listener method to receive
 
LifecycleEvent.PRE_PERSIST events.An annotation to place on the entity event listener method to receive
 
LifecycleEvent.PRE_REMOVE events.An annotation to place on the entity event listener method to receive
 
LifecycleEvent.PRE_UPDATE events.A mapping descriptor for a database stored procedure.
A SQLAction that runs a stored procedure.
Fluent API for calling stored procedures.
A descriptor for the Procedure parameter.
Describes a PreparedStatement parameter binding mapped to a DbAttribute.
A query based on Procedure.
Result of procedure call.
Stored procedure query translator.
Base interface for all types of properties
A utility accessor class that wraps a simple property.
A DataSourceFactrory that creates a DataSource based on system properties.
Defines bean property API used by Cayenne to access object data, do faulting
 and graph maintenance tasks.
An unchecked exception thrown on errors during property access, either within a
 Accessor or a Property.
Factory class that produces all property types.
Utility methods to quickly access object properties.
A visitor for various types of properties in a ClassDescriptor.
A DI object factory interface.
Qualifier of DB row.
Defines minimal API of a query descriptor that is executable via Cayenne.
Defines API of a cache that stores query results.
A factory that is used by the cache to rebuild expired entries.
Defines query result caching policy.
A Query decorator for a collection of other queries.
Generic descriptor of a Cayenne query.
A builder that constructs Cayenne queries from abstract configuration information
 defined in cayenne-data-map*.dtd.
Defines methods used to run Cayenne queries.
Provides a common interface for accessing query metadata.
Represents a result of query execution.
Represents a collection of items which are results of a multipart query execution.
Represents a single item in a multipart query execution.
An interface used by Queries to route themselves to an appropriate QueryEngine.
A query that allows to explicitly clear both object and list caches either via refetch
 (eager refresh) or invalidate (lazy refresh).
Defines a relationship between two entities.
Represents events resulted from Relationship changes 
 in CayenneModeler.
An abstract superclass of lazily faulted to-one and to-many relationships.
Interface (or "Trait") that provides basic functionality for all types of relationships.
A query that selects objects related to a given object via a mapped relationship.
An abstraction of a resource whose data can be accessed via a URL.
Defines API of a batch iterator over the ResultIterator returned as a result of
 Select queries execution.
Defines API of an iterator over the records returned as a result of
 Select queries execution.
A callback interface invoked on each row when iterating over
 
ResultIterator.A descriptor of a result row obtained from a database.
A builder class that helps to assemble 
RowDescriptor instances from various
 types of inputs.A strategy class that encapsulates an algorithm for converting a single
 ResultSet row into a DataRow.
Creates RowReader instances for executed queries.
Represents a properties map for a given 
CayenneRuntime.A superclass of nested tag handlers for parsing of XML documents with SAX.
A strategy for auto generating a database schema on the application startup.
A factory for 
SchemaUpdateStrategy instances.Defines the scope of the instances created by the DI container.
A class that wraps an annotated method call of an object, passing it DI scope events.
This interface duplicates default reflection based mechanism for receiving DI
 events.
A common interface for grouping together different kinds of queries that
 return results.
A SQLAction that handles SelectQuery execution.
A query to select objects by id.
An abstraction of 
ObjectSelect translator.A factory for 
SelectTranslator objects.Property that represents root entity
 
Usage example:
Usage example:
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.0, use 
CayenneRuntime class insteadProperty that represents to-many relationship mapped on 
Set.An operation that merges changes from a single object registered in some ObjectContext,
 to a peer object in an ObjectConext that is a child of that context.
Handles 
java.lang.Short type mapping.A descriptor of an "attribute" persistent property.
A base node for the EJBQL concrete nodes that satisfies JJTree requirements.
Superclass of AST* expressions that implements Node interface defined by JavaCC framework.
Represents a generic validation failure that contains
 failed object and a message describing the failure.
Optimized mutable single-entry map.
A SchemaUpdateStrategy that does nothing.
A 
JdbcEventLogger built on top of slf4j-api logger.Event sent on modification of the DataRowStore.
Implementation of {link #BatchTranslator}, which uses 'soft' delete
 (runs UPDATE and sets 'deleted' field to true instead-of running SQL DELETE)
Map that stores values wrapped into 
SoftReferenceConstants to order query results (the ORDER BY clause).
An annotation that defines the insertion sorting "weight" of an entity that is used
 when sorting DB operations.
Defines API for query execution strategy over JDBC connection (as in Strategy Pattern).
A factory interface to create standard SQLActions for a set of standard queries.
A generic query based on raw SQL and featuring fluent API.
A SQLite database adapter that works with Zentus JDBC driver.
Detects SQLite database from JDBC metadata.
A metadata object that defines how a row in a result set can be converted to
 result objects.
A selecting query based on raw SQL and featuring fluent API.
 Cayenne DbAdapter implementation for Microsoft SQL Server  engine.
The default PK generator for MS SQL,
 which uses sequences to generate a PK for an integer key type
 and NEWID() for UNIQUEIDENTIFIER key type
ProcedureAction for SQLServer MS JDBC driver.
Detects SQLServer database from JDBC metadata.
SQL tree processor that supports OFFSET X ROWS FETCH NEXT Y ROWS ONLY clause
 for the SQLServer 2012 and later.
A PreparedStatement descriptor containing a String of SQL and an array of parameters.
A query that executes unchanged (except for template preprocessing) "raw" SQL
 specified by the user.
Implements a strategy for execution of SQLTemplates.
Parser of Cayenne Templates.
Token literal values and constants.
Token Manager.
Implements utility methods used inside Velocity templates when rendering
 SQLTemplates.
Property that represents attributes mapped on string types
DbAdapter implementation for Sybase RDBMS.
Primary key generator implementation for Sybase.
Detects Sybase database from JDBC metadata.
Can convert to any class that has a constructor that takes a 
 single Object or a single String parameter.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Token Manager Error.
Token Manager Error.
Token Manager Error.
A list that holds objects for to-many relationships.
A property representing a map of objects keyed by one of the object properties.
A property representing a collection of objects.
An ArcProperty that points to a single graph node.
A utility class to simplify implementation of Object toString methods.
Cayenne Transaction interface.
Descriptor that allows to customize transaction logic.
Builder class for the TransactionDescriptor.
A 
DataChannelSyncFilter that provides transactions.A callback that is notified as transaction progresses through stages.
An optional utility service that simplifies wrapping multiple operations in
 transactions.
Propagation behaviour of transaction
This interface allows transparently use different queries (namely SelectQuery, ObjectSelect and ColumnSelect)
 in translator and as subqueries.
Context that holds all data necessary for query translation as well as a result of that translation.
Expression visitor interface.
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.0 as 
TraversalHandler has default no-op implementations for all methodsTypesHandler provides JDBC-RDBMS types mapping.
A utility class that handles mappings of JDBC data types to the database
 types and Java types.
A non-blocking 
DataSource with a pool of connections.An exception indicating that a connection request waiting in the queue
 timed out and was unable to obtain a connection.
A runtime exception thrown when 
PropertyUtils.getProperty() finds that
 there is a null value in middle of the resolved path.Batched UPDATE query.
A 
Resource implementation wrapping a resource URL.Contains various unorganized static utility methods used across Cayenne.
Maps 
java.util.Date to any of the three database date/time types: TIME,
 DATE, TIMESTAMP.Defines a number of callback methods that allow an object to be validated before safe.
An exception thrown on unsuccessful validation.
Defines a single failure during the validation process.
Represents a result of a validation execution.
Provides a level of indirection for property value access, most often used for deferred
 faulting of to-one relationships.
A 
ClassDescriptorFactory for Persistent objects that implement relationship
 faulting via ValueHolder.Describes expressions, that can "inject" value to an object, i.e.
Descriptor and serialization helper for custom value objects that can be safely stored in the DB.
Registry of user-defined descriptors of custom value objects' classes.
Collection of values that should be inserted or updated in DB.
Handler that can validate root tag name, version and namespace.
A noop type that is sometimes useful to suppress extended types operations.
Map that stores values wrapped into 
WeakReferenceEntitySorter that takes into account entity "weights", and otherwise delegating to
 another (topological) sorter.
A Cayenne-supported value object holding a WKT geometry String.
 A helper class to encode objects to XML.
A 
DataSourceFactory that loads JDBC connection information from an
 XML resource associated with the DataNodeDescriptor, returning a DataSource
 with simple connection pooling.Interface for Cayenne objects that can be saved to XML.
DataContextdirectly