@Test public void executePreparedTest() throws Exception { // Simple calls to all versions of the execute/executeAsync methods for prepared statements // Note: the goal is only to exercice the Session methods, PreparedStatementTest have better // prepared statement tests. String key = "execute_prepared_test"; ResultSet rs = session.execute(String.format(INSERT_FORMAT, TABLE, key, "foo", 42, 24.03f)); assertTrue(rs.isExhausted()); PreparedStatement p = session.prepare(String.format(SELECT_ALL_FORMAT + " WHERE k = ?", TABLE)); BoundStatement bs = p.bind(key); // executePrepared checkExecuteResultSet(session.execute(bs), key); checkExecuteResultSet(session.execute(bs.setConsistencyLevel(ConsistencyLevel.ONE)), key); // executePreparedAsync checkExecuteResultSet(session.executeAsync(bs).getUninterruptibly(), key); checkExecuteResultSet( session.executeAsync(bs.setConsistencyLevel(ConsistencyLevel.ONE)).getUninterruptibly(), key); }
/** * Execute the provided query asynchronously. * * <p>This method does not block. It returns as soon as the query has been successfully sent to a * Cassandra node. In particular, returning from this method does not guarantee that the query is * valid. Any exception pertaining to the failure of the query will be thrown by the first access * to the {@link ResultSet}. * * <p>Note that for queries that doesn't return a result (INSERT, UPDATE and DELETE), you will * need to access the ResultSet (i.e. call any of its method) to make sure the query was * successful. * * @param query the CQL query to execute (that can be either a {@code Statement} or a {@code * BoundStatement}). If it is a {@code BoundStatement}, all variables must have been bound * (the statement must be ready). * @return a future on the result of the query. * @throws IllegalStateException if {@code query} is a {@code BoundStatement} but {@code * !query.isReady()}. */ public ResultSetFuture executeAsync(Query query) { if (query instanceof Statement) { return manager.executeQuery( new QueryMessage( ((Statement) query).getQueryString(), ConsistencyLevel.toCassandraCL(query.getConsistencyLevel())), query); } else { assert query instanceof BoundStatement : query; BoundStatement bs = (BoundStatement) query; if (!bs.isReady()) throw new IllegalStateException( "Some bind variables haven't been bound in the provided statement"); return manager.executeQuery( new ExecuteMessage( bs.statement.id, Arrays.asList(bs.values), ConsistencyLevel.toCassandraCL(query.getConsistencyLevel())), query); } }
/** Loops collecting cql binded variable values from the queue and sending to Cassandra */ public void run() { outer: while (run || !queue.isEmpty()) { List<ByteBuffer> bindVariables; try { bindVariables = queue.take(); } catch (InterruptedException e) { // re-check loop condition after interrupt continue; } ListIterator<InetAddress> iter = endpoints.listIterator(); while (true) { // send the mutation to the last-used endpoint. first time through, this will NPE // harmlessly. try { int i = 0; PreparedStatement statement = preparedStatement(client); while (bindVariables != null) { BoundStatement boundStatement = new BoundStatement(statement); for (int columnPosition = 0; columnPosition < bindVariables.size(); columnPosition++) { boundStatement.setBytesUnsafe(columnPosition, bindVariables.get(columnPosition)); } client.execute(boundStatement); i++; if (i >= batchThreshold) break; bindVariables = queue.poll(); } break; } catch (Exception e) { closeInternal(); if (!iter.hasNext()) { lastException = new IOException(e); break outer; } } // attempt to connect to a different endpoint try { InetAddress address = iter.next(); String host = address.getHostName(); client = CqlConfigHelper.getOutputCluster(host, conf).connect(); } catch (Exception e) { // If connection died due to Interrupt, just try connecting to the endpoint again. // There are too many ways for the Thread.interrupted() state to be cleared, so // we can't rely on that here. Until the java driver gives us a better way of knowing // that this exception came from an InterruptedException, this is the best solution. if (canRetryDriverConnection(e)) { iter.previous(); } closeInternal(); // Most exceptions mean something unexpected went wrong to that endpoint, so // we should try again to another. Other exceptions (auth or invalid request) are // fatal. if ((e instanceof AuthenticationException || e instanceof InvalidQueryException) || !iter.hasNext()) { lastException = new IOException(e); break outer; } } } } // close all our connections once we are done. closeInternal(); }