コード例 #1
0
/**
 * @author Paul Ferraro
 * @param <D>
 * @param <P>
 */
@SuppressWarnings("nls")
public class ConnectionInvocationHandler<Z, D extends Database<Z>, P>
    extends ChildInvocationHandler<Z, D, P, Connection, SQLException> {
  private static final Set<Method> driverReadMethodSet =
      Methods.findMethods(
          Connection.class,
          "create(ArrayOf|Struct)",
          "getAutoCommit",
          "getCatalog",
          "getClientInfo",
          "getHoldability",
          "getTypeMap",
          "getWarnings",
          "isClosed",
          "isReadOnly",
          "nativeSQL");
  private static final Set<Method> databaseReadMethodSet =
      Methods.findMethods(Connection.class, "getTransactionIsolation", "isValid");
  private static final Set<Method> driverWriterMethodSet =
      Methods.findMethods(
          Connection.class, "clearWarnings", "setClientInfo", "setHoldability", "setTypeMap");
  private static final Set<Method> createStatementMethodSet =
      Methods.findMethods(Connection.class, "createStatement");
  private static final Set<Method> prepareStatementMethodSet =
      Methods.findMethods(Connection.class, "prepareStatement");
  private static final Set<Method> prepareCallMethodSet =
      Methods.findMethods(Connection.class, "prepareCall");
  private static final Set<Method> setSavepointMethodSet =
      Methods.findMethods(Connection.class, "setSavepoint");

  private static final Method setAutoCommitMethod =
      Methods.getMethod(Connection.class, "setAutoCommit", Boolean.TYPE);
  private static final Method commitMethod = Methods.getMethod(Connection.class, "commit");
  private static final Method rollbackMethod = Methods.getMethod(Connection.class, "rollback");
  private static final Method getMetaDataMethod =
      Methods.getMethod(Connection.class, "getMetaData");
  private static final Method releaseSavepointMethod =
      Methods.getMethod(Connection.class, "releaseSavepoint", Savepoint.class);
  private static final Method rollbackSavepointMethod =
      Methods.getMethod(Connection.class, "rollback", Savepoint.class);
  private static final Method closeMethod = Methods.getMethod(Connection.class, "close");
  private static final Method createBlobMethod = Methods.getMethod(Connection.class, "createBlob");
  private static final Method createClobMethod = Methods.getMethod(Connection.class, "createClob");
  private static final Method createNClobMethod =
      Methods.getMethod(Connection.class, "createNClob");
  private static final Method createSQLXMLMethod =
      Methods.getMethod(Connection.class, "createSQLXML");

  private static final Set<Method> endTransactionMethodSet =
      new HashSet<Method>(Arrays.asList(commitMethod, rollbackMethod, setAutoCommitMethod));
  private static final Set<Method> createLocatorMethodSet =
      new HashSet<Method>(
          Arrays.asList(createBlobMethod, createClobMethod, createNClobMethod, createSQLXMLMethod));

  private static final StaticRegistry<Method, Durability.Phase> phaseRegistry =
      new DurabilityPhaseRegistry(
          Arrays.asList(commitMethod, setAutoCommitMethod), Arrays.asList(rollbackMethod));

  private TransactionContext<Z, D> transactionContext;

  /**
   * Constructs a new ConnectionInvocationHandler
   *
   * @param proxy
   * @param handler
   * @param invoker
   * @param connectionMap
   * @param transactionContext
   */
  public ConnectionInvocationHandler(
      P proxy,
      SQLProxy<Z, D, P, SQLException> handler,
      Invoker<Z, D, P, Connection, SQLException> invoker,
      Map<D, Connection> connectionMap,
      TransactionContext<Z, D> transactionContext) {
    super(proxy, handler, invoker, Connection.class, SQLException.class, connectionMap);

    this.transactionContext = transactionContext;
  }

  /**
   * {@inheritDoc}
   *
   * @see net.sf.hajdbc.sql.AbstractInvocationHandler#getInvocationHandlerFactory(java.lang.Object,
   *     java.lang.reflect.Method, java.lang.Object[])
   */
  @Override
  protected InvocationHandlerFactory<Z, D, Connection, ?, SQLException> getInvocationHandlerFactory(
      Connection connection, Method method, Object[] parameters) {
    if (createStatementMethodSet.contains(method)) {
      return new StatementInvocationHandlerFactory<Z, D>(this.transactionContext);
    }

    if (prepareStatementMethodSet.contains(method)) {
      return new PreparedStatementInvocationHandlerFactory<Z, D>(
          this.transactionContext, (String) parameters[0]);
    }

    if (prepareCallMethodSet.contains(method)) {
      return new CallableStatementInvocationHandlerFactory<Z, D>(this.transactionContext);
    }

    if (setSavepointMethodSet.contains(method)) {
      return new SavepointInvocationHandlerFactory<Z, D>();
    }

    if (method.equals(getMetaDataMethod)) {
      return new DatabaseMetaDataInvocationHandlerFactory<Z, D>();
    }

    if (method.equals(createBlobMethod)) {
      return new BlobInvocationHandlerFactory<Z, D, Connection>(connection);
    }

    if (method.equals(createClobMethod)) {
      return new ClobInvocationHandlerFactory<Z, D, Connection>(connection);
    }

    if (method.equals(createNClobMethod)) {
      return new NClobInvocationHandlerFactory<Z, D, Connection>(connection);
    }

    if (method.equals(createSQLXMLMethod)) {
      return new SQLXMLInvocationHandlerFactory<Z, D, Connection>(connection);
    }

    return null;
  }

  /**
   * @throws SQLException
   * @see net.sf.hajdbc.sql.AbstractChildInvocationHandler#getInvocationStrategy(java.lang.Object,
   *     java.lang.reflect.Method, java.lang.Object[])
   */
  @Override
  protected InvocationStrategy getInvocationStrategy(
      Connection connection, Method method, Object[] parameters) throws SQLException {
    if (driverReadMethodSet.contains(method)) {
      return InvocationStrategyEnum.INVOKE_ON_ANY;
    }

    if (databaseReadMethodSet.contains(method) || method.equals(getMetaDataMethod)) {
      return InvocationStrategyEnum.INVOKE_ON_NEXT;
    }

    if (driverWriterMethodSet.contains(method)
        || method.equals(closeMethod)
        || createStatementMethodSet.contains(method)) {
      return InvocationStrategyEnum.INVOKE_ON_EXISTING;
    }

    if (prepareStatementMethodSet.contains(method)
        || prepareCallMethodSet.contains(method)
        || createLocatorMethodSet.contains(method)) {
      return InvocationStrategyEnum.INVOKE_ON_ALL;
    }

    if (endTransactionMethodSet.contains(method)) {
      return this.transactionContext.end(
          InvocationStrategyEnum.END_TRANSACTION_INVOKE_ON_ALL, phaseRegistry.get(method));
    }

    if (method.equals(rollbackSavepointMethod) || method.equals(releaseSavepointMethod)) {
      return InvocationStrategyEnum.END_TRANSACTION_INVOKE_ON_ALL;
    }

    if (setSavepointMethodSet.contains(method)) {
      return InvocationStrategyEnum.TRANSACTION_INVOKE_ON_ALL;
    }

    return super.getInvocationStrategy(connection, method, parameters);
  }

  /**
   * @see net.sf.hajdbc.sql.AbstractChildInvocationHandler#getInvoker(java.lang.Object,
   *     java.lang.reflect.Method, java.lang.Object[])
   */
  @Override
  protected <R> Invoker<Z, D, Connection, R, SQLException> getInvoker(
      Connection connection, Method method, Object[] parameters) throws SQLException {
    if (method.equals(releaseSavepointMethod)) {
      final SQLProxy<Z, D, Savepoint, SQLException> proxy =
          this.getInvocationHandler((Savepoint) parameters[0]);

      return new Invoker<Z, D, Connection, R, SQLException>() {
        @Override
        public R invoke(D database, Connection connection) throws SQLException {
          connection.releaseSavepoint(proxy.getObject(database));

          return null;
        }
      };
    }

    if (method.equals(rollbackSavepointMethod)) {
      final SQLProxy<Z, D, Savepoint, SQLException> proxy =
          this.getInvocationHandler((Savepoint) parameters[0]);

      return new Invoker<Z, D, Connection, R, SQLException>() {
        @Override
        public R invoke(D database, Connection connection) throws SQLException {
          connection.rollback(proxy.getObject(database));

          return null;
        }
      };
    }

    Invoker<Z, D, Connection, R, SQLException> invoker =
        super.getInvoker(connection, method, parameters);

    if (endTransactionMethodSet.contains(method)) {
      return this.transactionContext.end(invoker, phaseRegistry.get(method));
    }

    return invoker;
  }

  /** @see net.sf.hajdbc.sql.AbstractChildInvocationHandler#isSQLMethod(java.lang.reflect.Method) */
  @Override
  protected boolean isSQLMethod(Method method) {
    return prepareStatementMethodSet.contains(method);
  }

  @Override
  protected boolean isRecordable(Method method) {
    return driverWriterMethodSet.contains(method) || method.equals(setAutoCommitMethod);
  }

  /**
   * @see net.sf.hajdbc.sql.AbstractChildInvocationHandler#postInvoke(java.lang.Object,
   *     java.lang.reflect.Method, java.lang.Object[])
   */
  @Override
  protected void postInvoke(Connection object, Method method, Object[] parameters) {
    if (method.equals(closeMethod)) {
      this.transactionContext.close();

      this.getParentProxy().removeChild(this);
    } else if (method.equals(releaseSavepointMethod)) {
      @SuppressWarnings("unchecked")
      SQLProxy<Z, D, Savepoint, SQLException> proxy =
          (SQLProxy<Z, D, Savepoint, SQLException>) Proxy.getInvocationHandler(parameters[0]);

      this.removeChild(proxy);
    }
  }

  /**
   * @see net.sf.hajdbc.sql.AbstractChildInvocationHandler#close(java.lang.Object, java.lang.Object)
   */
  @Override
  protected void close(P parent, Connection connection) throws SQLException {
    connection.close();
  }
}
コード例 #2
0
/**
 * @author Paul Ferraro
 * @param <D>
 * @param <P>
 */
