All Classes

Class Summary
AccessPlan	An interface to make access to resources consistent, regardless of type.
AccessPlanFactory	Factory to get an accesss plan appropriate for an object
AutoResultMap	An automatic result map for simple stuff
BaseAccessPlan	Base implementation of the AccessPlan interface
BaseDataExchange	Base implementation for the DataExchange interface
BaseLogProxy	Base class for proxies to do logging
BaseProbe	Abstract class used to help development of Probe implementations
BaseTagHandler
BaseTransactionConfig
BaseTypeHandler	Base type handler for convenience
BatchException	This exception is thrown if a `java.sql.BatchUpdateException` is caught during the execution of any nested batch.
BatchResult	This class holds the statement and row information for every successful batch executed by iBATIS
BigDecimalTypeHandler	BigDecimal implementation of TypeHandler
BlobTypeHandlerCallback
BooleanTypeHandler	Boolean implementation of TypeHandler
ByteArrayTypeHandler	byte[] implementation of TypeHandler
ByteTypeHandler	Byte implementation of TypeHandler
CacheController	Cache controller (implementation) interface
CacheKey	Hash value generator for cache keys
CacheModel	Wrapper for Caches.
CacheModelConfig
CachingStatement
CallableStatementResultSet	A way to make a CallableStatement look like a ResultSet
ClassInfo	This class represents a cached set of class definition information that allows for easy mapping between property names and getter/setter methods.
ClobTypeHandlerCallback
ComplexAccessPlan	Access plan for working with beans
ComplexBeanProbe	StaticBeanProbe provides methods that allow simple, reflective access to JavaBeans style properties.
ComplexDataExchange	A DataExchange implemtation for working with beans
ConditionalTagHandler
ConnectionLogProxy	Connection proxy to add logging
CustomTypeHandler	Custom type handler for adding a TypeHandlerCallback
DataExchange	Interface for exchanging data between a parameter map/result map and the related objects
DataExchangeFactory	Factory for DataExchange objects
DataSourceFactory	Interface to provide a way to create and configure a DataSource for iBATIS
DateOnlyTypeHandler	Date only implementation of TypeHandler
DateTypeHandler	Date (and time) implementation of TypeHandler
DbcpConfiguration	Wrapper class to simplify use of DBCP
DbcpDataSourceFactory	DataSourceFactory implementation for DBCP
DefaultRowHandler
DeleteStatement
Discriminator	Created by IntelliJ IDEA.
DomCollectionTypeMarker
DomDataExchange	A DataExchange implemtation for working with DOM objects
DomProbe	A Probe implementation for working with DOM objects
DomTypeMarker
DoubleTypeHandler	Double implementation of TypeHandler
DynamicParent
DynamicSql
DynamicTagHandler
EnhancedLazyResultLoader	Class to lazily load results into objects (uses CGLib to improve performance)
EnhancedPropertyAccessPlan	Enhanced PropertyAccessPlan (for working with beans using CG Lib)
EnumTypeHandler	String implementation of TypeHandler
ErrorContext	An error context to help us create meaningful error messages
ExecuteListener
ExtendedSqlMapClient
ExternalTransaction
ExternalTransactionConfig
FifoCacheController	FIFO (first in, first out) cache controller implementation
FloatTypeHandler	Float implementation of TypeHandler
GenericProbe	StaticBeanProbe provides methods that allow simple, reflective access to JavaBeans style properties.
GetFieldInvoker
InlineParameterMapParser
InsertStatement
IntegerTypeHandler	Integer Decimal implementation of TypeHandler
Invoker
IsEmptyTagHandler
IsEqualTagHandler
IsGreaterEqualTagHandler
IsGreaterThanTagHandler
IsLessEqualTagHandler
IsLessThanTagHandler
IsNotEmptyTagHandler
IsNotEqualTagHandler
IsNotNullTagHandler
IsNotParameterPresentTagHandler
IsNotPropertyAvailableTagHandler
IsNullTagHandler
IsolationLevel
IsParameterPresentTagHandler
IsPropertyAvailableTagHandler
IterateContext
IterateTagHandler
JakartaCommonsLoggingImpl
JavaBeanDataExchange	DataExchange implementation for beans
JdbcTransaction
JdbcTransactionConfig
JdbcTypeRegistry	Singleton
Jdk14LoggingImpl
JndiDataSourceFactory	DataSourceFactory implementation for JNDI
JtaTransaction
JtaTransactionConfig
LazyResultLoader	Class to lazily load results into objects
ListDataExchange	DataExchange implementation for List objects
Log
Log4jImpl
LogFactory
LongTypeHandler	Long implementation of TypeHandler
LruCacheController	LRU (least recently used) cache controller implementation
MapAccessPlan	Access plan for working with Maps
MapDataExchange	DataExchange implementation for Map objects
MappedStatement
MappedStatementConfig
MemoryCacheController	Memory-based implementation of CacheController
MemoryCacheLevel	An enumeration for the values for the memory cache levels
MethodInvoker
NestedSQLException	Class to allow passing an Exception with the original SQLException
Nodelet	A nodelet is a sort of callback or event handler that can be registered to handle an XPath event registered with the NodeParser.
NodeletException
NodeletParser	The NodeletParser is a callback based parser similar to SAX.
NodeletUtils
NoLoggingImpl
NoParameterMap
ObjectTypeHandler	Object implementation of TypeHandler
OSCacheController	Cache implementation for using OSCache with iBATIS
PaginatedArrayList	Implementation of PaginatedList backed by an ArrayList
PaginatedDataList
PaginatedList	Interface for lists that support paging
ParameterMap
ParameterMapConfig
ParameterMapping
ParameterSetter	Allows parameters to be set on the underlying prepared statement.
ParameterSetterImpl	A ParameterSetter implementation
PreparedStatementLogProxy	PreparedStatement proxy to add logging
PrimitiveDataExchange	DataExchange implementation for primitive objects
Probe	A Probe is an object that is used to work with beans, DOM objects, or other objects.
ProbeException	BeansException for use for by BeanProbe and StaticBeanProbe.
ProbeFactory	An abstract factory for getting Probe implementations.
ProcedureStatement
PropertyAccessPlan	Property access plan (for working with beans)
RawSql	A non-executable SQL container simply for communicating raw SQL around the framework.
ReaderInputStream	An InputStream backed by a Reader
Resources	A class to simplify access to resources through the classloader.
ResultGetter	Allows values to be retrieved from the underlying result set.
ResultGetterImpl	A ResultGetter implementation
ResultLoader	Class to load results into objects
ResultMap	Basic implementation of ResultMap interface
ResultMapConfig
ResultMapping	Basic implementation of ResultMapping
ResultObjectFactory	iBATIS uses an implementation of this interface to create result objects after the execution of a statement.
ResultObjectFactoryUtil	This class is used to create instances of result objects.
ResultSetLogProxy	ResultSet proxy to add logging
RowHandler	Event handler for row by row processing.
RowHandlerCallback	Class to manager row handler access
RuntimeSQLException	Unchecked exception to allow passing an Exception with the original SQLException
ScriptRunner	Tool to run database scripts
SelectKeyStatement
SelectStatement
SessionScope	A Session based implementation of the Scope interface
SetFieldInvoker
ShortTypeHandler	Short implementation of TypeHandler
SimpleDataSource	This is a simple, synchronous, thread-safe database connection pool.
SimpleDataSource.SimplePooledConnection	--------------------------------------------------------------------------------------- SimplePooledConnection ---------------------------------------------------------------------------------------
SimpleDataSourceFactory	DataSourceFactory implementation for the iBATIS SimpleDataSource
SimpleDateFormatter
SimpleDynamicSql
Sql
SqlChild
SqlDateTypeHandler	SQL Date implementation of TypeHandler
SqlExecutor	Class responsible for executing the SQL
SqlMapClasspathEntityResolver	Offline entity resolver for the iBATIS DTDs
SqlMapClient	A thread safe client for working with your SQL Maps (Start Here).
SqlMapClientBuilder	Builds SqlMapClient instances from a supplied resource (e.g.
SqlMapClientImpl	Implementation of ExtendedSqlMapClient
SqlMapConfigParser
SqlMapConfiguration
SqlMapException	Thrown to indicate a problem with SQL Map configuration or state.
SqlMapExecutor	This interface declares all methods involved with executing statements and batches for an SQL Map.
SqlMapExecutorDelegate	The workhorse that really runs the SQL
SqlMapParser
SqlMapSession	A single threaded session for working with your SQL Maps.
SqlMapSessionImpl	Implementation of SqlMapSession
SqlMapTransactionManager	This interface declares methods for demarcating SQL Map transactions.
SqlSource
SqlStatementParser
SqlTag
SqlTagContext
SqlTagHandler
SqlTagHandlerFactory
SqlText
SqlTimestampTypeHandler	SQL timestamp implementation of TypeHandler
SqlTimeTypeHandler	SQL time implementation of TypeHandler
StatementLogProxy	Statement proxy to add logging
StatementScope	Request based implementation of Scope interface
StatementType
StaticSql
StringTypeHandler	String implementation of TypeHandler
TimeOnlyTypeHandler	Time (only) implementation of TypeHandler
Transaction
TransactionConfig
TransactionException
TransactionManager
TransactionState
TypeHandler	Interface for getting data into, and out of a mapped statement
TypeHandlerCallback	A simple interface for implementing custom type handlers.
TypeHandlerFactory	Not much of a suprise, this is a factory class for TypeHandler objects.
UnknownTypeHandler	Implementation of TypeHandler for dealing with unknown types
UpdateStatement
UserProvidedTransaction
XmlCollectionTypeMarker
XmlList	Not really sure what this is...it is not used internally
XmlParserState
XMLSqlSource
XmlTypeMarker