Skip to content

Commit 74172af

Browse files
mipo256mipo256
committed
DATAJDBC-1953 Introduced Comparator interface
Signed-off-by: Mikhail Polivakha <[email protected]>
1 parent b51c77b commit 74172af

File tree

9 files changed

+329
-192
lines changed

9 files changed

+329
-192
lines changed

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/QueryMapper.java

+53-45
Original file line numberDiff line numberDiff line change
@@ -34,9 +34,10 @@
3434
import org.springframework.data.mapping.context.MappingContext;
3535
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
3636
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
37+
import org.springframework.data.relational.core.query.Comparator;
3738
import org.springframework.data.relational.core.query.CriteriaDefinition;
38-
import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator;
3939
import org.springframework.data.relational.core.query.ValueFunction;
40+
import org.springframework.data.relational.core.query.Comparators;
4041
import org.springframework.data.relational.core.sql.*;
4142
import org.springframework.data.relational.domain.SqlSort;
4243
import org.springframework.data.util.Pair;
@@ -53,6 +54,7 @@
5354
* @author Mark Paluch
5455
* @author Jens Schauder
5556
* @author Yan Qiang
57+
* @author Mikhail Polivakha
5658
* @since 3.0
5759
*/
5860
public class QueryMapper {
@@ -422,7 +424,7 @@ private Condition mapEmbeddedObjectCondition(CriteriaDefinition criteria, MapSql
422424
@Nullable
423425
private Object convertValue(Comparator comparator, @Nullable Object value, TypeInformation<?> typeHint) {
424426

425-
if ((Comparator.IN.equals(comparator) || Comparator.NOT_IN.equals(comparator))
427+
if ((Comparators.IN.equals(comparator) || Comparators.NOT_IN.equals(comparator))
426428
&& value instanceof Collection<?> collection && !collection.isEmpty()) {
427429

428430
Collection<Object> mapped = new ArrayList<>(collection.size());
@@ -474,22 +476,22 @@ protected MappingContext<? extends RelationalPersistentEntity<?>, RelationalPers
474476
private Condition createCondition(Column column, @Nullable Object mappedValue, SQLType sqlType,
475477
MapSqlParameterSource parameterSource, Comparator comparator, boolean ignoreCase) {
476478

477-
if (comparator.equals(Comparator.IS_NULL)) {
479+
if (comparator.equals(Comparators.IS_NULL)) {
478480
return column.isNull();
479481
}
480482

481-
if (comparator.equals(Comparator.IS_NOT_NULL)) {
483+
if (comparator.equals(Comparators.IS_NOT_NULL)) {
482484
return column.isNotNull();
483485
}
484486

485-
if (comparator == Comparator.IS_TRUE) {
487+
if (comparator == Comparators.IS_TRUE) {
486488

487489
Expression bind = bindBoolean(column, parameterSource,
488490
mappedValue instanceof Boolean ? (Boolean) mappedValue : true);
489491
return column.isEqualTo(bind);
490492
}
491493

492-
if (comparator == Comparator.IS_FALSE) {
494+
if (comparator == Comparators.IS_FALSE) {
493495

494496
Expression bind = bindBoolean(column, parameterSource,
495497
mappedValue instanceof Boolean ? (Boolean) mappedValue : false);
@@ -501,7 +503,7 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, S
501503
columnExpression = Functions.upper(column);
502504
}
503505

504-
if (comparator == Comparator.NOT_IN || comparator == Comparator.IN) {
506+
if (comparator == Comparators.NOT_IN || comparator == Comparators.IN) {
505507

506508
Condition condition;
507509

@@ -524,61 +526,67 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, S
524526
condition = Conditions.in(columnExpression, expression);
525527
}
526528

527-
if (comparator == Comparator.NOT_IN) {
529+
if (comparator == Comparators.NOT_IN) {
528530
condition = condition.not();
529531
}
530532

531533
return condition;
532534
}
533535

534-
if (comparator == Comparator.BETWEEN || comparator == Comparator.NOT_BETWEEN) {
536+
if (comparator == Comparators.BETWEEN || comparator == Comparators.NOT_BETWEEN) {
535537

536538
Pair<Object, Object> pair = (Pair<Object, Object>) mappedValue;
537539

538540
Expression begin = bind(pair.getFirst(), sqlType, parameterSource, column.getName().getReference(), ignoreCase);
539541
Expression end = bind(pair.getSecond(), sqlType, parameterSource, column.getName().getReference(), ignoreCase);
540542

541-
return comparator == Comparator.BETWEEN ? Conditions.between(columnExpression, begin, end)
543+
return comparator == Comparators.BETWEEN ? Conditions.between(columnExpression, begin, end)
542544
: Conditions.notBetween(columnExpression, begin, end);
543545
}
544546

545547
String refName = column.getName().getReference();
546548

547-
switch (comparator) {
548-
case EQ -> {
549-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
550-
return Conditions.isEqual(columnExpression, expression);
551-
}
552-
case NEQ -> {
553-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
554-
return Conditions.isEqual(columnExpression, expression).not();
555-
}
556-
case LT -> {
557-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
558-
return column.isLess(expression);
559-
}
560-
case LTE -> {
561-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
562-
return column.isLessOrEqualTo(expression);
563-
}
564-
case GT -> {
565-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
566-
return column.isGreater(expression);
567-
}
568-
case GTE -> {
569-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
570-
return column.isGreaterOrEqualTo(expression);
571-
}
572-
case LIKE -> {
573-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
574-
return Conditions.like(columnExpression, expression);
575-
}
576-
case NOT_LIKE -> {
577-
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
578-
return Conditions.notLike(columnExpression, expression);
579-
}
580-
default -> throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
581-
}
549+
if (Comparators.EQUALS.equals(comparator)) {
550+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
551+
return Conditions.isEqual(columnExpression, expression);
552+
}
553+
554+
if (Comparators.NOT_EQUALS.equals(comparator)) {
555+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
556+
return Conditions.isEqual(columnExpression, expression).not();
557+
}
558+
559+
if (Comparators.LESS_THAN.equals(comparator)) {
560+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
561+
return column.isLess(expression);
562+
}
563+
564+
if (Comparators.LESS_THAN_OR_EQUALS.equals(comparator)) {
565+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
566+
return column.isLessOrEqualTo(expression);
567+
}
568+
569+
if (Comparators.GREATER_THAN.equals(comparator)) {
570+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
571+
return column.isGreater(expression);
572+
}
573+
574+
if (Comparators.GREATER_THAN_OR_EQUALS.equals(comparator)) {
575+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
576+
return column.isGreaterOrEqualTo(expression);
577+
}
578+
579+
if (Comparators.LIKE.equals(comparator)) {
580+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
581+
return Conditions.like(columnExpression, expression);
582+
}
583+
584+
if (Comparators.NOT_LIKE.equals(comparator)) {
585+
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
586+
return Conditions.notLike(columnExpression, expression);
587+
}
588+
589+
throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
582590
}
583591

584592
private Expression bindBoolean(Column column, MapSqlParameterSource parameterSource, boolean value) {

‎spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/query/QueryMapper.java

+47-48
Original file line numberDiff line numberDiff line change
@@ -33,9 +33,10 @@
3333
import org.springframework.data.relational.core.dialect.Escaper;
3434
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
3535
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
36+
import org.springframework.data.relational.core.query.Comparator;
3637
import org.springframework.data.relational.core.query.CriteriaDefinition;
37-
import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator;
3838
import org.springframework.data.relational.core.query.ValueFunction;
39+
import org.springframework.data.relational.core.query.Comparators;
3940
import org.springframework.data.relational.core.sql.*;
4041
import org.springframework.data.relational.domain.SqlSort;
4142
import org.springframework.data.util.Pair;
@@ -58,6 +59,7 @@
5859
* @author Manousos Mathioudakis
5960
* @author Jens Schauder
6061
* @author Yan Qiang
62+
* @author Mikhail Polivakha
6163
*/
6264
public class QueryMapper {
6365

@@ -325,7 +327,7 @@ private Condition mapCondition(CriteriaDefinition criteria, MutableBindings bind
325327

326328
private Escaper getEscaper(Comparator comparator) {
327329

328-
if (comparator == Comparator.LIKE || comparator == Comparator.NOT_LIKE) {
330+
if (comparator == Comparators.LIKE || comparator == Comparators.NOT_LIKE) {
329331
return dialect.getLikeEscaper();
330332
}
331333

@@ -351,7 +353,7 @@ public Parameter getBindValue(Parameter value) {
351353
@Nullable
352354
private Object convertValue(Comparator comparator, @Nullable Object value, TypeInformation<?> typeHint) {
353355

354-
if ((Comparator.IN.equals(comparator) || Comparator.NOT_IN.equals(comparator))
356+
if ((Comparators.IN.equals(comparator) || Comparators.NOT_IN.equals(comparator))
355357
&& value instanceof Collection<?> collection && !collection.isEmpty()) {
356358

357359
Collection<Object> mapped = new ArrayList<>(collection.size());
@@ -396,21 +398,21 @@ protected MappingContext<? extends RelationalPersistentEntity<?>, RelationalPers
396398
private Condition createCondition(Column column, @Nullable Object mappedValue, Class<?> valueType,
397399
MutableBindings bindings, Comparator comparator, boolean ignoreCase) {
398400

399-
if (comparator.equals(Comparator.IS_NULL)) {
401+
if (comparator.equals(Comparators.IS_NULL)) {
400402
return column.isNull();
401403
}
402404

403-
if (comparator.equals(Comparator.IS_NOT_NULL)) {
405+
if (comparator.equals(Comparators.IS_NOT_NULL)) {
404406
return column.isNotNull();
405407
}
406408

407-
if (comparator == Comparator.IS_TRUE) {
409+
if (comparator == Comparators.IS_TRUE) {
408410
Expression bind = booleanBind(column, mappedValue, valueType, bindings, ignoreCase);
409411

410412
return column.isEqualTo(bind);
411413
}
412414

413-
if (comparator == Comparator.IS_FALSE) {
415+
if (comparator == Comparators.IS_FALSE) {
414416
Expression bind = booleanBind(column, mappedValue, valueType, bindings, ignoreCase);
415417

416418
return column.isEqualTo(bind);
@@ -421,7 +423,7 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, C
421423
columnExpression = Functions.upper(column);
422424
}
423425

424-
if (comparator == Comparator.NOT_IN || comparator == Comparator.IN) {
426+
if (comparator == Comparators.NOT_IN || comparator == Comparators.IN) {
425427

426428
Condition condition;
427429

@@ -446,14 +448,14 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, C
446448
condition = Conditions.in(columnExpression, expression);
447449
}
448450

449-
if (comparator == Comparator.NOT_IN) {
451+
if (comparator == Comparators.NOT_IN) {
450452
condition = condition.not();
451453
}
452454

453455
return condition;
454456
}
455457

456-
if (comparator == Comparator.BETWEEN || comparator == Comparator.NOT_BETWEEN) {
458+
if (comparator == Comparators.BETWEEN || comparator == Comparators.NOT_BETWEEN) {
457459

458460
Pair<Object, Object> pair = (Pair<Object, Object>) mappedValue;
459461

@@ -462,49 +464,46 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, C
462464
Expression end = bind(pair.getSecond(), valueType, bindings, bindings.nextMarker(column.getName().getReference()),
463465
ignoreCase);
464466

465-
return comparator == Comparator.BETWEEN ? Conditions.between(columnExpression, begin, end)
467+
return comparator == Comparators.BETWEEN ? Conditions.between(columnExpression, begin, end)
466468
: Conditions.notBetween(columnExpression, begin, end);
467469
}
468470

469471
BindMarker bindMarker = bindings.nextMarker(column.getName().getReference());
470472

471-
switch (comparator) {
472-
case EQ: {
473-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
474-
return Conditions.isEqual(columnExpression, expression);
475-
}
476-
case NEQ: {
477-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
478-
return Conditions.isEqual(columnExpression, expression).not();
479-
}
480-
case LT: {
481-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
482-
return column.isLess(expression);
483-
}
484-
case LTE: {
485-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
486-
return column.isLessOrEqualTo(expression);
487-
}
488-
case GT: {
489-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
490-
return column.isGreater(expression);
491-
}
492-
case GTE: {
493-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
494-
return column.isGreaterOrEqualTo(expression);
495-
}
496-
case LIKE: {
497-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
498-
return Conditions.like(columnExpression, expression);
499-
}
500-
case NOT_LIKE: {
501-
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
502-
return Conditions.notLike(columnExpression, expression);
503-
}
504-
default:
505-
throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
506-
}
507-
}
473+
if (Comparators.EQUALS.equals(comparator)) {
474+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
475+
return Conditions.isEqual(columnExpression, expression);
476+
477+
} else if (Comparators.NOT_EQUALS.equals(comparator)) {
478+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
479+
return Conditions.isEqual(columnExpression, expression).not();
480+
481+
} else if (Comparators.LESS_THAN.equals(comparator)) {
482+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
483+
return column.isLess(expression);
484+
485+
} else if (Comparators.LESS_THAN_OR_EQUALS.equals(comparator)) {
486+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
487+
return column.isLessOrEqualTo(expression);
488+
489+
} else if (Comparators.GREATER_THAN.equals(comparator)) {
490+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
491+
return column.isGreater(expression);
492+
493+
} else if (Comparators.GREATER_THAN_OR_EQUALS.equals(comparator)) {
494+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
495+
return column.isGreaterOrEqualTo(expression);
496+
497+
} else if (Comparators.LIKE.equals(comparator)) {
498+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
499+
return Conditions.like(columnExpression, expression);
500+
501+
} else if (Comparators.NOT_LIKE.equals(comparator)) {
502+
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
503+
return Conditions.notLike(columnExpression, expression);
504+
}
505+
throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
506+
}
508507

509508
Field createPropertyField(@Nullable RelationalPersistentEntity<?> entity, SqlIdentifier key) {
510509
return entity == null ? new Field(key) : new MetadataBackedField(key, entity, mappingContext);

0 commit comments

Comments
 (0)