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 column-specific SQL expressions.
 
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.
 
Abstract base class for FROM clause terminals.
Abstract base class for GROUP BY clause terminals.
Abstract base class for HAVING clause terminals.
Provides common functionality for creating update metadata.
Abstract base class for JOIN clauses.
Abstract base class for JOIN clause terminals.
Abstract base class for JOIN condition clause terminals.
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.
 
Abstract base class for WHERE clause terminals.
 
 
 
 
 
 
Interface for generating aliases for tables and columns.
 
Factory to create references to selected columns.
 
 
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.
Result of a batch update operation performed on the database.
A converter for BigDecimal values.
A converter for BigInteger values.
A binding value and its associated SQL data type.
A bind value in a query expression.
Factory to create bind value expressions.
An encapsulated literal value in a query expression.
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.
Implementation of a condition clause for SQL-based queries.
Implementation of a terminal condition clause for SQL-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.
Maps a Java field or property to a database column.
A column-based expression within a SQL query.
Factory to create expressions targeting a specific column.
Query expression encapsulating a target column.
Represents a base type for various kinds of database column mappings.
Metadata information for a database column.
Reference to an unaliased column in the select query.
Specification of a database column, used to map DTO fields to target expressions.
 
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 thread-safe, lazily initialized value holder for values of type R that require an input of type T to compute 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.
Common implementation class for condition clauses providing relational and comparison operators.
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 JOIN USING condition in the query AST.
Represents a condition within a JOIN, WHERE or HAVING clause in the query AST.
An AST node representing a condition.
Specification for a condition in a database query.
Query condition node for selecting a record by its primary key.
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.
 
An abstract stack used to manage a hierarchical context structure.
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 date function.
CURRENT_TIMESTAMP(): Returns the current date/time from the database.
Information about the connected database and its JDBC driver.
Database metadata component.
Main interface for interacting with a database.
 
Information about the capabilities of the database provider.
Insert operation capability.
Merge operation capability.
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 sequence-based column value generator.
 
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.
Interface for nesting query expressions such as SQL functions.
Factory to create nestable column expressions.
A query expression that can nest another query expression.
Abstract terminal implementation delegating select execution methods to SelectEngineTerminal.
Logical representation of a SQL DELETE statement.
A builder class for constructing SQL DELETE statements.
Engine for processing DELETE statements.
Represents a DELETE statement in the query AST.
Generator for SQL DELETE statements.
Entry step for constructing a DELETE statement.
Represents the final stage of a delete query that can be executed.
Utility inspector for extracting the AST QueryNode from a DeleteTerminal.
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.
 
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.
DTO-mode entry step for constructing a DELETE statement.
Represents a WHERE condition clause for DTO delete operations.
Terminal clause for DTO delete WHERE conditions.
Implementation of DtoDeleteWhereConditionClauseTerminal 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.
DTO-mode insert step for specifying columns to insert into.
Provides metadata about the state of an entity/mapped DTO.
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.
Maps data from rows of a database query to DTO (Data Transfer Object) instances.
 
DTO-mode merge step for setting up WHEN NOT MATCHED INSERT clause.
 
