tekBlueprint

var query = Query.builder().page(10).size(20)
        .filter(or(
                isNotNull("_name"),
                and(eq("_name", "maria"), ilike("_name", "ari"), eq("type", "local")),
                and(eq("_name", "smith"), eq("type", "oidc"))))
        .search("any text")
        .build();

{
  "filter": {
    "or": [
      { "field": "_name", "op": "ISNN" },
      {
        "and": [
          { "field": "_name", "op": "EQ", "value": "maria" },
          { "field": "_name", "op": "ILIKE", "value": "ari" },
          { "field": "type", "op": "EQ", "value": "local" }
        ]
      },
      {
        "and": [
          { "field": "_name", "op": "EQ", "value": "smith" },
          { "field": "type", "op": "EQ", "value": "oidc" }
        ]
      }
    ]
  },
  "search": "any text",
  "page": 10,
  "size": 20
}

var query = Query.builder().page(10).size(20)
        .filter(QueryFilterCompiler.compile("""
                _name is not null
                        or (_name = "maria" or _name ilike "%ari%" and type="local")
                        or (_name = "smith" and type="type")
                """))
        .search("any text")
        .build();

/**
 * This class is responsible for compiling a filter string into an AST (Abstract Syntax Tree)
 * using the ANTLR4-generated parser and lexer.
 *
 * @author Sergey Grachev
 */
public final class QueryFilterCompiler extends QueryFilterBaseVisitor<FilterRule> {

    /**
     * Compiles a filter string into a FilterRule object.
     *
     * @param filter The filter string to compile.
     * @return A FilterRule object representing the parsed filter, or null if syntax errors are present.
     */
    @Nullable
    public static FilterRule compile(final String filter) {
        final var tokens = new CommonTokenStream(new QueryFilterLexer(CharStreams.fromString(filter)));
        final var parser = new QueryFilterParser(tokens);
        final var tree = parser.filter();
        if (parser.getNumberOfSyntaxErrors() > 0) {
            System.err.println("Syntax errors detected!");
            return null;
        }
        return new QueryFilterCompiler().visit(tree);
    }

    /**
     * Visits a filter context and returns the corresponding FilterRule.
     *
     * @param ctx The filter context to visit.
     * @return A FilterRule representing the parsed filter.
     */
    @Override
    public FilterRule visitFilter(final QueryFilterParser.FilterContext ctx) {
        return visit(ctx.expr());
    }

    /**
     * Visits a logical expression context and returns the corresponding FilterRule.
     *
     * @param ctx The logical expression context to visit.
     * @return A FilterRule representing the parsed logical expression.
     */
    @Override
    public FilterRule visitLogicalExpr(final QueryFilterParser.LogicalExprContext ctx) {
        final var left = visit(ctx.left);
        final var right = visit(ctx.right);
        final var operator = logicalOperatorOf(ctx.op);

        // flatten same-operator groups for cleaner AST

        final var rules = new ArrayList<FilterRule>();
        if (left instanceof final FilterLogicalRule l && l.getOperator().equals(operator)) {
            rules.addAll(l.getFilters());
        } else {
            rules.add(left);
        }

        if (right instanceof final FilterLogicalRule r && r.getOperator().equals(operator)) {
            rules.addAll(r.getFilters());
        } else {
            rules.add(right);
        }

        return new FilterLogicalRule(operator, rules);
    }

    /**
     * Visits a parenthesized expression context and returns the corresponding FilterRule.
     *
     * @param ctx The parenthesized expression context to visit.
     * @return A FilterRule representing the parsed parenthesized expression.
     */
    @Override
    public FilterRule visitParenExpr(final QueryFilterParser.ParenExprContext ctx) {
        return visit(ctx.expr());
    }

    /**
     * Visits a comparison expression context and returns the corresponding FilterRule.
     *
     * @param ctx The comparison expression context to visit.
     * @return A FilterRule representing the parsed comparison expression.
     */
    @Override
    public FilterRule visitCompareExpr(final QueryFilterParser.CompareExprContext ctx) {
        final var field = ctx.field().getText();
        final var operator = compareOperatorOf(ctx.op);
        final var value = parseValue(ctx.value().getText(), ctx.value().type);
        return new FilterFieldRule(field, operator, value);
    }

    /**
     * Visits a null check expression context and returns the corresponding FilterRule.
     *
     * @param ctx The null check expression context to visit.
     * @return A FilterRule representing the parsed null check expression.
     */
    @Override
    public FilterRule visitNullCheckExpr(final QueryFilterParser.NullCheckExprContext ctx) {
        final var field = ctx.field().getText();
        final var operator = compareOperatorOf(ctx.op);
        return new FilterFieldRule(field, operator);
    }

