Skip to content

Commit

Permalink
DATAJDBC-1953 Introduced Comparator interface
Browse files Browse the repository at this point in the history 
Signed-off-by: Mikhail Polivakha <[email protected]>
  • Loading branch information
@mipo256
mipo256 committed Jan 16, 2025
1 parent b51c77b commit 74172af
Show file tree
Hide file tree
Showing 9 changed files with 329 additions and 192 deletions.
98 changes: 53 additions & 45 deletions spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/QueryMapper.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,9 +34,10 @@
import org.springframework.data.mapping.context.MappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.core.query.Comparator;
import org.springframework.data.relational.core.query.CriteriaDefinition;
import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator;
import org.springframework.data.relational.core.query.ValueFunction;
import org.springframework.data.relational.core.query.Comparators;
import org.springframework.data.relational.core.sql.*;
import org.springframework.data.relational.domain.SqlSort;
import org.springframework.data.util.Pair;
Expand All @@ -53,6 +54,7 @@
* @author Mark Paluch
* @author Jens Schauder
* @author Yan Qiang
* @author Mikhail Polivakha
* @since 3.0
*/
public class QueryMapper {
Expand Down Expand Up @@ -422,7 +424,7 @@ private Condition mapEmbeddedObjectCondition(CriteriaDefinition criteria, MapSql
@Nullable
private Object convertValue(Comparator comparator, @Nullable Object value, TypeInformation<?> typeHint) {

if ((Comparator.IN.equals(comparator) || Comparator.NOT_IN.equals(comparator))
if ((Comparators.IN.equals(comparator) || Comparators.NOT_IN.equals(comparator))
&& value instanceof Collection<?> collection && !collection.isEmpty()) {

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

if (comparator.equals(Comparator.IS_NULL)) {
if (comparator.equals(Comparators.IS_NULL)) {
return column.isNull();
}

if (comparator.equals(Comparator.IS_NOT_NULL)) {
if (comparator.equals(Comparators.IS_NOT_NULL)) {
return column.isNotNull();
}

if (comparator == Comparator.IS_TRUE) {
if (comparator == Comparators.IS_TRUE) {

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

if (comparator == Comparator.IS_FALSE) {
if (comparator == Comparators.IS_FALSE) {

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

if (comparator == Comparator.NOT_IN || comparator == Comparator.IN) {
if (comparator == Comparators.NOT_IN || comparator == Comparators.IN) {

Condition condition;

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

if (comparator == Comparator.NOT_IN) {
if (comparator == Comparators.NOT_IN) {
condition = condition.not();
}

return condition;
}

if (comparator == Comparator.BETWEEN || comparator == Comparator.NOT_BETWEEN) {
if (comparator == Comparators.BETWEEN || comparator == Comparators.NOT_BETWEEN) {

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

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

return comparator == Comparator.BETWEEN ? Conditions.between(columnExpression, begin, end)
return comparator == Comparators.BETWEEN ? Conditions.between(columnExpression, begin, end)
: Conditions.notBetween(columnExpression, begin, end);
}

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

switch (comparator) {
case EQ -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.isEqual(columnExpression, expression);
}
case NEQ -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.isEqual(columnExpression, expression).not();
}
case LT -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isLess(expression);
}
case LTE -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isLessOrEqualTo(expression);
}
case GT -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isGreater(expression);
}
case GTE -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isGreaterOrEqualTo(expression);
}
case LIKE -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.like(columnExpression, expression);
}
case NOT_LIKE -> {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.notLike(columnExpression, expression);
}
default -> throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
}
if (Comparators.EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.isEqual(columnExpression, expression);
}

if (Comparators.NOT_EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.isEqual(columnExpression, expression).not();
}

if (Comparators.LESS_THAN.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isLess(expression);
}

if (Comparators.LESS_THAN_OR_EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isLessOrEqualTo(expression);
}

if (Comparators.GREATER_THAN.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isGreater(expression);
}

if (Comparators.GREATER_THAN_OR_EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName);
return column.isGreaterOrEqualTo(expression);
}

if (Comparators.LIKE.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.like(columnExpression, expression);
}

if (Comparators.NOT_LIKE.equals(comparator)) {
Expression expression = bind(mappedValue, sqlType, parameterSource, refName, ignoreCase);
return Conditions.notLike(columnExpression, expression);
}

throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
}

private Expression bindBoolean(Column column, MapSqlParameterSource parameterSource, boolean value) {
Expand Down
95 changes: 47 additions & 48 deletions spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/query/QueryMapper.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,9 +33,10 @@
import org.springframework.data.relational.core.dialect.Escaper;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.core.query.Comparator;
import org.springframework.data.relational.core.query.CriteriaDefinition;
import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator;
import org.springframework.data.relational.core.query.ValueFunction;
import org.springframework.data.relational.core.query.Comparators;
import org.springframework.data.relational.core.sql.*;
import org.springframework.data.relational.domain.SqlSort;
import org.springframework.data.util.Pair;
Expand All @@ -58,6 +59,7 @@
* @author Manousos Mathioudakis
* @author Jens Schauder
* @author Yan Qiang
* @author Mikhail Polivakha
*/
public class QueryMapper {

Expand Down Expand Up @@ -325,7 +327,7 @@ private Condition mapCondition(CriteriaDefinition criteria, MutableBindings bind

private Escaper getEscaper(Comparator comparator) {

if (comparator == Comparator.LIKE || comparator == Comparator.NOT_LIKE) {
if (comparator == Comparators.LIKE || comparator == Comparators.NOT_LIKE) {
return dialect.getLikeEscaper();
}

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

if ((Comparator.IN.equals(comparator) || Comparator.NOT_IN.equals(comparator))
if ((Comparators.IN.equals(comparator) || Comparators.NOT_IN.equals(comparator))
&& value instanceof Collection<?> collection && !collection.isEmpty()) {

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

if (comparator.equals(Comparator.IS_NULL)) {
if (comparator.equals(Comparators.IS_NULL)) {
return column.isNull();
}

if (comparator.equals(Comparator.IS_NOT_NULL)) {
if (comparator.equals(Comparators.IS_NOT_NULL)) {
return column.isNotNull();
}

if (comparator == Comparator.IS_TRUE) {
if (comparator == Comparators.IS_TRUE) {
Expression bind = booleanBind(column, mappedValue, valueType, bindings, ignoreCase);

return column.isEqualTo(bind);
}

if (comparator == Comparator.IS_FALSE) {
if (comparator == Comparators.IS_FALSE) {
Expression bind = booleanBind(column, mappedValue, valueType, bindings, ignoreCase);

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

if (comparator == Comparator.NOT_IN || comparator == Comparator.IN) {
if (comparator == Comparators.NOT_IN || comparator == Comparators.IN) {

Condition condition;

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

if (comparator == Comparator.NOT_IN) {
if (comparator == Comparators.NOT_IN) {
condition = condition.not();
}

return condition;
}

if (comparator == Comparator.BETWEEN || comparator == Comparator.NOT_BETWEEN) {
if (comparator == Comparators.BETWEEN || comparator == Comparators.NOT_BETWEEN) {

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

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

return comparator == Comparator.BETWEEN ? Conditions.between(columnExpression, begin, end)
return comparator == Comparators.BETWEEN ? Conditions.between(columnExpression, begin, end)
: Conditions.notBetween(columnExpression, begin, end);
}

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

switch (comparator) {
case EQ: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.isEqual(columnExpression, expression);
}
case NEQ: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.isEqual(columnExpression, expression).not();
}
case LT: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isLess(expression);
}
case LTE: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isLessOrEqualTo(expression);
}
case GT: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isGreater(expression);
}
case GTE: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isGreaterOrEqualTo(expression);
}
case LIKE: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.like(columnExpression, expression);
}
case NOT_LIKE: {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.notLike(columnExpression, expression);
}
default:
throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
}
}
if (Comparators.EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.isEqual(columnExpression, expression);

} else if (Comparators.NOT_EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.isEqual(columnExpression, expression).not();

} else if (Comparators.LESS_THAN.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isLess(expression);

} else if (Comparators.LESS_THAN_OR_EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isLessOrEqualTo(expression);

} else if (Comparators.GREATER_THAN.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isGreater(expression);

} else if (Comparators.GREATER_THAN_OR_EQUALS.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
return column.isGreaterOrEqualTo(expression);

} else if (Comparators.LIKE.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.like(columnExpression, expression);

} else if (Comparators.NOT_LIKE.equals(comparator)) {
Expression expression = bind(mappedValue, valueType, bindings, bindMarker, ignoreCase);
return Conditions.notLike(columnExpression, expression);
}
throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
}

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

0 comments on commit 74172af

Please sign in to comment.