Use Hibernates case-insensitive pattern matching when available.

This commit provides case-insensitive pattern matching when using
`=ilike=` or `=inotlike=` that relies on Hibernate's implementation
for `ilike`. However, if JPA provider is different from Hibernate
we fallback to old implementation.

The reason behind this change is to allow Hibernate generate
"proper" case-insensitive pattern matching query depending on database.

Author: nstdio

rsql-jpa/src/main/java/io/github/perplexhub/rsql/HibernateSupport.java

@@ -0,0 +1,32 @@
+package io.github.perplexhub.rsql;
+
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.Expression;
+import jakarta.persistence.criteria.Predicate;
+import org.hibernate.query.criteria.HibernateCriteriaBuilder;
+import org.springframework.util.ClassUtils;
+
+final class HibernateSupport {
+
+  private static final boolean isHibernatePresent = ClassUtils.isPresent(
+      "org.hibernate.query.criteria.HibernateCriteriaBuilder", HibernateSupport.class.getClassLoader());
+
+  private HibernateSupport() {
+  }
+
+  static boolean isHibernateCriteriaBuilder(CriteriaBuilder cb) {
+    return isHibernatePresent && cb instanceof HibernateCriteriaBuilder;
+  }
+
+  /**
+   * Must be guarded with {@linkplain #isHibernatePresent} before invoking.
+   */
+  static Predicate ilike(CriteriaBuilder cb, Expression<String> expression, String arg, Character escapeChar) {
+    var hcb = (HibernateCriteriaBuilder) cb;
+    var pattern = '%' + arg + '%';
+
+    return escapeChar != null
+        ? hcb.ilike(expression, pattern, escapeChar)
+        : hcb.ilike(expression, pattern);
+  }
+}

rsql-jpa/src/main/java/io/github/perplexhub/rsql/RSQLJPAPredicateConverter.java

@@ -330,21 +330,19 @@ private Predicate expressionPredicate(ComparisonNode node, ResolvedExpression.Pa
 				return builder.notEqual(expression, argument);
 			}
 			if (op.equals(LIKE)) {
-				return likePredicate(expression.as(String.class), "%" + argument.toString() + "%", builder);
+				return likePredicate(expression, argument, false);
 			}
 			if (op.equals(NOT_LIKE)) {
-				return likePredicate(expression.as(String.class), "%" + argument.toString() + "%", builder).not();
+				return likePredicate(expression, argument, false).not();
 			}
 			if (op.equals(IGNORE_CASE)) {
 				return builder.equal(builder.upper(expression), argument.toString().toUpperCase());
 			}
 			if (op.equals(IGNORE_CASE_LIKE)) {
-				return likePredicate(builder.upper(expression), "%" + argument.toString()
-						.toUpperCase() + "%", builder);
+				return likePredicate(expression, argument, true);
 			}
 			if (op.equals(IGNORE_CASE_NOT_LIKE)) {
-				return likePredicate(builder.upper(expression), "%" + argument.toString()
-						.toUpperCase() + "%", builder).not();
+				return likePredicate(expression, argument, true).not();
 			}
 			if (op.equals(EQUAL)) {
 				return equalPredicate(expression, type, argument);
@@ -388,6 +386,20 @@ private Predicate likePredicate(Expression attributePath, String likeExpression,
 				.orElseGet(() -> builder.like(attributePath, likeExpression));
 	}
 
+	private Predicate likePredicate(Expression<?> expression, Object argument, boolean ignoreCase) {
+		String argToUse = String.valueOf(argument);
+		Expression<String> strExpression = expression.as(String.class);
+		if (ignoreCase) {
+			if (HibernateSupport.isHibernateCriteriaBuilder(builder)) {
+				return HibernateSupport.ilike(builder, strExpression, argToUse, likeEscapeCharacter);
+			}
+
+			return likePredicate(builder.upper(strExpression), "%" + argToUse.toUpperCase(Locale.ROOT) + "%", builder);
+		}
+		
+		return likePredicate(strExpression, "%" + argToUse + "%", builder);
+	}
+
 	private Predicate equalPredicate(Expression expr, Class type, Object argument) {
 		if (type.equals(String.class)) {
 			String argStr = argument.toString();