    /**
     * Visits a string pattern expression context and returns the corresponding FilterRule.
     *
     * @param ctx The string pattern expression context to visit.
     * @return A FilterRule representing the parsed string pattern expression.
     */
    @Override
    public FilterRule visitStringPatternExpr(final QueryFilterParser.StringPatternExprContext ctx) {
        final var field = ctx.field().getText();
        final var operator = compareOperatorOf(ctx.op);
        final var string = ctx.STRING();
        final var value = parseValue(string.getText(), string.getSymbol());
        return new FilterFieldRule(field, operator, value);
    }

    /**
     * Visits an "in" expression context and returns the corresponding FilterRule.
     *
     * @param ctx The "in" expression context to visit.
     * @return A FilterRule representing the parsed "in" expression.
     */
    @Override
    public FilterRule visitInExpr(final QueryFilterParser.InExprContext ctx) {
        final var field = ctx.field().getText();
        final var operator = compareOperatorOf(ctx.op);

        final var values = new ArrayList<Object>();
        final var valuesParser = ctx.valueList().value();
        for (final var valueParser : valuesParser) {
            values.add(parseValue(valueParser.getText(), valueParser.type));
        }

        return new FilterFieldRule(field, operator, values);
    }

    /**
     * Parses a value from its textual representation and token type.
     *
     * @param text  The text of the value to parse.
     * @param token The token type of the value.
     * @return The parsed value object.
     */
    @Nullable
    private Object parseValue(final @Nullable String text, final Token token) {
        final var type = token.getType();
        final Object value;
        if (text == null || type == QueryFilterParser.NULL) {
            value = null;
        } else if (type == QueryFilterParser.STRING) {
            value = text.substring(1, text.length() - 1);
        } else if (type == QueryFilterParser.BOOLEAN) {
            value = Boolean.valueOf(text);
        } else if (type == QueryFilterParser.FLOAT) {
            value = Double.valueOf(text);
        } else if (type == QueryFilterParser.INTEGER) {
            value = Long.valueOf(text);
        } else {
            value = null;
        }
        return value;
    }

    /**
     * Converts a token representing a logical operator into its corresponding FilterLogicalRule.Operator enum.
     *
     * @param op The token representing the logical operator.
     * @return The corresponding FilterLogicalRule.Operator enum.
     */
    private FilterLogicalRule.Operator logicalOperatorOf(final Token op) {
        final var type = op.getType();
        if (type == QueryFilterParser.AND) {
            return FilterLogicalRule.Operator.AND;
        }
        if (type == QueryFilterParser.OR) {
            return FilterLogicalRule.Operator.OR;
        }
        throw new UnsupportedOperationException("Logical operator '" + op.getText() + "' not implemented");
    }

    /**
     * Converts a token representing a comparison operator into its corresponding FilterFieldRule.Operator enum.
     *
     * @param op The token representing the comparison operator.
     * @return The corresponding FilterFieldRule.Operator enum.
     */
    private FilterFieldRule.Operator compareOperatorOf(final Token op) {
        return switch (op.getType()) {
            case QueryFilterParser.EQ -> FilterFieldRule.Operator.EQ;
            case QueryFilterParser.NE -> FilterFieldRule.Operator.NE;
            case QueryFilterParser.LIKE -> FilterFieldRule.Operator.LIKE;
            case QueryFilterParser.ILIKE -> FilterFieldRule.Operator.ILIKE;
            case QueryFilterParser.GT -> FilterFieldRule.Operator.GT;
            case QueryFilterParser.GTE -> FilterFieldRule.Operator.GTE;
            case QueryFilterParser.LT -> FilterFieldRule.Operator.LT;
            case QueryFilterParser.LTE -> FilterFieldRule.Operator.LTE;
            case QueryFilterParser.IN -> FilterFieldRule.Operator.IN;
            case QueryFilterParser.NOT_IN -> FilterFieldRule.Operator.NIN;
            case QueryFilterParser.IS_NULL -> FilterFieldRule.Operator.ISN;
            case QueryFilterParser.IS_NOT_NULL -> FilterFieldRule.Operator.ISNN;
            default ->
                    throw new UnsupportedOperationException("Compare operator '" + op.getText() + "' not implemented");
        };
    }
}

/**
 * Represents a query for filtering and searching data.
 *
 * @author Sergey Grachev
 */
@Getter
@Setter
@Builder
@JsonInclude(JsonInclude.Include.NON_NULL)
@NoArgsConstructor
@AllArgsConstructor
public final class Query implements Serializable {

    @Serial
    private static final long serialVersionUID = -7649292546603153860L;