public class ConnectionInvocationHandler<Z, D extends Database<Z>, P>
    extends ChildInvocationHandler<
        Z, D, P, SQLException, Connection, SQLException, ConnectionProxyFactory<Z, D, P>> {
  private static final Set<Method> driverReadMethodSet =
      Methods.findMethods(
          Connection.class,
          "createStruct",
          "getAutoCommit",
          "getCatalog",
          "getClientInfo",
          "getHoldability",
          "getNetworkTimeout",
          "getSchema",
          "getTypeMap",
          "getWarnings",
          "isClosed",
          "isCloseOnCompletion",
          "isReadOnly",
          "nativeSQL");
  private static final Set<Method> databaseReadMethodSet =
      Methods.findMethods(Connection.class, "getTransactionIsolation", "isValid");
  private static final Set<Method> driverWriterMethodSet =
      Methods.findMethods(
          Connection.class,
          "abort",
          "clearWarnings",
          "closeOnCompletion",
          "setClientInfo",
          "setHoldability",
          "setNetworkTimeout",
          "setSchema",
          "setTypeMap");
  private static final Set<Method> createStatementMethodSet =
      Methods.findMethods(Connection.class, "createStatement");
  private static final Set<Method> prepareStatementMethodSet =
      Methods.findMethods(Connection.class, "prepareStatement");
  private static final Set<Method> prepareCallMethodSet =
      Methods.findMethods(Connection.class, "prepareCall");
  private static final Set<Method> setSavepointMethodSet =
      Methods.findMethods(Connection.class, "setSavepoint");

  private static final Method setAutoCommitMethod =
      Methods.getMethod(Connection.class, "setAutoCommit", Boolean.TYPE);
  private static final Method commitMethod = Methods.getMethod(Connection.class, "commit");
  private static final Method rollbackMethod = Methods.getMethod(Connection.class, "rollback");
  private static final Method getMetaDataMethod =
      Methods.getMethod(Connection.class, "getMetaData");
  private static final Method releaseSavepointMethod =
      Methods.getMethod(Connection.class, "releaseSavepoint", Savepoint.class);
  private static final Method rollbackSavepointMethod =
      Methods.getMethod(Connection.class, "rollback", Savepoint.class);
  private static final Method closeMethod = Methods.getMethod(Connection.class, "close");
  private static final Method createArrayMethod =
      Methods.getMethod(Connection.class, "createArrayOf", String.class, Object[].class);
  private static final Method createBlobMethod = Methods.getMethod(Connection.class, "createBlob");
  private static final Method createClobMethod = Methods.getMethod(Connection.class, "createClob");
  private static final Method createNClobMethod =
      Methods.getMethod(Connection.class, "createNClob");
  private static final Method createSQLXMLMethod =
      Methods.getMethod(Connection.class, "createSQLXML");

  private static final Set<Method> endTransactionMethodSet =
      new HashSet<Method>(Arrays.asList(commitMethod, rollbackMethod, setAutoCommitMethod));
  private static final Set<Method> createLocatorMethodSet =
      new HashSet<Method>(
          Arrays.asList(createBlobMethod, createClobMethod, createNClobMethod, createSQLXMLMethod));

  private static final StaticRegistry<Method, Durability.Phase> phaseRegistry =
      new DurabilityPhaseRegistry(
          Arrays.asList(commitMethod, setAutoCommitMethod), Arrays.asList(rollbackMethod));

  /**
   * Constructs a new ConnectionInvocationHandler
   *
   * @param proxy
   * @param handler
   * @param invoker
   * @param connectionMap
   * @param transactionContext
   */
  public ConnectionInvocationHandler(ConnectionProxyFactory<Z, D, P> map) {
    super(Connection.class, map, null);
  }

  @Override
  protected ProxyFactoryFactory<Z, D, Connection, SQLException, ?, ? extends Exception>
      getProxyFactoryFactory(Connection connection, Method method, Object... parameters)
          throws SQLException {
    if (createStatementMethodSet.contains(method)) {
      return new StatementProxyFactoryFactory<Z, D>(this.getProxyFactory().getTransactionContext());
    }
    if (prepareStatementMethodSet.contains(method)) {
      String sql = (String) parameters[0];
      return new PreparedStatementProxyFactoryFactory<Z, D>(
          this.getProxyFactory().getTransactionContext(),
          this.getProxyFactory().extractLocks(sql),
          this.getProxyFactory().isSelectForUpdate(sql));
    }
    if (prepareCallMethodSet.contains(method)) {
      String sql = (String) parameters[0];
      return new CallableStatementProxyFactoryFactory<Z, D>(
          this.getProxyFactory().getTransactionContext(), this.getProxyFactory().extractLocks(sql));
    }

    if (setSavepointMethodSet.contains(method)) {
      return new SavepointProxyFactoryFactory<Z, D>();
    }

    if (method.equals(getMetaDataMethod)) {
      return new DatabaseMetaDataProxyFactoryFactory<Z, D>();
    }

    if (method.equals(createArrayMethod)) {
      return new ArrayProxyFactoryFactory<Z, D, Connection>(
          this.getProxyFactory().locatorsUpdateCopy());
    }
    if (method.equals(createBlobMethod)) {
      return new BlobProxyFactoryFactory<Z, D, Connection>(
          this.getProxyFactory().locatorsUpdateCopy());
    }
    if (method.equals(createClobMethod)) {
      return new ClobProxyFactoryFactory<Z, D, Connection, Clob>(
          Clob.class, this.getProxyFactory().locatorsUpdateCopy());
    }
    if (method.equals(createNClobMethod)) {
      return new ClobProxyFactoryFactory<Z, D, Connection, NClob>(
          NClob.class, this.getProxyFactory().locatorsUpdateCopy());
    }
    if (method.equals(createSQLXMLMethod)) {
      return new SQLXMLProxyFactoryFactory<Z, D, Connection>(
          this.getProxyFactory().locatorsUpdateCopy());
    }

    return super.getProxyFactoryFactory(connection, method, parameters);
  }

  /**
   * @throws SQLException
   * @see net.sf.hajdbc.sql.AbstractChildInvocationHandler#getInvocationStrategy(java.lang.Object,
   *     java.lang.reflect.Method, java.lang.Object[])
   */
  @Override
  protected InvocationStrategy getInvocationStrategy(
      Connection connection, Method method, Object... parameters) throws SQLException {
    if (driverReadMethodSet.contains(method)) {
      return InvocationStrategies.INVOKE_ON_ANY;
    }

    if (databaseReadMethodSet.contains(method) || method.equals(getMetaDataMethod)) {
      return InvocationStrategies.INVOKE_ON_NEXT;
    }

    if (driverWriterMethodSet.contains(method)
        || method.equals(closeMethod)
        || createStatementMethodSet.contains(method)) {
      return InvocationStrategies.INVOKE_ON_EXISTING;
    }

    if (prepareStatementMethodSet.contains(method)
        || prepareCallMethodSet.contains(method)
        || createLocatorMethodSet.contains(method)) {
      return InvocationStrategies.INVOKE_ON_ALL;
    }

    if (endTransactionMethodSet.contains(method)) {
      return this.getProxyFactory()
          .getTransactionContext()
          .end(InvocationStrategies.END_TRANSACTION_INVOKE_ON_ALL, phaseRegistry.get(method));
    }

    if (method.equals(rollbackSavepointMethod) || method.equals(releaseSavepointMethod)) {
      return InvocationStrategies.END_TRANSACTION_INVOKE_ON_ALL;
    }

    if (setSavepointMethodSet.contains(method)) {
      return InvocationStrategies.TRANSACTION_INVOKE_ON_ALL;
    }

    return super.getInvocationStrategy(connection, method, parameters);
  }

  /**
   * @see net.sf.hajdbc.sql.AbstractChildInvocationHandler#getInvoker(java.lang.Object,
   *     java.lang.reflect.Method, java.lang.Object[])
   */
  @Override
  protected <R> Invoker<Z, D, Connection, R, SQLException> getInvoker(
      Connection connection, Method method, Object... parameters) throws SQLException {
    if (method.equals(releaseSavepointMethod) || method.equals(rollbackSavepointMethod)) {
      return this.getInvoker(Savepoint.class, 0, connection, method, parameters);
    }

    if (prepareStatementMethodSet.contains(method) || prepareCallMethodSet.contains(method)) {
      parameters[0] = this.getProxyFactory().evaluate((String) parameters[0]);
    }

    Invoker<Z, D, Connection, R, SQLException> invoker =
        super.getInvoker(connection, method, parameters);

    if (endTransactionMethodSet.contains(method)) {
      return this.getProxyFactory().getTransactionContext().end(invoker, phaseRegistry.get(method));
    }

    return invoker;
  }

  @Override
  protected <R> void postInvoke(
      Invoker<Z, D, Connection, R, SQLException> invoker,
      Connection proxy,
      Method method,
      Object... parameters) {
    if (driverWriterMethodSet.contains(method) || method.equals(setAutoCommitMethod)) {
      this.getProxyFactory().record(invoker);
    } else if (method.equals(closeMethod)) {
      this.getProxyFactory().getTransactionContext().close();
      this.getProxyFactory().remove();
    } else if (method.equals(releaseSavepointMethod)) {
      SavepointInvocationHandler<Z, D> handler =
          (SavepointInvocationHandler<Z, D>) Proxy.getInvocationHandler(parameters[0]);
      this.getProxyFactory().removeChild(handler.getProxyFactory());
    }
  }
}
コード例 #3
0
/**
 * @author Paul Ferraro
 * @param <D>
 * @param <S>
 */
