All Classes and Interfaces
Class
Description
ABS(column) scalar function.ABS(): Absolute value of a number.Abstract base class for condition clauses in the fluent select API.
Abstract base class for terminal condition clauses in the fluent select API.
Abstract base class for building SQL statements.
Abstract base class for the start of a condition clause in the fluent select API.
An abstract implementation of the
DatabaseProvider interface that provides a framework for interacting
with a database by managing SQL queries, metadata retrieval, and type conversions.An abstract base class for
Converter implementations that handle numeric types.Abstract base class for SQL generators.
Abstract base class for building SQL statements.
An abstract base class for
Converter implementations that primarily convert values by parsing their string representation.A name and an optional alias.
Interface for generating aliases for tables and columns.
Factory for creating
AliasGenerator instances.A transformer for database aliases
Specifies additional superinterfaces of the entity class that will be recognised by Litebridge relational mapping
if used in collections.
AVG(column) aggregate function.AVG(): Returns the average value of a column.A converter for
BigDecimal values.A converter for
BigInteger values.A binding value and its associated SQL data type.
An encapsulated literal value in a query expression.
Functional interface for creating bind value expressions.
A converter for
Boolean values.Utility class for boolean operations.
A converter for
byte[] values.A converter for
Byte values.Implementation of a condition clause for DTO-based queries.
Implementation of a terminal condition clause for DTO-based queries.
List-specific type of ChangedField which holds a snapshot of the original underlying map.A field which has undergone a change.
A collection of modified fields in a DTO, since the last snapshot.
Map-specific type of ChangedField which holds a snapshot of the original underlying map.This class provides functionality to track field-level changes of data transfer objects (DTOs)
by maintaining a snapshot of their specified fields.
A converter for
Character values.A utility class that facilitates caching and retrieving
FieldAccessor instances for DTO classes.Utility class for working with Java reflection.
Represents the different types of SQL clauses where an expression can be used.
Utility class for working with collections.
A database column that belongs to a specific table and optionally has an alias.
Annotation used to define mapping between a Java field or method and a database column.
A column-based expression within a SQL query.
Factory to create expressions targeting a specific column.
Abstract base class for column-specific SQL expressions.
Query expression encapsulating a target column.
The ColumnIdentifierGenerator class provides utilities for generating SQL column identifiers
with optional table qualifiers, handling reserved keywords, and creating aliases for columns.
Represents a base type for various kinds of database column mappings.
Metadata information for a database column.
Specification of a database column, used to map DTO fields to target expressions.
A value associated with a specific column in a database operation.
A functional interface for generating values for a specific database column.
Represents the result of a composite update operation, aggregating multiple
DtoUpdateResult objects
that represent individual update results.A thread-safe, lazily initialized value holder that allows resetting the value.
A condition in a database query, specifying a column, operator, and value/operand.
Generic condition clause for building conditional expressions in a fluent and type-safe manner.
Terminal interface for building SQL condition clauses in a fluent and type-safe manner.
A group of logically combined conditions and condition subgroups.
Represents a group of conditions in the query AST.
Groups conditions and condition subgroups using a logical operator.
Represents a condition within a JOIN, WHERE or HAVING clause in the query AST.
A node in a lightweight AST representing a step in a fluent query chain.
Specification for a condition in a database query.
A concrete implementation of
TypeConverter that allows manual registration and unregistration of converters.Provides a mechanism to obtain a managed database connection, typically bound to the scope of a transaction.
A select expression in a SQL query that requires a
ConnectionProvider to render.Represents a converter for a specific Java type.
A functional interface for converting an object to a specific type.
Represents a conversion expression that wraps another
SelectExpression,
potentially overriding its type.Intent to convert a database result into the specified Java type.
Converts a database result into the specified Java type.
COUNT(*) aggregate function.COUNT(): Selects the count of rows matching the query.CURRENT_TIMESTAMP(): Returns the current date/time from the database.Main interface for interacting with a database.
A converter that converts various date/time types to
Date.DefaultAliasGenerator is an implementation of
AliasGenerator used for generating unique aliases
for tables and columns in a database schema.Default implementation of
AliasTransformer that returns the alias as-is.A concrete implementation of
SequenceColumnValueGenerator that provides
a standardized SQL fragment for fetching the next value from a database sequence.Default Litebridge Transaction Manager
A factory for creating instances of
DefaultTransactionManager.Extends
ConfigurableTypeConverter and automatically populates itself with all
Converter implementations found on the classpath using the Java ServiceLoader mechanism.Abstract base class for nesting query expressions such as SQL functions.
A nestable column expression with support for SQL aliasing.
Interface for nesting query expressions such as SQL functions.
Factory to create nestable column expressions.
A query expression that can nest another query expression.
A SQL DELETE statement targeting a specific table with optional conditions.
A builder class for constructing SQL DELETE statements.
Represents a DELETE statement in the query AST.
Marker interface for a delete query at various stages of construction.
Base specification for constructing a SQL DELETE statement.
Generator for SQL DELETE statements.
Represents the final stage of a delete query that can be executed.
Interface for a WHERE condition clause in a delete query.
Interface for the terminal part of a WHERE condition clause in a delete query.
Direct field access
FieldAccessor implementation using Java 9's VarHandle.A converter for
Double values.A blueprint for creating and managing data transfer objects (DTOs).
Base class for entity/DTO-specific blueprint data.
Specialised data container for DTO-based joins in the context of a
DtoBlueprint.Specialised data container for DTO-based selections in the context of a
DtoBlueprint.The DtoCache interface defines methods for caching Data Transfer Objects (DTOs).
A concrete implementation of the
DtoCache interface that uses a Map-based caching mechanism.Start of a DTO-based condition clause.
A utility class responsible for constructing Data Transfer Object (DTO) instances
using default or canonical constructors.
The result of constructing a Data Transfer Object (DTO).
Dependency configuration for a Data Transfer Object (DTO).
A pair consisting of a
FieldAccessor and its corresponding value.Information about a particular constructor.
Specification for DTO-based data.
Specification for a DTO-based delete operation.
A WHERE clause for DTO-based delete operations.
Represents a WHERE condition clause for DTO delete operations.
Terminal clause for DTO delete WHERE conditions.
Implementation of
DtoDeleteWhereConditionClauseTerminal for DTO delete operations.Executor for DTO delete operations.
Mapping between an entity class and its DTO fields.
Terminal clause for DTO FROM clauses.
Terminal clause for DTO GROUP BY clauses.
Represents a HAVING condition clause for DTO queries.
Terminal clause for DTO HAVING conditions.
Terminal clause for DTO JOIN operations.
Represents a JOIN clause in a DTO-based query.
Represents a condition within a JOIN clause in a DTO-based query.
Represents the terminal part of a JOIN condition clause in a DTO-based query.
Specification for a JOIN clause in a DTO-based query.
Represents an ORDER BY clause in a DTO-based query.
Represents a chain of ORDER BY clauses in a DTO-based query.
Resolves proto-expressions into DTO-based select expressions.
Represents a pair of a DTO and its corresponding row value.
Selector for DTOs.
Specification for a DTO select query.
Represents a pair of a field accessor and its corresponding database column.
DTO-to-table mapping details, used for registering a DTO class as an entity with the Litebridge ORM.
Builder class for constructing instances of
DtoTableSpec.Updater for DTOs.
Represents the result of an update operation on a Data Transfer Object (DTO).
Specification for a DTO update query.
The starting interface for DTO update queries.
The step interface for DTO update queries.
Represents a where condition clause for a DTO update.
The terminal interface for DTO update where condition clauses.
Implementation of the terminal interface for DTO update where condition clauses.
DTO where condition clause.
DTO where condition clause terminal.
Mapper for converting between complex Data Transfer Objects (DTOs) and their corresponding "entity" objects.
A query expression modifier that changes the result of the query.
Marker interface for select query expressions.
Array of expression specifications.
Abstraction for accessing and manipulating fields or properties of a data transfer object (DTO).
Represents a chain of
FieldAccessor instances, allowing the traversal and manipulation of nested fields
of a data transfer object (DTO).Represents the mapping between a specific field in a Data Transfer Object (DTO) and its
corresponding database column specification.
A builder for specifying mappings between fields or properties in a DTO (Data Transfer Object)
and database expressions.
A builder step for defining the column specification associated with a field in a data model.
A builder step for configuring the mapping of a field in a data model to a database column or
relationship.
A builder step for defining the join column mapping in a field-to-database-column specification.
A terminal step in the fluent API for configuring field-to-database-column mappings within
an Object-Relational Mapping (ORM) system.
Final implementation of the
FieldColumnSpecBuilderTerminal interface, used to build
a FieldColumnSpec instance representing the mapping between a DTO field and its
corresponding database column or relationship specification.Defines a mapping of a field or a property in a class to its corresponding representation.
Represents a specification for mapping a field in a class to a database column or property.
A converter for
Float values.Functions: Utility class that provides static methods for constructing query expressions.
A foreign key constraint between two columns.
Starting point for constructing a SQL query by specifying the source table and schema.
The
FromClauseEngine class represents the generation of SQL "FROM" clauses
with support for both DTO-based and raw expression-based queries.Entry point for the "FROM" clause of a query.
Entry point for the "FROM" clause of a query with a type override.
Terminal stage of the FROM clause in a fluent API for constructing SQL queries.
Base class for function expressions operating on a column.
A generic implementation of
Converter that uses a ConverterFunction for the conversion logic.A generic implementation of
SqlConverter that uses a ConverterFunction for the conversion logic.Terminal clause in a fluent API for constructing SQL GROUP BY statements.
Represents a GROUP BY clause in the query AST.
Specification for a "GROUP BY" clause in a database query.
H2DatabaseProvider is a concrete implementation of AbstractDatabaseProvider
specifically designed to interact with H2 database instances.
A terminal step for a
HAVING clause in a SQL query.A condition clause for a
HAVING clause in a SQL query.A terminal condition clause for a
HAVING clause in a SQL query.HAVING clause condition in the query AST.
A SQL INSERT statement targeting specific table metadata with associated columns and rows of values.
Represents an INSERT statement in the query AST.
The result of an insert operation performed on the database.
SQL generator for INSERT statements.
A converter for
Integer values.Transaction isolation levels.
Represents an isolation clause in the context of transactional operations.
A database table join operation in a query.
Represents a join clause in a SQL query, allowing the definition of join operations
between tables.
Terminal clause in a fluent API for constructing SQL JOIN statements.
Generic join condition clause for constructing SQL-like join conditions in a type-safe
and fluent manner.
Terminal state of a join condition clause.
Represents a JOIN clause metadata in the query AST.
Specification for a database "JOIN" clause.
Pagination parameters for database queries, defining a limit on
the number of rows returned and an optional offset indicating the starting
point for the result set.
Terminal clause for applying a LIMIT clause in a SQL query.
Represents a LIMIT clause in the query AST.
Specification for limiting and offsetting the results of a database query.
Primary entry point for Litebridge.
Runtime configuration class for managing the behaviour of Litebridge, particularly
the handling strategy for related DTO (Data Transfer Object) fields
in queries.
A context object that provides access to core Litebridge components and configuration.
A simple
DataSource implementation that utilises DriverManager to create connections.An encapsulated literal value in a query expression.
Factory to create literal value expressions.
A converter for
LocalDate objects.A converter for
LocalDateTime objects.Logically combined condition.
Logically combined condition subgroup.
Specification for a logical condition group.
Specification for a logical condition.
Logical operator for chaining conditions in a query.
A converter for
Long values.LOWER(column) scalar function.LOWER(): Returns the lowercase value of a column.A wrapper for a
Connection object that ensures certain methods associated with
transaction and connection management are not directly invoked.Annotation used to define a many-to-many relationship between two entities
in the context of Object-Relational Mapping (ORM).
Represents a many-to-many relationship mapping between two tables using a join table.
Builder class for defining many-to-many relationships between DTOs (Data Transfer Objects)
and their corresponding relationship tables in a database.
Represents a step in the fluent API for defining the inverse join column in a many-to-many
relationship mapping.
Represents a configuration step in the fluent API for defining many-to-many relationships
between DTOs (Data Transfer Objects) and their corresponding join tables in a database.
Utility class for Collectors providing functionality to create
LinkedHashMap instances.Marker interface for a target for a mapped field in an object-relational mapping (ORM) context.
A many-to-many relationship mapping in an object-relational mapping (ORM) context.
Represents a one-to-many relationship mapping in an object-relational mapping (ORM) context.
A "pre-compiled" mapping plan for a specific DTO class and query specification.
Utility class for working with
Map instances.Represents a mathematical operation to be performed on a column in a SQL context.
Predefined mathematical operators for use in SQL operations.
MAX(column) aggregate function.MAX(): Returns the highest or largest value within a specified column or expressionMIN(column) aggregate function.MIN(): Returns the lowest or smallest value within a specified column or expressionUtility class for Java Module System (JPMS) related operations.
Cache for parsed named parameter-based queries.
Provides a context for executing native SQL queries and updates in a transactional database environment.
Utility class representing a field mapping that does not map to any database field.
Thrown to indicate that a query returned more than one result when exactly one was expected.
An
AliasGenerator implementation that does not generate any aliases,
returning the original table and column names instead.A no-operation implementation of the
DtoCache interface.A no-operation implementation of the
StatementBuilder interface.Number type-overriding nestable expression
Metamodel field for querying numeric-based columns in a type-safe manner.
Utility class for working with objects.
A converter for
OffsetDateTimeConverter values.Annotation that establishes a one-to-many relationship between two entities in the context of
Object-Relational Mapping (ORM).
Represents a one-to-many relationship mapping between a field in a DTO and a corresponding
collection of rows in a database table.
Builder class for defining one-to-many relationships between a field or property in a DTO (Data Transfer Object)
and a corresponding set of related records in a database.
Common abstraction for SQL operations in the database.
Enum of various operators that can be used in database query conditions.
Oracle-specific implementation of
ColumnIdentifierGenerator.Oracle Database Provider for Litebridge.
A specialised converter for Oracle-specific
OffsetDateTime SQL types.Implementation of
SequenceColumnValueGenerator for Oracle databases.Ordering clause in an SQL query.
Clause in a SQL query for specifying ordering of rows based on one or more expressions
or fields.
Chainable clause for constructing complex ORDER BY clauses in a type-safe
and fluent API for SQL query construction.
Terminal clause of an ORDER BY operation.
Represents an ORDER BY clause in the query AST.
Specification for an "ORDER BY" clause in a database query.
A table known by/registered with the ORM, facilitating the relationship between Java objects (DTOs)
and database table schema.
Represents a parsed SQL statement with positional parameters and their corresponding names.
The PersistenceFacade class provides an abstraction layer for managing the persistence
of Data Transfer Objects (DTOs) within a database system.
A statement in the context of dependent database operations that is built using an
AbstractStatementBuilder and optionally pipes result values using a Consumer.PostgreSQL-specific implementation of
AliasTransformer.PostgresqlDatabaseProvider is a concrete implementation of AbstractDatabaseProvider
specifically designed to interact with PostgreSQL database instances.
Implementation of
SequenceColumnValueGenerator for PostgreSQL databases.A database operation with bind values.
A prepared row with associated value specifiers and bound values.
A prepared SQL statement along with its associated bind values.
Property-based
FieldAccessor implementation.Proto-expression, used to specify column names/aliases for use in the target expression type.
Resolver for proto-expressions that have not yet been bound to a specific table or context.
Proto-expression, used to prescribe a
ExpressionSpec type when sufficient information is available.Proto-expression that allows nesting other proto-expressions.
A proto-expression capable of nesting other proto-expressions.
Type override proto-expression that allows nesting other proto-expressions.
Compiles a
QueryNode chain into a SelectSpec.Functional interface for building query conditions.
Basic metamodel field definition.
Inspector for
QueryField instances, providing access to their internal state.A node in a lightweight AST representing a step in a fluent query chain.
Caches SQL execution plans based on the structural fingerprint of a
Select operation.A class representing a read-only clause in a transaction context.
Registration context for associating a Data Transfer Object (DTO) class with database-related functionality
and specifications.
Terminal context for registering the mapping between a data transfer object (DTO)
class and its corresponding database table within the ORM framework.
The RegistrationEngine class handles the registration of data transfer objects (DTOs) and their
corresponding table specifications to enable mapping between application entities and database tables.
Defines how related DTOs should be handled when not included as a JOIN in a query.
Represents an entity that can be resolved into an
ExpressionSpec.Marker interface for the result of a query or database operation.
A row of data returned by a query.
A row of values corresponding to a SQL database operation.
SQL SELECT query structure.
Litebridge ORM select API.
Expression to select a database column.
Expression that selects a database column.
Provides methods for constructing SQL SELECT statements in a fluent, object-oriented manner.
A select expression in a SQL query.
Expression spec that selects a DTO field.
Represents a SELECT clause in the query AST.
Reference to another expression in the select query.
Factory to create references to selected columns.
Implementation of
SelectReference.Base specification for constructing a SQL SELECT statement.
The SelectSpecDtoMapper class is responsible for mapping data from rows of a database query to DTO (Data Transfer Object) instances.
SQL generator for SELECT statements.
Interface for executing and retrieving results from a select query.
Abstract base class for generating SQL fragments to retrieve the next value from a database sequence
to be used in SQL statements such as INSERT or UPDATE.
Represents a SET clause in an UPDATE statement in the query AST.
A converter for
Short values.Extends
Converter to add SQL-specific metadata.A converter for
Date values.SQL function registry.
Aggregate functions perform calculations on a set of values and return a single value.
Date functions.
Scalar functions perform calculations on one or more input values and return a single value.
Expressions dealing with selecting columns, sub-selects, literals, and references to selected columns.
Factory for creating
SqlFunctionRegistry instances.SQLite Database Provider for Litebridge.
Specification for a JOIN operation in a database query.
A utility class for parsing SQL statements containing named parameters and converting them
into SQL statements with positional placeholders.
Utility class for working with SQL reserved words.
Specification for constructing a SQL SELECT statement.
A converter for
Time values.A converter for
Timestamp values.Interface for building SQL execution/update statements.
A converter for
String values.Metamodel field for querying string-based columns in a type-safe manner.
String type-overriding nestable expression.
Utility class for working with strings.
A subselect expression.
A query expression that represents a subselect.
Factory to create expressions encapsulation a sub-select.
SUBSTRING(column, start, length) scalar function.SUBSTRING(): Returns a substring of a column's text.A database table with an associated catalog, schema, name, and optional alias.
Annotation that designates a class as corresponding to a database table (i.e. an entity).
A utility class responsible for mapping DTOs to database tables and managing
the relationships between them.
A database table and its corresponding relationships mapped within the ORM (Object-Relational Mapping) layer.
Represents the mapping between a Data Transfer Object (DTO) class and a database table,
along with a method lookup used for runtime operations.
Metadata for a database table, including its primary keys and expressions.
The TableRegistry class is a centralized registry responsible for managing the relationship
between Data Transfer Object (DTO) classes and their corresponding ORM table representations
(
OrmTable).Specification of a database table, used to map DTO instances to target tables.
Wrapper that tracks changes made to an external DTO.
Represents a transactional context that allows controlled execution of
operations within a transaction.
A decorator class that wraps a
DatabaseProvider to provide transactional support using
a TransactionManager.Represents a transactional context that provides methods for configuring
and managing transactions.
Represents the terminal stage of a transactional context, providing core methods for configuring
and managing transactions.
Provides control over the transaction lifecycle, including committing and rolling back transactions.
Exception type representing errors that occur during transactional operations.
Defines a contract for managing transactions within an application.
A factory interface for creating instances of
TransactionManager.The
TypeConverter interface defines a mechanism for converting objects
between different types, commonly used for database data type conversions and
domain-specific representations.Indicates that a query result should be converted to a different type.
A query expression that overrides the type of the result.
A SQL UPDATE statement targeting a specific table, with associated column values and conditions.
Update operation metadata.
Represents an UPDATE statement in the query AST.
Result of an update operation performed on the database.
Base specification for constructing a SQL UPDATE statement.
SQL generator for UPDATE statements.
Common marker interface for database update operations.
UPPER(column) scalar function.Implementation of
AliasTransformer that converts database alias strings to uppercase.UPPER(): Returns the uppercase value of a column.A Map implementation that uses weak references for keys and compares keys using identity comparison (==).
A Set implementation that uses identity comparison for object equality,
and holds its elements weakly, meaning elements are eligible for garbage
collection if no strong references to them exist outside this set.
Terminal clause for constructing SQL WHERE conditions, allowing transitions
to GROUP BY or ORDER BY stages in a fluent and type-safe query-building process.
Represents a WHERE condition clause in a query, allowing the composition of conditional
expressions for filtering data in a fluent and type-safe manner.
Terminal interface for a WHERE condition clause in SQL query construction.
Represents a WHERE clause condition in the query AST.