Skip to content

Commit 0813394

Browse files
mp911demp911de
committed
Polishing.
Consistently use toCql(…) and String.format for CQL retrieval. See #1186
1 parent ff2ebf2 commit 0813394

File tree

5 files changed

+80
-80
lines changed

5 files changed

+80
-80
lines changed

‎spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/AsyncCqlTemplate.java‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,14 @@
2222
import java.util.concurrent.ExecutionException;
2323
import java.util.function.Function;
2424

25+
import com.datastax.oss.driver.api.core.CqlSession;
26+
import com.datastax.oss.driver.api.core.DriverException;
27+
import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
28+
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
29+
import com.datastax.oss.driver.api.core.cql.ResultSet;
30+
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
31+
import com.datastax.oss.driver.api.core.cql.Statement;
32+
2533
import org.springframework.dao.DataAccessException;
2634
import org.springframework.dao.support.DataAccessUtils;
2735
import org.springframework.dao.support.PersistenceExceptionTranslator;
@@ -32,14 +40,6 @@
3240
import org.springframework.util.concurrent.ListenableFuture;
3341
import org.springframework.util.concurrent.SettableListenableFuture;
3442

35-
import com.datastax.oss.driver.api.core.CqlSession;
36-
import com.datastax.oss.driver.api.core.DriverException;
37-
import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
38-
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
39-
import com.datastax.oss.driver.api.core.cql.ResultSet;
40-
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
41-
import com.datastax.oss.driver.api.core.cql.Statement;
42-
4343
/**
4444
* <b>This is the central class in the CQL core package for asynchronous Cassandra data access.</b> It simplifies the
4545
* use of CQL and helps to avoid common errors. It executes core CQL workflow, leaving application code to provide CQL
@@ -163,7 +163,7 @@ public <T> ListenableFuture<T> query(String cql, AsyncResultSetExtractor<T> resu
163163

164164
try {
165165
if (logger.isDebugEnabled()) {
166-
logger.debug("Executing CQL statement [{}]", cql);
166+
logger.debug(String.format("Executing CQL statement [%s]", cql));
167167
}
168168

169169
CompletionStage<T> results = getCurrentSession().executeAsync(applyStatementSettings(newStatement(cql)))
@@ -285,7 +285,7 @@ public <T> ListenableFuture<T> query(Statement<?> statement, AsyncResultSetExtra
285285

286286
try {
287287
if (logger.isDebugEnabled()) {
288-
logger.debug("Executing statement [{}]", QueryExtractorDelegate.getCql(statement));
288+
logger.debug(String.format("Executing statement [%s]", toCql(statement)));
289289
}
290290

291291
CompletionStage<T> results = getCurrentSession() //
@@ -294,9 +294,9 @@ public <T> ListenableFuture<T> query(Statement<?> statement, AsyncResultSetExtra
294294
.thenCompose(ListenableFuture::completable);
295295

296296
return new CassandraFutureAdapter<>(results,
297-
ex -> translateExceptionIfPossible("Query", statement.toString(), ex));
297+
ex -> translateExceptionIfPossible("Query", toCql(statement), ex));
298298
} catch (DriverException e) {
299-
throw translateException("Query", statement.toString(), e);
299+
throw translateException("Query", toCql(statement), e);
300300
}
301301
}
302302

@@ -446,7 +446,7 @@ public <T> ListenableFuture<T> execute(AsyncPreparedStatementCreator preparedSta
446446
toCql(preparedStatementCreator), ex);
447447
try {
448448
if (logger.isDebugEnabled()) {
449-
logger.debug("Preparing statement [{}] using {}", toCql(preparedStatementCreator), preparedStatementCreator);
449+
logger.debug(String.format("Preparing statement [%s] using %s", toCql(preparedStatementCreator), preparedStatementCreator));
450450
}
451451

452452
CqlSession currentSession = getCurrentSession();
@@ -517,15 +517,15 @@ public <T> ListenableFuture<T> query(AsyncPreparedStatementCreator preparedState
517517
try {
518518

519519
if (logger.isDebugEnabled()) {
520-
logger.debug("Preparing statement [{}] using {}", toCql(preparedStatementCreator), preparedStatementCreator);
520+
logger.debug(String.format("Preparing statement [%s] using %s", toCql(preparedStatementCreator), preparedStatementCreator));
521521
}
522522

523523
CqlSession session = getCurrentSession();
524524

525525
ListenableFuture<Statement<?>> statementFuture = new MappingListenableFutureAdapter<>(
526526
preparedStatementCreator.createPreparedStatement(session), preparedStatement -> {
527527
if (logger.isDebugEnabled()) {
528-
logger.debug("Executing prepared statement [{}]", QueryExtractorDelegate.getCql(preparedStatement));
528+
logger.debug(String.format("Executing prepared statement [%s]", toCql(preparedStatement)));
529529
}
530530

531531
return applyStatementSettings(psb != null ? psb.bindValues(preparedStatement) : preparedStatement.bind());

‎spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/CqlTemplate.java‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -25,12 +25,6 @@
2525
import java.util.stream.Stream;
2626
import java.util.stream.StreamSupport;
2727

28-
import org.springframework.dao.DataAccessException;
29-
import org.springframework.dao.support.DataAccessUtils;
30-
import org.springframework.data.cassandra.SessionFactory;
31-
import org.springframework.lang.Nullable;
32-
import org.springframework.util.Assert;
33-
3428
import com.datastax.oss.driver.api.core.CqlSession;
3529
import com.datastax.oss.driver.api.core.DriverException;
3630
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
@@ -40,6 +34,12 @@
4034
import com.datastax.oss.driver.api.core.cql.Statement;
4135
import com.datastax.oss.driver.api.core.metadata.Node;
4236

37+
import org.springframework.dao.DataAccessException;
38+
import org.springframework.dao.support.DataAccessUtils;
39+
import org.springframework.data.cassandra.SessionFactory;
40+
import org.springframework.lang.Nullable;
41+
import org.springframework.util.Assert;
42+
4343
/**
4444
* <b>This is the central class in the CQL core package.</b> It simplifies the use of CQL and helps to avoid common
4545
* errors. It executes core CQL workflow, leaving application code to provide CQL and extract results. This class
@@ -166,7 +166,7 @@ public <T> T query(String cql, ResultSetExtractor<T> resultSetExtractor) throws
166166

167167
try {
168168
if (logger.isDebugEnabled()) {
169-
logger.debug("Executing CQL statement [{}]", cql);
169+
logger.debug(String.format("Executing CQL statement [%s]", cql));
170170
}
171171

172172
Statement<?> statement = applyStatementSettings(newStatement(cql));
@@ -292,12 +292,12 @@ public <T> T query(Statement<?> statement, ResultSetExtractor<T> resultSetExtrac
292292

293293
try {
294294
if (logger.isDebugEnabled()) {
295-
logger.debug("Executing statement [{}]", QueryExtractorDelegate.getCql(statement));
295+
logger.debug(String.format("Executing statement [%s]", toCql(statement)));
296296
}
297297

298298
return resultSetExtractor.extractData(getCurrentSession().execute(applyStatementSettings(statement)));
299299
} catch (DriverException e) {
300-
throw translateException("Query", statement.toString(), e);
300+
throw translateException("Query", toCql(statement), e);
301301
}
302302
}
303303

@@ -453,7 +453,7 @@ public <T> T execute(PreparedStatementCreator preparedStatementCreator, Prepared
453453

454454
try {
455455
if (logger.isDebugEnabled()) {
456-
logger.debug("Preparing statement [{}] using {}", toCql(preparedStatementCreator), preparedStatementCreator);
456+
logger.debug(String.format("Preparing statement [%s] using %s", toCql(preparedStatementCreator), preparedStatementCreator));
457457
}
458458

459459
CqlSession session = getCurrentSession();
@@ -523,15 +523,15 @@ public <T> T query(PreparedStatementCreator preparedStatementCreator, @Nullable
523523

524524
try {
525525
if (logger.isDebugEnabled()) {
526-
logger.debug("Preparing statement [{}] using {}", toCql(preparedStatementCreator), preparedStatementCreator);
526+
logger.debug(String.format("Preparing statement [%s] using %s", toCql(preparedStatementCreator), preparedStatementCreator));
527527
}
528528

529529
CqlSession session = getCurrentSession();
530530

531531
PreparedStatement preparedStatement = preparedStatementCreator.createPreparedStatement(session);
532532

533533
if (logger.isDebugEnabled()) {
534-
logger.debug("Executing prepared statement [{}]", QueryExtractorDelegate.getCql(preparedStatement));
534+
logger.debug(String.format("Executing prepared statement [%s]", QueryExtractorDelegate.getCql(preparedStatement)));
535535
}
536536

537537
Statement<?> boundStatement = applyStatementSettings(

‎spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/ReactiveCassandraAccessor.java‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515
*/
1616
package org.springframework.data.cassandra.core.cql;
1717

