Unify lucene versions in project

.github/dependabot.yml

@@ -15,10 +15,6 @@ updates:
         update-types: ["version-update:semver-patch"]
       - dependency-name: "com.amazonaws:aws-java-sdk-bom"
         update-types: ["version-update:semver-patch"]
-      # Lucene >=10 requires JDK 21
-      - dependency-name: "org.apache.lucene:lucene-*"
-        versions:
-          - ">= 10"
       # we want to manually update the opensearch-java client as long as it requires intensive testing
       - dependency-name: "org.opensearch.client:opensearch-java"
     groups:

data-node/pom.xml

@@ -42,9 +42,6 @@
         <mainClass>org.graylog.datanode.bootstrap.Main</mainClass>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
-        <!-- Lucene version required by opensearch-core 3.x -->
-        <lucene.version>10.3.2</lucene.version>
-
         <!-- 2.x versions -->
         <opensearch.compat.version>2.19.5</opensearch.compat.version>
         <opensearch.compat.mac.jdk.version>21.0.7</opensearch.compat.mac.jdk.version>

graylog2-server/src/main/java/org/graylog/plugins/views/search/validation/FixedBooleanQuery.java

@@ -75,8 +75,8 @@ public Spliterator<BooleanClause> spliterator() {
     @Override
     public void visit(QueryVisitor visitor) {
         delegate.clauses().forEach(c -> {
-            final QueryVisitor sub = visitor.getSubVisitor(c.getOccur(), delegate);
-            c.getQuery().visit(sub);
+            final QueryVisitor sub = visitor.getSubVisitor(c.occur(), delegate);
+            c.query().visit(sub);
         });
     }
 }

graylog2-server/src/main/java/org/graylog2/utilities/lucene/LuceneInMemorySearchEngine.java

@@ -27,8 +27,6 @@
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
-import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser;
-import org.apache.lucene.queryparser.flexible.standard.config.PointsConfig;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.Sort;
@@ -41,15 +39,10 @@
 import org.graylog2.rest.resources.entities.EntityAttribute;
 import org.graylog2.search.SearchQuery;
 import org.graylog2.search.SearchQueryField;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
-import java.text.NumberFormat;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
@@ -91,7 +84,7 @@ public PaginatedList<U> search(SearchQuery query, String sortField, SortOrder or
                 TopDocs results = searcher.search(luceneQuery, end, sort); // fetch enough docs
                 final List<U> searchResults = extractSearchResults(results, searcher, start, perPage, entries);
 
-                final int totalCount = Math.toIntExact(results.totalHits.value);
+                final int totalCount = Math.toIntExact(results.totalHits.value());
                 return new PaginatedList<>(searchResults, totalCount, page, perPage);
             }
         }

graylog2-server/src/test/java/org/graylog2/utilities/lucene/LuceneQueryBuilderTest.java

@@ -74,10 +74,10 @@ void testSimpleTermQuery() {
         assertThat(booleanQuery.clauses()).hasSize(1);
 
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getOccur()).isEqualTo(BooleanClause.Occur.SHOULD);
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.occur()).isEqualTo(BooleanClause.Occur.SHOULD);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         assertThat(regexpQuery.getRegexp().field()).isEqualTo("name");
         assertThat(regexpQuery.getRegexp().text()).isEqualTo(".*john.*");
     }
@@ -92,10 +92,10 @@ void testExactMatchWithEqualsOperator() {
         assertThat(booleanQuery.clauses()).hasSize(1);
 
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getOccur()).isEqualTo(BooleanClause.Occur.SHOULD);
-        assertThat(clause.getQuery()).isInstanceOf(TermQuery.class);
+        assertThat(clause.occur()).isEqualTo(BooleanClause.Occur.SHOULD);
+        assertThat(clause.query()).isInstanceOf(TermQuery.class);
 
-        TermQuery termQuery = (TermQuery) clause.getQuery();
+        TermQuery termQuery = (TermQuery) clause.query();
         assertThat(termQuery.getTerm().field()).isEqualTo("name");
         assertThat(termQuery.getTerm().text()).isEqualTo("john");
     }
@@ -110,9 +110,9 @@ void testRegexpQuery() {
         assertThat(booleanQuery.clauses()).hasSize(1);
 
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         assertThat(regexpQuery.getRegexp().field()).isEqualTo("name");
         // When user provides wildcards, just convert them without adding substring matching
         assertThat(regexpQuery.getRegexp().text()).isEqualTo("jo.*n");
@@ -126,9 +126,9 @@ void testRegexpQueryWithQuestionMark() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         // Wildcards in input are converted: ? -> . (no additional .* wrapping when wildcards present)
         assertThat(regexpQuery.getRegexp().text()).isEqualTo("jo.n");
     }