@SuppressWarnings("nls")
public abstract class AbstractStatementInvocationHandler<
        Z,
        D extends Database<Z>,
        S extends Statement,
        F extends AbstractStatementProxyFactory<Z, D, S>>
    extends InputSinkRegistryInvocationHandler<Z, D, Connection, S, F> {
  private static final Set<Method> driverReadMethodSet =
      Methods.findMethods(
          Statement.class,
          "getFetchDirection",
          "getFetchSize",
          "getGeneratedKeys",
          "getMaxFieldSize",
          "getMaxRows",
          "getQueryTimeout",
          "getResultSetConcurrency",
          "getResultSetHoldability",
          "getResultSetType",
          "getUpdateCount",
          "getWarnings",
          "isClosed",
          "isPoolable");
  private static final Set<Method> driverWriteMethodSet =
      Methods.findMethods(
          Statement.class,
          "clearWarnings",
          "setCursorName",
          "setEscapeProcessing",
          "setFetchDirection",
          "setFetchSize",
          "setMaxFieldSize",
          "setMaxRows",
          "setPoolable",
          "setQueryTimeout");
  private static final Set<Method> executeMethodSet =
      Methods.findMethods(Statement.class, "execute(Update)?");

  private static final Method getConnectionMethod =
      Methods.getMethod(Statement.class, "getConnection");
  private static final Method executeQueryMethod =
      Methods.getMethod(Statement.class, "executeQuery", String.class);
  private static final Method clearBatchMethod = Methods.getMethod(Statement.class, "clearBatch");
  private static final Method executeBatchMethod =
      Methods.getMethod(Statement.class, "executeBatch");
  private static final Method getMoreResultsMethod =
      Methods.getMethod(Statement.class, "getMoreResults", Integer.TYPE);
  private static final Method getResultSetMethod =
      Methods.getMethod(Statement.class, "getResultSet");
  private static final Method addBatchMethod =
      Methods.getMethod(Statement.class, "addBatch", String.class);
  private static final Method closeMethod = Methods.getMethod(Statement.class, "close");

  public AbstractStatementInvocationHandler(Class<S> statementClass, F proxyFactory) {
    super(statementClass, proxyFactory, getConnectionMethod);
  }

  @Override
  protected ProxyFactoryFactory<Z, D, S, SQLException, ?, ? extends Exception>
      getProxyFactoryFactory(S object, Method method, Object... parameters) throws SQLException {
    if (method.equals(executeQueryMethod) || method.equals(getResultSetMethod)) {
      return new ResultSetProxyFactoryFactory<Z, D, S>(
          this.getProxyFactory().getTransactionContext(),
          this.getProxyFactory().getInputSinkRegistry());
    }

    return super.getProxyFactoryFactory(object, method, parameters);
  }

  @Override
  protected InvocationStrategy getInvocationStrategy(
      S statement, Method method, Object... parameters) throws SQLException {
    if (driverReadMethodSet.contains(method)) {
      return InvocationStrategies.INVOKE_ON_ANY;
    }

    if (driverWriteMethodSet.contains(method) || method.equals(closeMethod)) {
      return InvocationStrategies.INVOKE_ON_EXISTING;
    }

    if (executeMethodSet.contains(method)) {
      List<Lock> locks = this.getProxyFactory().extractLocks((String) parameters[0]);

      return this.getProxyFactory()
          .getTransactionContext()
          .start(
              new LockingInvocationStrategy(InvocationStrategies.TRANSACTION_INVOKE_ON_ALL, locks),
              this.getProxyFactory().getParentProxy());
    }

    if (method.equals(executeQueryMethod)) {
      String sql = (String) parameters[0];

      List<Lock> locks = this.getProxyFactory().extractLocks(sql);
      int concurrency = statement.getResultSetConcurrency();
      boolean selectForUpdate = this.getProxyFactory().isSelectForUpdate(sql);

      if (locks.isEmpty() && (concurrency == ResultSet.CONCUR_READ_ONLY) && !selectForUpdate) {
        boolean repeatableReadSelect =
            (statement.getConnection().getTransactionIsolation()
                >= Connection.TRANSACTION_REPEATABLE_READ);

        return repeatableReadSelect
            ? InvocationStrategies.INVOKE_ON_PRIMARY
            : InvocationStrategies.INVOKE_ON_NEXT;
      }

      InvocationStrategy strategy = InvocationStrategies.TRANSACTION_INVOKE_ON_ALL;
      if (!locks.isEmpty()) {
        strategy = new LockingInvocationStrategy(strategy, locks);
      }

      return selectForUpdate
          ? this.getProxyFactory()
              .getTransactionContext()
              .start(strategy, this.getProxyFactory().getParentProxy())
          : strategy;
    }

    if (method.equals(executeBatchMethod)) {
      return this.getProxyFactory()
          .getTransactionContext()
          .start(
              new LockingInvocationStrategy(
                  InvocationStrategies.TRANSACTION_INVOKE_ON_ALL,
                  this.getProxyFactory().getBatchLocks()),
              this.getProxyFactory().getParentProxy());
    }

    if (method.equals(getMoreResultsMethod)) {
      if (parameters[0].equals(Statement.KEEP_CURRENT_RESULT)) {
        return InvocationStrategies.INVOKE_ON_EXISTING;
      }
    }

    if (method.equals(getResultSetMethod)) {
      if (statement.getResultSetConcurrency() == ResultSet.CONCUR_READ_ONLY) {
        return InvocationStrategies.INVOKE_ON_EXISTING;
      }

      return InvocationStrategies.INVOKE_ON_ALL;
    }

    return super.getInvocationStrategy(statement, method, parameters);
  }

  @Override
  protected <R> Invoker<Z, D, S, R, SQLException> getInvoker(
      S proxy, Method method, Object... parameters) throws SQLException {
    if (method.equals(addBatchMethod)
        || method.equals(executeQueryMethod)
        || executeMethodSet.contains(method)) {
      parameters[0] = this.getProxyFactory().evaluate((String) parameters[0]);
    }

    return super.getInvoker(proxy, method, parameters);
  }

  @Override
  protected <R> void postInvoke(
      Invoker<Z, D, S, R, SQLException> invoker, S proxy, Method method, Object... parameters) {
    if (method.equals(addBatchMethod)) {
      this.getProxyFactory().addBatchSQL((String) parameters[0]);
    } else if (method.equals(clearBatchMethod) || method.equals(executeBatchMethod)) {
      this.getProxyFactory().clearBatch();
      this.logger.log(Level.TRACE, "Clearing recorded batch methods");
      this.getProxyFactory().clearBatchInvokers();
    } else if (method.equals(closeMethod)) {
      Resources.close(this.getProxyFactory().getInputSinkRegistry());
      this.getProxyFactory().remove();
    }

    if (this.isBatchMethod(method)) {
      this.logger.log(Level.TRACE, "Recording batch method: {0}", invoker);
      this.getProxyFactory().addBatchInvoker(invoker);
    } else if (driverWriteMethodSet.contains(method)) {
      this.getProxyFactory().record(invoker);
    }
  }

  protected boolean isBatchMethod(Method method) {
    return method.equals(addBatchMethod);
  }
}