DTO-mode merge step for setting up the MERGE INTO ... USING ... ON condition.
DTO-mode step for specifying the action to take in a WHEN MATCHED clause.
Step to specify the DTO/entity class to use for a USING clause in a MERGE statement.
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.
Functional interface for building DTO-mode query conditions.
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.
Represents the result of an update operation on a Data Transfer Object (DTO).
DTO-mode step for specifying the value of a column or expression in a SET clause.
DTO-mode entry step for constructing an UPDATE statement.
DTO-mode step for specifying SET assignments or WHERE conditions in an UPDATE statement.
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.
A builder that assists with programmatically constructe WHERE clauses.
Mapper for converting between complex Data Transfer Objects (DTOs) and their corresponding "entity" objects.
 
 
 
 
Marker interface for select query expressions.
Array of expression specifications.
 
 
Configures a single column mapping in a multi-column field-to-column mapping step.
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.
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.
H2 database provider for Litebridge.
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.
Logical representation of a SQL INSERT statement.
Represents a VALUES clause of an INSERT STATEMENT in the query AST, specifically for extracting and inserting values from a DTO instance.
Engine for processing INSERT statements.
Base class for INSERT INTO steps in the fluent insert API.
Represents an INSERT statement in the query AST.
The result of an insert operation performed on the database.
SQL generator for INSERT statements.
Represents a VALUES clause of an INSERT STATEMENT in the query AST.
Insert step for specifying the values to insert into a row.
Utility class for extracting the terminal AST query nodes of InsertValuesStep instances.
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.
 
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.
Implementation of LimitClauseTerminal for LIMIT and OFFSET clauses.
Represents a LIMIT clause in the query AST.
Default primary entry point for Litebridge.
A builder class for constructing Litebridge instances.
Constructor arguments for a custom database provider-provided Litebridge instance.
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.
The operational mode of Litebridge.
Basic primary entry point for Litebridge.
A simple DataSource implementation that utilises DriverManager to create connections.
Inspector for LitebridgeCore instances, providing access to internal components.
Specialised database provider for a custom Litebridge implementation.
 
Factory to create literal value expressions.
An encapsulated literal value in a query expression.
 
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.
 
Specifies a many-to-many relationship between two entities.
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.
A mapped composite key, used for mapping multiple columns to a single field containing a related DTO.
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.
Thread-safe cache for storing compiled DTO DtoMapper.MappingPlan instances.
Cache key identifying a compiled mapping plan by target DTO class, context DTO class, and row structural hash.
Utility class for working with Map instances.
 
Predefined mathematical operators for use in SQL operations.
MAX(column) aggregate function.
MAX(): Returns the highest or largest value within a specified column or expression
Logical representation of a SQL MERGE statement.
Logical representation of a DELETE in a merge WHEN MATCHED clause.
Logical representation of an INSERT in a merge WHEN NOT MATCHED clause.
Logical representation of an UPDATE in a merge WHEN MATCHED clause.
Logical representation of a merge WHEN MATCHED/WHEN NOT MATCHED clause.
Marker interface for merge WHEN MATCHED update operations.
Represents a condition clause in a MERGE statement.
Engine for processing MERGE INTO statements.
Step to specify the columns to insert into for a WHEN NOT MATCHED INSERT clause.
Represents a MERGE INTO statement in the query AST.
Terminal step for a MERGE ON condition clause.
Merge step for setting up the MERGE INTO ... USING ... ON condition.
SQL generator for MERGE statements.
Terminal step for a MERGE statement.
Utility inspector for extracting the AST QueryNode from a MergeTerminal.
Abstract base for steps specifying the action to take in a WHEN MATCHED clause.
Abstract base step for specifying the source in a MERGE statement.
Merge step for setting up WHEN MATCHED and/or WHEN NOT MATCHED clauses.
Merge step for setting up WHEN NOT MATCHED clauses.
 
MIN(column) aggregate function.
MIN(): Returns the lowest or smallest value within a specified column or expression
Utility class for Java Module System (JPMS) related operations.
Specification of multiple database columns, used to map a single complex field to multiple database columns.
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.
Specifies a one-to-many relationship between two entities.
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.
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.
Implementation of OrderByClauseTerminal for ORDER BY terminal clauses.
Represents an ORDER BY clause in the query AST.
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.
A database operation with bind 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.
 
An expression that alters the query in some way.
Extracts bind values from a query node abstract syntax tree.
Compiler for AST query nodes.
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.
Cached operation representing compiled SQL, bind value types, and conversion metadata.
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 a result of an update operation performed on the database.
A row of data returned from a database query.
A column within a row of a database query result.
 
