DATAJDBC-514 - Add support for Between and Not Like to Criteria API and SQL generation.

We now support Conditions.between, notBetween, and notLike as additional criteria conditions and support case-insensitive comparisons.
For LIKE escaping we pick up the Escaper configured at Dialect level. The newly introduced ValueFunction allows string transformation before computing a value by applying the Escaper to the raw value. Escaping is required for StartingWith, Contains and EndsWith PartTree operations.

Original pull request: spring-projects/spring-data-r2dbc#295.

Author: mp911de

spring-data-relational/src/main/java/org/springframework/data/relational/core/dialect/Dialect.java

@@ -15,9 +15,9 @@
  */
 package org.springframework.data.relational.core.dialect;
 
-import org.springframework.data.relational.core.sql.render.SelectRenderContext;
 import org.springframework.data.relational.core.sql.IdentifierProcessing;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
+import org.springframework.data.relational.core.sql.render.SelectRenderContext;
 
 /**
  * Represents a dialect that is implemented by a particular database. Please note that not all features are supported by
@@ -63,4 +63,14 @@ default ArrayColumns getArraySupport() {
 	default IdentifierProcessing getIdentifierProcessing() {
 		return IdentifierProcessing.ANSI;
 	}
+
+	/**
+	 * Returns the {@link Escaper} used for {@code LIKE} value escaping.
+	 *
+	 * @return the {@link Escaper} used for {@code LIKE} value escaping.
+	 * @since 2.0
+	 */
+	default Escaper getLikeEscaper() {
+		return Escaper.DEFAULT;
+	}
 }

spring-data-relational/src/main/java/org/springframework/data/relational/core/dialect/SqlServerDialect.java

