All Classes and Interfaces
Class
Description
An abstract base class for identity generators in Bibernate, providing common functionality
which can be used for generating insert queries to database.
Represents an action queue for executing entity-related actions.
Enumerates different types of entity actions that can be performed, including INSERT, UPDATE, and DELETE.
The
Banner class provides functionality for printing a banner to the console,
either from a predefined string or custom banner by reading from a file.An enumeration of possible values for configuring the Banner.
Configuration class for loading properties from a configuration file.
Internal usage for repositories etc.
Configuration class for Bibernate database settings.
BibernateDataSource is an implementation of the DataSource interface that provides connections to a database.
Exception thrown to indicate an issue related to the data source in a Bibernate application.
BibernateDatasSourceConfig represents the configuration for BibernateDataSource.
Implementation of the EntityManagerFactory interface for creating EntityManager instances in the Bibernate framework.
BibernateFirstLevelCacheSession is an implementation of the BibernateSession interface
that introduces a first-level cache to improve the performance of entity retrieval operations.
The base exception class for handling general runtime exceptions within a Bibernate application.
Generic interface for a basic Bibernate repository providing common CRUD operations.
Implementation of the
BibernateSession interface that provides second-level caching functionality
for immutable entities fetched from the database.Interface representing a session with a Bibernate-based data store.
Exception thrown to indicate an attempt to perform an operation on a closed session
in a Bibernate application.
Represents a session factory in the Bibernate framework, responsible for creating sessions to interact with the database.
Exception thrown to indicate a validation failure in the Bibernate framework.
Utility class for creating new instances of classes using reflection.
Exception thrown when there is an issue creating a class limitation.
The 'CloseBibernateSession' class extends the BibernateSession and implements session management
by delegating calls to an underlying BibernateSession while maintaining the ability to close the session.
Implementation of
TypeFieldResolver for resolving custom injection values for collection fields of an entity class.Exception thrown when an operation or method expects a collection to contain elements,
but the provided collection is empty.
Utility class for common operations on collections.
Specifies the mapping of an entity attribute to a database column.
Represents metadata about a column in an entity, including its name, database type, uniqueness, nullability,
column definition, and other properties.
Represents a snapshot of a column in a data representation.
Exception thrown to indicate an issue related to the connection pool in a program.
Indicates that the annotated field should be automatically populated with the timestamp of entity creation.
Represents metadata for a creation timestamp in an entity, indicating that the associated field is automatically
populated with the timestamp of the entity's creation.
Interface representing a Data Access Object (DAO) for performing CRUD operations and querying on entities.
Configuration class responsible for processing DDL (Data Definition Language) properties
based on the provided BibernateDatabaseSettings.
The DDLFieldMetadataHolder class represents metadata for a field in a Data Definition Language (DDL) query.
The DDLProcessor class is responsible for processing Data Definition Language (DDL) queries
to create database schema elements.
The DDLQueryCreator class is responsible for creating Data Definition Language (DDL) queries
based on the metadata of entities in the Bibernate framework.
Utility class for generating foreign key constraint names and index names.
Default implementation of the
ActionQueue interface.Represents an entity action for bulk deletion of entities by their primary keys.
Represents an entity action for bulk deletion of entities of a specific class.
Represents an entity action for deleting entities by their primary key in the Bibernate framework.
Represents an entity action for deleting a collection of entities in the Bibernate framework.
Represents a SQL DELETE query builder for constructing DELETE statements with optional WHERE conditions.
Implementation of the DistributedSet interface using Redis as the distributed cache.
Interface representing a distributed set for caching entities.
Indicates that the annotated entity should use dynamic update behavior,
where only modified fields are included in the SQL update statement.
Exception thrown to indicate that a collection of entities could not be found in a program.
Represents an action to be performed on entities, defining methods for execution, obtaining the entity class,
retrieving entities involved in the action, and determining the action type.
Represents a mapping between a field name and its corresponding column name in an entity.
Represents metadata about an entity class, including details about its columns, indexes, and relationships.
Data Access Object (DAO) implementation for managing entities in Bibernate.
Implementation of
TypeFieldResolver for resolving custom injection values for entity fields of an entity class.Represents the key of an entity, consisting of the entity class, ID, and key type.
Interface representing a factory for creating EntityManager instances in the Bibernate framework.
Represents metadata for an entity, including table name, immutability, dynamic update,
entity type, index metadata and entity columns.
The EntityMetadataCollector class is responsible for collecting metadata for entities within a specified package.
Exception thrown to indicate that an entity could not be found in a program.
Provides functionality for mapping data from a ResultSet to an entity object.
Utility class providing reflection-based operations for entity classes.
Utility class for handling entity relationships in Bibernate.
Exception thrown to indicate that the state of an entity in a Bibernate application
was changed unexpectedly.
Exception thrown to indicate a failure in matching properties during
a comparison or matching operation in a program.
The FieldResolver interface defines methods for resolving fields during DDL query creation.
Configures and executes Flyway database migrations based on the provided BibernateDatabaseSettings.
Indicates that the annotated field represents a foreign key constraint in a database table.
Represents metadata for a generated value in an entity, indicating that the associated field's value is generated
automatically upon entity creation.
An interface for database generators in Bibernate application.
Represents information extracted from an HQL (Bibernate Query Language) query.
An interface for handling identity-related operations in Bibernate application.
Implementation of the identity-based ID generator in Bibernate.
Represents metadata for the primary key (ID) of an entity.
Indicates that the annotated entity is immutable, meaning its state cannot be changed after creation.
Exception thrown to indicate an attempt to modify an immutable entity
in a Bibernate application.
Indicates that the annotated entity should have an index created on specified columns.
Represents metadata for an index associated with an entity.
Represents an entity action for inserting a collection of entities in the Bibernate framework.
Represents an entity action for inserting entities in the Bibernate framework.
Represents a SQL INSERT query builder for constructing INSERT statements with specified fields and values.
A record representing a field to be used in an INSERT operation.
Represents a SQL JOIN clause with information about the joined table, the ON condition,
and the type of JOIN (INNER, LEFT, RIGHT, FULL).
Specifies a column for joining an entity association.
Represents metadata for a join column in a database table.
Represents information about a join operation in a Bibernate query.
Specifies a join table for defining a many-to-many association between two entities.
Represents metadata for a join table in a database.
Represents the types of SQL JOIN operations: INNER, LEFT, RIGHT, FULL.
Implementation of
TypeFieldResolver for resolving custom injection values for lazy-loaded entity fields.Annotation used to specify a many-to-many relationship between entities.
The ManyToManyFieldResolver class implements the FieldResolver interface to handle Many-to-Many relationships
defined in entity classes.
Represents metadata for a Many-to-Many relationship between entities.
Represents metadata for a Many-to-One relationship between entities.
Exception thrown to indicate an error or issue related to object mapping
in a program.
Utility class containing message constants for logging and exception handling in the Bibernate framework.
Nested utility class containing message constants for exception handling in the Bibernate framework.
Nested utility class containing message constants for logging in the Bibernate framework.
Represents metadata information for a method, including its name, return type, and parameters.
Exception thrown to indicate that an operation or functionality in a program expects
the presence of a specific annotation, but the required annotation is missing.
Exception thrown to indicate that a method in a Bibernate application is missing
required parameters.
Implementation of the insert generation without ID generation in Bibernate.
Exception thrown to indicate that a query or operation resulted in a non-unique result
in a runtime context.
The NoRelationFieldResolver class implements the FieldResolver interface to handle fields that are not part of any relationship mapping.
Exception thrown to indicate that no implementation is found for a custom repository
in a Bibernate application.
Represents metadata for a One-to-Many relationship between entities.
Implementation of
TypeFieldResolver for resolving custom injection values for one-to-one eager fetch
fields of an entity class.Represents metadata for a One-to-One relationship between entities.
The OperationOrder utility class defines constants representing the order of database operations for
Data Definition Language (DDL) queries.
Indicates that the annotated parameter is a named parameter for a method or constructor.
Represents a method parameter with its name and type.
The Persistent class provides methods for configuring and creating Bibernate entity managers, stateless sessions, and enabling Flyway migrations and Redis caching.
Represents a persistent list that lazily initializes its internal list using a supplier.
Implementation of the Identity interface for managing identity-related operations
in Bibernate application specific to PostgreSQL databases.
Utility class for parsing properties, including resolving environment variables.
ProxyConnection is a wrapper around a JDBC Connection that intercepts calls to create statements and provides
additional functionality such as managing statement lifecycles and releasing connections back to a connection pool.
Utility class providing methods to create proxies.
Indicates that the annotated method represents a query.
An abstract class representing a generic SQL query builder with common constants and methods
for constructing SQL statements such as SELECT, UPDATE, DELETE, etc.
Configuration class for setting up Redis connections and distributed caching.
Implementation of
TypeFieldResolver for resolving custom injection values for regular fields of an entity class.Represents details about a repository, including its name, primary key type, entity type,
implemented interfaces, and metadata for each repository method.
Exception thrown to indicate an issue related to repository method invocation in a Bibernate application.
Utility class for parsing repository method names and building corresponding SQL WHERE queries.
Custom implementation of
AnnotationParanamer to handle the @Param annotation.Represents the return type of a method, including the entity class and generic parameters if applicable.
Represents a SQL SELECT query builder for constructing SELECT statements with optional clauses
such as JOIN, WHERE, GROUP BY, HAVING, and UNION.
A configuration class for managing and providing sequences of IDs in a Bibernate application.
Represents metadata for a sequence generator used in entity mapping.
Implementation of the sequence-based ID generator in Bibernate.
Utility class for serializing and deserializing objects using Kryo serialization.
Factory class for handling dynamic proxy creation and method invocations on repository interfaces.
Handler for executing the "findById" method in a simple repository.
Handler for executing the "findOne" method in a simple repository.
InvocationHandler implementation for dynamically handling method invocations on repository interfaces.
Handler for executing custom methods in a custom repository implementation.
Handler for executing the deleteAll method in a simple repository.
Handler for executing the delete method in a simple repository.
Handler for executing the findAll method in a simple repository.
Handler for executing the findBy methods in a simple repository.
Interface for handling the execution of repository methods.
Implementation of
SimpleRepositoryMethodHandler for handling methods annotated with Query.Implementation of
SimpleRepositoryMethodHandler for handling methods annotated with Query.Implementation of
SimpleRepositoryMethodHandler for handling the "saveAll" method.Implementation of
SimpleRepositoryMethodHandler for handling the "save" method.Implementation of
SimpleRepositoryMethodHandler for handling the "update" method.Utility class for building SQL statements (SELECT, UPDATE, INSERT, DELETE) based on different scenarios.
The StatelessSession class represents a stateless session for executing database operations.
Indicates that the annotated class represents a database table.
Resolves fields representing one-to-one or many-to-one relationships in entity columns.
Enables the application to delineate units of work while abstracting away the specifics of the underlying
transaction implementation.
TransactionalDatasource extends BibernateDataSource and provides support for managing
transactions within the data source.The
TransactionHolder class is a utility for managing thread-local transactions.The
TransactionJdbcUtils class provides utility methods for handling JDBC resources in the context of transactions.Contains utility methods for converting Java types to database types and checking compatibility of types for DDL creation.
Interface for resolving custom injection values for fields of an entity class.
Factory class for creating type field resolvers based on the type of field encountered during custom injection.
Exception thrown to indicate that an unsupported or invalid action type has been encountered
in the Bibernate framework.
Exception thrown to indicate that an unsupported or invalid data type has been encountered.
Exception thrown to indicate that an unsupported or invalid return type has been encountered
in the Bibernate framework.
Represents an entity action for updating entities in the Bibernate framework.
Represents a SQL UPDATE query builder for constructing UPDATE statements with specified fields and conditions.
Represents an individual field to be updated with its corresponding value.
Indicates that the annotated field represents a timestamp that should be updated automatically upon entity modification.
Represents metadata for an update timestamp used in entity mapping.
Wrapper class that provides validation functionality for a Bibernate session.
Indicates that the annotated field represents a version attribute used for optimistic locking.