18+
import com.datastax.oss.driver.api.core.DriverException;
1819
import org.slf4j.Logger;
1920
import org.slf4j.LoggerFactory;
2021

@@ -147,4 +148,17 @@ protected DataAccessException translate(String task, @Nullable String cql, Runti
147148

148149
return getExceptionTranslator().translate(task, cql, ex);
149150
}
151+
152+
/**
153+
* Determine CQL from potential provider object.
154+
*
155+
* @param cqlProvider object that's potentially a {@link CqlProvider}
156+
* @return the CQL string, or {@literal null}
157+
* @see CqlProvider
158+
* @since 3.2.7
159+
*/
160+
@Nullable
161+
protected static String toCql(@Nullable Object cqlProvider) {
162+
return QueryExtractorDelegate.getCql(cqlProvider);
163+
}
150164
}

‎spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/ReactiveCqlTemplate.java‎

Lines changed: 27 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -15,24 +15,10 @@
1515
*/
1616
package org.springframework.data.cassandra.core.cql;
1717

18-
import reactor.core.publisher.Flux;
19-
import reactor.core.publisher.Mono;
20-
2118
import java.util.Map;
2219
import java.util.Optional;
2320
import java.util.function.Function;
2421

25-
import org.reactivestreams.Publisher;
26-
27-
import org.springframework.dao.DataAccessException;
28-
import org.springframework.dao.support.DataAccessUtils;
29-
import org.springframework.data.cassandra.ReactiveResultSet;
30-
import org.springframework.data.cassandra.ReactiveSession;
31-
import org.springframework.data.cassandra.ReactiveSessionFactory;
32-
import org.springframework.data.cassandra.core.cql.session.DefaultReactiveSessionFactory;
33-
import org.springframework.lang.Nullable;
34-
import org.springframework.util.Assert;
35-
3622
import com.datastax.oss.driver.api.core.ConsistencyLevel;
3723
import com.datastax.oss.driver.api.core.CqlIdentifier;
3824
import com.datastax.oss.driver.api.core.CqlSession;
@@ -44,6 +30,18 @@
4430
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
4531
import com.datastax.oss.driver.api.core.cql.Statement;
4632
import com.datastax.oss.driver.api.core.retry.RetryPolicy;
33+
import org.reactivestreams.Publisher;
34+
import reactor.core.publisher.Flux;
35+
import reactor.core.publisher.Mono;
36+
37+
import org.springframework.dao.DataAccessException;
38+
import org.springframework.dao.support.DataAccessUtils;
39+
import org.springframework.data.cassandra.ReactiveResultSet;
40+
import org.springframework.data.cassandra.ReactiveSession;
41+
import org.springframework.data.cassandra.ReactiveSessionFactory;
42+
import org.springframework.data.cassandra.core.cql.session.DefaultReactiveSessionFactory;
43+
import org.springframework.lang.Nullable;
44+
import org.springframework.util.Assert;
4745

