#282 - Use 'StatementMapper' to create 'BindableQuery' instead of 'StatementBuilder'

Author: rchigvintsev

src/main/java/org/springframework/data/r2dbc/query/Criteria.java

@@ -57,20 +57,28 @@ public class Criteria {
 	private final @Nullable SqlIdentifier column;
 	private final @Nullable Comparator comparator;
 	private final @Nullable Object value;
+	private final boolean ignoreCase;
 
 	private Criteria(SqlIdentifier column, Comparator comparator, @Nullable Object value) {
-		this(null, Combinator.INITIAL, Collections.emptyList(), column, comparator, value);
+		this(null, Combinator.INITIAL, Collections.emptyList(), column, comparator, value, false);
 	}
 
 	private Criteria(@Nullable Criteria previous, Combinator combinator, List<Criteria> group,
 			@Nullable SqlIdentifier column, @Nullable Comparator comparator, @Nullable Object value) {
+		this(previous, combinator, group, column, comparator, value, false);
+	}
+
+	private Criteria(@Nullable Criteria previous, Combinator combinator, List<Criteria> group,
+			@Nullable SqlIdentifier column, @Nullable Comparator comparator, @Nullable Object value,
+			boolean ignoreCase) {
 
 		this.previous = previous;
 		this.combinator = previous != null && previous.isEmpty() ? Combinator.INITIAL : combinator;
 		this.group = group;
 		this.column = column;
 		this.comparator = comparator;
 		this.value = value;
+		this.ignoreCase = ignoreCase;
 	}
 
 	private Criteria(@Nullable Criteria previous, Combinator combinator, List<Criteria> group) {
@@ -81,6 +89,7 @@ private Criteria(@Nullable Criteria previous, Combinator combinator, List<Criter
 		this.column = null;
 		this.comparator = null;
 		this.value = null;
+		this.ignoreCase = false;
 	}
 
 	/**
@@ -236,6 +245,19 @@ public Criteria or(List<Criteria> criteria) {
 		return new Criteria(Criteria.this, Combinator.OR, criteria);
 	}
 
+	/**
+	 * Creates a new {@link Criteria} with the given "ignore case" flag.
+	 *
+	 * @param ignoreCase {@literal true} if comparison should be done in case-insensitive way
+	 * @return a new {@link Criteria} object
+	 */
+	public Criteria ignoreCase(boolean ignoreCase) {
+		if (this.ignoreCase != ignoreCase) {
+			return new Criteria(previous, combinator, group, column, comparator, value, ignoreCase);
+		}
+		return this;
+	}
+
 	/**
 	 * @return the previous {@link Criteria} object. Can be {@literal null} if there is no previous {@link Criteria}.
 	 * @see #hasPrevious()
@@ -338,8 +360,17 @@ Object getValue() {
 		return value;
 	}
 
+	/**
+	 * Checks whether comparison should be done in case-insensitive way.
+	 *
+	 * @return {@literal true} if comparison should be done in case-insensitive way
+	 */
+	boolean isIgnoreCase() {
+		return ignoreCase;
+	}
+
 	enum Comparator {
-		INITIAL, EQ, NEQ, LT, LTE, GT, GTE, IS_NULL, IS_NOT_NULL, LIKE, NOT_IN, IN,
+		INITIAL, EQ, NEQ, LT, LTE, GT, GTE, IS_NULL, IS_NOT_NULL, LIKE, NOT_LIKE, NOT_IN, IN, IS_TRUE, IS_FALSE
 	}
 
 	enum Combinator {
@@ -428,6 +459,14 @@ public interface CriteriaStep {
 		 */
 		Criteria like(Object value);
 
+		/**
+		 * Creates a {@link Criteria} using {@code NOT LIKE}.
+		 *
+		 * @param value must not be {@literal null}
+		 * @return a new {@link Criteria} object
+		 */
+		Criteria notLike(Object value);
+
 		/**
 		 * Creates a {@link Criteria} using {@code IS NULL}.
 		 */
@@ -437,6 +476,20 @@ public interface CriteriaStep {
 		 * Creates a {@link Criteria} using {@code IS NOT NULL}.
 		 */
 		Criteria isNotNull();
+
+		/**
+		 * Creates a {@link Criteria} using {@code IS TRUE}.
+		 *
+		 * @return a new {@link Criteria} object
+		 */
+		Criteria isTrue();
+
+		/**
+		 * Creates a {@link Criteria} using {@code IS FALSE}.
+		 *
+		 * @return a new {@link Criteria} object
+		 */
+		Criteria isFalse();
 	}
 
 	/**
@@ -596,6 +649,16 @@ public Criteria like(Object value) {
 			return createCriteria(Comparator.LIKE, value);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.function.query.Criteria.CriteriaStep#notLike(java.lang.Object)
+		 */
+		@Override
+		public Criteria notLike(Object value) {
+			Assert.notNull(value, "Value must not be null!");
+			return createCriteria(Comparator.NOT_LIKE, value);
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.data.r2dbc.function.query.Criteria.CriteriaStep#isNull()
@@ -614,6 +677,24 @@ public Criteria isNotNull() {
 			return createCriteria(Comparator.IS_NOT_NULL, null);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.function.query.Criteria.CriteriaStep#isTrue()
+		 */
+		@Override
+		public Criteria isTrue() {
+			return createCriteria(Comparator.IS_TRUE, null);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.function.query.Criteria.CriteriaStep#isFalse()
+		 */
+		@Override
+		public Criteria isFalse() {
+			return createCriteria(Comparator.IS_FALSE, null);
+		}
+
 		protected Criteria createCriteria(Comparator comparator, Object value) {
 			return new Criteria(this.property, comparator, value);
 		}

src/main/java/org/springframework/data/r2dbc/query/QueryMapper.java

@@ -320,7 +320,8 @@ private Condition mapCondition(Criteria criteria, MutableBindings bindings, Tabl
 			typeHint = actualType.getType();
 		}
 
-		return createCondition(column, mappedValue, typeHint, bindings, criteria.getComparator());
+		return createCondition(column, mappedValue, typeHint, bindings, criteria.getComparator(),
+				criteria.isIgnoreCase());
 	}
 
 	/**
@@ -370,7 +371,7 @@ protected MappingContext<? extends RelationalPersistentEntity<?>, RelationalPers
 	}
 
 	private Condition createCondition(Column column, @Nullable Object mappedValue, Class<?> valueType,
-			MutableBindings bindings, Comparator comparator) {
+			MutableBindings bindings, Comparator comparator, boolean ignoreCase) {
 
 		if (comparator.equals(Comparator.IS_NULL)) {
 			return column.isNull();
@@ -380,6 +381,19 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, C
 			return column.isNotNull();
 		}
 
+		if (comparator == Comparator.IS_TRUE) {
+			return column.isEqualTo(SQL.literalOf((Object) ("TRUE")));
+		}
+
+		if (comparator == Comparator.IS_FALSE) {
+			return column.isEqualTo(SQL.literalOf((Object) ("FALSE")));
+		}
+
+		Expression columnExpression = column;
+		if (ignoreCase && String.class == valueType) {
+			columnExpression = new Upper(column);
+		}
+
 		if (comparator == Comparator.NOT_IN || comparator == Comparator.IN) {
 
 			Condition condition;
@@ -395,14 +409,14 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, C
 					expressions.add(bind(o, valueType, bindings, bindMarker));
 				}
 
-				condition = column.in(expressions.toArray(new Expression[0]));
+				condition = Conditions.in(columnExpression, expressions.toArray(new Expression[0]));
 
 			} else {
 
 				BindMarker bindMarker = bindings.nextMarker(column.getName().getReference());
 				Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
 
-				condition = column.in(expression);
+				condition = Conditions.in(columnExpression, expression);
 			}
 
 			if (comparator == Comparator.NOT_IN) {
@@ -413,23 +427,40 @@ private Condition createCondition(Column column, @Nullable Object mappedValue, C
 		}
 
 		BindMarker bindMarker = bindings.nextMarker(column.getName().getReference());
-		Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
 
 		switch (comparator) {
-			case EQ:
-				return column.isEqualTo(expression);
-			case NEQ:
-				return column.isNotEqualTo(expression);
-			case LT:
+			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:
+			}
+			case LTE: {
+				Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
 				return column.isLessOrEqualTo(expression);
-			case GT:
+			}
+			case GT: {
+				Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
 				return column.isGreater(expression);
-			case GTE:
+			}
+			case GTE: {
+				Expression expression = bind(mappedValue, valueType, bindings, bindMarker);
 				return column.isGreaterOrEqualTo(expression);
-			case LIKE:
-				return column.like(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 NotLike.create(columnExpression, expression);
+			}
 			default:
 				throw new UnsupportedOperationException("Comparator " + comparator + " not supported");
 		}
@@ -459,14 +490,20 @@ Class<?> getTypeHint(@Nullable Object mappedValue, Class<?> propertyType, Settab
 
 	private Expression bind(@Nullable Object mappedValue, Class<?> valueType, MutableBindings bindings,
 			BindMarker bindMarker) {
+		return bind(mappedValue, valueType, bindings, bindMarker, false);
+	}
+
+	private Expression bind(@Nullable Object mappedValue, Class<?> valueType, MutableBindings bindings,
+			BindMarker bindMarker, boolean ignoreCase) {
 
 		if (mappedValue != null) {
 			bindings.bind(bindMarker, mappedValue);
 		} else {
 			bindings.bindNull(bindMarker, valueType);
 		}
 
-		return SQL.bindMarker(bindMarker.getPlaceholder());
+		return ignoreCase ? new Upper(SQL.bindMarker(bindMarker.getPlaceholder()))
+				: SQL.bindMarker(bindMarker.getPlaceholder());
 	}
 
 	/**
@@ -665,4 +702,89 @@ public String toString() {
 			return toSql(IdentifierProcessing.ANSI);
 		}
 	}
+
+	// TODO: include support of NOT LIKE operator into spring-data-relational
+	/**
+	 * Negated LIKE {@link Condition} comparing two {@link Expression}s.
+	 * <p/>
+	 * Results in a rendered condition: {@code <left> NOT LIKE <right>}.
+	 */
+	private static class NotLike implements Segment, Condition {
+		private final Comparison delegate;
+
+		private NotLike(Expression leftColumnOrExpression, Expression rightColumnOrExpression) {
+			this.delegate = Comparison.create(leftColumnOrExpression, "NOT LIKE", rightColumnOrExpression);
+		}
+
+		/**
+		 * Creates new instance of this class with the given {@link Expression}s.
+		 *
+		 * @param leftColumnOrExpression the left {@link Expression}
+		 * @param rightColumnOrExpression the right {@link Expression}
+		 * @return {@link NotLike} condition
+		 */
+		public static NotLike create(Expression leftColumnOrExpression, Expression rightColumnOrExpression) {
+			Assert.notNull(leftColumnOrExpression, "Left expression must not be null!");
+			Assert.notNull(rightColumnOrExpression, "Right expression must not be null!");
+			return new NotLike(leftColumnOrExpression, rightColumnOrExpression);
+		}
+
+		@Override
+		public void visit(Visitor visitor) {
+			Assert.notNull(visitor, "Visitor must not be null!");
+			delegate.visit(visitor);
+		}
+
+		@Override
+		public String toString() {
+			return delegate.toString();
+		}
+	}
+
+	// TODO: include support of functions in WHERE conditions into spring-data-relational
+	/**
+	 * Models the ANSI SQL {@code UPPER} function.
+	 * <p>
+	 * Results in a rendered function: {@code UPPER(<expression>)}.
+	 */
+	private class Upper implements Expression {
+		private Literal<Object> delegate;
+
+		/**
+		 * Creates new instance of this class with the given expression. Only expressions of type {@link Column} and
+		 * {@link org.springframework.data.relational.core.sql.BindMarker} are supported.
+		 *
+		 * @param expression expression to be uppercased (must not be {@literal null})
+		 */
+		private Upper(Expression expression) {
+			Assert.notNull(expression, "Expression must not be null!");
+			String functionArgument;
+			if (expression instanceof org.springframework.data.relational.core.sql.BindMarker) {
+				functionArgument = expression instanceof Named ? ((Named) expression).getName().getReference()
+						: expression.toString();
+			} else if (expression instanceof Column) {
+				functionArgument = "";
+				Table table = ((Column) expression).getTable();
+				if (table != null) {
+					functionArgument = toSql(table.getName()) + ".";
+				}
+				functionArgument += toSql(((Column) expression).getName());
+			} else {
+				throw new IllegalArgumentException("Unable to ignore case expression of type " + expression.getClass().getName()
+						+ ". Only " + Column.class.getName() + " and "
+						+ org.springframework.data.relational.core.sql.BindMarker.class.getName() + " types are supported");
+			}
+			this.delegate = SQL.literalOf((Object) ("UPPER(" + functionArgument + ")"));
+		}
+
+		@Override
+		public void visit(Visitor visitor) {
+			delegate.visit(visitor);
+		}
+
+		@Override
+		public String toString() {
+			return delegate.toString();
+		}
+	}
 }