public T execute()

in wrapper/src/main/java/software/amazon/jdbc/plugin/DataCacheConnectionPlugin.java [106:163]
50 lines of code
10 McCabe index (conditional complexity)

  public <T, E extends Exception> T execute(
      final Class<T> resultClass,
      final Class<E> exceptionClass,
      final Object methodInvokeOn,
      final String methodName,
      final JdbcCallable<T, E> jdbcMethodFunc,
      final Object[] jdbcMethodArgs)
      throws E {

    if (StringUtils.isNullOrEmpty(this.dataCacheTriggerCondition) || resultClass != ResultSet.class) {
      return jdbcMethodFunc.call();
    }

    totalCallsCounter.inc();

    ResultSet result;
    boolean needToCache = false;
    final String sql = getQuery(jdbcMethodArgs);

    if (!StringUtils.isNullOrEmpty(sql) && sql.matches(this.dataCacheTriggerCondition)) {
      result = dataCache.get(sql);
      if (result == null) {
        needToCache = true;
        missCounter.inc();
        LOGGER.finest(
            () -> Messages.get(
                "DataCacheConnectionPlugin.queryResultsCached",
                new Object[]{methodName, sql}));
      } else {
        hitCounter.inc();
        try {
          result.beforeFirst();
        } catch (final SQLException ex) {
          if (exceptionClass.isAssignableFrom(ex.getClass())) {
            throw exceptionClass.cast(ex);
          }
          throw new RuntimeException(ex);
        }
        return resultClass.cast(result);
      }
    }

    result = (ResultSet) jdbcMethodFunc.call();

    if (needToCache) {
      final ResultSet cachedResultSet;
      try {
        cachedResultSet = new CachedResultSet(result);
        dataCache.put(sql, cachedResultSet);
        cachedResultSet.beforeFirst();
        return resultClass.cast(cachedResultSet);
      } catch (final SQLException ex) {
        // ignore exception
      }
    }

    return resultClass.cast(result);
  }