AbstractResultSetHandler (MockRunner-JDBC 2.0.7 API)

java.lang.Object
- com.mockrunner.jdbc.AbstractResultSetHandler

Direct Known Subclasses:

AbstractParameterResultSetHandler, StatementResultSetHandler
```
public abstract class AbstractResultSetHandler
extends Object
```
Abstract base class for all ResultSet handlers. Used to coordinate ResultSet objects for a statement. You can use this class to prepare ResultSet objects and update count values that are returned by the execute method of a statement, if the current SQL string matches. Furthermore it can be used to create ResultSet objects. Please note that the ResultSet objects you create and prepare with this handler are cloned when executing statements. So you cannot rely on object identity. You have to use the id of the ResultSet to identify it. The ResultSet objects returned by getReturnedResultSets() are actually the instances the executed statements returned.

Constructor Summary

Constructors
Constructor and Description

AbstractResultSetHandler()

Constructors
Constructor and Description
`AbstractResultSetHandler()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addExecutedStatement(String sql)` Collects all SQL strings that were executed.
`void`	`addReturnedResultSet(MockResultSet resultSet)` Collects all `ResultSet` objects that were returned by a `Statement`, `PreparedStatement` or `CallableStatement`.
`void`	`addReturnedResultSets(MockResultSet[] resultSets)` Collects all `ResultSet[]` objects that were returned by a `Statement`, `PreparedStatement` or `CallableStatement`.
`void`	`clearGeneratedKeys()` Clears the list of statements that return generated keys.
`void`	`clearGlobalGeneratedKeys()` Clears the prepared global generated keys `ResultSet`.
`void`	`clearGlobalResultSet()` Clears the prepared global `ResultSet`.
`void`	`clearGlobalUpdateCount()` Clears the prepared global update count.
`void`	`clearResultSets()` Clears all prepared `ResultSet` objects.
`void`	`clearReturnsResultSet()` Clears the definitions if statements return `ResultSet` objects or update counts.
`void`	`clearThrowsSQLException()` Clears the list of statements that should throw an exception.
`void`	`clearUpdateCounts()` Clears all prepared update counts.
`MockResultSet`	`createResultSet()` Creates a new `ResultSet` with a random id.
`MockResultSet`	`createResultSet(ResultSetFactory factory)` Returns a new `ResultSet` created by the specified factory.
`MockResultSet`	`createResultSet(String id)` Creates a new `ResultSet` with the specified id.
`MockResultSet`	`createResultSet(String id, ResultSetFactory factory)` Returns a new `ResultSet` created by the specified factory.
`protected boolean`	`getCaseSensitive()` Returns if specified SQL strings should be handled case sensitive.
`boolean`	`getContinueProcessingOnBatchFailure()` Returns if batch processing should be continued if one of the commands in the batch fails.
`protected boolean`	`getExactMatch()` Returns if specified SQL statements must match exactly.
`List<String>`	`getExecutedStatements()` Returns the `List` of all executed SQL strings.
`MockResultSet`	`getGeneratedKeys(String sql)` Returns the first generated keys `ResultSet` that matches the specified SQL string.
`protected MockResultSet`	`getGeneratedKeys(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`MockResultSet`	`getGlobalGeneratedKeys()` Returns the global generated keys `ResultSet`.
`MockResultSet`	`getGlobalResultSet()` Returns the global `ResultSet`.
`MockResultSet[]`	`getGlobalResultSets()` Returns the global `ResultSet[]`.
`int`	`getGlobalUpdateCount()` Returns the global update count for `executeUpdate` calls.
`Integer[]`	`getGlobalUpdateCounts()` Returns the array of global update counts.
`protected <S,T> List<T>`	`getListFromMapForSQLStatement(S sql, Map<S,List<T>> map)`
`protected <T> List<T>`	`getMatchingObjects(Map<PatternMatcher,? extends T> dataMap, String query)`
`protected <T> ParameterWrapper<T>`	`getMatchingParameterWrapper(String sql, MockParameterMap parameters, Map<PatternMatcher,List<ParameterWrapper<T>>> statementMap, boolean exactMatchParameter)`
`PatternMatcher.Factory`	`getPatternMatcherFactory()`
`MockResultSet`	`getResultSet(String sql)` Returns the first `ResultSet` that matches the specified SQL string.
`protected MockResultSet`	`getResultSet(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`ResultSetFactory`	`getResultSetFactory()`
`MockResultSet[]`	`getResultSets(String sql)` Returns the first `ResultSet[]` that matches the specified SQL string.
`protected MockResultSet[]`	`getResultSets(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`List<MockResultSet[]>`	`getReturnedResultSets()` Returns the `List` of all returned `ResultSet` or `ResultSet[]` objects.
`Boolean`	`getReturnsResultSet(String sql)` Returns if the specified SQL string is a select that returns a `ResultSet`.
`SQLException`	`getSQLException(String sql)` Returns the `SQLException` the specified SQL string should throw.
`protected SQLException`	`getSQLException(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`boolean`	`getThrowsSQLException(String sql)` Returns if the specified SQL string should raise an exception.
`Integer`	`getUpdateCount(String sql)` Returns the first update count that matches the specified SQL string.
`protected Integer`	`getUpdateCount(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`Integer[]`	`getUpdateCounts(String sql)` Returns the first update count array that matches the specified SQL string.
`Integer[]`	`getUpdateCounts(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`protected boolean`	`getUseRegularExpressions()` Returns if regular expression matching is enabled
`boolean`	`hasMultipleGlobalResultSets()` Returns if multiple global result sets have been prepared, i.e.
`boolean`	`hasMultipleGlobalUpdateCounts()` Returns if multiple global update counts have been prepared, i.e.
`boolean`	`hasMultipleResultSets(String sql)` Returns the if the specified SQL string returns multiple result sets.
`protected boolean`	`hasMultipleResultSets(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`boolean`	`hasMultipleUpdateCounts(String sql)` Returns the if the specified SQL string returns multiple update counts.
`protected boolean`	`hasMultipleUpdateCounts(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`protected void`	`onPatternMatcherFactoryChanged()`
`void`	`prepareGeneratedKeys(String sql, MockResultSet generatedKeysResult)` Prepare the generated keys `ResultSet` for a specified SQL string.
`protected void`	`prepareGeneratedKeys(String sql, MockResultSet generatedKeysResult, MockParameterMap parameters)`
`void`	`prepareGlobalGeneratedKeys(MockResultSet generatedKeysResult)` Prepare the global generated keys `ResultSet`.
`void`	`prepareGlobalResultSet(MockResultSet resultSet)` Prepare the global `ResultSet`.
`void`	`prepareGlobalResultSets(MockResultSet[] resultSets)` Prepare an array of global `ResultSet` objects.
`void`	`prepareGlobalUpdateCount(int updateCount)` Prepare the global update count for `executeUpdate` calls.
`void`	`prepareGlobalUpdateCounts(Integer[] updateCounts)` Prepare an array of global update count values for `executeUpdate` calls.
`void`	`prepareResultSet(String sql, MockResultSet resultSet)` Prepare a `ResultSet` for a specified SQL string.
`protected void`	`prepareResultSet(String sql, MockResultSet resultSet, MockParameterMap parameters)`
`void`	`prepareResultSets(String sql, MockResultSet[] resultSets)` Prepare an array of `ResultSet` objects for a specified SQL string.
`protected void`	`prepareResultSets(String sql, MockResultSet[] resultSets, MockParameterMap parameters)`
`void`	`prepareReturnsResultSet(String sql, boolean returnsResultSet)` Prepare if the specified SQL string is a select that returns a `ResultSet`.
`void`	`prepareThrowsSQLException(String sql)` Prepare that the specified SQL string should raise an exception.
`protected void`	`prepareThrowsSQLException(String sql, MockParameterMap parameters)`
`void`	`prepareThrowsSQLException(String sql, SQLException exc)` Prepare that the specified SQL string should raise an exception.
`protected void`	`prepareThrowsSQLException(String sql, SQLException exc, MockParameterMap parameters)`
`void`	`prepareUpdateCount(String sql, int updateCount)` Prepare the update count for `executeUpdate` calls for a specified SQL string.
`protected void`	`prepareUpdateCount(String sql, int updateCount, MockParameterMap parameters)`
`void`	`prepareUpdateCounts(String sql, Integer[] updateCounts)` Prepare an array update count values for `executeUpdate` calls for a specified SQL string.
`void`	`prepareUpdateCounts(String sql, Integer[] updateCounts, MockParameterMap parameters)`
`protected <T> void`	`recompile(Map<String,T> source, Map<PatternMatcher,T> compiled)`
`void`	`removeAllGeneratedKeys(String sql)` Remove the generated keys mock for the specified SQL string.
`void`	`removeAllResultSet(String sql)` Given a SQL string, remove the associated entry from the resultSetsForStatement TreeMap
`void`	`removeAllThrowsSqlException(String sql)` Remove the throws mock for the specified SQL string.
`void`	`removeAllUpdateCount(String sql)` Remove the update count mock for the specified SQL string.
`void`	`removeGeneratedKeys(String sql)` Remove the generated keys mock for the specified SQL string.
`protected void`	`removeGeneratedKeys(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`protected <S,T> ParameterWrapper<T>`	`removeMatchingParameterWrapper(S sql, MockParameterMap parameters, Map<S,List<ParameterWrapper<T>>> map, boolean exactMatchParameter)`
`void`	`removeResultSet(String sql)` Given a SQL string, remove the associated entry from the resultSetsForStatement TreeMap
`protected void`	`removeResultSet(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`void`	`removeThrowsSqlException(String sql)` Remove the throws mock for the specified SQL string.
`protected void`	`removeThrowsSqlException(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`void`	`removeUpdateCount(String sql)` Remove the update count mock for the specified SQL string.
`protected void`	`removeUpdateCount(String sql, MockParameterMap parameters, boolean exactMatchParameter)`
`protected void`	`resetPatternMatcherFactory()`
`void`	`setCaseSensitive(boolean caseSensitive)` Set if specified SQL strings should be handled case sensitive.
`void`	`setContinueProcessingOnBatchFailure(boolean continueProcessingOnBatchFailure)` Set if batch processing should be continued if one of the commands in the batch fails.
`void`	`setExactMatch(boolean exactMatch)` Set if specified SQL statements must match exactly.
`void`	`setPatternMatcherFactory(PatternMatcher.Factory factory)` Sets custom factory for patterns for matching SQL statements.
`void`	`setResultSetFactory(ResultSetFactory resultSetFactory)` Set factory used for `createResultSet()` and `createResultSet(String)`
`void`	`setUseRegularExpressions(boolean useRegularExpressions)` Set if regular expressions should be used when matching SQL statements.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AbstractResultSetHandler
```
public AbstractResultSetHandler()
```
- Method Detail
  - createResultSet
```
public MockResultSet createResultSet()
```
    Creates a new ResultSet with a random id.
    
    Returns:
    
    the new ResultSet
  - createResultSet
```
public MockResultSet createResultSet(String id)
```
    Creates a new ResultSet with the specified id.
    
    Parameters:
    
    id - the id
    
    Returns:
    
    the new ResultSet
  - createResultSet
```
public MockResultSet createResultSet(ResultSetFactory factory)
```
    Returns a new ResultSet created by the specified factory. Creates a random id.
    
    Parameters:
    
    factory - the ResultSetFactory
    
    Returns:
    
    the new ResultSet
  - createResultSet
```
public MockResultSet createResultSet(String id,
                                     ResultSetFactory factory)
```
    Returns a new ResultSet created by the specified factory.
    
    Parameters:
    
    id - the id
    
    factory - the ResultSetFactory
    
    Returns:
    
    the new ResultSet
  - getResultSetFactory
```
public ResultSetFactory getResultSetFactory()
```
    Returns:
    
    Current falctory used for createResultSet() and createResultSet(String)
  - setResultSetFactory
```
public void setResultSetFactory(ResultSetFactory resultSetFactory)
```
    Set factory used for createResultSet() and createResultSet(String)
    
    Parameters:
    
    resultSetFactory -
  - setCaseSensitive
```
public void setCaseSensitive(boolean caseSensitive)
```
    Set if specified SQL strings should be handled case sensitive. Defaults to to false, i.e. INSERT is the same as insert. Please note that this method controls SQL statement matching for prepared results and update counts, i.e. what statements the tested application has to execute to receive a specified result. Unlike JDBCTestModule.setCaseSensitive(boolean) it does not control the statement matching of JDBCTestModule methods.
    
    Parameters:
    
    caseSensitive - enable or disable case sensitivity
  - setExactMatch
```
public void setExactMatch(boolean exactMatch)
```
    Set if specified SQL statements must match exactly. Defaults to false, i.e. the SQL string does not need to match exactly. If the original statement is insert into mytable values(?, ?, ?) the string insert into mytable will match this statement. Usually false is the best choice, so prepared ResultSet objects do not have to match exactly the current statements SQL string. The current SQL string just has to contain the SQL string for the prepared prepared ResultSet. Please note that this method controls SQL statement matching for prepared results and update counts, i.e. what statements the tested application has to execute to receive a specified result. Unlike JDBCTestModule.setExactMatch(boolean) it does not control the statement matching of JDBCTestModule methods.
    
    Parameters:
    
    exactMatch - enable or disable exact matching
  - setUseRegularExpressions
```
public void setUseRegularExpressions(boolean useRegularExpressions)
```
    Set if regular expressions should be used when matching SQL statements. Irrelevant if exactMatch is true. Default is false, i.e. you cannot use regular expressions and matching is based on string comparison. Please note that this method controls SQL statement matching for prepared results and update counts, i.e. what statements the tested application has to execute to receive a specified result. Unlike JDBCTestModule.setUseRegularExpressions(boolean) it does not control the statement matching of JDBCTestModule methods.
    
    Parameters:
    
    useRegularExpressions - should regular expressions be used
  - setPatternMatcherFactory
```
public void setPatternMatcherFactory(PatternMatcher.Factory factory)
```
    Sets custom factory for patterns for matching SQL statements. When custom factory is set, caseSensitive, exactMatch, useRegularExpressions are ignored. When one of these parameters is set, the custom factory is discarded.
    
    Parameters:
    
    factory - The factory that provides pattern interprets.
  - getPatternMatcherFactory
```
public PatternMatcher.Factory getPatternMatcherFactory()
```
    Returns:
    
    Factory used for creation of pattern matchers.
  - resetPatternMatcherFactory
```
protected void resetPatternMatcherFactory()
```
  - onPatternMatcherFactoryChanged
```
protected void onPatternMatcherFactoryChanged()
```
  - setContinueProcessingOnBatchFailure
```
public void setContinueProcessingOnBatchFailure(boolean continueProcessingOnBatchFailure)
```
    Set if batch processing should be continued if one of the commands in the batch fails. This behaviour is driver dependend. The default is false, i.e. if a command fails with an exception, batch processing will not continue and the remaining commands will not be executed.
    
    Parameters:
    
    continueProcessingOnBatchFailure - should batch processing be continued
  - addExecutedStatement
```
public void addExecutedStatement(String sql)
```
    Collects all SQL strings that were executed.
    
    Parameters:
    
    sql - the SQL string
  - addReturnedResultSet
```
public void addReturnedResultSet(MockResultSet resultSet)
```
    Collects all ResultSet objects that were returned by a Statement, PreparedStatement or CallableStatement.
    
    Parameters:
    
    resultSet - the ResultSet
  - addReturnedResultSets
```
public void addReturnedResultSets(MockResultSet[] resultSets)
```
    Collects all ResultSet[] objects that were returned by a Statement, PreparedStatement or CallableStatement. Called if a statement returns multiple result sets.
    
    Parameters:
    
    resultSets - the ResultSet[]
  - getExecutedStatements
```
public List<String> getExecutedStatements()
```
    Returns the List of all executed SQL strings.
    
    Returns:
    
    the List of executed SQL strings
  - getReturnedResultSets
```
public List<MockResultSet[]> getReturnedResultSets()
```
    Returns the List of all returned ResultSet or ResultSet[] objects. The List contains arrays of result sets, if a query returned multiple result sets. If a query returned multiple result sets, the list will always contain the full array of ResultSet objects that were prepared, even if MockStatement.getMoreResults() was not called for all the result sets.
    
    Returns:
    
    the List of returned ResultSet or ResultSet[] objects
  - clearResultSets
```
public void clearResultSets()
```
    Clears all prepared ResultSet objects.
  - clearUpdateCounts
```
public void clearUpdateCounts()
```
    Clears all prepared update counts.
  - clearReturnsResultSet
```
public void clearReturnsResultSet()
```
    Clears the definitions if statements return ResultSet objects or update counts.
  - clearThrowsSQLException
```
public void clearThrowsSQLException()
```
    Clears the list of statements that should throw an exception.
  - clearGeneratedKeys
```
public void clearGeneratedKeys()
```
    Clears the list of statements that return generated keys.
  - clearGlobalResultSet
```
public void clearGlobalResultSet()
```
    Clears the prepared global ResultSet.
  - clearGlobalGeneratedKeys
```
public void clearGlobalGeneratedKeys()
```
    Clears the prepared global generated keys ResultSet.
  - clearGlobalUpdateCount
```
public void clearGlobalUpdateCount()
```
    Clears the prepared global update count.
  - getResultSet
```
public MockResultSet getResultSet(String sql)
```
    Returns the first ResultSet that matches the specified SQL string. If the specified SQL string was prepared to return multiple result sets, the first one will be returned. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    the corresponding MockResultSet
  - getResultSet
```
protected MockResultSet getResultSet(String sql,
                                     MockParameterMap parameters,
                                     boolean exactMatchParameter)
```
  - getResultSets
```
public MockResultSet[] getResultSets(String sql)
```
    Returns the first ResultSet[] that matches the specified SQL string. If the specified SQL string was prepared to return one single result set, this ResultSet will be wrapped in an array with one element. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    the corresponding MockResultSet[]
  - getResultSets
```
protected MockResultSet[] getResultSets(String sql,
                                        MockParameterMap parameters,
                                        boolean exactMatchParameter)
```
  - hasMultipleResultSets
```
public boolean hasMultipleResultSets(String sql)
```
    Returns the if the specified SQL string returns multiple result sets. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    true if the query returns multiple result sets, false otherwise
  - hasMultipleResultSets
```
protected boolean hasMultipleResultSets(String sql,
                                        MockParameterMap parameters,
                                        boolean exactMatchParameter)
```
  - getGlobalResultSet
```
public MockResultSet getGlobalResultSet()
```
    Returns the global ResultSet. If an array of global result sets was prepared, the first one will be returned.
    
    Returns:
    
    the global MockResultSet
  - getGlobalResultSets
```
public MockResultSet[] getGlobalResultSets()
```
    Returns the global ResultSet[]. If one single ResultSet was prepared, this ResultSet will be wrapped in an array with one element.
    
    Returns:
    
    the global MockResultSet[]
  - hasMultipleGlobalResultSets
```
public boolean hasMultipleGlobalResultSets()
```
    Returns if multiple global result sets have been prepared, i.e. if an array of global result sets was prepared.
    
    Returns:
    
    true if an array of global result sets was prepared, false otherwise
  - getUpdateCount
```
public Integer getUpdateCount(String sql)
```
    Returns the first update count that matches the specified SQL string. If the specified SQL string was prepared to return multiple update counts, the first one will be returned. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    the corresponding update count
  - getUpdateCount
```
protected Integer getUpdateCount(String sql,
                                 MockParameterMap parameters,
                                 boolean exactMatchParameter)
```
  - getUpdateCounts
```
public Integer[] getUpdateCounts(String sql)
```
    Returns the first update count array that matches the specified SQL string. If the specified SQL string was prepared to return one update count, this value will be wrapped in an array with one element. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    the corresponding update count array
  - hasMultipleUpdateCounts
```
public boolean hasMultipleUpdateCounts(String sql)
```
    Returns the if the specified SQL string returns multiple update counts. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    true if the SQL string returns multiple update counts, false otherwise
  - hasMultipleUpdateCounts
```
protected boolean hasMultipleUpdateCounts(String sql,
                                          MockParameterMap parameters,
                                          boolean exactMatchParameter)
```
  - getUpdateCounts
```
public Integer[] getUpdateCounts(String sql,
                                 MockParameterMap parameters,
                                 boolean exactMatchParameter)
```
  - getGlobalUpdateCount
```
public int getGlobalUpdateCount()
```
    Returns the global update count for executeUpdate calls. If an array of global update counts was prepared, the first one will be returned.
    
    Returns:
    
    the global update count
  - getGlobalUpdateCounts
```
public Integer[] getGlobalUpdateCounts()
```
    Returns the array of global update counts. If one single update count value was prepared, this value will be wrapped in an array with one element.
    
    Returns:
    
    the array of global update counts
  - hasMultipleGlobalUpdateCounts
```
public boolean hasMultipleGlobalUpdateCounts()
```
    Returns if multiple global update counts have been prepared, i.e. if an array of global update counts was prepared.
    
    Returns:
    
    true if an array of global update counts was prepared, false otherwise
  - getGeneratedKeys
```
public MockResultSet getGeneratedKeys(String sql)
```
    Returns the first generated keys ResultSet that matches the specified SQL string. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    the corresponding generated keys MockResultSet
  - getGeneratedKeys
```
protected MockResultSet getGeneratedKeys(String sql,
                                         MockParameterMap parameters,
                                         boolean exactMatchParameter)
```
  - getGlobalGeneratedKeys
```
public MockResultSet getGlobalGeneratedKeys()
```
    Returns the global generated keys ResultSet.
    
    Returns:
    
    the global generated keys MockResultSet
  - getReturnsResultSet
```
public Boolean getReturnsResultSet(String sql)
```
    Returns if the specified SQL string is a select that returns a ResultSet. Usually you do not have to specify this. It is assumed that an SQL string returns a ResultSet if it contains the string select (case insensitive). Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    true if the SQL string returns a ResultSet
  - getThrowsSQLException
```
public boolean getThrowsSQLException(String sql)
```
    Returns if the specified SQL string should raise an exception. This can be used to simulate database exceptions. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    true if the specified SQL string should raise an exception, false otherwise
  - getSQLException
```
public SQLException getSQLException(String sql)
```
    Returns the SQLException the specified SQL string should throw. Returns null if the specified SQL string should not throw an exception. This can be used to simulate database exceptions. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    Returns:
    
    the SQLException or null
  - getSQLException
```
protected SQLException getSQLException(String sql,
                                       MockParameterMap parameters,
                                       boolean exactMatchParameter)
```
  - prepareResultSet
```
public void prepareResultSet(String sql,
                             MockResultSet resultSet)
```
    Prepare a ResultSet for a specified SQL string. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    resultSet - the corresponding MockResultSet
  - prepareResultSet
```
protected void prepareResultSet(String sql,
                                MockResultSet resultSet,
                                MockParameterMap parameters)
```
  - prepareResultSets
```
public void prepareResultSets(String sql,
                              MockResultSet[] resultSets)
```
    Prepare an array of ResultSet objects for a specified SQL string. This method can be used for queries that return multiple result sets. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    resultSets - the corresponding MockResultSet[]
  - prepareResultSets
```
protected void prepareResultSets(String sql,
                                 MockResultSet[] resultSets,
                                 MockParameterMap parameters)
```
  - prepareGlobalResultSet
```
public void prepareGlobalResultSet(MockResultSet resultSet)
```
    Prepare the global ResultSet.
    
    Parameters:
    
    resultSet - the MockResultSet
  - prepareGlobalResultSets
```
public void prepareGlobalResultSets(MockResultSet[] resultSets)
```
    Prepare an array of global ResultSet objects.
    
    Parameters:
    
    resultSets - the corresponding MockResultSet[]
  - prepareUpdateCount
```
public void prepareUpdateCount(String sql,
                               int updateCount)
```
    Prepare the update count for executeUpdate calls for a specified SQL string. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    updateCount - the update count
  - prepareUpdateCount
```
protected void prepareUpdateCount(String sql,
                                  int updateCount,
                                  MockParameterMap parameters)
```
  - prepareUpdateCounts
```
public void prepareUpdateCounts(String sql,
                                Integer[] updateCounts)
```
    Prepare an array update count values for executeUpdate calls for a specified SQL string. This method can be used if multiple update counts are returned. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    updateCounts - the update count array
  - prepareUpdateCounts
```
public void prepareUpdateCounts(String sql,
                                Integer[] updateCounts,
                                MockParameterMap parameters)
```
  - prepareGlobalUpdateCount
```
public void prepareGlobalUpdateCount(int updateCount)
```
    Prepare the global update count for executeUpdate calls.
    
    Parameters:
    
    updateCount - the update count
  - prepareGlobalUpdateCounts
```
public void prepareGlobalUpdateCounts(Integer[] updateCounts)
```
    Prepare an array of global update count values for executeUpdate calls.
    
    Parameters:
    
    updateCounts - the update count array
  - prepareGeneratedKeys
```
public void prepareGeneratedKeys(String sql,
                                 MockResultSet generatedKeysResult)
```
    Prepare the generated keys ResultSet for a specified SQL string. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    generatedKeysResult - the generated keys MockResultSet
  - prepareGeneratedKeys
```
protected void prepareGeneratedKeys(String sql,
                                    MockResultSet generatedKeysResult,
                                    MockParameterMap parameters)
```
  - prepareGlobalGeneratedKeys
```
public void prepareGlobalGeneratedKeys(MockResultSet generatedKeysResult)
```
    Prepare the global generated keys ResultSet.
    
    Parameters:
    
    generatedKeysResult - the generated keys MockResultSet
  - prepareReturnsResultSet
```
public void prepareReturnsResultSet(String sql,
                                    boolean returnsResultSet)
```
    Prepare if the specified SQL string is a select that returns a ResultSet. Usually you do not have to specify this. It is assumed that an SQL string returns a ResultSet if it contains the string select (case insensitive). Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    returnsResultSet - specify if the SQL string returns a ResultSet
  - prepareThrowsSQLException
```
public void prepareThrowsSQLException(String sql)
```
    Prepare that the specified SQL string should raise an exception. This can be used to simulate database exceptions. This method creates an SQLException and will throw this exception. With prepareThrowsSQLException(String, SQLException) you can specify the exception. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
  - prepareThrowsSQLException
```
protected void prepareThrowsSQLException(String sql,
                                         MockParameterMap parameters)
```
  - prepareThrowsSQLException
```
public void prepareThrowsSQLException(String sql,
                                      SQLException exc)
```
    Prepare that the specified SQL string should raise an exception. This can be used to simulate database exceptions. This method takes an exception object that will be thrown. Please note that you can modify the match parameters with setCaseSensitive(boolean), setExactMatch(boolean) and setUseRegularExpressions(boolean).
    
    Parameters:
    
    sql - the SQL string
    
    exc - the SQLException that should be thrown
  - prepareThrowsSQLException
```
protected void prepareThrowsSQLException(String sql,
                                         SQLException exc,
                                         MockParameterMap parameters)
```
  - getCaseSensitive
```
protected boolean getCaseSensitive()
```
    Returns if specified SQL strings should be handled case sensitive.
    
    Returns:
    
    is case sensitivity enabled or disabled
  - getExactMatch
```
protected boolean getExactMatch()
```
    Returns if specified SQL statements must match exactly.
    
    Returns:
    
    is exact matching enabled or disabled
  - getUseRegularExpressions
```
protected boolean getUseRegularExpressions()
```
    Returns if regular expression matching is enabled
    
    Returns:
    
    if regular expression matching is enabled
  - getContinueProcessingOnBatchFailure
```
public boolean getContinueProcessingOnBatchFailure()
```
    Returns if batch processing should be continued if one of the commands in the batch fails.
    
    Returns:
    
    if batch processing should be continued
  - removeAllResultSet
```
public void removeAllResultSet(String sql)
```
    Given a SQL string, remove the associated entry from the resultSetsForStatement TreeMap
    
    Parameters:
    
    sql - The SQL string associated with the resultset
  - removeAllThrowsSqlException
```
public void removeAllThrowsSqlException(String sql)
```
    Remove the throws mock for the specified SQL string.
    
    Parameters:
    
    sql - The SQL string which identifies the conditions under which to throw a SQLException
  - removeAllUpdateCount
```
public void removeAllUpdateCount(String sql)
```
    Remove the update count mock for the specified SQL string.
    
    Parameters:
    
    sql - The SQL string which identifies the conditions under which to return the specified update count
  - removeAllGeneratedKeys
```
public void removeAllGeneratedKeys(String sql)
```
    Remove the generated keys mock for the specified SQL string.
    
    Parameters:
    
    sql - The SQL string which identifies the conditions under which the generated keys result would be returned.
  - removeResultSet
```
public void removeResultSet(String sql)
```
    Given a SQL string, remove the associated entry from the resultSetsForStatement TreeMap
    
    Parameters:
    
    sql - The SQL string associated with the resultset
  - removeResultSet
```
protected void removeResultSet(String sql,
                               MockParameterMap parameters,
                               boolean exactMatchParameter)
```
  - removeThrowsSqlException
```
public void removeThrowsSqlException(String sql)
```
    Remove the throws mock for the specified SQL string.
    
    Parameters:
    
    sql - The SQL string which identifies the conditions under which to throw a SQLException
  - removeThrowsSqlException
```
protected void removeThrowsSqlException(String sql,
                                        MockParameterMap parameters,
                                        boolean exactMatchParameter)
```
  - removeUpdateCount
```
public void removeUpdateCount(String sql)
```
    Remove the update count mock for the specified SQL string.
    
    Parameters:
    
    sql - The SQL string which identifies the conditions under which to return the specified update count
  - removeUpdateCount
```
protected void removeUpdateCount(String sql,
                                 MockParameterMap parameters,
                                 boolean exactMatchParameter)
```
  - removeGeneratedKeys
```
public void removeGeneratedKeys(String sql)
```
    Remove the generated keys mock for the specified SQL string.
    
    Parameters:
    
    sql - The SQL string which identifies the conditions under which the generated keys result would be returned.
  - removeGeneratedKeys
```
protected void removeGeneratedKeys(String sql,
                                   MockParameterMap parameters,
                                   boolean exactMatchParameter)
```
  - getMatchingObjects
```
protected <T> List<T> getMatchingObjects(Map<PatternMatcher,? extends T> dataMap,
                                         String query)
```
  - getMatchingParameterWrapper
```
protected <T> ParameterWrapper<T> getMatchingParameterWrapper(String sql,
                                                              MockParameterMap parameters,
                                                              Map<PatternMatcher,List<ParameterWrapper<T>>> statementMap,
                                                              boolean exactMatchParameter)
```
  - removeMatchingParameterWrapper
```
protected <S,T> ParameterWrapper<T> removeMatchingParameterWrapper(S sql,
                                                                   MockParameterMap parameters,
                                                                   Map<S,List<ParameterWrapper<T>>> map,
                                                                   boolean exactMatchParameter)
```
  - getListFromMapForSQLStatement
```
protected <S,T> List<T> getListFromMapForSQLStatement(S sql,
                                                      Map<S,List<T>> map)
```
  - recompile
```
protected <T> void recompile(Map<String,T> source,
                             Map<PatternMatcher,T> compiled)
```

Class AbstractResultSetHandler

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractResultSetHandler

Method Detail

createResultSet

createResultSet

createResultSet

createResultSet

getResultSetFactory

setResultSetFactory

setCaseSensitive

setExactMatch

setUseRegularExpressions

setPatternMatcherFactory

getPatternMatcherFactory

resetPatternMatcherFactory

onPatternMatcherFactoryChanged

setContinueProcessingOnBatchFailure

addExecutedStatement

addReturnedResultSet

addReturnedResultSets

getExecutedStatements

getReturnedResultSets

clearResultSets

clearUpdateCounts

clearReturnsResultSet

clearThrowsSQLException

clearGeneratedKeys

clearGlobalResultSet

clearGlobalGeneratedKeys

clearGlobalUpdateCount

getResultSet

getResultSet

getResultSets

getResultSets

hasMultipleResultSets

hasMultipleResultSets

getGlobalResultSet

getGlobalResultSets

hasMultipleGlobalResultSets

getUpdateCount

getUpdateCount

getUpdateCounts

hasMultipleUpdateCounts

hasMultipleUpdateCounts

getUpdateCounts

getGlobalUpdateCount

getGlobalUpdateCounts

hasMultipleGlobalUpdateCounts

getGeneratedKeys

getGeneratedKeys

getGlobalGeneratedKeys

getReturnsResultSet

getThrowsSQLException

getSQLException

getSQLException

prepareResultSet

prepareResultSet

prepareResultSets

prepareResultSets

prepareGlobalResultSet

prepareGlobalResultSets

prepareUpdateCount

prepareUpdateCount

prepareUpdateCounts

prepareUpdateCounts

prepareGlobalUpdateCount

prepareGlobalUpdateCounts

prepareGeneratedKeys

prepareGeneratedKeys

prepareGlobalGeneratedKeys

prepareReturnsResultSet

prepareThrowsSQLException

prepareThrowsSQLException

prepareThrowsSQLException

prepareThrowsSQLException

getCaseSensitive