Java Code Examples for com.datastax.driver.core.Statement#setConsistencyLevel()

protected ListenableFuture<List<D>> findListByStatementAsync(Statement statement) {
    if (statement != null) {
        statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
        ResultSetFuture resultSetFuture = getSession().executeAsync(statement);
        return Futures.transform(resultSetFuture, new Function<ResultSet, List<D>>() {
            @Nullable
            @Override
            public List<D> apply(@Nullable ResultSet resultSet) {
                Result<E> result = getMapper().map(resultSet);
                if (result != null) {
                    List<E> entities = result.all();
                    return DaoUtil.convertDataList(entities);
                } else {
                    return Collections.emptyList();
                }
            }
        });
    }
    return Futures.immediateFuture(Collections.emptyList());
}
 

protected ListenableFuture<D> findOneByStatementAsync(Statement statement) {
    if (statement != null) {
        statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
        ResultSetFuture resultSetFuture = getSession().executeAsync(statement);
        return Futures.transform(resultSetFuture, new Function<ResultSet, D>() {
            @Nullable
            @Override
            public D apply(@Nullable ResultSet resultSet) {
                Result<E> result = getMapper().map(resultSet);
                if (result != null) {
                    E entity = result.one();
                    return DaoUtil.getData(entity);
                } else {
                    return null;
                }
            }
        });
    }
    return Futures.immediateFuture(null);
}
 

@Override
public Collection<RepairSegment> getSegmentsWithState(UUID runId, State segmentState) {
  Collection<RepairSegment> segments = Lists.newArrayList();

  Statement statement = null != getRepairSegmentsByRunIdAndStatePrepStmt
      ? getRepairSegmentsByRunIdAndStatePrepStmt.bind(runId, segmentState.ordinal())
      // legacy mode for Cassandra-2 backends
      : getRepairSegmentsByRunIdPrepStmt.bind(runId);

  if (State.STARTED == segmentState) {
    statement = statement.setConsistencyLevel(ConsistencyLevel.LOCAL_QUORUM);
  }
  for (Row segmentRow : session.execute(statement)) {
    if (segmentRow.getInt("segment_state") == segmentState.ordinal()) {
      segments.add(createRepairSegmentFromRow(segmentRow));
    }
  }
  return segments;
}
 

/**
 * Tunes CQL statement execution options (consistency level, fetch option and etc.).
 *
 * @param statement Statement.
 * @return Modified statement.
 */
private Statement tuneStatementExecutionOptions(Statement statement) {
    String qry = "";

    if (statement instanceof BoundStatement)
        qry = ((BoundStatement)statement).preparedStatement().getQueryString().trim().toLowerCase();
    else if (statement instanceof PreparedStatement)
        qry = ((PreparedStatement)statement).getQueryString().trim().toLowerCase();

    boolean readStatement = qry.startsWith("select");
    boolean writeStatement = statement instanceof Batch || statement instanceof BatchStatement ||
        qry.startsWith("insert") || qry.startsWith("delete") || qry.startsWith("update");

    if (readStatement && readConsistency != null)
        statement.setConsistencyLevel(readConsistency);

    if (writeStatement && writeConsistency != null)
        statement.setConsistencyLevel(writeConsistency);

    if (fetchSize != null)
        statement.setFetchSize(fetchSize);

    return statement;
}
 

@Override
public void removeForPlace(UUID placeId) {
   try(Context ctxt = removeForPlaceTimer.time()) {
      List<AuthorizationGrant> grants = findForPlace(placeId);
      Statement statement = QueryBuilder.delete().from(AUTHORIZATION_GRANT_TABLE)
            .where(QueryBuilder.in(Cols.ENTITY_ID, grants.stream().map(AuthorizationGrant::getEntityId).collect(Collectors.toList())))
            .and(QueryBuilder.eq(Cols.PLACE_ID, placeId));
      statement.setConsistencyLevel(ConsistencyLevel.LOCAL_QUORUM);
      BatchStatement batch = new BatchStatement();
      batch.add(statement);
      batch.add(new BoundStatement(removeForPlace).bind(placeId));
      session.execute(batch);
   }
}
 

private ResultSet execute(Statement statement, ConsistencyLevel level) {
    log.debug("Execute cassandra statement {}", statement);
    if (statement.getConsistencyLevel() == null) {
        statement.setConsistencyLevel(level);
    }
    return getSession().execute(statement);
}
 

private ResultSetFuture executeAsync(Statement statement, ConsistencyLevel level) {
    log.debug("Execute cassandra async statement {}", statement);
    if (statement.getConsistencyLevel() == null) {
        statement.setConsistencyLevel(level);
    }
    return getSession().executeAsync(statement);
}
 

protected List<E> findListByStatement(Statement statement) {
    List<E> list = Collections.emptyList();
    if (statement != null) {
        statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
        ResultSet resultSet = getSession().execute(statement);
        Result<E> result = getMapper().map(resultSet);
        if (result != null) {
            list = result.all();
        }
    }
    return list;
}
 

protected E findOneByStatement(Statement statement) {
    E object = null;
    if (statement != null) {
        statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
        ResultSet resultSet = getSession().execute(statement);
        Result<E> result = getMapper().map(resultSet);
        if (result != null) {
            object = result.one();
        }
    }
    return object;
}
 

protected EntityResultSet<E> saveWithResult(E entity) {
    log.debug("Save entity {}", entity);
    if (entity.getId() == null) {
        entity.setId(UUIDs.timeBased());
    } else if (isDeleteOnSave()) {
        removeById(entity.getId());
    }
    Statement saveStatement = getSaveQuery(entity);
    saveStatement.setConsistencyLevel(cluster.getDefaultWriteConsistencyLevel());
    ResultSet resultSet = executeWrite(saveStatement);
    return new EntityResultSet<>(resultSet, entity);
}
 

public ListenableFuture<?> writeAsync(Statement statement) throws Exception {
    if (statement.getConsistencyLevel() == null && writeConsistencyLevel != null) {
        statement.setConsistencyLevel(writeConsistencyLevel);
    }
    return throttleWrite(() -> {
        // for now, need to record metrics in the same method because CassandraWriteMetrics
        // relies on some thread locals
        cassandraWriteMetrics.recordMetrics(statement);
        return wrappedSession.executeAsync(statement);
    });
}