@@ -141,9 +141,9 @@ void testRegexpQueryWithPrefixWildcard() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         // User provided wildcard, so no additional wrapping
         assertThat(regexpQuery.getRegexp().text()).isEqualTo(".*john");
     }
@@ -156,9 +156,9 @@ void testRegexpQueryWithSuffixWildcard() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         // User provided wildcard, so no additional wrapping
         assertThat(regexpQuery.getRegexp().text()).isEqualTo("john.*");
     }
@@ -172,9 +172,9 @@ void testRegexpQueryWithSubstringMatching() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         // Should be wrapped with .* for substring matching: "local" matches "localhost"
         assertThat(regexpQuery.getRegexp().text()).isEqualTo(".*local.*");
     }
@@ -187,9 +187,9 @@ void testGreaterThanQuery() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(PointRangeQuery.class);
+        assertThat(clause.query()).isInstanceOf(PointRangeQuery.class);
 
-        PointRangeQuery rangeQuery = (PointRangeQuery) clause.getQuery();
+        PointRangeQuery rangeQuery = (PointRangeQuery) clause.query();
         assertThat(rangeQuery.getField()).isEqualTo("age");
         // For age:>30, the range should be [31, MAX_VALUE] (exclusive converted to inclusive by adding 1)
         assertThat(rangeQuery.toString()).contains("age:[31 TO 2147483647]");
@@ -203,9 +203,9 @@ void testGreaterThanOrEqualsQuery() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(PointRangeQuery.class);
+        assertThat(clause.query()).isInstanceOf(PointRangeQuery.class);
 
-        PointRangeQuery rangeQuery = (PointRangeQuery) clause.getQuery();
+        PointRangeQuery rangeQuery = (PointRangeQuery) clause.query();
         assertThat(rangeQuery.getField()).isEqualTo("age");
         // For age:>=30, the range should be [30, MAX_VALUE]
         assertThat(rangeQuery.toString()).contains("age:[30 TO 2147483647]");
@@ -219,9 +219,9 @@ void testLessThanQuery() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(PointRangeQuery.class);
+        assertThat(clause.query()).isInstanceOf(PointRangeQuery.class);
 
-        PointRangeQuery rangeQuery = (PointRangeQuery) clause.getQuery();
+        PointRangeQuery rangeQuery = (PointRangeQuery) clause.query();
         assertThat(rangeQuery.getField()).isEqualTo("age");
         // For age:<30, the range should be [MIN_VALUE, 29] (exclusive converted to inclusive by subtracting 1)
         assertThat(rangeQuery.toString()).contains("age:[-2147483648 TO 29]");
