All Classes and Interfaces
Class
Description
An
ArgumentFactory base class for arguments of type T.Base module class for element configuration modules.
Base module class to define
Jdbi instances.Suppresses error when bindings are created but never used in the query.
Signifies that a public API (public class, method or field) is subject to incompatible changes,
or even removal, in a future release.
Locates SQL on the SQL method annotations like
@SqlQuery("foo").Represents an argument to a prepared statement.
Inspect a value with optional static type information and produce
an
Argument that binds the value to a prepared statement.ArgumentFactory extension interface that allows preparing arguments for efficient batch binding.
A registry for ArgumentFactory instances.
Represents a group of non-prepared statements to be sent to the RDMBS in one "request".
Used to control the batch chunk size for sql batch operations.
A row mapper which maps the columns in a statement into a JavaBean.
Signifies that a public API (public class, method or field) is subject to incompatible changes,
or even removal, in a future release.
Binds the annotated argument as a named parameter, and as a positional parameter.
Binds the properties of a JavaBean to a SQL statement.
Binds each property for each value in the annotated
Iterable or array/varargs argument,
and defines a named attribute as a comma-separated list of each bound parameter name.Binds the properties and public fields of an object to a SQL statement.
Represents the arguments bound to a particular statement.
Bind a class based on the subset of
JPA annotations we understand.Binds each value in the annotated
Iterable or array/varargs argument, and defines a named attribute as a
comma-separated list of each bound parameter name.describes what needs to be done if the passed argument is null or empty
Binds the entries of a
Map<String, Object> to a SQL statement.Binds each method for each value in the annotated
Iterable or array/varargs argument,
and defines a named attribute as a comma-separated list of each bound method name.Standard implementation of
ParameterCustomizerFactory that delegates to
BindFactory.createForParameter(Annotation, Class, Method, Parameter, int, Type) passing null for Annotation parameter.Binds the properties of an object to a SQL statement.
Used for invoking stored procedures.
Map an
OUT parameter in a callable statement to a result type.Matches column names with identical java names, ignoring case.
Strategies for comparing case sensitive strings.
Bind a
Reader as a character stream parameter.Locates SQL in
.sql files on the classpath.Cleans up some JDBC resource e.g.
Thrown when an exception occurs while attempting to close a database resource.
Handler designed to behave properly in a J2EE CMT environment.
A Codec provides a convenient way for a bidirectional mapping of an attribute to a database column.
CodecFactory provides column mappers and arguments for bidirectional mapping types to database columns.
Fluent Builder for
CodecFactory.Factory for building Collectors to assemble containers of elements.
SQL parser which recognizes named parameter tokens of the form
:tokenNameMaps result set columns to objects.
Factory interface used to produce column mappers.
Configuration registry for
ColumnMapperFactory instances.Specify the mapping name for a property or parameter explicitly.
Strategy for matching SQL column names to Java property, field, or parameter names.
A registry of
JdbiConfig instances by type.A type with access to access and modify arbitrary Jdbi configuration.
Configures
ConfigRegistry instances to satisfy the contract of a
ConfiguringAnnotation-annotated annotation.Annotation used to modify configuration in the context of a SQL object or method.
Supplies
Connection instances to a created Handle and allows
custom close handling.A row mapper which maps the fields in a result set into a constructor.
Use this annotation on a sql object method to create a new sql object with the same underlying handle as the sql
object the method is invoked on.
Bind a
DateTime as a Timestamp.Map a
Timestamp to a DateTime.Determines the order in which SQL method decorators are invoked.
A StatementBuilder which will always create a new PreparedStatement.
Defines a named attribute as the argument passed to the annotated parameter.
Template engine which replaces angle-bracketed tokens like
<name> with the string value of the named attribute.Defines all bound arguments that don't already have a definition.
Simple delegating subclass that just invokes its delegate.
Postgres version of argument factory for
Duration.A column mapper which maps Postgres's
PGInterval type to Java's Duration.Thrown when Jdbi tries to build a Collector, but cannot determine the element
type intended for it.
describes what should be done if the value passed to
SqlStatement.bindList(java.lang.String, java.lang.Object...) is null or emptyType qualifying annotation for pre-encoded
json data.Thrown when a JPA getter or setter fails.
Specifies that an
Enum value should be bound or mapped as its Enum.name().Specifies that an
Enum value should be bound or mapped as its Enum.ordinal().Column mapper for Java
enum types.Configuration for behavior related to
Enums.Factory interface used to produce Jdbi extension objects.
Configuration class for defining
Jdbi extensions via ExtensionFactory
instances.Specify batch size to fetch resulting rows in.
A row mapper which maps the columns in a statement into an object, using reflection
to set fields on the object.
Rewrites a Freemarker template, using the attributes on the
StatementContext as template parameters.Locates SQL in
.sql.ftl Freemarker files on the classpath.Decorate a SqlObject type to instruct the
jdbi3-generator annotation processor
to create a compiled implementation.Factory for a RowMapper that can map resultset rows to column name/generic value
Maps.Utilities for working with generic types.
Factory that uses
ResultSet.getObject(int, Class) to fetch values.Provide ArgumentFactory instances that understand Guava types.
Provides Collectors for Guava collection types.
Plugin to enable all
Guava functionality.Allows specific customizations of the
Jdbi instance during creation.Configure vendor supported types for the H2 Java database implementation
This represents a connection to the database system.
Callback that accepts a Handle that remains open for the duration
of the callback invocation.
Callback that accepts a
Handle and returns no result.Implements the contract of a SQL Object method.
Decorates Handler objects with additional behavior.
Registry for
handler decorators.Creates Handler objects for methods annotated with a specific SQL method annotation, which satisfy the contract of
that annotation.
Registry for
handler factories, which produce handlers for SQL object methods.Configuration class for handles.
A handle supplier for extension implementors.
SQL parser which recognizes named parameter tokens of the form
#tokenName.Type qualifying annotation for
HSTORE data type.An argument factory which binds Java's
Map to Postgres' hstore type.A column mapper which maps Postgres' hstore type to Java's
Map.Postgres version of argument factory for
InetAddress.Bind an input stream as either an ASCII (discouraged) or binary stream.
Customizer contributing all customizations from a module to a Jdbi instance.
JDBI Factory creates a new
Jdbi instance.Import binding builder.
Exposes binders for all aspects of JDBI objects.
Binding builder for loose bindings (with optional default).
Implements Iterator methods for unidentified arrays and Iterable things that do not
have a more specific type than Object.
Configuration class for Jackson 2 integration.
Jackson 2 integration plugin.
Provide mappers corresponding to java time types.
Main entry point; configurable wrapper around a JDBC
DataSource.Describes all operations to bind Jdbi elements in Guice.
Simple cache interface.
Hold metadata caches which maps various JVM constants into pre-parsed forms.
Registry of collector factories.
Interface for classes that hold configuration.
Indicate to
ConstructorMapper and other reflective mappers
how to construct an instance.Utilities for
JdbiConstructor annotation.Base unchecked exception for exceptions thrown from jdbi.
Common functionality for all JUnit 5 extensions.
Initialize the data source before running a test.
Use
Flyway to create a database schema and/or preload a database instance.Configures support for an FreeBuilder generated
Builder) value type.Annotation for the default element configuration modules.
Jdbi H2 JUnit 5 rule.
An instance of an interception chain.
An interception chain holder to manage transformation operations.
Generic interface to allow transformation operation interception.
Jdbi PostgreSQL JUnit 5 rule using the otj-pg-embedded component.
A plugin is given an opportunity to customize instances of various
Jdbi
types before they are returned from their factories.Abstract base class for single-install JdbiPlugins.
Jdbi PostgreSQL JUnit 5 rule using the pg-embedded component.
JUnit
@Rule to manage a Jdbi instance pointed to a managed database.Jdbi SQLite JUnit 5 rule.
Register date and time providers to integrate with
joda-time.Holder for a single joined row.
A
RowMapper implementation to easily compose existing
RowMappers.Row mapper for a JPA-annotated type as a result.
Enable minimal
JPA compatibility layer.Type qualifying annotation for converting Java types to
json data type.converts a value object to json text and delegates to another factory to perform the
(@Json) String bindingconverts a
(@Json) String fetched by another mapper into a value objectDeserializes JSON to Java objects, and serializes Java objects to JSON.
Configures the column to use for map keys, for SQL methods that return
Map, or Guava's Multimap.A row reducer that uses
LinkedHashMap (which preserves insertion order) as a
result container, and returns map.values().stream() as the final result.This
TransactionHandler uses local JDBC transactions
demarcated explicitly on the handle and passed through to be handled
directly on the JDBC Connection instance.Type qualifying annotation for
MACADDR data type.Maps rows to
Map.Entry<K, V>, provided there are mappers registered for types K and V.Configuration class for MapEntryMapper.
Yo dawg, I heard you like maps, so I made you a mapper that maps rows into
Map<String,Object>.Configuration class for obtaining row or column mappers.
Thrown when a mapper fails to map the row to a result type.
Used to specify a polymorphic return type as a parameter on a query method.
Used to specify the maximum number of rows to return on a result set.
Access to Database Metadata.
Represents a Flyway migration Jdbi should run.
Returns an Argument based on a name.
Signals that the annotated element is a nested mapped type.
Thrown when no results were found in a context that requires at least one.
Thrown when Jdbi tries to produce a result Collector
but doesn't have a factory to produce it with.
Thrown when an extension of an unknown type is created.
Thrown when you attempt to map a type that
Jdbi doesn't have a
registered mapper factory for.A typed SQL null argument.
Argument qualifier annotation, indicating that the annotated String element should be bound as an
NVARCHAR instead of a VARCHAR.An Argument which uses
setObject to support
vendor specific types.Argument factory that matches a specified type and binds
it as an
ObjectArgument.Base
NamedArgumentFinder implementation that can be used when binding properties of an object, with an
optional prefix.Factory methods for
collectors of optional types.Declare a named out parameter on an
@SqlCall annotated method.Represents output from a Call (CallableStatement).
The parsed parameters from an SQL statement.
The SQL and parameters parsed from an SQL statement.
Fluent builder for ParsedSql instances.
Postgres version of argument factory for
Period.A column mapper which maps Postgres's
PGInterval type to Java's Period.This class is the future home of BeanMapper functionality.
Row mapper that inspects an
immutables-style Immutable or Modifiable value class for properties
and binds them in the style of BeanMapper.Introspector-like interface that works with arbitrary pojos, not just beans.This class hosts the logic from BeanPropertyArguments.
Postgres plugin.
Handler for PostgreSQL custom types.
Represents a prepared batch statement.
Signals that the annotated property signals the presence of the mapped type:
reflective mappers should map a null bean if this property is null, rather than a
present bean with a null property value.
Inspect a value with optional static qualified type information and produce an
Argument
that binds the value to a prepared statement.QualifiedArgumentFactory extension interface that allows preparing arguments for efficient batch binding.
Factory interface used to produce column mappers.
A
Type qualified by a set of qualifier annotations.Annotation used to identify type qualifying annotations.
Utility class for type qualifiers supported by Jdbi core.
Statement providing convenience result handling for SQL queries.
Specify the query timeout in seconds.
Configuration class for reflective mappers.
Utilities for reflective mappers.
Used to register an argument factory with either a sql object type or for a specific method.
Registers a BeanMapper for a specific bean class
Used to register a collector factory on the current
SqlStatement either for a sql object type
or for a method.Registers a column mapper in the scope of a SQL Object type or method.
Registers a column mapper factory in the scope of a SQL Object type or method.
Registers a constructor mapper factory for the given type(s).
Register types to reflectively assign fields with
FieldMapper.Used to register a
JoinRowMapper factory.Registers an argument factory for a type compatible with
PreparedStatement.setObject(int, Object).Register a row mapper in the context of a SQL Object type or method.
Registers a row mapper factory in the scope of a SQL Object type or method.
Provides access to the contents of a
ResultSet by mapping to Java types.Represents a forward-only iterator over a result set, which will lazily iterate
the results.
Produces a result from an executed
PreparedStatement.Commonly used ResultProducer implementations.
A
ResultSetAccumulator repeatedly combines rows
from the given ResultSet to produce a single
result.Wraps exceptions thrown while traversing the JDBC result set.
Scan over rows of result sets, mapping and collecting the rows to a result type.
A transaction handler that always calls
DelegatingTransactionHandler.rollback(org.jdbi.v3.core.Handle) instead
of RollbackOnlyTransactionHandler.commit(org.jdbi.v3.core.Handle).Maps result set rows to objects.
Factory interface used to produce row mappers.
Configuration registry for
RowMapperFactory instances.Reduces row data from a
ResultSet into a stream of result
elements.A RowView is an accessor for
ResultSet that uses
RowMapper or ColumnMapper to extract values.Represents a number of SQL statements which will be executed in a batch statement.
A TransactionHandler that automatically retries transactions that fail due to
serialization failures, which can generally be resolved by automatically
retrying the transaction.
Configuration for serializable transaction runner.
Factory that uses
PreparedStatement.setObject(int, Object, int) to bind values.Adapts a
ColumnMapper into a RowMapper by mapping a single column.Indicate to SqlObject that a type that looks like a container
should be treated as a single element.
Simple
SqlLogger that emits some diagnostic information about
Jdbi usage.Matches snake case column names to java camel case names, ignoring case.
Bind a Java array or
Collection to a SQL array using the
SqlArrayTypeFactory for the given type information.Strategies used to bind SQL array arguments to a
PreparedStatement.Maps SQL array columns into Java arrays or other Java container types.
Strategy for converting elements of array-like arguments into SQL array elements.
Factory interface to produce
SqlArrayType instances.Configuration class for SQL array binding and mapping.
Annotate a method to indicate that it will create and execute a SQL batch.
Support for stored proc invocation.
Jdbi plugin for SQLite.
Locates SQL for jdbi SQL Object methods.
SqlLoggers receive query data before and after a query is executed, and after an exception is thrown by a bad query.
Annotation used to identify SQL method decorating annotations.
SqlObject base interface.
Locates SQL in
.sql files on the classpath for use with SqlQuery.Creates implementations for SqlObject interfaces.
Plugin that installs the SqlObject extension.
Configuration class for SQL objects.
Annotation used to identify SQL operation annotations.
Parses the named parameters out of an SQL statement, and returns the
ParsedSql containing the JDBC-ready SQL statement, along with the
type of parameters used (named or positional), the number, and the parameter
name for each position (if applicable).Used to indicate that a method should execute a query.
Annotate a method to indicate that it will execute one or more SQL statements.
An SQL script parser.
Holder for repeating
SqlScripts.This class provides the common functions between
Query and
Update.Used with
SqlStatementCustomizerFactory to
customize sql statements via annotations.Interface used in conjunction with
SqlStatementCustomizingAnnotation to generate
SqlStatementCustomizer instances.Annotation used to build customizing annotations.
Customize a
SqlStatement according to the value of an annotated parameter.Configuration holder for
SqlStatements.Used to indicate that a method should execute a non-query sql statement.
Used to convert translated SQL into a prepared statement.
Used to specify how prepared statements are built.
The statement context provides access to statement-local configuration.
Allows tweaking of statement behaviour.
Some simple
StatementCustomizers you might find handy.Superclass for exceptions thrown while trying to execute a statement.
Configuration for
StatementException and subclasses behavior.Control exception message generation.
Callback for use with
ResultIterable.withStream(StreamCallback)Callback for use with
ResultIterable.useStream(StreamConsumer)Register an instance of this class (
SqlStatements.setTemplateEngine(org.jdbi.v3.core.statement.TemplateEngine)) to use an Apache Commons Text StringSubstitutor as a TemplateEngine.Rewrites a StringTemplate template, using the attributes on the
StatementContext as template parameters.Locates SQL in
.sql.stg StringTemplate group files on the classpath.Renders an SQL statement from a template.
This class is used in the various Jdbi unit tests.
Binds the named parameter
:now or a custom named parameter with
the current DateTime as an OffsetDateTime.Configuration for
Timestamped.Causes the annotated method to be run in a transaction.
A mixin interface to expose transaction methods on the sql object.
Callback that expects an open transaction and produces a result.
Callback that expects an open transaction and returns no results.
Thrown when there's a problem manipulating the transaction isolation level.
Interface which defines callbacks to be used when transaction methods are called on a handle.
Supported transaction isolation levels.
Mappers similar to
MapEntryMappers but map entries in vavr are in fact
of type Tuple2.Default
jdbi behavior is to bind Enum subclasses as
a string, which Postgres won't implicitly convert to an enum type.A container to combine a value with a specific type.
An extended
CodecFactory which can resolve Codecs for subtypes.Thrown when constructing a SqlObject fails.
Thrown when
Jdbi couldn't create a statement.Thrown when statement execution fails.
Thrown when
Jdbi isn't able to change the transaction isolation level.Wraps exceptions thrown while producing Java result types.
Thrown after a transaction finishes if we can't reset its isolation level.
Thrown when
Jdbi couldn't retrieve metadata from the connection.Configure reflective bean and pojo mapping to skip a property.
Used for INSERT, UPDATE, and DELETE statements
Configures SQL Object to use AnnotationSqlLocator (the default SqlLocator).
Configures SQL Object to locate SQL using the
ClasspathSqlLocator.findSqlOnClasspath(Class, String) method.Use the specified
EnumStrategy for binding and mapping enum
values.Configures a SQL object class or method to rewrite SQL statements using Freemarker.
Configures SQL Object to locate SQL using the
FreemarkerSqlLocator class.Used to specify specific row mapper on a query method.
Used to specify a row reducer on a result-bearing method.
Use the specified
SqlParser class to parse SQL for the annotated SQL object class or method.Configures a SQL object class or method to rewrite SQL statements using StringTemplate.
Configures SQL Object to locate SQL using the
StringTemplateSqlLocator.findStringTemplate(Class, String)
method.Use the specified
TemplateEngine class to render SQL for the
annotated SQL object class or method.Bind UUID arguments as an Object.
Configures the column to use for map values, for SQL methods that return
Map, or Guava's Multimap.JDBI-Plugin for vavr.io library
supports single-value arguments (
Option, ...)
supports vavr collections via ResultBearing.collectInto(java.lang.reflect.Type) call
supports key-value mappings of a tuple result (implicitly used by map collectors)
supports tuple projection
supports column mapping for Option