use of com.datastax.oss.driver.api.core.cql.ColumnDefinitions in project java-driver by datastax.
the class DefaultReactiveResultSetIT method should_write_cas.
@Test
public void should_write_cas() {
SimpleStatement statement = SimpleStatement.builder("INSERT INTO test_reactive_write (pk, cc, v) VALUES (?, ?, ?) IF NOT EXISTS").addPositionalValue(0).addPositionalValue(1).addPositionalValue(2).setExecutionProfile(sessionRule.slowProfile()).build();
// execute statement for the first time: the insert should succeed and the server should return
// only one acknowledgement row with just the [applied] column = true
ReactiveResultSet rs = sessionRule.session().executeReactive(statement);
List<ReactiveRow> results = Flowable.fromPublisher(rs).toList().blockingGet();
assertThat(results).hasSize(1);
ReactiveRow row = results.get(0);
assertThat(row.getExecutionInfo()).isNotNull();
assertThat(row.getColumnDefinitions()).hasSize(1);
assertThat(row.wasApplied()).isTrue();
assertThat(row.getBoolean("[applied]")).isTrue();
List<ExecutionInfo> execInfos = Flowable.<ExecutionInfo>fromPublisher(rs.getExecutionInfos()).toList().blockingGet();
assertThat(execInfos).hasSize(1).containsExactly(row.getExecutionInfo());
List<ColumnDefinitions> colDefs = Flowable.<ColumnDefinitions>fromPublisher(rs.getColumnDefinitions()).toList().blockingGet();
assertThat(colDefs).hasSize(1).containsExactly(row.getColumnDefinitions());
List<Boolean> wasApplied = Flowable.fromPublisher(rs.wasApplied()).toList().blockingGet();
assertThat(wasApplied).hasSize(1).containsExactly(row.wasApplied());
// re-execute same statement: server should return one row with data that failed to be inserted,
// with [applied] = false
rs = sessionRule.session().executeReactive(statement);
results = Flowable.fromPublisher(rs).toList().blockingGet();
assertThat(results).hasSize(1);
row = results.get(0);
assertThat(row.getExecutionInfo()).isNotNull();
assertThat(row.getColumnDefinitions()).hasSize(4);
assertThat(row.wasApplied()).isFalse();
assertThat(row.getBoolean("[applied]")).isFalse();
assertThat(row.getInt("pk")).isEqualTo(0);
assertThat(row.getInt("cc")).isEqualTo(1);
assertThat(row.getInt("v")).isEqualTo(2);
execInfos = Flowable.<ExecutionInfo>fromPublisher(rs.getExecutionInfos()).toList().blockingGet();
assertThat(execInfos).hasSize(1).containsExactly(row.getExecutionInfo());
colDefs = Flowable.<ColumnDefinitions>fromPublisher(rs.getColumnDefinitions()).toList().blockingGet();
assertThat(colDefs).hasSize(1).containsExactly(row.getColumnDefinitions());
wasApplied = Flowable.fromPublisher(rs.wasApplied()).toList().blockingGet();
assertThat(wasApplied).hasSize(1).containsExactly(row.wasApplied());
}
use of com.datastax.oss.driver.api.core.cql.ColumnDefinitions in project java-driver by datastax.
the class DefaultReactiveResultSetIT method should_retrieve_all_rows.
@Test
@DataProvider(value = { "1", "10", "100", "999", "1000", "1001", "2000" }, format = "%m [page size %p[0]]")
public void should_retrieve_all_rows(int pageSize) {
DriverExecutionProfile profile = sessionRule.session().getContext().getConfig().getDefaultProfile().withInt(DefaultDriverOption.REQUEST_PAGE_SIZE, pageSize);
SimpleStatement statement = SimpleStatement.builder("SELECT cc, v FROM test_reactive_read WHERE pk = 0").setExecutionProfile(profile).build();
ReactiveResultSet rs = sessionRule.session().executeReactive(statement);
List<ReactiveRow> results = Flowable.fromPublisher(rs).toList().blockingGet();
assertThat(results.size()).isEqualTo(1000);
Set<ExecutionInfo> expectedExecInfos = new LinkedHashSet<>();
for (int i = 0; i < results.size(); i++) {
ReactiveRow row = results.get(i);
assertThat(row.getColumnDefinitions()).isNotNull();
assertThat(row.getExecutionInfo()).isNotNull();
assertThat(row.wasApplied()).isTrue();
assertThat(row.getInt("cc")).isEqualTo(i);
assertThat(row.getInt("v")).isEqualTo(i);
expectedExecInfos.add(row.getExecutionInfo());
}
List<ExecutionInfo> execInfos = Flowable.<ExecutionInfo>fromPublisher(rs.getExecutionInfos()).toList().blockingGet();
// DSE may send an empty page as it can't always know if it's done paging or not yet.
// See: CASSANDRA-8871. In this case, this page's execution info appears in
// rs.getExecutionInfos(), but is not present in expectedExecInfos since the page did not
// contain any rows.
assertThat(execInfos).containsAll(expectedExecInfos);
List<ColumnDefinitions> colDefs = Flowable.<ColumnDefinitions>fromPublisher(rs.getColumnDefinitions()).toList().blockingGet();
ReactiveRow first = results.get(0);
assertThat(colDefs).hasSize(1).containsExactly(first.getColumnDefinitions());
List<Boolean> wasApplied = Flowable.fromPublisher(rs.wasApplied()).toList().blockingGet();
assertThat(wasApplied).hasSize(1).containsExactly(first.wasApplied());
}
use of com.datastax.oss.driver.api.core.cql.ColumnDefinitions in project java-driver by datastax.
the class ContinuousCqlRequestReactiveProcessorTest method should_complete_single_page_result.
@Test
@UseDataProvider(value = "allDseProtocolVersions", location = DseTestDataProviders.class)
public void should_complete_single_page_result(DseProtocolVersion version) {
try (RequestHandlerTestHarness harness = continuousHarnessBuilder().withProtocolVersion(version).withResponse(node1, defaultFrameOf(DseTestFixtures.singleDseRow())).build()) {
DefaultSession session = harness.getSession();
InternalDriverContext context = harness.getContext();
ContinuousReactiveResultSet publisher = new ContinuousCqlRequestReactiveProcessor(new ContinuousCqlRequestAsyncProcessor()).process(UNDEFINED_IDEMPOTENCE_STATEMENT, session, context, "test");
List<ReactiveRow> rows = Flowable.fromPublisher(publisher).toList().blockingGet();
assertThat(rows).hasSize(1);
ReactiveRow row = rows.get(0);
assertThat(row.getString("message")).isEqualTo("hello, world");
ExecutionInfo executionInfo = row.getExecutionInfo();
assertThat(executionInfo.getCoordinator()).isEqualTo(node1);
assertThat(executionInfo.getErrors()).isEmpty();
assertThat(executionInfo.getIncomingPayload()).isEmpty();
assertThat(executionInfo.getPagingState()).isNull();
assertThat(executionInfo.getSpeculativeExecutionCount()).isEqualTo(0);
assertThat(executionInfo.getSuccessfulExecutionIndex()).isEqualTo(0);
assertThat(executionInfo.getWarnings()).isEmpty();
Flowable<ExecutionInfo> execInfosFlowable = Flowable.fromPublisher(publisher.getExecutionInfos());
assertThat(execInfosFlowable.toList().blockingGet()).containsExactly(executionInfo);
Flowable<ColumnDefinitions> colDefsFlowable = Flowable.fromPublisher(publisher.getColumnDefinitions());
assertThat(colDefsFlowable.toList().blockingGet()).containsExactly(row.getColumnDefinitions());
Flowable<Boolean> wasAppliedFlowable = Flowable.fromPublisher(publisher.wasApplied());
assertThat(wasAppliedFlowable.toList().blockingGet()).containsExactly(row.wasApplied());
}
}
use of com.datastax.oss.driver.api.core.cql.ColumnDefinitions in project java-driver by datastax.
the class ContinuousCqlRequestReactiveProcessorTest method should_complete_multi_page_result.
@Test
@UseDataProvider(value = "allDseProtocolVersions", location = DseTestDataProviders.class)
public void should_complete_multi_page_result(DseProtocolVersion version) {
RequestHandlerTestHarness.Builder builder = continuousHarnessBuilder().withProtocolVersion(version);
PoolBehavior node1Behavior = builder.customBehavior(node1);
try (RequestHandlerTestHarness harness = builder.build()) {
DefaultSession session = harness.getSession();
InternalDriverContext context = harness.getContext();
ContinuousReactiveResultSet publisher = new ContinuousCqlRequestReactiveProcessor(new ContinuousCqlRequestAsyncProcessor()).process(UNDEFINED_IDEMPOTENCE_STATEMENT, session, context, "test");
Flowable<ReactiveRow> rowsPublisher = Flowable.fromPublisher(publisher).cache();
rowsPublisher.subscribe();
node1Behavior.setResponseSuccess(defaultFrameOf(DseTestFixtures.tenDseRows(1, false)));
node1Behavior.setResponseSuccess(defaultFrameOf(DseTestFixtures.tenDseRows(2, true)));
List<ReactiveRow> rows = rowsPublisher.toList().blockingGet();
assertThat(rows).hasSize(20);
ReactiveRow first = rows.get(0);
ExecutionInfo firstExecutionInfo = first.getExecutionInfo();
assertThat(firstExecutionInfo.getCoordinator()).isEqualTo(node1);
assertThat(firstExecutionInfo.getErrors()).isEmpty();
assertThat(firstExecutionInfo.getIncomingPayload()).isEmpty();
assertThat(firstExecutionInfo.getPagingState()).isNotNull();
assertThat(firstExecutionInfo.getSpeculativeExecutionCount()).isEqualTo(0);
assertThat(firstExecutionInfo.getSuccessfulExecutionIndex()).isEqualTo(0);
assertThat(firstExecutionInfo.getWarnings()).isEmpty();
ReactiveRow inSecondPage = rows.get(10);
ExecutionInfo secondExecutionInfo = inSecondPage.getExecutionInfo();
assertThat(secondExecutionInfo.getCoordinator()).isEqualTo(node1);
assertThat(secondExecutionInfo.getErrors()).isEmpty();
assertThat(secondExecutionInfo.getIncomingPayload()).isEmpty();
assertThat(secondExecutionInfo.getPagingState()).isNull();
assertThat(secondExecutionInfo.getSpeculativeExecutionCount()).isEqualTo(0);
assertThat(secondExecutionInfo.getSuccessfulExecutionIndex()).isEqualTo(0);
assertThat(secondExecutionInfo.getWarnings()).isEmpty();
Flowable<ExecutionInfo> execInfosFlowable = Flowable.fromPublisher(publisher.getExecutionInfos());
assertThat(execInfosFlowable.toList().blockingGet()).containsExactly(firstExecutionInfo, secondExecutionInfo);
Flowable<ColumnDefinitions> colDefsFlowable = Flowable.fromPublisher(publisher.getColumnDefinitions());
assertThat(colDefsFlowable.toList().blockingGet()).containsExactly(first.getColumnDefinitions());
Flowable<Boolean> wasAppliedFlowable = Flowable.fromPublisher(publisher.wasApplied());
assertThat(wasAppliedFlowable.toList().blockingGet()).containsExactly(first.wasApplied());
}
}
use of com.datastax.oss.driver.api.core.cql.ColumnDefinitions in project java-driver by datastax.
the class ReactiveResultSetSubscriptionTest method should_report_error_on_intermediary_page.
@Test
public void should_report_error_on_intermediary_page() {
CompletableFuture<AsyncResultSet> future1 = new CompletableFuture<>();
CompletableFuture<AsyncResultSet> future2 = new CompletableFuture<>();
MockAsyncResultSet page1 = new MockAsyncResultSet(3, future2);
TestSubscriber<ReactiveRow> mainSubscriber = new TestSubscriber<>();
TestSubscriber<ColumnDefinitions> colDefsSubscriber = new TestSubscriber<>();
TestSubscriber<ExecutionInfo> execInfosSubscriber = new TestSubscriber<>();
TestSubscriber<Boolean> wasAppliedSubscriber = new TestSubscriber<>();
ReactiveResultSetSubscription<AsyncResultSet> subscription = new ReactiveResultSetSubscription<>(mainSubscriber, colDefsSubscriber, execInfosSubscriber, wasAppliedSubscriber);
mainSubscriber.onSubscribe(subscription);
subscription.start(() -> future1);
future1.complete(page1);
future2.completeExceptionally(new UnavailableException(null, null, 0, 0));
mainSubscriber.awaitTermination();
assertThat(mainSubscriber.getElements()).extracting("row").isEqualTo(page1.currentPage());
assertThat(mainSubscriber.getError()).isNotNull().isInstanceOf(UnavailableException.class);
// colDefsSubscriber completed normally when page1 arrived
assertThat(colDefsSubscriber.getError()).isNull();
assertThat(colDefsSubscriber.getElements()).hasSize(1).containsExactly(page1.getColumnDefinitions());
// execInfosSubscriber completed with error, but should have emitted 1 item for page1
assertThat(execInfosSubscriber.getElements()).hasSize(1).containsExactly(page1.getExecutionInfo());
assertThat(execInfosSubscriber.getError()).isNotNull().isInstanceOf(UnavailableException.class);
// colDefsSubscriber completed normally when page1 arrived
assertThat(wasAppliedSubscriber.getElements()).hasSize(1).containsExactly(true);
assertThat(wasAppliedSubscriber.getError()).isNull();
}
Aggregations