@@ -31,7 +31,7 @@ public class SqlServerDialect extends AbstractDialect {
 	 */
 	public static final SqlServerDialect INSTANCE = new SqlServerDialect();
 
-	protected SqlServerDialect() {	}
+	protected SqlServerDialect() {}
 
 	private static final LimitClause LIMIT_CLAUSE = new LimitClause() {
 
@@ -84,6 +84,15 @@ public LimitClause limit() {
 		return LIMIT_CLAUSE;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.relational.core.dialect.Dialect#getLikeEscaper()
+	 */
+	@Override
+	public Escaper getLikeEscaper() {
+		return Escaper.DEFAULT.withRewriteFor("[", "]");
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.relational.core.dialect.AbstractDialect#getSelectContext()

spring-data-relational/src/main/java/org/springframework/data/relational/core/query/Criteria.java

@@ -22,6 +22,7 @@
 
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
+import org.springframework.data.util.Pair;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
@@ -93,7 +94,6 @@ private Criteria(@Nullable Criteria previous, Combinator combinator, List<Criter
 		this.ignoreCase = false;
 	}
 
-
 	/**
 	 * Static factory method to create an empty Criteria.
 	 *
@@ -417,6 +417,24 @@ public interface CriteriaStep {
 		 */
 		Criteria notIn(Collection<?> values);
 
+		/**
+		 * Creates a {@link Criteria} using between ({@literal BETWEEN begin AND end}).
+		 *
+		 * @param begin must not be {@literal null}.
+		 * @param end must not be {@literal null}.
+		 * @since 2.2
+		 */
+		Criteria between(Object begin, Object end);
+
+		/**
+		 * Creates a {@link Criteria} using not between ({@literal NOT BETWEEN begin AND end}).
+		 *
+		 * @param begin must not be {@literal null}.
+		 * @param end must not be {@literal null}.
+		 * @since 2.2
+		 */
+		Criteria notBetween(Object begin, Object end);
+
 		/**
 		 * Creates a {@link Criteria} using less-than ({@literal <}).
 		 *
@@ -582,6 +600,32 @@ public Criteria notIn(Collection<?> values) {
 			return createCriteria(Comparator.NOT_IN, values);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.function.query.Criteria.CriteriaStep#between(java.lang.Object, java.lang.Object)
+		 */
+		@Override
+		public Criteria between(Object begin, Object end) {
+
+			Assert.notNull(begin, "Begin value must not be null!");
+			Assert.notNull(end, "End value must not be null!");
+
+			return createCriteria(Comparator.BETWEEN, Pair.of(begin, end));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.function.query.Criteria.CriteriaStep#notBetween(java.lang.Object, java.lang.Object)
+		 */
+		@Override
+		public Criteria notBetween(Object begin, Object end) {
+
+			Assert.notNull(begin, "Begin value must not be null!");
+			Assert.notNull(end, "End value must not be null!");
+
+			return createCriteria(Comparator.NOT_BETWEEN, Pair.of(begin, end));
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.data.r2dbc.function.query.Criteria.CriteriaStep#lessThan(java.lang.Object)

spring-data-relational/src/main/java/org/springframework/data/relational/core/query/CriteriaDefinition.java

@@ -135,6 +135,6 @@ enum Combinator {
 	}
 
 	enum Comparator {
-		INITIAL, EQ, NEQ, LT, LTE, GT, GTE, IS_NULL, IS_NOT_NULL, LIKE, NOT_LIKE, NOT_IN, IN, IS_TRUE, IS_FALSE
+		INITIAL, EQ, NEQ, BETWEEN, NOT_BETWEEN, LT, LTE, GT, GTE, IS_NULL, IS_NOT_NULL, LIKE, NOT_LIKE, NOT_IN, IN, IS_TRUE, IS_FALSE
 	}
 }

spring-data-relational/src/main/java/org/springframework/data/relational/core/query/ValueFunction.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.relational.core.query;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import org.springframework.data.relational.core.dialect.Escaper;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Represents a value function to return arbitrary values that can be escaped before returning the actual value. Can be
+ * used with the criteria API for deferred value retrieval.
+ *
+ * @author Mark Paluch
+ * @since 2.0
+ * @see Escaper
+ * @see Supplier
+ */
+@FunctionalInterface
+public interface ValueFunction<T> extends Function<Escaper, T> {
+
+	/**
+	 * Produces a value by considering the given {@link Escaper}.
+	 *
+	 * @param escaper the escaper to use.
+	 * @return the return value, may be {@literal null}.
+	 */
+	@Nullable
+	@Override
+	T apply(Escaper escaper);
+
+	/**
+	 * Adapts this value factory into a {@link Supplier} by using the given {@link Escaper}.
+	 *
+	 * @param escaper the escaper to use.
+	 * @return the value factory
+	 */
+	default Supplier<T> toSupplier(Escaper escaper) {
+
+		Assert.notNull(escaper, "Escaper must not be null");
+
+		return () -> apply(escaper);
+	}
+}

spring-data-relational/src/main/java/org/springframework/data/relational/core/sql/Between.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.relational.core.sql;
+
+import org.springframework.util.Assert;
+
+/**
+ * BETWEEN {@link Condition} comparing between {@link Expression}s.
+ * <p/>
+ * Results in a rendered condition: {@code <left> BETWEEN <begin> AND <end>}.
+ *
+ * @author Mark Paluch
+ * @since 2.2
+ */
+public class Between extends AbstractSegment implements Condition {
+
+	private final Expression column;
+	private final Expression begin;
+	private final Expression end;
+	private final boolean negated;
+
+	private Between(Expression column, Expression begin, Expression end, boolean negated) {
+
+		super(column, begin, end);
+
+		this.column = column;
+		this.begin = begin;
+		this.end = end;
+		this.negated = negated;
+	}
+
+	/**
+	 * Creates a new {@link Between} {@link Condition} given two {@link Expression}s.
+	 *
+	 * @param columnOrExpression left side of the comparison.
+	 * @param begin begin value of the comparison.
+	 * @param end end value of the comparison.
+	 * @return the {@link Between} condition.
+	 */
+	public static Between create(Expression columnOrExpression, Expression begin, Expression end) {
+
+		Assert.notNull(columnOrExpression, "Column or expression must not be null!");
+		Assert.notNull(begin, "Begin value must not be null!");
+		Assert.notNull(end, "end value must not be null!");
+
+		return new Between(columnOrExpression, begin, end, false);
+	}
+
+	/**
+	 * @return the column {@link Expression}.
+	 */
+	public Expression getColumn() {
+		return column;
+	}
+
+	/**
+	 * @return the begin {@link Expression}.
+	 */
+	public Expression getBegin() {
+		return begin;
+	}
+
+	/**
+	 * @return the end {@link Expression}.
+	 */
+	public Expression getEnd() {
+		return end;
+	}
+
+	public boolean isNegated() {
+		return negated;
+	}
+
+	@Override
+	public Between not() {
+		return new Between(this.column, this.begin, this.end, !negated);
+	}
+
+	@Override
+	public String toString() {
+		return column.toString() + " BETWEEN " + begin.toString() + " AND " + end.toString();
+	}
+}

spring-data-relational/src/main/java/org/springframework/data/relational/core/sql/BooleanLiteral.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.relational.core.sql;
+
+/**
+ * Represents a {@link Boolean} literal.
+ *
+ * @author Mark Paluch
+ * @since 2.0
+ */
+public class BooleanLiteral extends Literal<Boolean> {
+
+	BooleanLiteral(boolean content) {
+		super(content);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.relational.core.sql.Literal#getContent()
+	 */
+	@Override
+	public Boolean getContent() {
+		return super.getContent();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.relational.core.sql.Literal#toString()
+	 */
+	@Override
+	public String toString() {
+		return getContent() ? "TRUE" : "FALSE";
+	}
+}