@SuppressWarnings("ConstantConditions") private int getEffectiveFetchSize(Statement statement) { if (statement.getFetchSize() > 0) { return statement.getFetchSize(); } if (getCqlOperations() instanceof CassandraAccessor) { CassandraAccessor accessor = (CassandraAccessor) getCqlOperations(); if (accessor.getFetchSize() != -1) { return accessor.getFetchSize(); } } return getCqlOperations().execute(this::getConfiguredFetchSize); }
@Override public <T> List<T> select(Statement statement, Class<T> entityClass) { Assert.notNull(statement, "Statement must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); Function<Row, T> mapper = getMapper(entityClass, entityClass, QueryUtils.getTableName(statement)); return getCqlOperations().query(statement, (row, rowNum) -> mapper.apply(row)); }
@Override public <T> Stream<T> stream(Statement statement, Class<T> entityClass) throws DataAccessException { Assert.notNull(statement, "Statement must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); ResultSet resultSet = getCqlOperations().queryForResultSet(statement); return StreamSupport.stream(resultSet.spliterator(), false) .map(getMapper(entityClass, entityClass, QueryUtils.getTableName(statement))); }
@Override public boolean update(Query query, org.springframework.data.cassandra.core.query.Update update, Class<?> entityClass) throws DataAccessException { Assert.notNull(query, "Query must not be null"); Assert.notNull(update, "Update must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); Statement updateStatement = getStatementFactory().update(query, update, getRequiredPersistentEntity(entityClass)); return getCqlOperations().execute(updateStatement); }
@Override public <T> 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"); ResultSet resultSet = getCqlOperations().queryForResultSet(statement); Function<Row, T> mapper = getMapper(entityClass, entityClass, QueryUtils.getTableName(statement)); return QueryUtils.readSlice(resultSet, (row, rowNum) -> mapper.apply(row), 0, getEffectiveFetchSize(statement)); }
<T> Stream<T> doStream(Query query, Class<?> entityClass, CqlIdentifier tableName, Class<T> returnType) { RegularStatement statement = getStatementFactory().select(query, getRequiredPersistentEntity(entityClass), tableName); ResultSet resultSet = getCqlOperations().queryForResultSet(statement); return StreamSupport.stream(resultSet.spliterator(), false).map(getMapper(entityClass, returnType, tableName)); }
<T> List<T> doSelect(Query query, Class<?> entityClass, CqlIdentifier tableName, Class<T> returnType) { Function<Row, T> mapper = getMapper(entityClass, returnType, tableName); RegularStatement select = getStatementFactory().select(query, getRequiredPersistentEntity(entityClass), tableName); return getCqlOperations().query(select, (row, rowNum) -> mapper.apply(row)); }
@Nullable WriteResult doUpdate(Query query, org.springframework.data.cassandra.core.query.Update update, Class<?> entityClass, CqlIdentifier tableName) { RegularStatement updateStatement = getStatementFactory().update(query, update, getRequiredPersistentEntity(entityClass), tableName); return getCqlOperations().execute(new StatementCallback(updateStatement)); }
@Override public <T> T selectOneById(Object id, Class<T> entityClass) { Assert.notNull(id, "Id must not be null"); Assert.notNull(entityClass, "Entity type must not be null"); CqlIdentifier tableName = getTableName(entityClass); Select select = QueryBuilder.select().all().from(tableName.toCql()); getConverter().write(id, select.where(), getRequiredPersistentEntity(entityClass)); Function<Row, T> mapper = getMapper(entityClass, entityClass, tableName); List<T> result = getCqlOperations().query(select, (row, rowNum) -> mapper.apply(row)); return result.isEmpty() ? null : result.get(0); }
@Override public 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()); maybeEmitEvent(new BeforeDeleteEvent<>(delete, entity.getClass(), tableName)); // noinspection ConstantConditions WriteResult result = getCqlOperations().execute(new StatementCallback(delete)); maybeEmitEvent(new AfterDeleteEvent<>(delete, entity.getClass(), tableName)); return result; }
long doCount(Query query, Class<?> entityClass, CqlIdentifier tableName) { RegularStatement countStatement = getStatementFactory().count(query, getRequiredPersistentEntity(entityClass), tableName); Long count = getCqlOperations().queryForObject(countStatement, Long.class); return count != null ? count : 0L; }
@Override public long count(Class<?> entityClass) { Assert.notNull(entityClass, "Entity type must not be null"); Select select = QueryBuilder.select().countAll().from(getTableName(entityClass).toCql()); Long count = getCqlOperations().queryForObject(select, Long.class); return count != null ? count : 0L; }
boolean doExists(Query query, Class<?> entityClass, CqlIdentifier tableName) { RegularStatement select = getStatementFactory().select(query.limit(1), getRequiredPersistentEntity(entityClass), tableName); return getCqlOperations().queryForResultSet(select).iterator().hasNext(); }
@Override public 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(getTableName(entityClass).toCql()); getConverter().write(id, select.where(), entity); return getCqlOperations().queryForResultSet(select).iterator().hasNext(); }
@Override public void truncate(Class<?> entityClass) { Assert.notNull(entityClass, "Entity type must not be null"); CqlIdentifier tableName = getTableName(entityClass); Truncate truncate = QueryBuilder.truncate(tableName.toCql()); maybeEmitEvent(new BeforeDeleteEvent<>(truncate, entityClass, tableName)); getCqlOperations().execute(truncate); maybeEmitEvent(new AfterDeleteEvent<>(truncate, entityClass, tableName)); }
@Override public <T> 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()); maybeEmitEvent(new BeforeSaveEvent<>(entity, tableName, update)); // noinspection ConstantConditions WriteResult result = getCqlOperations().execute(new StatementCallback(update)); maybeEmitEvent(new AfterSaveEvent<>(entity, tableName)); return EntityWriteResult.of(result, entity); }
@Nullable WriteResult doDelete(Query query, Class<?> entityClass, CqlIdentifier tableName) { RegularStatement delete = getStatementFactory().delete(query, getRequiredPersistentEntity(entityClass), tableName); maybeEmitEvent(new BeforeDeleteEvent<>(delete, entityClass, tableName)); WriteResult writeResult = getCqlOperations().execute(new StatementCallback(delete)); maybeEmitEvent(new AfterDeleteEvent<>(delete, entityClass, tableName)); return writeResult; }
@Override public 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); maybeEmitEvent(new BeforeDeleteEvent<>(delete, entityClass, tableName)); boolean result = getCqlOperations().execute(delete); maybeEmitEvent(new AfterDeleteEvent<>(delete, entityClass, tableName)); return result; }
<T> EntityWriteResult<T> doInsert(T entity, WriteOptions options, CqlIdentifier tableName) { CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass()); Insert insert = QueryUtils.createInsertQuery(tableName.toCql(), entity, options, getConverter(), persistentEntity); maybeEmitEvent(new BeforeSaveEvent<>(entity, tableName, insert)); // noinspection ConstantConditions WriteResult result = getCqlOperations().execute(new StatementCallback(insert)); maybeEmitEvent(new AfterSaveEvent<>(entity, tableName)); return EntityWriteResult.of(result, entity); }