All Classes and Interfaces
Class
Description
Common code for Dto/Orm/RelationalQuery
Wraps the objects involved in executing a SQL / Relational Query.
Stack based on ArrayList.
Collects and manages the the profile information.
Used to help mark PropertyVisitor methods that need to be implemented
to visit base table properties.
Controls the batch ordering of persist requests.
A batched statement that is held in BatchedPstmtHolder.
Used to hold BatchedPstmt objects for batch based execution.
Holds the first SQLException found when executing a JDBC batch.
Handles the processing required after batch execution.
The results of bean cache hit.
Persist info for determining if save or delete should be performed.
Helper functions for performing tasks on Lists Sets or Maps.
Creates Helpers specific to the type of the property (List Set or Map).
Utility methods for BeanCollections.
Describes Beans including their deployment information.
Creates BeanDescriptors.
Provides a method to find a BeanDescriptor.
Used to evaluate imported foreign keys so as to avoid unnecessary joins.
Helper object for dealing with Lists.
Helper for element collection List.
Holds the BeanDescriptor and its associated BeanPersister.
Helper specifically for dealing with Maps.
Natural key for a bean type.
Defines bean insert update and delete implementation.
Factory for creating BeanPersister implementations.
Organises the individual bean persist requests by type.
Wraps the information representing a Inserted Updated or Deleted Bean.
Description of a property of a bean.
Abstract base for properties mapped to an associated bean, list, set or map.
Property mapped to a List Set or Map.
Property mapped to a joined bean.
Bean property for an IdClass embeddedId.
A DbJson property that does not use Jackson ObjectMapper.
Handle json property with MutationDetection of SOURCE or HASH only.
Bean property for synthetic sort order value / order column.
Used to visit a BeanProperty given the type of bean property it is.
Base class for find and persist requests.
Helper specifically for dealing with Sets.
Helper for element collection List.
Used for associated beans in place of a BeanDescriptor.
Context used to read binary format messages.
Mechanism to convert RemoteTransactionEvent to/from byte[] content.
Messages that can be sent in binary form.
Context used to write binary message (like RemoteTransactionEvent).
Binds bean values to a PreparedStatement.
The max length check on bind values.
Standard string length implementation.
Length check based on UTF8 bytes.
Supports padding bind parameters for IN expressions.
Parameters used for binding to a statement.
The bind parameters in the correct binding order.
A In Out capable parameter for the CallableStatement.
Parses the BindParams if they are using named parameters.
BindValues used for L2 query cache key matching.
Bitwise expression operator.
Interesting classes for a EbeanServer such as Embeddable, Entity,
ScalarTypes, Finders, Listeners and Controllers.
Searches for interesting classes such as Entities, Embedded and ScalarTypes.
A change to the cache.
List of changes to be applied to L2 cache.
Data held in the bean cache for cached beans.
The cached data for O2M and M2M relationships.
Process Cache lookup by Id(s).
Used for bean cache lookup with where ids in expression.
Used for bean cache lookup with a single id value.
Configuration options when creating the default cache manager.
Options for controlling cache behaviour for a given type.
Represent the findCount query as a Callable.
Represent the fetch Id's query as a Callable.
Represent the findList query as a Callable.
Creates CallOrigin based on the stack trace.
Defines a cancelable query.
Chains multiple BeanPersistController's together.
Handles multiple BeanPersistListener's for a given entity type.
Handles multiple BeanPostLoad's for a given entity type.
Handles multiple BeanPostLoad's for a given entity type.
Handles multiple BeanQueryAdapter for a given entity type.
Case insensitive string matching.
Compute a checksum for String content.
Utility to finds and return the list of ClassPathScanner services.
Wraps the Clock such that we can change the Clock for testing purposes.
Sends messages to the cluster members.
Factory to create the cluster broadcast service.
Manages the cluster service.
Optimistic concurrency mode used for updates and deletes.
Common loggers used in ebean-core.
An object that represents a SqlSelect statement.
Defines interface for adding beans to the collection which might be a List, Set or Map.
Handles the Object Relational fetching.
Represents a query for a given SQL statement.
Key used for caching query plans for ORM and RawSql queries.
Statistics for a specific query plan that can accumulate.
Compile Query Predicates.
Create a DatabasePlatform from the configuration.
Supply the DataSource to the transaction manager.
Define if a Calendar representing the time zone should be used in JDBC calls.
Adds the db platform specific json expression.
Request building the expression sql.
Class to hold the DDL-migration information that is needed to do correct alters.
Helper to indicate that an EbeanServer should come up offline
typically for DDL generation purposes.
Context provided when a BeanProperty reads from a ResultSet.
Used to provide context during sql construction.
Default implementation of BeanState.
Adapts SpiCacheManager to ServerCacheManager.
Default Server side implementation of ServerFactory.
Default implementation of DtoQuery.
Default Expression factory for creating standard expressions.
Default implementation of ExpressionList.
Default implementation of an Object Relational query.
Default implementation of OrmUpdate.
Default implementation of PersistenceContext.
Persister implementation using DML.
Default profile handler.
Default transaction profiling event collection.
Default implementation of SQuery - SQL Query.
Perform native sql fetches.
The default server side implementation of EbeanServer.
The default cache implementation.
Wraps the value to additionally hold createTime and lastAccessTime and hit counter.
Comparator for sorting by last access sort, a copy of last access time that should not mutate during trim processing.
Manages the bean and query caches.
Default implementation of ServerCachePlugin.
Server cache for query caching.
Used to return raw SQL query results.
A SQL Update Delete or Insert statement that can be executed.
Manages the transaction scoping using a Ebean thread local.
Default implementation of TypeManager.
Default implementation of UpdateQuery.
Beans deleted by Id used for updating L2 Cache.
The delete mode of the persistence request.
Describes Beans including their deployment information.
Collects Deployment information on Embedded beans.
Description of a property of a bean.
Abstract base for properties mapped to an associated bean, list, set or map.
Property mapped to a List Set or Map.
Property mapped to a joined bean.
Helper object to classify BeanProperties into appropriate lists.
Used for associated beans in place of a BeanDescriptor.
Converts logical property names to database columns.
Converts logical property names to database columns with table alias.
Converts logical property names to database columns using a Map.
Represents a join to another table during deployment phase.
A join pair of local and foreign properties.
For updates converts logical property names to database columns and bean type to base table.
Default implementation of SpiFetchGroupService.
Helper to perform a diff given two beans of the same type.
A 'context' for reading entity beans from JSON.
Default implementation of JsonContext.
Default implementation of JsonScalar.
Utility that converts between JSON content and simple java Maps/Lists.
Utility object with helper methods for DML.
Default implementation of SpiRawSql.
Splits a select clause into 'logical columns' taking into account functions and quotes.
Wraps the objects involved in executing a DtoQuery.
Comparator for use with the expression objects.
Comparator based on multiple ordered comparators.
Comparator with no operation for unsortable properties.
Comparator based on a ElGetValue.
Collects (List/Set/Map) of elements.
Default implementation of the Filter interface.
Interface for defining matches for filter expressions.
A ElGetValue based on a chain of properties.
Utility object used to build a ElPropertyChain.
Used to parse expressions in queries (where, orderBy etc).
The expression language object that can get values.
Used to create column alias for encrypted columns.
Transaction based on a java.sql.Connection supplied by an external
transaction manager such as Spring.
A TransactionScopeManager aware of external transaction managers.
Extra metrics collected to measure internal behaviour.
This is the path prefix for filterMany.
Flags used in persistence.
Binder for Geometry types.
Provider of Geometry type binder support.
A hash key for a query including both the query plan and bind values.
Helper object to make AOP generated code simpler.
Binds id values to prepared statements.
Bind an Id that is an Embedded bean.
Creates the appropriate IdConvertSet depending on the type of Id property(s).
Bind an Id where the Id is made of a single property (not embedded).
ID IN expression common for cache handling.
In a collection of ID values.
Represents a imported property.
Imported Embedded id.
Single scalar imported id.
Holds multiple column unique constraints defined for an entity.
Used to extend the DatabaseConfig with additional objects used to configure and
construct an Database.
Used to reduce memory consumption of strings used in deployment processing.
Helper to build IntersectionTable.
Jta based transaction.
Hook into external JTA transaction manager.
PagedList implementation based on limit offset types of queries.
A buffer of beans for batch lazy loading and secondary query loading.
Controls the loading of ManyToOne and OneToOne relationships.
Request for loading ManyToOne and OneToOne relationships.
Controls the loading of reference objects for a query instance.
A buffer of bean collections for batch lazy loading and secondary query loading.
Controls the loading of OneToMany and ManyToMany relationships.
Request for loading Associated Many Beans.
Request for loading Associated One Beans.
Defines the method for executing secondary queries.
Scalar type that wraps a local/client side encrypted value.
Represents the type of a OneToMany or ManyToMany property.
Holds the joins needs to support the many where predicates.
Detects when content has been modified and as such needs to be persisted (included in an update).
Wraps an iterator for the purposes of detecting modifications.
Modify aware wrapper of a list.
Modify aware wrapper of a ListIterator.
Map that is wraps an underlying map for the purpose of detecting changes.
Wraps a Set for the purposes of detecting modifications.
Wraps the multi values that are used for "property in (...)" queries
Implementation of DataTimeZone when single Calendar instance is used with local timezone.
QueryPlanKey for native sql queries.
An entry for natural key lookup.
A property value pair in a natural key lookup.
Collects the data for processing the natural key cache processing.
Noop service when AutoTuneService is not available.
Implementation of DataTimeZone when no time zone is specified.
A do nothing SpiProfileHandler.
Simple operators - equals, greater than, less than etc.
Implementation of DataTimeZone that clones the Calendar instance.
Represents the internal structure of an Object Relational query.
Parses a Object relational query statement into a OrmQueryDetail and OrmQueryAttributes.
The Object Relational query execution API.
Represents the Properties of an Object Relational query.
Wraps the objects involved in executing a Query.
Set properties for a UpdateQuery.
Bind value used in the set clause for update query.
Deferred update of a relationship where an Id value is not initially available
so instead we execute this later as a SqlUpdate statement.
Utility to find the root bean type.
API for persisting a bean.
The actual execution of persist requests.
Wraps all the objects used to persist a bean.
PersistRequest for insert update or delete of a bean.
Persist request specifically for CallableSql.
Persist request specifically for CallableSql.
Persist request specifically for CallableSql.
Factory for platform specific handling/ScalarTypes for DB ARRAY.
Collects the events of a transaction being profiled.
Profiling listener gets call backs for node usage and the associated query executions.
Represents a join required for a given property and whether than needs to be an outer join.
Default implementation of FutureIds.
Default implementation for FutureList.
Future implementation for the row count query.
A QueryPlanLogger that prefixes "EXPLAIN " to the query.
A QueryPlanLogger for oracle.
A QueryPlanLogger for SqlServer.
Manage query plan capture.
Context for JSON read processing.
Wraps the objects involved in executing a SqlQuery.
Cache events broadcast across the cluster.
Read a row building a result for that row.
A DataReader with indexed positions for the properties to read specifically for RawSql use.
Save many that can be queued up to execute after the associated
bean has been actually been persisted.
DB Array types.
Boolean ScalarType's must implement to support DDL default values etc.
ScalarType for Boolean and boolean.
Base type for binary types.
Encrypted ScalarType that wraps a byte[] types.
Marker interface for the Enum scalar types.
Marks types that can be mapped differently to different DB platforms.
ScalarType for String.
A ScalarType that uses a ScalarTypeConverter to convert to and from another underlying
ScalarType.
Manage scoped (typically thread local) transactions.
Used internally to handle the scoping of transactions for methods.
Returns Database instances for remote message reading.
Simple AES based encryption and decryption.
Implementation of DataTimeZone when single Calendar instance is used.
Internal Extension to BackgroundExecutor with shutdown.
SPI interface for underlying BeanDescriptor.
Manager of SpiBeanTypes.
The cache service for server side caching of beans and query results.
Cache region can be enabled independently.
Cancellable query, that has a delegate.
Internal database query plan being capture.
DDL generate and run for drop all/create all.
Provides the DDL Generator for create-all/drop-all.
Internal extension to DtoQuery.
Service Provider extension to EbeanServer.
An expression that becomes part of a Where clause or Having clause.
Expression bind values capture.
Internal extension of ExpressionList.
Request object used for gathering expression sql and bind values.
Property expression validation request for a given root bean type.
Service API of FetchGroup.
Extended Json Context for internal server use.
Internal API extensions for JSON writing of Bean properties.
SPI methods for Junction.
Logger for SQL, TXN and Summary logging.
API for Plugins to define the logger for io.ebean.SQL, io.ebean.TXN and io.ebean.SUM.
Log manager for SQL, TXN and Summary logging.
Defines the ORM query request api.
SPI extension to PersistenceContext.
Handle the logging or processing of transaction profiling information that is collected.
Event that adds to a profiling transaction.
Object Relational query - Internal extension to Query object.
The type of query result.
Capture query bind values and with those actual database query plans.
Query select and fetch properties (that avoids parsing).
The internal ORM "query plan".
The secondary query paths for 'query joins' and 'lazy loading'.
Internal service API for Raw Sql.
Defines the column mapping for raw sql DB columns to bean properties.
A Column of the RawSql that is mapped to a bean property (or ignored).
A key for the RawSql object using for the query plan.
Represents the sql part of the query.
Hold the JDBC PreparedStatement and ResultSet.
SQL query binding (for SqlQuery and DtoQuery).
SQL query - Internal extension to SqlQuery.
Extends Transaction with additional API required on server.
Service provider interface for the transaction manager.
Proxy for an underlying SpiTransaction (most of the API).
Per Transaction logging of SQL, TXN and Summary messages.
Internal extension to the Update interface.
The type of the update request.
A plan for executing bean updates for a given set of changed properties.
Controls the loading of property data into a bean.
Inner join, Outer join or automatic determination based on cardinality and optionality.
Factory for SqlTree.
Extra Sql joins conditionally added if required (after children are joined).
The select properties for a node in the SqlTree.
String utility for adding strings together.
A property in the SQL Tree.
Bean type interface for Sql query tree.
Represents a join to another table.
A join pair of local and foreign properties.
Holds timestamp of last modification per table.
Meta data for table spaces.
Holder of the changes handling the case when we send the changes
prior to commit or rollback as we hit the allowed 'batch size'.
Holds information for a transaction.
Manages transactions.
Objects supplied for constructing the TransactionManager.
Profiling information for a single transaction that has completed.
Manages the Transactions typically held in a ThreadLocal.
Utility to improve logging of raw SQL that contains new line characters.
Event codes used in transaction profiling.
Convert an Object to the required type.
Marked interface for expressions unsupported in doc store.
IdGenerator for java util UUID.
IdGenerator for (pseudo) type 1 UUIDs.
IdGenerator for java util UUID.
Makes use of BeanVisitor and PropertyVisitor to navigate BeanDescriptors
and their properties.