/** * Executes the provided query asynchronously. * * @param statement the CQL query to execute (that can be any {@code Statement}). * * @return a future on the result of the query. */ ResultSetFuture executeAsync(Statement statement) { return ses.executeAsync(statement); } }
public ResultSetFuture executeAsync(Statement statement) { return m_session.executeAsync(statement); }
@Override public ListenableFuture<ResultSet> send(IN value) { return session.executeAsync(mapper.saveQuery(value)); } }
/** * Asynchronously executes the specified batch statement. Inputs will be passed to * the {@link #handler} once query succeed or failed. */ public SettableFuture<T> execAsync(final Statement statement, final T inputs, final AsyncResultHandler<T> handler) { final SettableFuture<T> settableFuture = SettableFuture.create(); pending.incrementAndGet(); ResultSetFuture future = session.executeAsync(statement); Futures.addCallback(future, new FutureCallback<ResultSet>() { public void release() { pending.decrementAndGet(); } @Override public void onSuccess(ResultSet result) { release(); settableFuture.set(inputs); handler.success(inputs); } @Override public void onFailure(Throwable t) { LOG.error(String.format("Failed to execute statement '%s' ", statement), t); release(); settableFuture.setException(t); handler.failure(t, inputs); } }, executorService); return settableFuture; }
@Override public void writeRecord(OUT record) throws IOException { if (exception != null) { throw new IOException("write record failed", exception); } Object[] fields = extractFields(record); ResultSetFuture result = session.executeAsync(prepared.bind(fields)); Futures.addCallback(result, callback); }
@Override public ListenableFuture<ResultSet> send(IN value) { Object[] fields = extract(value); return session.executeAsync(ps.bind(fields)); }
ResultSetFuture result = session.executeAsync(s); updatesSent++; if (result != null) {
ResultSetFuture result = session.executeAsync(s); updatesSent++; if (result != null) {
final T input = inputs.get(i); final Statement statement = statements.get(i); ResultSetFuture future = session.executeAsync(statement); Futures.addCallback(future, new FutureCallback<ResultSet>() { @Override
/** * Execute a query and map result to entityClass. * * @param entityClass Entity class. * @param statement Statement to execute. * @return A listenable future holding the result. */ public <T> ListenableFuture<Result<T>> queryAsync(final Class<T> entityClass, final Statement statement) { Mapper<T> mapper = mapper(entityClass); Session session = mapper.getManager().getSession(); ResultSetFuture rs = session.executeAsync(statement); return Futures.transformAsync(rs, rs1 -> Futures.immediateFuture(mapper.map(rs1))); } }
@Override public ListenableFuture<ResultSet> apply(Session session) throws Exception { return session.executeAsync(useQuery); } });
ResultSetFuture future = connectionSession.executeAsync(boundStatement); if (statementTimeout > 0) { future.getUninterruptibly(statementTimeout, TimeUnit.MILLISECONDS);
private static void createTableIfNotExists(final com.datastax.driver.core.Session session, final String table, final Logger log) { Create createTable = SchemaBuilder.createTable(table) .addPartitionKey(ID, DataType.varchar()) .addColumn(CREATED_AT, DataType.timestamp()) .addColumn(ACCESSED_AT, DataType.timestamp()) .addColumn(SAVED_AT, DataType.timestamp()) .addColumn(ATTRIBUTES, DataType.map(DataType.varchar(), DataType.varchar())) .ifNotExists(); Futures.addCallback(session.executeAsync(createTable), new FutureCallback<ResultSet>() { @Override public void onSuccess(final ResultSet result) { log.debug("Session table successfully created"); } @Override public void onFailure(final Throwable x) { log.error("Create session table resulted in exception", x); } }); }
public ResultSetFuture findCounters(String metricName, String groupId) { if(metricName == null || groupId == null) throw new IllegalArgumentException("Counter table metricname and groupid can not be null!"); BoundStatement statement = findCountersByMetricGroup .bind(metricName, groupId); return session.executeAsync(statement); } }
@Override public ListenableFuture<ResultSet> apply(Session session) throws Exception { return session.executeAsync("select v from foo where k = 1"); } },
final ResultSetFuture queryFuture = connectionSession.executeAsync(selectQuery); final AtomicLong nrOfRows = new AtomicLong(0L);
@Override public void run() { while (!Thread.currentThread().isInterrupted()) { logger.debug("Sending ping, for which we expect no response"); session.executeAsync("ping"); Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); } } }
@Override public ListenableFuture<ResultSet> apply(ResultSet result) { Row row = result.one(); String c = row.getString("c"); // Execute async might hang if no streams are available. This happens if the // connection // was not release. return session.executeAsync("select n from test2 where c='" + c + "'"); } });
/** Checks that a cancelled query releases the connection (JAVA-407). */ @Test(groups = "short") public void cancelled_query_should_release_the_connection() throws InterruptedException { ResultSetFuture future = session().executeAsync("select release_version from system.local"); future.cancel(true); assertTrue(future.isCancelled()); TimeUnit.MILLISECONDS.sleep(100); HostConnectionPool pool = getPool(session()); for (Connection connection : pool.connections) { assertEquals(connection.inFlight.get(), 0); } }
private void should_iterate_result_set_asynchronously(int totalCount, int fetchSize) { for (int i = 0; i < totalCount; i++) session().execute(String.format("insert into ints (i) values (%d)", i)); Statement statement = new SimpleStatement("select * from ints").setFetchSize(fetchSize); ResultsAccumulator results = new ResultsAccumulator(); ListenableFuture<ResultSet> future = GuavaCompatibility.INSTANCE.transformAsync(session().executeAsync(statement), results); Futures.getUnchecked(future); assertThat(results.all.size()).isEqualTo(totalCount); }