Java Statement.setFetchSize方法代碼示例

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
private static ListenableFuture<ResultSet> executeAdaptiveQueryAsync(Session session, Statement statement, int fetchSize,
                                                                     int remainingAdaptations) {

    statement.setFetchSize(fetchSize);

    ResultSetFuture rawFuture = session.executeAsync(statement);

    // Lazily wrap the result set from the async result with an AdaptiveResultSet
    ListenableFuture<ResultSet> adaptiveFuture = Futures.transform(rawFuture, new Function<ResultSet, ResultSet>() {
        @Override
        public ResultSet apply(ResultSet resultSet) {
            return new AdaptiveResultSet(session, resultSet, remainingAdaptations);
        }
    });

    return Futures.withFallback(adaptiveFuture, t -> {
        if (isAdaptiveException(t) && remainingAdaptations > 0 && fetchSize > MIN_FETCH_SIZE) {
            // Try again with half the fetch size
            int reducedFetchSize = Math.max(fetchSize / 2, MIN_FETCH_SIZE);
            _log.debug("Repeating previous query with fetch size {} due to {}", reducedFetchSize, t.getMessage());
            return executeAdaptiveQueryAsync(session, statement, reducedFetchSize, remainingAdaptations - 1);
        }
        throw Throwables.propagate(t);
    });
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
/**
 * 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;
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
/**
 * Executes a query sychronously, dynamically adjusting the fetch size down if necessary.
 */
public static ResultSet executeAdaptiveQuery(Session session, Statement statement, int fetchSize) {
    int remainingAdaptations = MAX_ADAPTATIONS;
    while (true) {
        try {
            statement.setFetchSize(fetchSize);
            ResultSet resultSet = session.execute(statement);
            return new AdaptiveResultSet(session, resultSet, remainingAdaptations);
        } catch (Throwable t) {
            if (isAdaptiveException(t) && --remainingAdaptations != 0 && fetchSize > MIN_FETCH_SIZE) {
                // Try again with half the fetch size
                fetchSize = Math.max(fetchSize / 2, MIN_FETCH_SIZE);
                _log.debug("Repeating previous query with fetch size {} due to {}", fetchSize, t.getMessage());
            } else {
                throw Throwables.propagate(t);
            }
        }
    }
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
/**
 * @return a Collection view of all refs in the store
 * @throws IOException if an exception occurs when communicating to the
 *                     database
 */
public Collection<Ref> values() throws IOException {
    try {
        List<Ref> refs = new ArrayList<Ref>();
        Statement stmt = QueryBuilder
                .select()
                .all()
                .from(keyspace, TABLE_NAME);
        stmt.setFetchSize(FETCH_SIZE);
        ResultSet results = session.execute(stmt);
        for (Row row : results) {
            refs.add(rowToRef(row));
        }
        return refs;
    } catch (RuntimeException e) {
        e.printStackTrace();
        throw new IOException(e);
    }
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
/**
 * 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;
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
/**
 * Reduces the fetch size and retries the query.  Returns true if the query succeeded, false if the root cause
 * of the exception does not indicate a frame size issue, if the frame size cannot be adjusted down any further,
 * or if the retried query fails for an unrelated reason.
 */
private boolean reduceFetchSize(Throwable reason) {
    if (!isAdaptiveException(reason) || --_remainingAdaptations == 0) {
        return false;
    }

    ExecutionInfo executionInfo = _delegate.getExecutionInfo();
    Statement statement = executionInfo.getStatement();
    PagingState pagingState = executionInfo.getPagingState();
    int fetchSize = statement.getFetchSize();

    while (fetchSize > MIN_FETCH_SIZE) {
        fetchSize = Math.max(fetchSize / 2, MIN_FETCH_SIZE);
        _log.debug("Retrying query at next page with fetch size {} due to {}", fetchSize, reason.getMessage());
        statement.setFetchSize(fetchSize);
        statement.setPagingState(pagingState);
        try {
            _delegate = _session.execute(statement);
            return true;
        } catch (Throwable t) {
            // Exit the adaptation loop if the exception isn't one where adapting further may help
            if (!isAdaptiveException(t) || --_remainingAdaptations == 0) {
                return false;
            }
        }
    }

    return false;
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
/**
 * @return a list of all pack descriptions in the store.
 * @throws IOException  if an exception occurs when communicating to the
 *                      database
 */
public List<DfsPackDescription> listPacks() throws IOException {
    Statement stmt = QueryBuilder
            .select()
            .all()
            .from(keyspace, DESC_TABLE_NAME);
    stmt.setFetchSize(FETCH_SIZE);
    ResultSet results = session.execute(stmt);
    List<DfsPackDescription> packs = new ArrayList<DfsPackDescription>();
    for (Row row : results) {
        packs.add(rowToPackDescription(row));
    }
    return packs;
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
@Test
public void pageQueriedResults() {
    Statement query = new SimpleStatement("select * from cql3_pagination.simple_uuid_pk");
    query.setFetchSize(5);
    ResultSet resultSet = embeddedCassandra.session().execute(query);

    List<Row> page1 = new ArrayList<>();
    Iterator<Row> iterator1 = resultSet.iterator();
    while (resultSet.getAvailableWithoutFetching() > 0) {
        page1.add(iterator1.next());
    }
    print("Page 1: ", page1);

    Assert.assertEquals(5, page1.size());

    List<Row> page2 = new ArrayList<>();
    Iterator<Row> iterator2 = resultSet.iterator();
    resultSet.fetchMoreResults();
    iterator2.hasNext();
    while (resultSet.getAvailableWithoutFetching() > 0) {
        page2.add(iterator2.next());
    }
    print("Page 2: ", page2);

    Assert.assertEquals(5, page2.size());

    Assert.assertNotEquals(page1.get(0).getUUID("id"), page2.get(0).getUUID("id"));
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
private void executePagingQuery(String cql, int rowCount)
{
    // Execute an index query which should return all rows,
    // setting the fetch size < than the row count. Assert
    // that all rows are returned, so we know that paging
    // of the results was involved.
    Session session = sessionNet();
    Statement stmt = new SimpleStatement(String.format(cql, KEYSPACE + '.' + currentTable()));
    stmt.setFetchSize(rowCount - 1);
    assertEquals(rowCount, session.execute(stmt).all().size());
}
 

import com.datastax.driver.core.Statement; //導入方法依賴的package包/類
public boolean run() throws Exception
{
    State state = currentState.get();
    if (state == null)
    { // start processing a new token range
        TokenRange range = tokenRangeIterator.next();
        if (range == null)
            return true; // no more token ranges to process

        state = new State(range, buildQuery(range));
        currentState.set(state);
    }

    ResultSet results;
    Statement statement = new SimpleStatement(state.query);
    statement.setFetchSize(pageSize);

    if (state.pagingState != null)
        statement.setPagingState(state.pagingState);

    results = client.getSession().execute(statement);
    state.pagingState = results.getExecutionInfo().getPagingState();

    int remaining = results.getAvailableWithoutFetching();
    rowCount += remaining;

    for (Row row : results)
    {
        // this call will only succeed if we've added token(partition keys) to the query
        Token partition = row.getPartitionKeyToken();
        if (!state.partitions.contains(partition))
        {
            partitionCount += 1;
            state.partitions.add(partition);
        }

        if (--remaining == 0)
            break;
    }

    if (results.isExhausted() || isWarmup)
    { // no more pages to fetch or just warming up, ready to move on to another token range
        currentState.set(null);
    }

    return true;
}