All Classes

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 :tokenName
Maps 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 a named attribute as a comma-separated String from the elements of the annotated array or List argument.
 
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 empty
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().
EnumMapper<E extends Enum<E>>
Column mapper for Java enum types.
 
Configuration for behavior related to Enums.
 
 
 
 
Factory interface used to produce Jdbi extension objects.
Holder for a Class and a Method that together define which extension method was invoked.
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.
Configures support for an FreeBuilder generated Builder) value type.
Annotation for the default element configuration modules.
Configures support for an Immutables generated Immutable or Modifiable value type.
 
 
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.
JUnit @Rule to manage a Jdbi instance pointed to a managed database.
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.
Create JpaMappers for Entity annotated classes.
 
Enable minimal JPA compatibility layer.
Type qualifying annotation for json data type.
converts a value object to json text and delegates to another factory to perform the (@Json) String binding
converts a (@Json) String fetched by another mapper into a value object
 
Deserializes 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.
An Iterable of values, usually mapped from a ResultSet.
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.
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.
 
Higher level cousin of RowMapper that operates over RowViews rather than the bare ResultSet.
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.
 
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.
StreamCallback<T,​R,​X extends Exception>
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.
 
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.
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.
 
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