Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.mysql.jdbc
Class ReflectiveStatementInterceptorAdapter

    java.lang.Object
      com.mysql.jdbc.ReflectiveStatementInterceptorAdapter

All Implemented Interfaces:
  Extension, StatementInterceptorV2

    public class ReflectiveStatementInterceptorAdapter

extends java.lang.Object
implements StatementInterceptorV2

Field Summary
`(package private) java.lang.reflect.Method` | `v2PostProcessMethod`

Constructor Summary
`ReflectiveStatementInterceptorAdapter(StatementInterceptor toProxy)`

Method Summary
`void` | `destroy()` Called by the driver when this extension should release any resources it is holding and cleanup internally before the connection is closed.
`boolean` | `executeTopLevelOnly()` Should the driver execute this interceptor only for the "original" top-level query, and not put it in the execution path for queries that may be executed from other interceptors?
`static java.lang.reflect.Method` | `getV2PostProcessMethod(java.lang.Class<?> toProxyClass)`
`void` | `init(Connection conn, java.util.Properties props)` Called once per connection that wants to use the interceptor The properties are the same ones passed in in the URL or arguments to Driver.connect() or DriverManager.getConnection().
`ResultSetInternalMethods` | `postProcess(java.lang.String sql, Statement interceptedStatement, ResultSetInternalMethods originalResultSet, Connection connection, int warningCount, boolean noIndexUsed, boolean noGoodIndexUsed, java.sql.SQLException statementException)` Called after the given statement has been sent to the server for processing, instead of the StatementAware postProcess() of the earlier api.
`ResultSetInternalMethods` | `preProcess(java.lang.String sql, Statement interceptedStatement, Connection connection)` Called before the given statement is going to be sent to the server for processing.

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

Field Detail

### v2PostProcessMethod

    final java.lang.reflect.Method v2PostProcessMethod

Constructor Detail

### ReflectiveStatementInterceptorAdapter

    public ReflectiveStatementInterceptorAdapter(StatementInterceptor toProxy)

Method Detail

### destroy

    public void destroy()

  Description copied from interface: `StatementInterceptorV2`
  Called by the driver when this extension should release any resources it is holding and cleanup internally before the connection is closed.

  Specified by:
    `destroy` in interface `Extension`
  Specified by:
    `destroy` in interface `StatementInterceptorV2`

### executeTopLevelOnly

    public boolean executeTopLevelOnly()

  Description copied from interface: `StatementInterceptorV2`
  Should the driver execute this interceptor only for the "original" top-level query, and not put it in the execution path for queries that may be executed from other interceptors? If an interceptor issues queries using the connection it was created for, and does not return `true` for this method, it must ensure that it does not cause infinite recursion.

  Specified by:
    `executeTopLevelOnly` in interface `StatementInterceptorV2`
  Returns:
    true if the driver should ensure that this interceptor is only executed for the top-level "original" query.

### init

    public void init(Connection conn,
                     java.util.Properties props)
              throws java.sql.SQLException

  Description copied from interface: `StatementInterceptorV2`
  Called once per connection that wants to use the interceptor The properties are the same ones passed in in the URL or arguments to Driver.connect() or DriverManager.getConnection().

  Specified by:
    `init` in interface `Extension`
  Specified by:
    `init` in interface `StatementInterceptorV2`
  Parameters:
    `conn` - the connection for which this interceptor is being created
    `props` - configuration values as passed to the connection. Note that in order to support javax.sql.DataSources, configuration properties specific to an interceptor must be passed via setURL() on the DataSource. StatementInterceptor properties are not exposed via accessor/mutator methods on DataSources.
  Throws:
    `java.sql.SQLException` - should be thrown if the the StatementInterceptor can not initialize itself.

### postProcess

    public ResultSetInternalMethods postProcess(java.lang.String sql,
                                                Statement interceptedStatement,
                                                ResultSetInternalMethods originalResultSet,
                                                Connection connection,
                                                int warningCount,
                                                boolean noIndexUsed,
                                                boolean noGoodIndexUsed,
                                                java.sql.SQLException statementException)
                                         throws java.sql.SQLException

  Description copied from interface: `StatementInterceptorV2`
  Called after the given statement has been sent to the server for processing, instead of the StatementAware postProcess() of the earlier api. Interceptors are free to inspect the "original" result set, and if a different result set is returned by the interceptor, it is used in place of the "original" result set. (the result set returned by the interceptor must implement the interface com.mysql.jdbc.ResultSetInternalMethods). This method will be called while the connection-level mutex is held, so it will only be called from one thread at a time.

  Specified by:
    `postProcess` in interface `StatementInterceptorV2`
  Parameters:
    `sql` - the SQL representation of the statement
    `interceptedStatement` - the actual statement instance being intercepted
    `connection` - the connection the statement is using (passed in to make thread-safe implementations straightforward)
  Returns:
    a result set that should be returned to the application instead of results that are created from actual execution of the intercepted statement.
  Throws:
    `java.sql.SQLException` - if an error occurs during execution
  See Also:
    `ResultSetInternalMethods`

### preProcess

    public ResultSetInternalMethods preProcess(java.lang.String sql,
                                               Statement interceptedStatement,
                                               Connection connection)
                                        throws java.sql.SQLException

  Description copied from interface: `StatementInterceptorV2`
  Called before the given statement is going to be sent to the server for processing. Interceptors are free to return a result set (which must implement the interface com.mysql.jdbc.ResultSetInternalMethods), and if so, the server will not execute the query, and the given result set will be returned to the application instead. This method will be called while the connection-level mutex is held, so it will only be called from one thread at a time.

  Specified by:
    `preProcess` in interface `StatementInterceptorV2`
  Parameters:
    `sql` - the SQL representation of the statement
    `interceptedStatement` - the actual statement instance being intercepted
    `connection` - the connection the statement is using (passed in to make thread-safe implementations straightforward)
  Returns:
    a result set that should be returned to the application instead of results that are created from actual execution of the intercepted statement.
  Throws:
    `java.sql.SQLException` - if an error occurs during execution
  See Also:
    `ResultSetInternalMethods`

### getV2PostProcessMethod

    public static final java.lang.reflect.Method getV2PostProcessMethod(java.lang.Class<?> toProxyClass)

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD