Esempio n. 1
0
 @Override
 public Statement getStatement(Connection connection) throws SQLException {
   Statement statement = connection.createStatement();
   if (statement.isWrapperFor(com.mysql.jdbc.Statement.class)) {
     statement.unwrap(com.mysql.jdbc.Statement.class).enableStreamingResults();
   }
   return statement;
 }
  @Test
  public void testStartKeyStopKey() throws SQLException {
    long ts = nextTimestamp();
    Properties props = new Properties();
    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts));
    Connection conn = DriverManager.getConnection(getUrl(), props);
    conn.createStatement()
        .execute(
            "CREATE TABLE start_stop_test (pk char(2) not null primary key) SPLIT ON ('EA','EZ')");
    conn.close();

    String query = "select count(*) from start_stop_test where pk >= 'EA' and pk < 'EZ'";
    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 2));
    conn = DriverManager.getConnection(getUrl(), props);
    Statement statement = conn.createStatement();
    statement.execute(query);
    PhoenixStatement pstatement = statement.unwrap(PhoenixStatement.class);
    List<KeyRange> splits = pstatement.getQueryPlan().getSplits();
    assertTrue(splits.size() > 0);
  }
Esempio n. 3
0
 private static void enableStreamingResults(Statement statement) throws SQLException {
   if (statement.isWrapperFor(com.mysql.jdbc.Statement.class)) {
     statement.unwrap(com.mysql.jdbc.Statement.class).enableStreamingResults();
   }
 }
  public Object invoke(Method method, Object[] args) throws Throwable {

    final String methodName = method.getName();

    if (!METHODS_TO_INTERCEPT.contains(methodName)) {
      return MethodUtils.proceedExecution(method, stmt, args);
    }

    // special treat for toString method
    if ("toString".equals(methodName)) {
      final StringBuilder sb = new StringBuilder();
      sb.append(stmt.getClass().getSimpleName());
      sb.append(" [");
      sb.append(stmt.toString());
      sb.append("]");
      return sb.toString(); // differentiate toString message.
    } else if ("getDataSourceName".equals(methodName)) {
      return dataSourceName;
    } else if ("getTarget".equals(methodName)) {
      // ProxyJdbcObject interface has method to return original object.
      return stmt;
    }

    if (StatementMethodNames.JDBC4_METHODS.contains(methodName)) {
      final Class<?> clazz = (Class<?>) args[0];
      if ("unwrap".equals(methodName)) {
        return stmt.unwrap(clazz);
      } else if ("isWrapperFor".equals(methodName)) {
        return stmt.isWrapperFor(clazz);
      }
    }

    if (StatementMethodNames.GET_CONNECTION_METHOD.contains(methodName)) {
      return connectionProxy;
    }

    if ("addBatch".equals(methodName) || "clearBatch".equals(methodName)) {
      if ("addBatch".equals(methodName) && ObjectArrayUtils.isFirstArgString(args)) {
        final QueryTransformer queryTransformer = interceptorHolder.getQueryTransformer();
        final String query = (String) args[0];
        final Class<? extends Statement> clazz = Statement.class;
        final int batchCount = batchQueries.size();
        final TransformInfo transformInfo =
            new TransformInfo(clazz, dataSourceName, query, true, batchCount);
        final String transformedQuery = queryTransformer.transformQuery(transformInfo);
        args[0] = transformedQuery; // replace to the new query
        batchQueries.add(transformedQuery);
      } else if ("clearBatch".equals(methodName)) {
        batchQueries.clear();
      }

      // proceed execution, no need to call listener
      try {
        return method.invoke(stmt, args);
      } catch (InvocationTargetException ex) {
        throw ex.getTargetException();
      }
    }

    List<QueryInfo> queries;
    boolean isBatchExecute = false;
    int batchSize = 0;

    if (StatementMethodNames.BATCH_EXEC_METHODS.contains(methodName)) {

      queries = new ArrayList<QueryInfo>(batchQueries.size());
      for (String batchQuery : batchQueries) {
        queries.add(new QueryInfo(batchQuery));
      }
      batchSize = batchQueries.size();
      batchQueries.clear();
      isBatchExecute = true;
      queries = Collections.unmodifiableList(queries);
    } else if (StatementMethodNames.QUERY_EXEC_METHODS.contains(methodName)
        && ObjectArrayUtils.isFirstArgString(args)) {
      final QueryTransformer queryTransformer = interceptorHolder.getQueryTransformer();
      final String query = (String) args[0];
      final TransformInfo transformInfo =
          new TransformInfo(Statement.class, dataSourceName, query, false, 0);
      final String transformedQuery = queryTransformer.transformQuery(transformInfo);
      args[0] = transformedQuery; // replace to the new query
      queries = Collections.singletonList(new QueryInfo(transformedQuery, null));
    } else {
      queries = Collections.emptyList();
    }

    final QueryExecutionListener listener = interceptorHolder.getListener();
    final ExecutionInfoBuilder execInfoBuilder =
        ExecutionInfoBuilder.create()
            .dataSourceName(dataSourceName)
            .batch(isBatchExecute)
            .batchSize(batchSize)
            .method(method)
            .methodArgs(args)
            .statement(stmt);
    listener.beforeQuery(execInfoBuilder.build(), queries);

    // Invoke method on original Statement.
    try {
      final TimeProvider timeProvider = connectionProxy.getTimeProvider();
      final long beforeTime = timeProvider.getCurrentTime();
      Object retVal;
      try {
        retVal = method.invoke(stmt, args);
      } finally {
        final long afterTime = timeProvider.getCurrentTime();
        execInfoBuilder.elapsedTime(afterTime - beforeTime, timeProvider.getTimeUnit());
      }

      execInfoBuilder.result(retVal);
      execInfoBuilder.success(true);

      return retVal;
    } catch (InvocationTargetException ex) {
      execInfoBuilder.throwable(ex.getTargetException());
      execInfoBuilder.success(false);
      throw ex.getTargetException();
    } finally {
      listener.afterQuery(execInfoBuilder.build(), queries);
    }
  }
Esempio n. 5
0
 @Override
 public <T> T unwrap(Class<T> iface) throws SQLException {
   return stat.unwrap(iface);
 }
 @Override
 public <T> T unwrap(Class<T> iface) throws SQLException {
   return inner.unwrap(iface); // TODO wrap this in a dynamic proxy to allow instrumentation?
 }