diff --git a/hawkbit-mgmt/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtActionResourceTest.java b/hawkbit-mgmt/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtActionResourceTest.java
index 928467666..2897139aa 100644
--- a/hawkbit-mgmt/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtActionResourceTest.java
+++ b/hawkbit-mgmt/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtActionResourceTest.java
@@ -322,15 +322,10 @@ class MgmtActionResourceTest extends AbstractManagementApiIntegrationTest {
final DistributionSet ds = testdataFactory.createDistributionSet("");
assignDistributionSet(ds, Collections.singletonList(target));
- final String rsqlTargetControllerId = "target.controllerId==knownTargetId";
- final String rsqlTargetName = "target.name==knownTargetName";
- final String rsqlTargetUpdateStatus = "target.updateStatus==pending";
- final String rsqlTargetAddress = "target.address==http://0.0.0.0";
-
- verifyResultsByTargetPropertyFilter(target, ds, rsqlTargetControllerId);
- verifyResultsByTargetPropertyFilter(target, ds, rsqlTargetName);
- verifyResultsByTargetPropertyFilter(target, ds, rsqlTargetUpdateStatus);
- verifyResultsByTargetPropertyFilter(target, ds, rsqlTargetAddress);
+ verifyResultsByTargetPropertyFilter(target, ds, "target.controllerId==knownTargetId");
+ verifyResultsByTargetPropertyFilter(target, ds, "target.name==knownTargetName");
+ verifyResultsByTargetPropertyFilter(target, ds, "target.updateStatus==pending");
+ verifyResultsByTargetPropertyFilter(target, ds, "target.address==http://0.0.0.0");
}
@Test
diff --git a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/rsql/RsqlConfigHolder.java b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/rsql/RsqlConfigHolder.java
index b72094be1..0b9c5fd13 100644
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/rsql/RsqlConfigHolder.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/rsql/RsqlConfigHolder.java
@@ -11,6 +11,7 @@ package org.eclipse.hawkbit.repository.rsql;
import lombok.Getter;
import lombok.NoArgsConstructor;
+import lombok.Setter;
import org.springframework.beans.factory.annotation.Value;
/**
@@ -23,6 +24,11 @@ public final class RsqlConfigHolder {
private static final RsqlConfigHolder SINGLETON = new RsqlConfigHolder();
+ public enum RsqlToSpecBuilder {
+ LEGACY_G1, // legacy RSQL visitor
+ LEGACY_G2, // G2 RSQL visitor
+ G3 // G3 RSQL visitor - still experimental / yet default
+ }
/**
* If RSQL comparison operators shall ignore the case. If ignore case is true "x == ax" will match "x == aX"
*/
@@ -39,11 +45,12 @@ public final class RsqlConfigHolder {
private boolean caseInsensitiveDB;
/**
- * @deprecated in favour of G2 RSQL visitor. since 0.6.0
+ * @deprecated in favour fixed final visitor / spec builder of G2 RSQL visitor / G3 spec builder. since 0.6.0
*/
+ @Setter // for tests only
@Deprecated(forRemoval = true, since = "0.6.0")
- @Value("${hawkbit.rsql.legacy-rsql-visitor:false}")
- private boolean legacyRsqlVisitor;
+ @Value("${hawkbit.rsql.rsql-to-spec-builder:G3}") //
+ private RsqlToSpecBuilder rsqlToSpecBuilder;
/**
* @return The holder singleton instance.
diff --git a/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/Node.java b/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/Node.java
new file mode 100644
index 000000000..cc532749e
--- /dev/null
+++ b/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/Node.java
@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.jpa.rsql;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import jakarta.annotation.Nonnull;
+import jakarta.annotation.Nullable;
+
+import lombok.Builder;
+import lombok.Value;
+
+/**
+ * Node is always in Disjunctive Normal Form (DNF). This means:
+ *
+ * - single comparison
+ * - and composition of comparisons
+ * - or of comparisons or and composition of comparisons
+ *
+ * Node: if there are custom implementation they shall also follow this contract!
+ */
+public interface Node {
+
+ default Logical and(final Node other) {
+ return op(this, Logical.Operator.AND, other);
+ }
+
+ default Logical or(final Node other) {
+ return op(this, Logical.Operator.OR, other);
+ }
+
+ static Logical op(final Node node1, final Logical.Operator op, final Node node2) {
+ if (node1 instanceof Logical logical1 && logical1.getOp() == op) {
+ if (node2 instanceof Logical logical2 && logical2.getOp() == op) { // same op
+ final List children = new ArrayList<>(logical1.getChildren().size() + logical2.getChildren().size());
+ children.addAll(logical1.getChildren());
+ children.addAll(logical2.getChildren());
+ return new Logical(op, children);
+ } else { // node2 is not a logical
+ final List children = new ArrayList<>(logical1.getChildren().size() + 1);
+ children.addAll(logical1.getChildren());
+ children.add(node2);
+ return new Logical(op, children);
+ }
+ } else if (node2 instanceof Logical logical2 && logical2.getOp() == op) {
+ final List children = new ArrayList<>(logical2.getChildren().size() + 1);
+ children.add(node1);
+ children.addAll(logical2.getChildren());
+ return new Logical(op, children);
+ } else {
+ return new Logical(op, List.of(node1, node2));
+ }
+ }
+
+ @Value
+ class Logical implements Node {
+
+ public enum Operator {
+ AND("&&"),
+ OR("||");
+
+ private final String symbol;
+
+ Operator(String symbol) {
+ this.symbol = symbol;
+ }
+
+ @Override
+ public String toString() {
+ return symbol;
+ }
+ }
+
+ Logical.Operator op;
+ List children;
+
+ public Logical(final Operator op, final List children) {
+ Objects.requireNonNull(op, "Operator must not be null");
+ if (children == null || children.size() < 2) {
+ throw new IllegalArgumentException("Children of a logical must not be null or empty or single element list");
+ }
+ this.op = op;
+ this.children = children;
+ }
+
+ @Override
+ public String toString() {
+ return children.stream()
+ .map(child -> op == Operator.OR || child instanceof Comparison
+ ? child.toString()
+ : "(" + child.toString() + ")")
+ .reduce((a, b) -> a + " " + op + " " + b)
+ .orElse("");
+ }
+ }
+
+ @Value
+ @Builder(builderClassName = "Builder")
+ class Comparison implements Node {
+
+ public enum Operator {
+ EQ("=="),
+ NE("!="),
+ GT(">"),
+ LT("<"),
+ GTE(">="),
+ LTE("<="),
+ IN("in"),
+ NOT_IN("not in"),
+ LIKE("like"),
+ NOT_LIKE("not like");
+
+ private final String symbol;
+
+ Operator(String symbol) {
+ this.symbol = symbol;
+ }
+
+ @Override
+ public String toString() {
+ return symbol;
+ }
+ }
+
+ @Nonnull
+ String key;
+ @Nonnull
+ Operator op;
+ @Nullable
+ Object value; // String, Number, Boolean, String[] or Number[] or null
+
+ @Nullable
+ Object context;
+
+ public Comparison(@Nonnull final String key, @Nonnull final Operator op, @Nullable final Object value) {
+ this(key, op, value, null);
+ }
+
+ public Comparison(@Nonnull final String key, @Nonnull final Operator op, @Nullable final Object value, @Nullable final Object context) {
+ Objects.requireNonNull(key, "Key must not be null");
+ if (key.trim().isEmpty()) {
+ throw new IllegalArgumentException("Key must not be empty");
+ }
+ Objects.requireNonNull(op, "Operator must not be null");
+ if (value == null) {
+ switch (op) {
+ case GT, LT, LIKE, NOT_LIKE:
+ throw new IllegalArgumentException("Value must not be null for operator " + op);
+ default: // ok
+ }
+ } else if (value instanceof List list) {
+ switch (op) {
+ case IN, NOT_IN:
+ break;
+ default:
+ throw new IllegalArgumentException("Value must not be a list for operator " + op);
+ }
+ if (list.isEmpty()) {
+ throw new IllegalArgumentException("List value must not be empty");
+ }
+ list.forEach(listElement -> {
+ if (notValid(listElement)) {
+ throw new IllegalArgumentException("List type value must be String or Number");
+ }
+ });
+ } else if (notValid(value)) {
+ throw new IllegalArgumentException(
+ "Value must be String, Number, Boolean, non-empty String list, non-empty Number list or null");
+ }
+
+ this.key = key.trim();
+ this.op = op;
+ this.value = value;
+
+ this.context = context;
+ }
+
+ @Override
+ public String toString() {
+ return key + " " + op + " " + valueToString(value);
+ }
+
+ private static String valueToString(final Object value) {
+ if (value == null) {
+ return "null";
+ } else if (value instanceof String) {
+ return String.format("\"%s\"", value);
+ } else if (value instanceof List list) {
+ return "(" + list.stream()
+ .map(Comparison::valueToString)
+ .reduce((a, b) -> a + ", " + b)
+ .orElse("") + ")";
+ } else {
+ return value.toString();
+ }
+ }
+
+ private static boolean notValid(final Object value) {
+ return !(value instanceof String) && !(value instanceof Number) && !(value instanceof Boolean);
+ }
+ }
+}
\ No newline at end of file
diff --git a/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/PropertyMapper.java b/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/PropertyMapper.java
deleted file mode 100644
index 062d0f8b9..000000000
--- a/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/PropertyMapper.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2015 Bosch Software Innovations GmbH and others
- *
- * This program and the accompanying materials are made
- * available under the terms of the Eclipse Public License 2.0
- * which is available at https://www.eclipse.org/legal/epl-2.0/
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package org.eclipse.hawkbit.repository.jpa.rsql;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Maps property of entity to its alias .
- */
-public final class PropertyMapper {
-
- private static Map, Map> allowedColumns = new HashMap<>();
-
- private PropertyMapper() {
-
- }
-
- /**
- * Add new mapping - property name and alias.
- *
- * @param type entity type
- * @param property alias of property
- * @param mapping property name
- */
- public static void addNewMapping(final Class type, final String property, final String mapping) {
- allowedColumns.computeIfAbsent(type, k -> new HashMap<>());
- allowedColumns.get(type).put(property, mapping);
- }
-
- /**
- * @return the allowedcolmns
- */
- public static Map, Map> getAllowedcolmns() {
- return allowedColumns;
- }
-
-}
diff --git a/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLUtility.java b/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLUtility.java
index 237df0d6e..863159d3c 100644
--- a/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLUtility.java
+++ b/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLUtility.java
@@ -9,11 +9,11 @@
*/
package org.eclipse.hawkbit.repository.jpa.rsql;
+import static org.eclipse.hawkbit.repository.rsql.RsqlConfigHolder.RsqlToSpecBuilder.G3;
+import static org.eclipse.hawkbit.repository.rsql.RsqlConfigHolder.RsqlToSpecBuilder.LEGACY_G1;
+
import java.io.Serial;
-import java.util.Collections;
-import java.util.HashSet;
import java.util.List;
-import java.util.Set;
import jakarta.persistence.EntityManager;
import jakarta.persistence.criteria.CriteriaBuilder;
@@ -23,9 +23,7 @@ import jakarta.persistence.criteria.Root;
import cz.jirutka.rsql.parser.RSQLParser;
import cz.jirutka.rsql.parser.RSQLParserException;
-import cz.jirutka.rsql.parser.ast.ComparisonOperator;
import cz.jirutka.rsql.parser.ast.Node;
-import cz.jirutka.rsql.parser.ast.RSQLOperators;
import cz.jirutka.rsql.parser.ast.RSQLVisitor;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
@@ -34,6 +32,9 @@ import org.apache.commons.lang3.text.StrLookup;
import org.eclipse.hawkbit.repository.RsqlQueryField;
import org.eclipse.hawkbit.repository.exception.RSQLParameterSyntaxException;
import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
+import org.eclipse.hawkbit.repository.jpa.rsqllegacy.JpaQueryRsqlVisitor;
+import org.eclipse.hawkbit.repository.jpa.rsqllegacy.JpaQueryRsqlVisitorG2;
+import org.eclipse.hawkbit.repository.jpa.rsqllegacy.SpecificationBuilderLegacy;
import org.eclipse.hawkbit.repository.rsql.RsqlConfigHolder;
import org.eclipse.hawkbit.repository.rsql.VirtualPropertyReplacer;
import org.eclipse.hawkbit.repository.rsql.VirtualPropertyResolver;
@@ -79,12 +80,11 @@ import org.springframework.util.CollectionUtils;
public final class RSQLUtility {
/**
- * Builds a JPA {@link Specification} which corresponds with the given RSQL
- * query. The specification can be used to filter for JPA entities with the
- * given RSQL query.
+ * Builds a JPA {@link Specification} which corresponds with the given RSQL query. The specification can be used to filter for JPA entities
+ * with the given RSQL query.
*
* @param rsql the rsql query to be parsed
- * @param fieldNameProvider the enum class type which implements the {@link RsqlQueryField}
+ * @param rsqlQueryFieldType the enum class type which implements the {@link RsqlQueryField}
* @param virtualPropertyReplacer holds the logic how the known macros have to be resolved; may be null
* @param database database in use
* @return a specification which can be used with JPA
@@ -93,98 +93,34 @@ public final class RSQLUtility {
* @throws RSQLParameterSyntaxException if the RSQL syntax is wrong
*/
public static & RsqlQueryField, T> Specification buildRsqlSpecification(
- final String rsql, final Class fieldNameProvider,
+ final String rsql, final Class rsqlQueryFieldType,
final VirtualPropertyReplacer virtualPropertyReplacer, final Database database) {
- return new RSQLSpecification<>(rsql, fieldNameProvider, virtualPropertyReplacer, database);
+ if (RsqlConfigHolder.getInstance().getRsqlToSpecBuilder() == G3) {
+ return new SpecificationBuilder(
+ virtualPropertyReplacer,
+ !RsqlConfigHolder.getInstance().isCaseInsensitiveDB() && RsqlConfigHolder.getInstance().isIgnoreCase(),
+ database).specification(RsqlParser.parse(rsql, rsqlQueryFieldType));
+ } else {
+ return new SpecificationBuilderLegacy(rsqlQueryFieldType, virtualPropertyReplacer, database).specification(rsql);
+ }
}
/**
* Validates the RSQL string
*
* @param rsql RSQL string to validate
- * @param fieldNameProvider
+ * @param rsqlQueryFieldType
* @throws RSQLParserException if RSQL syntax is invalid
* @throws RSQLParameterUnsupportedFieldException if RSQL key is not allowed
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public static & RsqlQueryField> void validateRsqlFor(
- final String rsql, final Class fieldNameProvider,
+ final String rsql, final Class rsqlQueryFieldType,
final Class jpaType,
final VirtualPropertyReplacer virtualPropertyReplacer, final EntityManager entityManager) {
final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
final CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(jpaType);
- new RSQLSpecification<>(rsql, fieldNameProvider, virtualPropertyReplacer, null)
+ buildRsqlSpecification(rsql, rsqlQueryFieldType, virtualPropertyReplacer, null)
.toPredicate(criteriaQuery.from((Class)jpaType), criteriaQuery, criteriaBuilder);
}
-
- static final ComparisonOperator IS = new ComparisonOperator("=is=", "=eq=");
- static final ComparisonOperator NOT = new ComparisonOperator("=not=", "=ne=");
- private static final Set OPERATORS;
-
- static {
- final Set operators = new HashSet<>(RSQLOperators.defaultOperators());
- // == and != alternatives just treating "null" string as null not as a "null"
- operators.add(IS);
- operators.add(NOT);
- OPERATORS = Collections.unmodifiableSet(operators);
- }
-
- private static final class RSQLSpecification & RsqlQueryField, T> implements Specification {
-
- @Serial
- private static final long serialVersionUID = 1L;
-
- private final String rsql;
- private final Class enumType;
- private final VirtualPropertyReplacer virtualPropertyReplacer;
- private final Database database;
-
- private RSQLSpecification(
- final String rsql, final Class enumType,
- final VirtualPropertyReplacer virtualPropertyReplacer, final Database database) {
- this.rsql = rsql;
- this.enumType = enumType;
- this.virtualPropertyReplacer = virtualPropertyReplacer;
- this.database = database;
- }
-
- @Override
- public Predicate toPredicate(final Root root, final CriteriaQuery query, final CriteriaBuilder cb) {
- final Node rootNode = parseRsql(rsql);
- query.distinct(true);
-
- final RSQLVisitor, String> jpqQueryRSQLVisitor =
- RsqlConfigHolder.getInstance().isLegacyRsqlVisitor()
- ? new JpaQueryRsqlVisitor<>(
- root, cb, enumType,
- virtualPropertyReplacer, database, query,
- !RsqlConfigHolder.getInstance().isCaseInsensitiveDB() && RsqlConfigHolder.getInstance().isIgnoreCase())
- : new JpaQueryRsqlVisitorG2<>(
- enumType, root, query, cb,
- database, virtualPropertyReplacer,
- !RsqlConfigHolder.getInstance().isCaseInsensitiveDB() && RsqlConfigHolder.getInstance()
- .isIgnoreCase());
- final List accept = rootNode.accept(jpqQueryRSQLVisitor);
-
- if (CollectionUtils.isEmpty(accept)) {
- return cb.conjunction();
- } else {
- return cb.and(accept.toArray(new Predicate[0]));
- }
- }
- }
-
- private static Node parseRsql(final String rsql) {
- log.debug("Parsing rsql string {}", rsql);
- try {
- return new RSQLParser(OPERATORS).parse(
- RsqlConfigHolder.getInstance().isCaseInsensitiveDB() || RsqlConfigHolder.getInstance().isIgnoreCase()
- ? rsql.toLowerCase()
- : rsql);
- } catch (final IllegalArgumentException e) {
- throw new RSQLParameterSyntaxException("RSQL filter must not be null", e);
- } catch (final RSQLParserException e) {
- throw new RSQLParameterSyntaxException(e);
- }
- }
}
\ No newline at end of file
diff --git a/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RsqlParser.java b/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RsqlParser.java
new file mode 100644
index 000000000..43768dbbb
--- /dev/null
+++ b/hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/rsql/RsqlParser.java
@@ -0,0 +1,270 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.jpa.rsql;
+
+import static org.eclipse.hawkbit.repository.RsqlQueryField.SUB_ATTRIBUTE_SEPARATOR;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.EQ;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.GT;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.GTE;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.IN;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.LIKE;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.LT;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.LTE;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.NE;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.NOT_IN;
+import static org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison.Operator.NOT_LIKE;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+import jakarta.annotation.Nullable;
+
+import cz.jirutka.rsql.parser.RSQLParser;
+import cz.jirutka.rsql.parser.RSQLParserException;
+import cz.jirutka.rsql.parser.ast.AndNode;
+import cz.jirutka.rsql.parser.ast.ComparisonNode;
+import cz.jirutka.rsql.parser.ast.ComparisonOperator;
+import cz.jirutka.rsql.parser.ast.OrNode;
+import cz.jirutka.rsql.parser.ast.RSQLOperators;
+import cz.jirutka.rsql.parser.ast.RSQLVisitor;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.hawkbit.repository.FieldValueConverter;
+import org.eclipse.hawkbit.repository.RsqlQueryField;
+import org.eclipse.hawkbit.repository.exception.RSQLParameterSyntaxException;
+import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
+import org.eclipse.hawkbit.repository.jpa.rsql.Node.Comparison;
+import org.eclipse.hawkbit.repository.rsql.RsqlConfigHolder;
+
+/**
+ * {@link RsqlParser} parses RSQL query stings to {@link Node} objects. Doing that it does the following:
+ *
+ * - check for null value and pass it properly (IS, NOT)
+ * - check for * and convert EQ/NEQ to LIKE/NOT_LIKE
+ * - replace the rsql fields (enum values) with the JPA entity field names
+ * - checks sub-attributes (if allowed)
+ * - append the default sub-attributes if needed)
+ * - apply value conversion for implementing with FieldValueConverter
+ *
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@Slf4j
+public class RsqlParser {
+
+ public static final Character LIKE_WILDCARD = '*';
+
+ public static final ComparisonOperator IS = new ComparisonOperator("=is=", "=eq=");
+ public static final ComparisonOperator NOT = new ComparisonOperator("=not=", "=ne=");
+
+ private static final RSQLParser PARSER;
+
+ static {
+ final Set operators = new HashSet<>(RSQLOperators.defaultOperators());
+ // == and != alternatives just treating "null" string as null not as a "null"
+ operators.add(IS);
+ operators.add(NOT);
+ PARSER = new RSQLParser(operators);
+ }
+
+ public static Node parse(final String rsql) {
+ return parse(rsql, (Function) null);
+ }
+
+ public static & RsqlQueryField> Node parse(final String rsql, final Class rsqlQueryFieldType) {
+ return parse(rsql, key -> resolveKey(key, rsqlQueryFieldType));
+ }
+
+ private static Node parse(final String rsql, final Function keyResolver) {
+ try {
+ return PARSER
+ .parse(RsqlConfigHolder.getInstance().isCaseInsensitiveDB() || RsqlConfigHolder.getInstance().isIgnoreCase()
+ ? rsql.toLowerCase()
+ : rsql)
+ .accept(new RsqlVisitor(keyResolver));
+ } catch (final RSQLParserException e) {
+ throw new RSQLParameterSyntaxException(e);
+ }
+ }
+
+ private static & RsqlQueryField> Key resolveKey(final String key, final Class rsqlQueryFieldType) {
+ final int firstSeparatorIndex = key.indexOf(SUB_ATTRIBUTE_SEPARATOR);
+ final String enumName = (firstSeparatorIndex == -1 ? key : key.substring(0, firstSeparatorIndex)).toUpperCase();
+ log.debug("Get field identifier by name {} of enum type {}", enumName, rsqlQueryFieldType);
+
+ final T enumValue;
+ try {
+ enumValue = Enum.valueOf(rsqlQueryFieldType, enumName);
+ } catch (final IllegalArgumentException e) {
+ throw new RSQLParameterUnsupportedFieldException(e);
+ }
+
+ final String attribute;
+ if (firstSeparatorIndex == -1) { // just field name without sub-attribute
+ if (enumValue.getSubEntityAttributes().isEmpty()) {
+ // no sub-attributes -> simple field
+ attribute = enumValue.getJpaEntityFieldName();
+ } else {
+ // just enum name for a complex type (with sub-attributes), should have single (default!) sub-attribute
+ if (enumValue.isMap()) {
+ throw new RSQLParameterUnsupportedFieldException("No key specified for a map type " + enumValue);
+ } else if (enumValue.getSubEntityAttributes().size() == 1) {
+ // single sub attribute - so, treat it as a default
+ attribute = enumValue.getJpaEntityFieldName() + SUB_ATTRIBUTE_SEPARATOR + enumValue.getSubEntityAttributes().get(0);
+ } else {
+ throw new RSQLParameterUnsupportedFieldException(
+ String.format(
+ "The given search parameter field {%s} requires one of the following sub-attributes %s",
+ key, enumValue.getSubEntityAttributes()));
+ }
+ }
+ } else { // field name with sub-attribute
+ final String subAttribute = key.substring(firstSeparatorIndex + 1);
+
+ if (enumValue.isMap()) {
+ // map, the part after the enum name is the key of the map
+ attribute = enumValue.getJpaEntityFieldName() + SUB_ATTRIBUTE_SEPARATOR + subAttribute;
+ } else if (enumValue.getSubEntityAttributes().isEmpty()) {
+ // simple type without sub-attributes, so the sub-attribute is not allowed
+ throw new RSQLParameterUnsupportedFieldException("Sub-attributes not supported for simple field " + enumValue);
+ } else {
+ attribute = enumValue.getJpaEntityFieldName() + SUB_ATTRIBUTE_SEPARATOR + enumValue.getSubEntityAttributes().stream()
+ .filter(attr -> attr.equalsIgnoreCase(subAttribute)) // case normalized
+ .findFirst()
+ .orElseThrow(() -> new RSQLParameterUnsupportedFieldException(
+ String.format(
+ "The given search field {%s} has unsupported sub-attributes. Supported sub-attributes are %s",
+ key, enumValue.getSubEntityAttributes())));
+ }
+ }
+
+ return new Key(attribute, RsqlVisitor.valueConverter(enumValue));
+ }
+
+ private record Key(String path, UnaryOperator