All Classes
Class
Description
An
ArgumentFactory
base class for arguments of type T
.Signifies that a public API (public class, method or field) is subject to incompatible changes,
or even removal, in a future release.
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".
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.
Represents the arguments bound to a particular 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.
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.
A StatementBuilder which will always create a new PreparedStatement.
Template engine which replaces angle-bracketed tokens like
<name>
with the string value of the named attribute.Simple delegating subclass that just invokes its delegate.
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 emptySpecifies 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
Enum
s.Factory interface used to produce Jdbi extension objects.
Configuration class for defining
Jdbi
extensions via ExtensionFactory
instances.A row mapper which maps the columns in a statement into an object, using reflection
to set fields on the object.
Factory for a RowMapper that can map resultset rows to column name/generic value
Map
s.Utilities for working with generic types.
Factory that uses
ResultSet.getObject(int, Class)
to fetch values.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.Configuration class for handles.
A handle supplier for extension implementors.
SQL parser which recognizes named parameter tokens of the form
#tokenName
.Bind an input stream as either an ASCII (discouraged) or binary stream.
Implements Iterator methods for unidentified arrays and Iterable things that do not
have a more specific type than Object.
Main entry point; configurable wrapper around a JDBC
DataSource
.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.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.
Holder for a single joined row.
A
RowMapper
implementation to easily compose existing
RowMappers.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.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.
Access to Database Metadata.
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.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.
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.
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.
Configuration class for reflective mappers.
Utilities for reflective mappers.
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.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.
SqlLoggers receive query data before and after a query is executed, and after an exception is thrown by a bad query.
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).An SQL script parser.
This class provides the common functions between
Query
and
Update
.Configuration holder for
SqlStatement
s.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
StatementCustomizer
s 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)
Renders an SQL statement from a template.
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.
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