/** * @param ses Session. * @param qry Query. * @param ctrl Control. * @param log Logger. * @param clo Closure for loaded values. */ public LoadCacheCustomQueryWorker(CassandraSession ses, String qry, PersistenceController ctrl, IgniteLogger log, IgniteBiInClosure<K, V> clo) { this(ses, new SimpleStatement(qry.trim().endsWith(";") ? qry : qry + ';'), ctrl, log, clo); }
/** * Execute a query and map result to entityClass. * * @param entityClass Entity class. * @param statement Statement to execute. * @param values Statement parameters. * @return A query result. */ public <T> Result<T> query(final Class<T> entityClass, final String statement, final Map<String, Object> values) { return query(entityClass, new SimpleStatement(statement, values)); }
/** * Execute a query and map result to entityClass. * * @param entityClass Entity class. * @param statement Statement to execute. * @param values Statement parameters. * @return A listenable future holding the result. */ public <T> ListenableFuture<Result<T>> queryAsync(final Class<T> entityClass, final String statement, final Object... values) { return queryAsync(entityClass, new SimpleStatement(statement, values)); }
/** * Execute a query and map result to entityClass. * * @param entityClass Entity class. * @param statement Statement to execute. * @param values Statement parameters. * @return A listenable future holding the result. */ public <T> ListenableFuture<Result<T>> queryAsync(final Class<T> entityClass, final String statement, final Map<String, Object> values) { return queryAsync(entityClass, new SimpleStatement(statement, values)); }
/** * Execute a query and map result to entityClass. * * @param entityClass Entity class. * @param statement Statement to execute. * @param values Statement parameters. * @return A query result. */ public <T> Result<T> query(final Class<T> entityClass, final String statement, final Object... values) { return query(entityClass, new SimpleStatement(statement, values)); }
/** * {@inheritDoc}. */ @Override public List<Statement> map(Map<String, Object> conf, Session session, ITuple tuple) { List<Column> columns = mapper.map(tuple); SimpleStatement statement = new SimpleStatement(queryString, Column.getVals(columns)); if (hasRoutingKeys()) { List<ByteBuffer> keys = rkGenerator.getRoutingKeys(tuple); if (keys.size() == 1) { statement.setRoutingKey(keys.get(0)); } else { statement.setRoutingKey(keys.toArray(new ByteBuffer[keys.size()])); } } return Arrays.asList((Statement) statement); }
/** {@inheritDoc} */ @Override public ResultSet execute(String query) { return execute(new SimpleStatement(query)); }
/** {@inheritDoc} */ @Override public ResultSetFuture executeAsync(String query, Map<String, Object> values) { return executeAsync(new SimpleStatement(query, values)); }
/** {@inheritDoc} */ @Override public ResultSetFuture executeAsync(String query, Object... values) { return executeAsync(new SimpleStatement(query, values)); }
@Test(groups = "unit", expectedExceptions = NullPointerException.class) public void should_throw_npe_when_null_key_on_regular_statement() throws Exception { Map<String, ByteBuffer> payload = new HashMap<String, ByteBuffer>(); payload.put(null, ByteBuffer.wrap(new byte[] {1})); new SimpleStatement("SELECT c2 FROM t1 where c1 = ?", 1).setOutgoingPayload(payload); }
@Test(groups = "unit", expectedExceptions = NullPointerException.class) public void should_throw_npe_when_null_value_on_regular_statement() throws Exception { Map<String, ByteBuffer> payload = new HashMap<String, ByteBuffer>(); payload.put("k1", null); new SimpleStatement("SELECT c2 FROM t1 where c1 = ?", 1).setOutgoingPayload(payload); }
@Test( groups = "unit", expectedExceptions = {IndexOutOfBoundsException.class}) public void should_throw_IOOBE_if_getObject_called_with_wrong_index() { new SimpleStatement("doesn't matter", new Object()).getObject(1); }
@Test( groups = "unit", expectedExceptions = {IllegalStateException.class}) public void should_throw_ISE_if_getObject_called_on_statement_without_values() { new SimpleStatement("doesn't matter").getObject(0); }
@Test( groups = "unit", expectedExceptions = {IllegalStateException.class}) public void should_throw_ISE_if_getObject_called_on_statement_without_named_values() { new SimpleStatement("doesn't matter").getObject("name"); }
@Test(groups = "short") public void should_pass_wrapped_statement_to_speculative_execution_policy() { speculativeExecutionPolicy.customStatementsHandled.set(0); SimpleStatement s = new SimpleStatement("select * from system.local"); session().execute(s); assertThat(speculativeExecutionPolicy.customStatementsHandled.get()).isEqualTo(0); session().execute(new CustomStatement(s)); assertThat(speculativeExecutionPolicy.customStatementsHandled.get()).isEqualTo(1); }
@Test(groups = "unit") public void should_default_to_false_when_not_set_on_statement_nor_query_options() { QueryOptions queryOptions = new QueryOptions(); SimpleStatement statement = new SimpleStatement("", cluster); assertThat(statement.isIdempotentWithDefault(queryOptions)).isFalse(); }
@Test(groups = "short") public void should_pass_wrapped_statement_to_retry_policy() { retryPolicy.customStatementsHandled.set(0); // Set CL TWO with only one node, so the statement will always cause UNAVAILABLE, // which our custom policy ignores. Statement s = new SimpleStatement("select * from system.local").setConsistencyLevel(ConsistencyLevel.TWO); session().execute(s); assertThat(retryPolicy.customStatementsHandled.get()).isEqualTo(0); session().execute(new CustomStatement(s)); assertThat(retryPolicy.customStatementsHandled.get()).isEqualTo(1); }
@Test(groups = "unit") public void should_use_query_options_when_not_set_on_statement() { QueryOptions queryOptions = new QueryOptions(); SimpleStatement statement = new SimpleStatement("", cluster); for (boolean valueInOptions : new boolean[] {true, false}) { queryOptions.setDefaultIdempotence(valueInOptions); assertThat(statement.isIdempotentWithDefault(queryOptions)).isEqualTo(valueInOptions); } }
@Test(groups = "short") public void should_use_CQL_timestamp_over_anything_else() { timestampFromGenerator = 10; String query = "INSERT INTO foo (k, v) VALUES (1, 1) USING TIMESTAMP 20"; session().execute(new SimpleStatement(query).setDefaultTimestamp(30)); long writeTime = session().execute("SELECT writeTime(v) FROM foo WHERE k = 1").one().getLong(0); assertEquals(writeTime, 20); }
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); }