How to use

addPrepared

method

in

com.datastax.driver.core.Cluster$Manager

  DefaultPreparedStatement.fromMessage(
    pmsg, cluster, query, poolsState.keyspace);
stmt = cluster.manager.addPrepared(stmt);
if (cluster.getConfiguration().getQueryOptions().isPrepareOnAllHosts()) {

  public PreparedStatement apply(Message.Response response) {
    switch (response.type) {
      case RESULT:
        Responses.Result rm = (Responses.Result)response;
        switch (rm.kind) {
          case PREPARED:
            Responses.Result.Prepared pmsg = (Responses.Result.Prepared)rm;
            PreparedStatement stmt = DefaultPreparedStatement.fromMessage(pmsg, cluster.getMetadata(), query, poolsState.keyspace);
            stmt = cluster.manager.addPrepared(stmt);
            try {
              // All Sessions are connected to the same nodes so it's enough to prepare only the nodes of this session.
              // If that changes, we'll have to make sure this propagate to other sessions too.
              prepare(stmt.getQueryString(), future.getAddress());
            } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
              // This method doesn't propagate interruption, at least not for now. However, if we've
              // interrupted preparing queries on other node it's not a problem as we'll re-prepare
              // later if need be. So just ignore.
            }
            return stmt;
          default:
            throw new DriverInternalError(String.format("%s response received when prepared statement was expected", rm.kind));
        }
      case ERROR:
        throw ((Responses.Error)response).asException(future.getAddress());
      default:
        throw new DriverInternalError(String.format("%s response received when prepared statement was expected", response.type));
    }
  }
}, executor()); // Since the transformation involves querying other nodes, we should not do that in an I/O thread

  @Override
  public ListenableFuture<PreparedStatement> apply(Response response) {
    switch (response.type) {
      case RESULT:
        Responses.Result rm = (Responses.Result) response;
        switch (rm.kind) {
          case PREPARED:
            Responses.Result.Prepared pmsg = (Responses.Result.Prepared) rm;
            PreparedStatement stmt = DefaultPreparedStatement.fromMessage(pmsg, cluster, query, poolsState.keyspace);
            stmt = cluster.manager.addPrepared(stmt);
            if (cluster.getConfiguration().getQueryOptions().isPrepareOnAllHosts()) {
              // All Sessions are connected to the same nodes so it's enough to prepare only the nodes of this session.
              // If that changes, we'll have to make sure this propagate to other sessions too.
              return prepare(stmt, future.getAddress());
            } else {
              return Futures.immediateFuture(stmt);
            }
          default:
            return Futures.immediateFailedFuture(
                new DriverInternalError(String.format("%s response received when prepared statement was expected", rm.kind)));
        }
      case ERROR:
        return Futures.immediateFailedFuture(
            ((Responses.Error) response).asException(future.getAddress()));
      default:
        return Futures.immediateFailedFuture(
            new DriverInternalError(String.format("%s response received when prepared statement was expected", response.type)));
    }
  }
}, executor());

  @Override
  public ListenableFuture<PreparedStatement> apply(Response response) {
    switch (response.type) {
      case RESULT:
        Responses.Result rm = (Responses.Result) response;
        switch (rm.kind) {
          case PREPARED:
            Responses.Result.Prepared pmsg = (Responses.Result.Prepared) rm;
            PreparedStatement stmt = DefaultPreparedStatement.fromMessage(pmsg, cluster, query, poolsState.keyspace);
            stmt = cluster.manager.addPrepared(stmt);
            if (cluster.getConfiguration().getQueryOptions().isPrepareOnAllHosts()) {
              // All Sessions are connected to the same nodes so it's enough to prepare only the nodes of this session.
              // If that changes, we'll have to make sure this propagate to other sessions too.
              return prepare(stmt, future.getAddress());
            } else {
              return Futures.immediateFuture(stmt);
            }
          default:
            return Futures.immediateFailedFuture(
                new DriverInternalError(String.format("%s response received when prepared statement was expected", rm.kind)));
        }
      case ERROR:
        return Futures.immediateFailedFuture(
            ((Responses.Error) response).asException(future.getAddress()));
      default:
        return Futures.immediateFailedFuture(
            new DriverInternalError(String.format("%s response received when prepared statement was expected", response.type)));
    }
  }
}, executor());

  @Override
  public ListenableFuture<PreparedStatement> apply(Response response) {
    switch (response.type) {
      case RESULT:
        Responses.Result rm = (Responses.Result) response;
        switch (rm.kind) {
          case PREPARED:
            Responses.Result.Prepared pmsg = (Responses.Result.Prepared) rm;
            PreparedStatement stmt = DefaultPreparedStatement.fromMessage(pmsg, cluster, query, poolsState.keyspace);
            stmt = cluster.manager.addPrepared(stmt);
            if (cluster.getConfiguration().getQueryOptions().isPrepareOnAllHosts()) {
              // All Sessions are connected to the same nodes so it's enough to prepare only the nodes of this session.
              // If that changes, we'll have to make sure this propagate to other sessions too.
              return prepare(stmt, future.getAddress());
            } else {
              return Futures.immediateFuture(stmt);
            }
          default:
            return Futures.immediateFailedFuture(
                new DriverInternalError(String.format("%s response received when prepared statement was expected", rm.kind)));
        }
      case ERROR:
        return Futures.immediateFailedFuture(
            ((Responses.Error) response).asException(future.getAddress()));
      default:
        return Futures.immediateFailedFuture(
            new DriverInternalError(String.format("%s response received when prepared statement was expected", response.type)));
    }
  }
}, executor());