All Classes and Interfaces

Provides a base implementation of BeanPersistListener.
Base type for DB platform specific Encryption.
Options for the text match and multi match expressions.
An abstract MetricVisitor that handles the boolean flags - reset, collectTransactionMetrics and collectQueryMetrics.
Provides some base implementation for NamingConventions.
Thrown when failing to acquire a pessimistic lock.
Annotation utility methods to find annotations.
Used to provide some automatic configuration early in the creation of a Database.
Administrative control of AutoTune during runtime.
Defines the AutoTune behaviour for a Database.
The mode for determining if AutoTune will be used for a given query when Query.setAutoTune(boolean) has not been explicitly set on a query.
Background executor service for executing of tasks asynchronously.
BackgroundExecutorWrapper that can be used to wrap tasks that are sent to background (i.e.
A simple MetricVisitor that can collect the desired metrics into lists.
Adds ANSI based OFFSET FETCH NEXT clauses to a SQL query.
Simple SQL limiter for use with SqlQuery.
Adds LIMIT OFFSET clauses to a SQL query.
A bean insert, update or delete change sent as part of a ChangeSet.
Lazy loading capable Maps, Lists and Sets.
Interface to define the addition of a bean to the underlying collection.
Loads a entity bean collection.
A request to delete a bean by Id value.
Visitor for collecting new/old values for a bean update.
Doc store functions for a specific entity bean type.
Used to override the finding implementation for a bean.
Provides finder functionality for use with "Dependency Injection style" use of Ebean.
List capable of lazy loading.
Loads a entity bean.
Map capable of lazy loading.
Throw when an processing an entity bean that is not bytecode enhanced.
Throw when an processing thinks a bean is not registered.
A no operation implementation of BeanPersistController.
Used to enhance or override the default bean persistence mechanism.
Listens for committed bean events.
Holds the information available for a bean persist (insert, update or delete).
Fired after a bean is constructed, but not yet loaded from database.
Fired after a bean is fetched and loaded from the database.
Objects extending this modify queries prior their execution.
Holds the information available for a bean query.
Provides finder functionality for use with "Dependency Injection style" use of Ebean.
Set capable of lazy loading.
Provides access to the internal state of an entity bean.
Information and methods on BeanDescriptors made available to plugins.
The bulk table event.
Listen for bulk table events that occur.
Enum to control the different cache modes for queryCache and beanCache.
For making calls to stored procedures.
A call origin for query execution profiling to collect graph use (for query tuning).
Represent the call stack (stack trace elements).
Defines a cancelable query.
Used to provide fine grained control over what persist requests are included in the change log.
Listen for changes.
Listen for changes.
Used to assign ChangeLogFilters to bean types.
Holds a set of changes.
The type of the change.
Helper to find classes taking into account the context class loader.
Wraps the preferred, caller and context class loaders.
Configuration for the container that holds the Database instances.
List that copies itself on first write access.
Holds a distinct value with it's count.
Metric for timed events like transaction execution times.
Provides callback methods for customisation of CSV processing.
Reads CSV data turning it into object graphs that you can be saved (inserted) or processed yourself.
Provides the Tenant Id for the current request based on the current user.
Provides the current user in order to support 'Who created', 'Who modified' and other audit features.
Custom mappings for DB types that override the default.
Provides the API for fetching and saving beans to a particular database.
The configuration used for creating a Database.
Provides a ServiceLoader based mechanism to configure a DatabaseConfig.
Creates Database instances.
Database platform specific settings.
Behavior used when ending a query only transaction (at read committed isolation level).
Provides DatabasePlatform matching by name, JDBC product name and specific platform enum.
Specific persistence error types we wish to map.
Thrown when a foreign key constraint is enforced.
DB is a registry of Database by name.
Naming convention used for constraint names.
Defines how constraint names are shortened if required based on platform limitations.
Used to normalise table and column names which means stripping out quoted identifier characters and any catalog or schema prefix.
DB Column default values mapping to database platform specific literals.
Defines DB encryption support for encrypting and decrypting data using DB encryption features.
History support for the database platform.
Defines the identity/sequence behaviour for the database.
Represents a DB type with name, length, precision, and scale.
Used to map bean property types to DB specific types for DDL generation.
SQL2011 based history support using 'as of timestamp' type clause appended as part of the the from or join clause.
The known DB types that are mapped.
Database view based implementation of DbHistorySupport.
Provides the default implementation of CsvCallback.
Document Mapping for a bean marker interface.
Document query request context marker interface.
Configuration for the Document store integration (e.g.
Bean holding the details to update the document store.
Action to either update or delete a document from the index.
Document storage operations.
Document update context marker interface.
Query for performing native SQL queries that return DTO Bean's.
Thrown when a duplicate is attempted on a unique constraint.
Class to determine the ebean version.
Utility that converts between JSON content and simple java Maps/Lists.
An empty PagedList.
Integer to base64 encoder.
Define the encryption options for a bean property.
The Encryption mode.
Programmatically define which database columns are encrypted.
Represents the key used for encryption.
Determine keys used for encryption and decryption.
Used for Java side encryption of properties when DB encryption is not used.
Marker interface for classes enhanced to support Transactional methods.
Bean that is aware of EntityBeanIntercept.
Query by Example expression.
Expression factory for creating standard expressions for WHERE and HAVING clauses.
An expression that is part of a WHERE or HAVING clause.
Expression factory for creating standard expressions.
List of Expressions that make up a where or having clause.
A dot notation expression path.
The extended API for Database.
Provides awareness of externally managed transactions.
Integer codes for the extra types beyond java.sql.Types.
Defines how a relationship is fetched via either normal SQL join, a eager secondary query, via lazy loading or via eagerly hitting L2 cache.
Defines what part of the object graph to load (select and fetch clauses).
Builds a FetchGroup by adding fetch clauses.
Provides paths and properties for an object graph that can be used to control what parts of the object graph is fetching (select and fetch clauses) and also can be used to control JSON marshalling (what parts of the object graph are included in the JSON).
Provides support for filtering and sorting lists of entities without going back to the database.
Intended to be used as a base class for 'Finder' implementations that can then be injected or used as public static fields on the associated entity bean.
FutureIds represents the result of a background query execution for the Id's.
FutureList represents the result of a background query execution that will return a list of entities.
Represents the result of a background query execution for the total row count for a query.
A customer Id generator that can be registered with Ebean and assigned to @Id properties using the name attribute of @GeneratedValue.
The types of Identity generation that can be defined.
This is the object added to every entity bean using byte code enhancement.
Utilities for IO.
Utility for closing raw Jdbc resources.
Provides a JSON reader that can hold a persistence context and load context while reading JSON.
Configuration for JSON features.
Defined the format used for Date types.
Defined the format used for DateTime types.
Converts objects to and from JSON format.
Unchecked exception thrown when an IOException occurs in json processing.
Provides for custom handling of json content as it is read.
Provides the ability to customise the reading of JSON content.
Allows for customising the JSON write processing.
Provides options for customising the JSON write process.
Wraps an underlying JsonGenerator taking into account null suppression and exposing isIncludeEmpty() etc.
Represents a Conjunction or a Disjunction.
The type of Junction used in full text expressions.
Used to specify the type of like matching used.
Adds LIMIT OFFSET clauses to a SQL query.
Options for the text match expression.
The JPA naming convention where column names match property names and table names match entity names.
Propagates MDC context for tasks executed in the background.
Options used to control a merge.
Builds a MergeOptions which is immutable and thread safe.
Count metrics.
Provides access to the meta data in Database such as query execution statistics.
Metrics collected by Ebean including timed metrics and counters.
Query execution metrics.
Meta data for captured query plan.
Timed execution statistics.
An individual metric.
Factory to create timed metric counters.
Defines visitor to read and report the transaction and query metrics.
A MappedSuperclass base class that provides convenience methods for inserting, updating and deleting beans.
Owner object notified when a modification is detected.
Used by generated code to hold entity classes to register with Ebean.
Loads and returns entity classes to register with Ebean databases.
Options for the text match expression.
The MultiMatch type.
Holds information on mutable values (like plain beans stored as json).
Represents a next value to use for mutable content properties (DbJson with jackson beans).
Defines the naming convention for converting between logical property names/entity names and physical DB column names/table names.
Collects profile information for a bean (or reference/proxy bean) at a given node.
Collects the profile information.
This exception is thrown, when the default implementation of EntityBean is not or not properly overwritten by enhancer.
Identifies a unique node of an object graph.
Represents a "origin" of an ORM object graph.
Represents an Order By for a Query.
A property and its ascending descending order.
Represents a page of results.
Holds a list of value object pairs.
A pair of 2 value objects.
This is a Tree like structure of paths and properties that can be used for defining which parts of an object graph to render in JSON or XML, and can also be used to define which parts to select and fetch for an ORM query.
Holds entity beans by there type and id.
Wrapper on a bean to also indicate if a bean has been deleted.
Defines the scope for PersistenceContext.
Captures and wraps IOException's occurring during ElasticSearch processing etc.
Configuration for DB types such as UUID, Geometry etc.
Specify how UUID is stored.
Generates unique id's for objects.
A 'plugin' that wants to be configured on startup so it can use features of the Database itself.
A callback that can be registered to fire on getter method calls.
A location for profiling transactions and queries.
Configuration for transaction profiling.
Property of a entity bean that can be read.
Property of a entity bean that is a ToMany property.
Object relational query for finding a List, Set, Map or single entity bean.
The lock type (strength) to use with query FOR UPDATE row locking.
FOR UPDATE wait mode.
For query cache entries we additionally hold the dependent tables and timestamp for the query result.
Used to validate that a query cache entry is still valid based on dependent tables.
Used to provide iteration over query results.
The captured query plans.
Object used to collect query plan metrics.
Initiate query plan collection for plans by their hash or all query plans.
EXPERIMENTAL: Listener for captured query plans.
Internal Query plan metric holder.
Request used to capture query plans.
The type of the query being executed.
Raw document.
Used to build object graphs based on a raw SQL statement (rather than generated by Ebean).
Builds RawSql instances from a SQL string and column mappings.
Log that the query was executed
Set user context information into the read event prior to it being logged.
A SQL query and associated keys.
Read event sent to the ReadEventLogger.
Used with SqlQuery to process potentially large queries reading directly from the JDBC ResultSet.
Used with SqlQuery to map raw JDBC ResultSet to objects.
Matches the functionality of javax.persistence.AttributeConverter
Runs DDL and SQL scripts.
Database sequence based IdGenerator using Sequence Step 1 but batch fetch many sequence values.
Database sequence based IdGenerator.
Database sequence based IdGenerator using Sequence Step (e.g.
Thrown at SERIALIZABLE isolation level for non-recoverable concurrent conflict.
Represents part of the "L2" server side cache.
Configuration used to create ServerCache instances.
Defines method for constructing caches for beans and queries.
The cache service for server side caching of beans and query results.
Notification event that dependent tables have been modified.
Interface for both listening to notification changes and sending them to other members of the cluster.
Plugin that provides a ServerCacheNotify implementation.
Options for controlling a cache.
The plugin interface that creates a ServerCacheFactory.
Cache region can be enabled independently.
The statistics collected per cache.
The type of L2 caches.
Used to configure the server on startup.
Metrics of the Database instance.
Collect the metrics in raw JSON form.
Listens for webserver server starting and stopping events.
Manages the shutdown of Ebean.
A very simple Database sequence based IdGenerator.
BeanLoader used when single beans are loaded (which is usually not ideal / N+1).
Single bean lazy loaded when a reference bean.
Single bean lazy loaded when bean from L2 cache.
Single bean lazy loaded when a reference bean.
Slow query event.
Listener for slow query events.
Comparator for timed metrics sorted by name and then count.
Sort by count desc.
Sort MetaCountMetric's by name.
Sort by max desc.
Sort by mean desc.
Sort by name.
Sort by total time desc.
Creates the Database implementations.
Provides shutdown of the entire container.
Extension of Query to build FetchGroup via query beans.
Service that parses FetchGroup expressions.
JSON service that Ebean is expected to provide.
Factory for creating profile locations.
Service provided by Ebean for parsing and column mapping raw SQL queries.
Extensions to Database API made available to plugins.
Helper for dot notation property paths.
Translate SQLException based on SQLState codes.
Used to build a SQLCodeTranslator given DB platform specific codes.
Used to translate SQLExceptions to specific persistence exceptions.
Adds SQL limiting to a query (such as LIMIT OFFSET).
The request object for the query that can have sql limiting applied to it (such as a LIMIT OFFSET clause).
The resulting SQL from a SqlLimit process.
Query object for performing native SQL queries that return SqlRow or directly read ResultSet using a RowMapper.
Query mapping to single scalar values.
Used to return raw SQL query results.
A SqlUpdate for executing insert update or delete statements.
Convert an Object value into a String value.
Utility String class that supports String manipulation functions.
Convert a String value into an Object value.
TableName holds catalog, schema and table name.
A ServerCache proxy that is tenant aware.
Tenant aware handling for caching.
We use a combined key, if this serverCache is per tenant.
For multi-tenancy via DB CATALOG supply the catalog given the tenantId.
For multi-tenancy via DB supply the DataSource given the tenantId.
The mode to use for multi-tenancy.
For multi-tenancy via DB SCHEMA supply the schema given the tenantId.
Text common terms query.
An exception occurred typically in processing CSV, JSON or XML.
Text query string options.
Simple text query options.
Metric for timed events like transaction execution times.
A map of timed metrics keyed by a string.
Extend public MetaTimedMetric with ability to set details from profile location.
Parser for TIME types that supports both HH:mm:ss and HH:mm.
A type that can participate in building toString content with ToStringBuilder.
Helps build toString content taking into account recursion.
The Transaction object.
Provides a callback that can be registered with a Transaction.
Adapter that can be extended for easier implementation of TransactionCallback.
Transaction state when ChangeSets are sent to the ChangeSetListener.
Holds the definition of how a transactional method should run.
Converts between Camel Case and Underscore based names for both table and column names (and is the default naming convention in Ebean).
An Insert Update or Delete statement.
An update query typically intended to perform a bulk update of many rows that match the query.
Holds two values as the result of a difference comparison.
Wraps a version of a @History bean.