private Mono<WriteResult> handleStatement(Message<?> requestMessage) { Object payload = requestMessage.getPayload(); Mono<ReactiveResultSet> resultSetMono; if (payload instanceof Statement) { resultSetMono = this.cassandraOperations.getReactiveCqlOperations().queryForResultSet((Statement) payload); } else { resultSetMono = this.cassandraOperations.getReactiveCqlOperations() .execute((ReactiveSessionCallback<ReactiveResultSet>) session -> this.sessionMessageCallback.doInSession(session, requestMessage)) .next(); } return resultSetMono.transform(this::transformToWriteResult); }
@Override protected Mono<Health> doHealthCheck(Health.Builder builder) { Select select = QueryBuilder.select("release_version").from("system", "local"); return this.reactiveCassandraOperations.getReactiveCqlOperations() .queryForObject(select, String.class) .map((version) -> builder.up().withDetail("version", version).build()) .single(); }
@Override public <T> Flux<T> select(Statement cql, Class<T> entityClass) { Assert.notNull(cql, "Statement must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); Function<Row, T> mapper = getMapper(entityClass, entityClass, QueryUtils.getTableName(cql)); return getReactiveCqlOperations().query(cql, (row, rowNum) -> mapper.apply(row)); }
@Override public Mono<WriteResult> delete(Object entity, QueryOptions options) { Assert.notNull(entity, "Entity must not be null"); Assert.notNull(options, "QueryOptions must not be null"); CqlIdentifier tableName = getTableName(entity); Delete delete = QueryUtils.createDeleteQuery(tableName.toCql(), entity, options, getConverter()); Mono<WriteResult> result = getReactiveCqlOperations() // .execute(new StatementCallback(delete)) // .doOnSubscribe(it -> maybeEmitEvent(new BeforeDeleteEvent<>(delete, entity.getClass(), tableName))) // .next(); return result.doOnNext(it -> maybeEmitEvent(new AfterDeleteEvent<>(delete, entity.getClass(), tableName))); }
@Override public Mono<WriteResult> execute() { return Mono.defer(() -> { if (executed.compareAndSet(false, true)) { return Flux.merge(batchMonos) // .flatMapIterable(Function.identity()) // .collectList() // .flatMap(statements -> { statements.forEach(batch::add); return operations.getReactiveCqlOperations().queryForResultSet(batch); }).flatMap(resultSet -> resultSet.rows().collectList() .map(rows -> new WriteResult(resultSet.getAllExecutionInfo(), resultSet.wasApplied(), rows))); } return Mono.error(new IllegalStateException("This Cassandra Batch was already executed")); }); }
@Override public Object execute(Statement statement, Class<?> type) { Mono<List<Row>> rows = this.operations.getReactiveCqlOperations().queryForRows(statement).buffer(2).next(); return rows.map(it -> { if (it.isEmpty()) { return false; } if (it.size() == 1) { Row row = it.get(0); if (ProjectionUtil.qualifiesAsCountProjection(row)) { Object object = row.getObject(0); return ((Number) object).longValue() > 0; } } return true; }).switchIfEmpty(Mono.just(false)); } }
@SuppressWarnings("ConstantConditions") private Mono<Integer> getEffectiveFetchSize(Statement statement) { if (statement.getFetchSize() > 0) { return Mono.just(statement.getFetchSize()); } if (getReactiveCqlOperations() instanceof CassandraAccessor) { CassandraAccessor accessor = (CassandraAccessor) getReactiveCqlOperations(); if (accessor.getFetchSize() != -1) { return Mono.just(accessor.getFetchSize()); } } return getReactiveCqlOperations().execute((ReactiveSessionCallback<Integer>) session -> Mono .just(session.getCluster().getConfiguration().getQueryOptions().getFetchSize())).single(); }
@Override public <T> Mono<Slice<T>> slice(Statement statement, Class<T> entityClass) { Assert.notNull(statement, "Statement must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); Mono<ReactiveResultSet> resultSetMono = getReactiveCqlOperations().queryForResultSet(statement); Mono<Integer> effectiveFetchSizeMono = getEffectiveFetchSize(statement); RowMapper<T> rowMapper = (row, i) -> getConverter().read(entityClass, row); return resultSetMono.zipWith(effectiveFetchSizeMono).flatMap(tuple -> { ReactiveResultSet resultSet = tuple.getT1(); Integer effectiveFetchSize = tuple.getT2(); return resultSet.availableRows().collectList().map(it -> { return QueryUtils.readSlice(it, resultSet.getExecutionInfo().getPagingState(), rowMapper, 1, effectiveFetchSize); }); }).defaultIfEmpty(new SliceImpl<>(Collections.emptyList())); }
Mono<Boolean> doExists(Query query, Class<?> entityClass, CqlIdentifier tableName) { RegularStatement select = getStatementFactory().select(query.limit(1), getRequiredPersistentEntity(entityClass), tableName); return getReactiveCqlOperations().queryForRows(select).hasElements(); }
Mono<WriteResult> doUpdate(Query query, org.springframework.data.cassandra.core.query.Update update, Class<?> entityClass, CqlIdentifier tableName) { RegularStatement statement = getStatementFactory().update(query, update, getRequiredPersistentEntity(entityClass), tableName); return getReactiveCqlOperations().execute(new StatementCallback(statement)).next(); }
private Mono<WriteResult> handleStatement(Message<?> requestMessage) { Object payload = requestMessage.getPayload(); Mono<ReactiveResultSet> resultSetMono; if (payload instanceof Statement) { resultSetMono = this.cassandraOperations.getReactiveCqlOperations().queryForResultSet((Statement) payload); } else { resultSetMono = this.cassandraOperations.getReactiveCqlOperations() .execute((ReactiveSessionCallback<ReactiveResultSet>) session -> this.sessionMessageCallback.doInSession(session, requestMessage)) .next(); } return resultSetMono.transform(this::transformToWriteResult); }
Mono<Long> doCount(Query query, Class<?> entityClass, CqlIdentifier tableName) { RegularStatement count = getStatementFactory().count(query, getRequiredPersistentEntity(entityClass), tableName); return getReactiveCqlOperations().queryForObject(count, Long.class).switchIfEmpty(Mono.just(0L)); }
@Override public Mono<Boolean> exists(Object id, Class<?> entityClass) { Assert.notNull(id, "Id must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass); Select select = QueryBuilder.select().from(entity.getTableName().toCql()); getConverter().write(id, select.where(), entity); return getReactiveCqlOperations().queryForRows(select).hasElements(); }
<T> Flux<T> doSelect(Query query, Class<?> entityClass, CqlIdentifier tableName, Class<T> returnType) { RegularStatement select = getStatementFactory().select(query, getRequiredPersistentEntity(entityClass), tableName); Function<Row, T> mapper = getMapper(entityClass, returnType, tableName); return getReactiveCqlOperations().query(select, (row, rowNum) -> mapper.apply(row)); }
@Override public <T> Mono<EntityWriteResult<T>> update(T entity, UpdateOptions options) { Assert.notNull(entity, "Entity must not be null"); Assert.notNull(options, "UpdateOptions must not be null"); CqlIdentifier tableName = getTableName(entity); Update update = QueryUtils.createUpdateQuery(tableName.toCql(), entity, options, getConverter()); Mono<EntityWriteResult<T>> result = getReactiveCqlOperations() // .execute(new StatementCallback(update)) // .doOnSubscribe(it -> maybeEmitEvent(new BeforeSaveEvent<>(entity, tableName, update))) // .map(it -> EntityWriteResult.of(it, entity)) // .next(); return result.doOnNext(it -> maybeEmitEvent(new AfterSaveEvent<>(entity, tableName))); }
@Override public Mono<Long> count(Class<?> entityClass) { Assert.notNull(entityClass, "Entity type must not be null"); Select select = QueryBuilder.select().countAll().from(getTableName(entityClass).toCql()); return getReactiveCqlOperations().queryForObject(select, Long.class); }
.execute((ReactiveSessionCallback<WriteResult>) session -> session.prepare(this.ingestQuery) .map(s -> QueryOptionsUtil.addPreparedStatementOptions(s, this.writeOptions))
.execute((ReactiveSessionCallback<WriteResult>) session -> session.prepare(this.ingestQuery) .map(s -> QueryOptionsUtil.addPreparedStatementOptions(s, this.writeOptions))
<T> Mono<EntityWriteResult<T>> doInsert(T entity, WriteOptions options, CqlIdentifier tableName) { CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass()); Insert insert = QueryUtils.createInsertQuery(tableName.toCql(), entity, options, getConverter(), persistentEntity); // noinspection ConstantConditions Mono<EntityWriteResult<T>> result = getReactiveCqlOperations() // .execute(new StatementCallback(insert)) // .doOnSubscribe(it -> maybeEmitEvent(new BeforeSaveEvent<>(entity, tableName, insert))) // .map(it -> EntityWriteResult.of(it, entity)) // .next(); return result.doOnNext(it -> maybeEmitEvent(new AfterSaveEvent<>(entity, tableName))); }
@Override public Mono<Boolean> deleteById(Object id, Class<?> entityClass) { Assert.notNull(id, "Id must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass); CqlIdentifier tableName = entity.getTableName(); Delete delete = QueryBuilder.delete().from(tableName.toCql()); getConverter().write(id, delete.where(), entity); Mono<Boolean> result = getReactiveCqlOperations().execute(delete) .doOnSubscribe(it -> maybeEmitEvent(new BeforeDeleteEvent<>(delete, entityClass, tableName))); return result.doOnNext(it -> maybeEmitEvent(new AfterDeleteEvent<>(delete, entityClass, tableName))); }