All Classes and Interfaces
Class
Description
ABS(column) scalar function.ABS(): Absolute value of a number.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.An abstract base class for
Converter implementations that primarily convert values by parsing their string representation.A name and an optional alias.
A column expression with support for SQL aliasing.
A nestable column expression with support for SQL aliasing.
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.
A converter for
Boolean values.Utility class for boolean operations.
A converter for
byte[] values.A converter for
Byte values.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.
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.
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.
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.
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.
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.
Direct field access
FieldAccessor implementation using Java 9's VarHandle.A converter for
Double values.The DtoCache interface defines methods for caching Data Transfer Objects (DTOs).
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.Mapper for converting between complex Data Transfer Objects (DTOs) and their corresponding "entity" objects.
Automated discovery of entity mappings used by Litebridge.
A query expression modifier that changes the result of the query.
Marker interface for select query expressions.
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.
Starting point for constructing a SQL query by specifying the source table and schema.
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.Represents the terminal
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 SQL INSERT statement targeting specific table metadata with associated columns and rows of values.
The result of an insert operation performed on the database.
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.
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.
Specification for limiting and offsetting the results of a database query.
Primary entry point for Litebridge.
Litebridge Spring Boot autoconfiguration
Runtime configuration class for managing the behaviour of Litebridge, particularly
the handling strategy for related DTO (Data Transfer Object) fields
in queries.
Provides a mechanism for configuring an instance of Litebridge.
A simple
DataSource implementation that utilises DriverManager to create connections.Spring Boot configuration properties for Litebridge.
Database provider configuration properties.
Spring-compatible
PlatformTransactionManager for Litebridge.An encapsulated literal value in a query expression.
Factory to create literal value expressions.
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.
Represents a mathematical operation to be performed on a column in a SQL context.
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 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.
A no-operation implementation of the
DtoCache 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 Database Provider for Litebridge.
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.
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.
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.PostgresqlDatabaseProvider is a concrete implementation of AbstractDatabaseProvider
specifically designed to interact with PostgreSQL database instances.
Implementation of
SequenceColumnValueGenerator for PostgreSQL databases.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.
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.
Basic metamodel field definition.
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.
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.
A select expression in a SQL query.
Expression spec that selects a DTO field.
Reference to another expression in the select query.
Factory to create references to selected columns.
Base specification for constructing a SQL SELECT statement.
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.
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.
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.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.
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).
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 tab, used to map DTO instances to 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.
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.
Result of an update operation performed on the database.
Base specification for constructing a SQL UPDATE statement.
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.