    /**
     * The filter rule used to define the filtering criteria for the query.
     */
    @JsonDeserialize(using = FilterDeserializer.class)
    @JsonSerialize(using = FilterSerializer.class)
    @JsonProperty("filter")
    private @Nullable FilterRule filter;

    /**
     * The search term used to define the global search criteria for the query.
     */
    @JsonProperty("search")
    private @Nullable String search;

    /**
     * The page number for pagination of results.
     */
    @JsonProperty("page")
    private int page = 0;

    /**
     * The size of the result set to return.
     */
    @JsonProperty("size")
    private int size = 20;
}

/**
 * Represents a filter rule for a specific field.
 *
 * @author Sergey Grachev
 */
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public final class FilterFieldRule implements FilterRule {

    /**
     * The field name to which this rule applies.
     */
    @JsonProperty("field")
    private String field;

    /**
     * The operator used for comparison in this filter rule.
     */
    @JsonProperty("op")
    private Operator operator;

    /**
     * The value against which the field is compared.
     */
    @JsonProperty("value")
    private @Nullable Object value;

    public FilterFieldRule(final String field, final Operator operator) {
        this.field = field;
        this.operator = operator;
    }

    public static FilterFieldRule eq(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.EQ, value);
    }

    public static FilterFieldRule ne(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.NE, value);
    }

    public static FilterFieldRule ilike(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.ILIKE, value);
    }

    public static FilterFieldRule gt(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.GT, value);
    }

    public static FilterFieldRule lt(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.LT, value);
    }

    public static FilterFieldRule gte(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.GTE, value);
    }

    public static FilterFieldRule lte(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.LTE, value);
    }

    public static FilterFieldRule in(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.IN, value);
    }

    public static FilterFieldRule nin(final String field, final Object value) {
        return new FilterFieldRule(field, Operator.NIN, value);
    }

    public static FilterFieldRule isNull(final String field) {
        return new FilterFieldRule(field, Operator.ISN);
    }

    public static FilterFieldRule isNotNull(final String field) {
        return new FilterFieldRule(field, Operator.ISNN);
    }

    /**
     * Enum representing the various operators used in filter rules.
     * Each operator defines a specific type of comparison or condition
     * that can be applied to a field.
     */
    public enum Operator {
        EQ, NE, LIKE, ILIKE, GT, LT, GTE, LTE, IN, NIN, ISN, ISNN
    }
}

/**
 * Represents a logical rule for filtering, which can be either AND or OR.
 *
 * @author Sergey Grachev
 */
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public final class FilterLogicalRule implements FilterRule {

    /**
     * The operator for this logical rule, indicating whether it's an AND or OR operation.
     */
    @JsonProperty("op")
    private Operator operator;

    /**
     * A list of filter rules that are combined under this logical rule.
     */
    @Singular
    @JsonProperty("f")
    private List<FilterRule> filters;

    public FilterLogicalRule(final List<FilterRule> filters) {
        this.filters = filters;
    }

    /**
     * Enum representing the logical operators for filter rules.
     */
    public enum Operator {
        AND, OR
    }

    public static FilterLogicalRule or(final FilterRule... rules) {
        return new FilterLogicalRule(Operator.OR, List.of(rules));
    }

    public static FilterLogicalRule and(final FilterRule... rules) {
        return new FilterLogicalRule(Operator.AND, List.of(rules));
    }
}

/**
 * Represents a filter rule that can be applied to query data.
 *
 * @author Sergey Grachev
 */
public interface FilterRule {
}

public class CompilerTest {

    private static final ObjectMapper MAPPER = new ObjectMapper()
            .enable(SerializationFeature.INDENT_OUTPUT);

    public static void main(final String[] args) throws JsonProcessingException {
        final var query1 = Query.builder().page(10).size(20)
                .filter(or(
                        isNotNull("_name"),
                        and(eq("_name", "maria"), ilike("_name", "%ari%"), eq("type", "local")),
                        and(eq("_name", "smith"), eq("type", "oidc"))))
                .search("any text")
                .build();

        final var query2 = Query.builder().page(10).size(20)
                .filter(QueryFilterCompiler.compile("""
                        _name is not null
                                or (_name = "maria" and _name ilike "%ari%" and type = "local")
                                or (_name = "smith" and type = "oidc")
                        """))
                .search("any text")
                .build();

        System.out.println(query1.equals(query2));
        System.out.println(MAPPER.writeValueAsString(query1));
    }
}

Benchmark                     Mode  Cnt      Score   Error  Units
FormulaBenchmark.benchJson   thrpt       86892.340          ops/s
FormulaBenchmark.benchQuery  thrpt       70803.605          ops/s