All Classes and Interfaces
Class
Description
An interface to make access to resources consistent, regardless of type.
Factory to get an accesss plan appropriate for an object.
An automatic result map for simple stuff.
Base implementation of the AccessPlan interface.
Base implementation for the DataExchange interface.
Base class for proxies to do logging.
Abstract class used to help development of Probe implementations.
The Class BaseTagHandler.
The Class BaseTransactionConfig.
Base type handler for convenience.
This exception is thrown if a
java.sql.BatchUpdateException is caught during the execution of any nested
batch.This class holds the statement and row information for every successful batch executed by iBATIS.
BigDecimal implementation of TypeHandler.
The Class BlobTypeHandlerCallback.
Boolean implementation of TypeHandler.
byte[] implementation of TypeHandler.
Byte implementation of TypeHandler.
Cache controller (implementation) interface.
Hash value generator for cache keys.
Wrapper for Caches.
The Class CacheModelConfig.
The Class CachingStatement.
A way to make a CallableStatement look like a ResultSet.
This class represents a cached set of class definition information that allows for easy mapping between property
names and getter/setter methods.
The Class ClobTypeHandlerCallback.
Access plan for working with beans.
StaticBeanProbe provides methods that allow simple, reflective access to JavaBeans style properties.
A DataExchange implemtation for working with beans.
The Class ConditionalTagHandler.
Connection proxy to add logging.
Custom type handler for adding a TypeHandlerCallback.
Interface for exchanging data between a parameter map/result map and the related objects.
Factory for DataExchange objects.
Interface to provide a way to create and configure a DataSource for iBATIS.
Date only implementation of TypeHandler.
Date (and time) implementation of TypeHandler.
Wrapper class to simplify use of DBCP.
DataSourceFactory implementation for DBCP.
The Class DefaultRowHandler.
Class responsible for executing the SQL.
The Class DeleteStatement.
Created by IntelliJ IDEA.
The Interface DomCollectionTypeMarker.
A DataExchange implemtation for working with DOM objects.
A Probe implementation for working with DOM objects.
The Interface DomTypeMarker.
Double implementation of TypeHandler.
The Interface DynamicParent.
The Class DynamicSql.
The Class DynamicTagHandler.
Class to lazily load results into objects (uses CGLib to improve performance).
Enhanced PropertyAccessPlan (for working with beans using CG Lib).
String implementation of TypeHandler.
An error context to help us create meaningful error messages.
The listener interface for receiving execute events.
Deprecated.
- this class is uneccessary and should be removed as soon as possible.
The Class ExternalTransaction.
The Class ExternalTransactionConfig.
FIFO (first in, first out) cache controller implementation.
Float implementation of TypeHandler.
StaticBeanProbe provides methods that allow simple, reflective access to JavaBeans style properties.
The Class GetFieldInvoker.
The Class InlineParameterMapParser.
The Class InsertStatement.
Integer Decimal implementation of TypeHandler.
The Interface Invoker.
The Class IsEmptyTagHandler.
The Class IsEqualTagHandler.
The Class IsGreaterEqualTagHandler.
The Class IsGreaterThanTagHandler.
The Class IsLessEqualTagHandler.
The Class IsLessThanTagHandler.
The Class IsNotEmptyTagHandler.
The Class IsNotEqualTagHandler.
The Class IsNotNullTagHandler.
The Class IsNotParameterPresentTagHandler.
The Class IsNotPropertyAvailableTagHandler.
The Class IsNullTagHandler.
The Class IsolationLevel.
The Class IsParameterPresentTagHandler.
The Class IsPropertyAvailableTagHandler.
The Class IterateContext.
The Class IterateTagHandler.
The Class JakartaCommonsLoggingImpl.
DataExchange implementation for beans.
The Class JdbcTransaction.
The Class JdbcTransactionConfig.
Singleton.
The Class Jdk14LoggingImpl.
DataSourceFactory implementation for JNDI.
The Class JtaTransaction.
The Class JtaTransactionConfig.
Class to lazily load results into objects.
DataExchange implementation for List objects.
The Interface Log.
The Class Log4jImpl.
A factory for creating Log objects.
Long implementation of TypeHandler.
LRU (least recently used) cache controller implementation.
Access plan for working with Maps.
DataExchange implementation for Map objects.
The Class MappedStatement.
The Class MappedStatementConfig.
Memory-based implementation of CacheController.
An enumeration for the values for the memory cache levels.
The Class MethodInvoker.
Class to allow passing an Exception with the original SQLException.
A nodelet is a sort of callback or event handler that can be registered to handle an XPath event registered with the
NodeParser.
The Class NodeletException.
The NodeletParser is a callback based parser similar to SAX.
The Class NodeletUtils.
The Class NoLoggingImpl.
The Class NoParameterMap.
Object implementation of TypeHandler.
Deprecated.
All paginated list features have been deprecated
Deprecated.
All paginated list features have been deprecated
Deprecated.
All paginated list features have been deprecated
The Class ParameterMap.
The Class ParameterMapConfig.
The Class ParameterMapping.
Allows parameters to be set on the underlying prepared statement.
A ParameterSetter implementation.
PreparedStatement proxy to add logging.
DataExchange implementation for primitive objects.
A Probe is an object that is used to work with beans, DOM objects, or other objects.
BeansException for use for by BeanProbe and StaticBeanProbe.
An abstract factory for getting Probe implementations.
The Class ProcedureStatement.
Property access plan (for working with beans).
A non-executable SQL container simply for communicating raw SQL around the framework.
An InputStream backed by a Reader.
A class to simplify access to resources through the classloader.
Allows values to be retrieved from the underlying result set.
A ResultGetter implementation.
Class to load results into objects.
Basic implementation of ResultMap interface.
The Class ResultMapConfig.
Basic implementation of ResultMapping.
iBATIS uses an implementation of this interface to create result objects after the execution of a statement.
This class is used to create instances of result objects.
ResultSet proxy to add logging.
Event handler for row by row processing.
Class to manager row handler access.
Unchecked exception to allow passing an Exception with the original SQLException.
Tool to run database scripts.
The Class SelectKeyStatement.
The Class SelectStatement.
A Session based implementation of the Scope interface.
The Class SetFieldInvoker.
Short implementation of TypeHandler.
This is a simple, synchronous, thread-safe database connection pool.
--------------------------------------------------------------------------------------- SimplePooledConnection
---------------------------------------------------------------------------------------.
DataSourceFactory implementation for the iBATIS SimpleDataSource.
The Class SimpleDateFormatter.
The Class SimpleDynamicSql.
The Interface Sql.
The Interface SqlChild.
SQL Date implementation of TypeHandler.
Classes responsible for executing the SQL implement this interface Support for custom SQL Executors.
Offline entity resolver for the iBATIS DTDs.
A thread safe client for working with your SQL Maps (Start Here).
Builds SqlMapClient instances from a supplied resource (e.g.
Implementation of ExtendedSqlMapClient.
The Class SqlMapConfigParser.
The Class SqlMapConfiguration.
Thrown to indicate a problem with SQL Map configuration or state.
This interface declares all methods involved with executing statements and batches for an SQL Map.
The workhorse that really runs the SQL.
The Class SqlMapParser.
A single threaded session for working with your SQL Maps.
Implementation of SqlMapSession.
This interface declares methods for demarcating SQL Map transactions.
The Interface SqlSource.
The Class SqlStatementParser.
The Class SqlTag.
The Class SqlTagContext.
The Interface SqlTagHandler.
A factory for creating SqlTagHandler objects.
The Class SqlText.
SQL timestamp implementation of TypeHandler.
SQL time implementation of TypeHandler.
Statement proxy to add logging.
Request based implementation of Scope interface.
The Class StatementType.
The Class StaticSql.
String implementation of TypeHandler.
Time (only) implementation of TypeHandler.
The Interface Transaction.
The Interface TransactionConfig.
The Class TransactionException.
The Class TransactionManager.
The Class TransactionState.
Interface for getting data into, and out of a mapped statement.
A simple interface for implementing custom type handlers.
Not much of a suprise, this is a factory class for TypeHandler objects.
Implementation of TypeHandler for dealing with unknown types.
The Class UpdateStatement.
The Class UserProvidedTransaction.
The Interface XmlCollectionTypeMarker.
Not really sure what this is...it is not used internally
The Class XmlParserState.
The Class XMLSqlSource.
The Interface XmlTypeMarker.