4846
/**
4947
* <b>This is the central class in the CQL core package for reactive Cassandra data access.</b> It simplifies the use of
@@ -303,7 +301,7 @@ public <T> Flux<T> execute(ReactiveSessionCallback<T> action) throws DataAccessE
303301

304302
Assert.notNull(action, "Callback object must not be null");
305303

306-
return createFlux(action).onErrorMap(translateException("ReactiveSessionCallback", getCql(action)));
304+
return createFlux(action).onErrorMap(translateException("ReactiveSessionCallback", toCql(action)));
307305
}
308306

309307
// -------------------------------------------------------------------------
@@ -440,11 +438,12 @@ public <T> Flux<T> query(Statement<?> statement, ReactiveResultSetExtractor<T> r
440438
return createFlux(statement, (session, stmt) -> {
441439

442440
if (logger.isDebugEnabled()) {
443-
logger.debug("Executing statement [{}]", QueryExtractorDelegate.getCql(statement));
441+
logger.debug(String.format("Executing statement [%s]", toCql(statement)));
444442
}
445443

446-
return session.execute(applyStatementSettings(statement)).flatMapMany(rse::extractData);
447-
}).onErrorMap(translateException("Query", statement.toString()));
444+
return session.execute(applyStatementSettings(statement))
445+
.flatMapMany(rse::extractData);
446+
}).onErrorMap(translateException("Query", toCql(statement)));
448447
}
449448

450449
/* (non-Javadoc)
@@ -507,17 +506,17 @@ public Mono<ReactiveResultSet> queryForResultSet(Statement<?> statement) throws
507506
return createMono(statement, (session, executedStatement) -> {
508507

509508
if (logger.isDebugEnabled()) {
510-
logger.debug("Executing statement [{}]", QueryExtractorDelegate.getCql(statement));
509+
logger.debug(String.format("Executing statement [%s]", toCql(statement)));
511510
}
512511

513512
return session.execute(applyStatementSettings(executedStatement));
514-
}).onErrorMap(translateException("QueryForResultSet", statement.toString()));
513+
}).onErrorMap(translateException("QueryForResultSet", toCql(statement)));
515514
}
516515

517516
@Override
518517
public Flux<Row> queryForRows(Statement<?> statement) throws DataAccessException {
519518
return queryForResultSet(statement).flatMapMany(ReactiveResultSet::rows)
520-
.onErrorMap(translateException("QueryForRows", statement.toString()));
519+
.onErrorMap(translateException("QueryForRows", toCql(statement)));
521520
}
522521

523522
// -------------------------------------------------------------------------
@@ -536,10 +535,11 @@ public <T> Flux<T> execute(ReactivePreparedStatementCreator psc, ReactivePrepare
536535

537536
return createFlux(session -> {
538537

539-
logger.debug("Preparing statement [{}] using {}", getCql(psc), psc);
538+
logger.debug(String.format("Preparing statement [%s] using %s", toCql(psc), psc));
540539

541-
return psc.createPreparedStatement(session).flatMapMany(ps -> action.doInPreparedStatement(session, ps));
542-
}).onErrorMap(translateException("ReactivePreparedStatementCallback", getCql(psc)));
540+
return psc.createPreparedStatement(session)
541+
.flatMapMany(ps -> action.doInPreparedStatement(session, ps));
542+
}).onErrorMap(translateException("ReactivePreparedStatementCallback", toCql(psc)));
543543
}
544544

545545
/* (non-Javadoc)
@@ -570,15 +570,15 @@ public <T> Flux<T> query(ReactivePreparedStatementCreator psc,
570570
return execute(psc, (session, preparedStatement) -> Mono.just(preparedStatement).flatMapMany(pps -> {
571571

572572
if (logger.isDebugEnabled()) {
573-
logger.debug("Executing prepared statement [{}]", QueryExtractorDelegate.getCql(preparedStatement));
573+
logger.debug(String.format("Executing prepared statement [%s]", toCql(preparedStatement)));
574574
}
575575

576576
BoundStatement boundStatement = (preparedStatementBinder != null
577577
? preparedStatementBinder.bindValues(preparedStatement)
578578
: preparedStatement.bind());
579579

580580
return session.execute(applyStatementSettings(boundStatement));
581-
}).flatMap(rse::extractData)).onErrorMap(translateException("Query", getCql(psc)));
581+
}).flatMap(rse::extractData)).onErrorMap(translateException("Query", toCql(psc)));
582582
}
583583

584584
/* (non-Javadoc)
@@ -738,7 +738,7 @@ public Flux<Boolean> execute(String cql, Publisher<Object[]> args) throws DataAc
738738
return execute(newReactivePreparedStatementCreator(cql), (session, ps) -> Flux.from(args).flatMap(objects -> {
739739

740740
if (logger.isDebugEnabled()) {
741-
logger.debug("Executing prepared CQL statement [{}]", cql);
741+
logger.debug(String.format("Executing prepared CQL statement [%s]", cql));
742742
}
743743

744744
BoundStatement boundStatement = newArgPreparedStatementBinder(objects).bindValues(ps);
@@ -909,18 +909,6 @@ private Mono<ReactiveSession> getSession() {
909909
return sessionFactory.getSession();
910910
}
911911

912-
/**
913-
* Determine CQL from potential provider object.
914-
*
915-
* @param cqlProvider object that's potentially a {@link CqlProvider}
916-
* @return the CQL string, or {@literal null}
917-
* @see CqlProvider
918-
*/
919-
@Nullable
920-
private static String getCql(@Nullable Object cqlProvider) {
921-
return QueryExtractorDelegate.getCql(cqlProvider);
922-
}
923-
924912
static class SimpleReactivePreparedStatementCreator implements ReactivePreparedStatementCreator, CqlProvider {
925913

926914
private final SimpleStatement statement;

0 commit comments

Comments
 (0)