Logical representation of a SQL SELECT statement.
Litebridge ORM select API.
Implementation of SelectApi providing entry points for SELECT queries.
Expression to select a database column.
Expression that selects a database column.
Initiates the fluent API for creating SELECT statements.
Executes SQL SELECT statements.
A select expression in a SQL query.
Maps high-level ExpressionSpec query expressions to dialect-specific SelectExpression instances.
Represents a SELECT clause in the query AST.
Factory to create references to selected columns.
SQL generator for SELECT statements.
 
 
 
Interface for executing and retrieving results from a select query.
Utility class for inspecting SelectTerminal instances.
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.
Start of a SQL-based condition clause.
Extends Converter to add SQL-specific metadata.
A converter for Date values.
SQL-mode entry step for constructing a DELETE statement.
SQL-mode WHERE condition clause for delete operations.
Terminal clause for SQL delete WHERE conditions.
Implementation of SqlDeleteWhereConditionClauseTerminal for SQL delete operations.
SQL-mode terminal clause for FROM clauses.
 
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.
Contract for SQL generators used by AbstractDatabaseProvider implementations.
SQL-mode terminal clause for GROUP BY clauses.
Represents a HAVING condition clause for SQL queries.
Terminal clause for SQL HAVING conditions.
SQL-mode insert step for specifying columns to insert into.
Represents a JOIN clause in a SQL-based query.
Terminal interface for SQL JOIN operations.
Represents a condition within a JOIN clause in a SQL-based query.
Represents the terminal part of a JOIN condition clause in a SQL-based query.
 
 
SQL-mode step for specifying the action to take in a WHEN MATCHED clause.
Step to specify the table to use for a USING clause in a MERGE statement.
Represents an ORDER BY clause in a SQL-based query.
Represents a chain of ORDER BY clauses in a SQL-based query.
A utility class for parsing SQL statements containing named parameters and converting them into SQL statements with positional placeholders.
Resolves proto-expressions into SQL-based select expressions.
Functional interface for building SQL-mode query conditions.
Utility class for working with SQL reserved words.
A converter for Time values.
A converter for Timestamp values.
SQL-mode step for specifying the value of a column or expression in a SET clause.
SQL-mode entry step for constructing an UPDATE statement.
SQL-mode step for specifying SET assignments or WHERE conditions in an UPDATE statement.
SQL-mode WHERE condition clause for update operations.
The terminal interface for SQL update where condition clauses.
Implementation of SqlUpdateWhereConditionClauseTerminal for SQL update operations.
SQL-mode where condition clause.
SQL-mode where condition clause terminal.
Interface for building SQL execution/update statements.
Manages dependencies and dependents between piped database statements for related entities.
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.
Maps a Java class to a database table.
 
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.
Caches table metadata retrieved from the database provider.
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.
Utility class for converting and formatting date and time objects.
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.
Represents a function that accepts three arguments and produces a result.
 
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.
Logical representation of a SQL UPDATE statement.
 
Engine for processing UPDATE statements.
Update operation metadata.
Represents an UPDATE statement in the query AST.
Marker interface for the result of an update operation performed on the database.
Marker interface representing an update query specification or step.
Utility for extracting the underlying QueryNode from an UpdateQuery.
Result of an update operation performed on the database.
Base step for specifying the value of a column or expression in a SET clause.
SQL generator for UPDATE statements.
Entry step for constructing an UPDATE statement.
Common marker interface for database update operations.
Step in an UPDATE statement allowing additional SET assignments or transitioning to a WHERE clause.
Abstract base class for update and delete fluent API steps.
Condition clause interface for specifying conditions in an update statement WHERE clause.
Terminal interface for update WHERE condition clauses.
UPPER(column) scalar function.
UPPER(): Returns the uppercase value of a column.
Represents a USING clause in a MERGE statement in the query AST.
 
 
Virtual table
Metadata for a database table, including its primary keys and expressions.
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.
Represents a WHEN MATCHED clause in a MERGE statement in the query AST.
Represents a WHEN NOT MATCHED clause in a MERGE statement in the query AST.
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.
A converter for ZonedDateTime values.