@@ -235,9 +235,9 @@ void testLessThanOrEqualsQuery() {
         assertThat(query).isInstanceOf(BooleanQuery.class);
         BooleanQuery booleanQuery = (BooleanQuery) query;
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(PointRangeQuery.class);
+        assertThat(clause.query()).isInstanceOf(PointRangeQuery.class);
 
-        PointRangeQuery rangeQuery = (PointRangeQuery) clause.getQuery();
+        PointRangeQuery rangeQuery = (PointRangeQuery) clause.query();
         assertThat(rangeQuery.getField()).isEqualTo("age");
         // For age:<=30, the range should be [MIN_VALUE, 30]
         assertThat(rangeQuery.toString()).contains("age:[-2147483648 TO 30]");
@@ -253,7 +253,7 @@ void testNegatedQuery() {
         assertThat(booleanQuery.clauses()).hasSize(1);
 
         BooleanClause clause = booleanQuery.clauses().get(0);
-        assertThat(clause.getOccur()).isEqualTo(BooleanClause.Occur.MUST_NOT);
+        assertThat(clause.occur()).isEqualTo(BooleanClause.Occur.MUST_NOT);
     }
 
     @Test
@@ -265,13 +265,13 @@ void testMultipleFields() {
         BooleanQuery booleanQuery = (BooleanQuery) query;
         assertThat(booleanQuery.clauses()).hasSize(2);
 
-        assertThat(booleanQuery.clauses().get(0).getOccur()).isEqualTo(BooleanClause.Occur.SHOULD);
-        assertThat(booleanQuery.clauses().get(1).getOccur()).isEqualTo(BooleanClause.Occur.SHOULD);
+        assertThat(booleanQuery.clauses().get(0).occur()).isEqualTo(BooleanClause.Occur.SHOULD);
+        assertThat(booleanQuery.clauses().get(1).occur()).isEqualTo(BooleanClause.Occur.SHOULD);
 
         // First clause should be RegexpQuery for name
-        assertThat(booleanQuery.clauses().get(0).getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(booleanQuery.clauses().get(0).query()).isInstanceOf(RegexpQuery.class);
         // Second clause should be PointRangeQuery for age (numeric field)
-        assertThat(booleanQuery.clauses().get(1).getQuery()).isInstanceOf(PointRangeQuery.class);
+        assertThat(booleanQuery.clauses().get(1).query()).isInstanceOf(PointRangeQuery.class);
     }
 
     @Test
@@ -284,8 +284,8 @@ void testMultipleValuesForSameField() {
         assertThat(booleanQuery.clauses()).hasSize(2);
 
         // Default operator is REGEXP, so both should be RegexpQuery with substring matching
-        assertThat(booleanQuery.clauses().get(0).getQuery()).isInstanceOf(RegexpQuery.class);
-        assertThat(booleanQuery.clauses().get(1).getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(booleanQuery.clauses().get(0).query()).isInstanceOf(RegexpQuery.class);
+        assertThat(booleanQuery.clauses().get(1).query()).isInstanceOf(RegexpQuery.class);
     }
 
     @Test
@@ -297,12 +297,12 @@ void testMixedPositiveAndNegativeQueries() {
         BooleanQuery booleanQuery = (BooleanQuery) query;
         assertThat(booleanQuery.clauses()).hasSize(2);
 
-        assertThat(booleanQuery.clauses().get(0).getOccur()).isEqualTo(BooleanClause.Occur.SHOULD);
-        assertThat(booleanQuery.clauses().get(1).getOccur()).isEqualTo(BooleanClause.Occur.MUST_NOT);
+        assertThat(booleanQuery.clauses().get(0).occur()).isEqualTo(BooleanClause.Occur.SHOULD);
+        assertThat(booleanQuery.clauses().get(1).occur()).isEqualTo(BooleanClause.Occur.MUST_NOT);
 
         // Both should be RegexpQuery (default operator)
-        assertThat(booleanQuery.clauses().get(0).getQuery()).isInstanceOf(RegexpQuery.class);
-        assertThat(booleanQuery.clauses().get(1).getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(booleanQuery.clauses().get(0).query()).isInstanceOf(RegexpQuery.class);
+        assertThat(booleanQuery.clauses().get(1).query()).isInstanceOf(RegexpQuery.class);
     }
 
     @Test
@@ -316,9 +316,9 @@ void testDefaultField() {
 
         BooleanClause clause = booleanQuery.clauses().get(0);
         // Default operator is REGEXP, so it should use RegexpQuery with substring matching
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         assertThat(regexpQuery.getRegexp().field()).isEqualTo("defaultfield");
         assertThat(regexpQuery.getRegexp().text()).isEqualTo(".*john.*");
     }
@@ -334,9 +334,9 @@ void testCaseInsensitiveRegexpQuery() {
         assertThat(booleanQuery.clauses()).hasSize(1);
 
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         assertThat(regexpQuery.getRegexp().field()).isEqualTo("name");
         // Input "John" should be lowercased to "john" for case-insensitive matching
         assertThat(regexpQuery.getRegexp().text()).isEqualTo(".*john.*");
@@ -353,9 +353,9 @@ void testCaseInsensitiveExactMatch() {
         assertThat(booleanQuery.clauses()).hasSize(1);
 
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(TermQuery.class);
+        assertThat(clause.query()).isInstanceOf(TermQuery.class);
 
-        TermQuery termQuery = (TermQuery) clause.getQuery();
+        TermQuery termQuery = (TermQuery) clause.query();
         assertThat(termQuery.getTerm().field()).isEqualTo("name");
         // Input "JOHN" should be lowercased to "john" for case-insensitive matching
         assertThat(termQuery.getTerm().text()).isEqualTo("john");
@@ -372,9 +372,9 @@ void testCaseInsensitiveWithWildcards() {
         assertThat(booleanQuery.clauses()).hasSize(1);
 
         BooleanClause clause = booleanQuery.clauses().getFirst();
-        assertThat(clause.getQuery()).isInstanceOf(RegexpQuery.class);
+        assertThat(clause.query()).isInstanceOf(RegexpQuery.class);
 
-        RegexpQuery regexpQuery = (RegexpQuery) clause.getQuery();
+        RegexpQuery regexpQuery = (RegexpQuery) clause.query();
         assertThat(regexpQuery.getRegexp().field()).isEqualTo("name");
         // Input "Jo*N" should be lowercased and wildcards converted: "jo.*n"
         assertThat(regexpQuery.getRegexp().text()).isEqualTo("jo.*n");

pom.xml

@@ -162,7 +162,7 @@
         <kafka.version>4.3.0</kafka.version>
         <kafka09.version>0.9.0.1-7</kafka09.version>
         <log4j.version>2.26.0</log4j.version>
-        <lucene.version>9.12.3</lucene.version>
+        <lucene.version>10.3.2</lucene.version>
         <lz4.version>1.11.0</lz4.version>
         <metrics.version>4.2.39</metrics.version>
         <mongodb-driver.version>5.8.0</mongodb-driver.version>