Fix merges, add some testing

Author: carlosdelest

x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/plugin/ScoringIT.java

@@ -27,7 +27,10 @@
 import java.util.Map;
 
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
+import static org.elasticsearch.xpack.esql.EsqlTestUtils.getValuesList;
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.lessThan;
 
 public class ScoringIT extends AbstractEsqlIntegTestCase {
 
@@ -186,8 +189,6 @@ public void testPushableFunctionsScoring() {
 
     private void assertZeroScore(String query) {
         try (var resp = run(query)) {
-            assertColumnNames(resp.columns(), List.of("id", "_score"));
-            assertColumnTypes(resp.columns(), List.of("integer", "double"));
             List<List<Object>> values = EsqlTestUtils.getValuesList(resp.values());
             for (List<Object> value : values) {
                 assertThat((Double) value.get(1), equalTo(0.0));
@@ -229,6 +230,112 @@ public void testPushableAndFullTextFunctionsConjunctionScoring() {
         checkSameScores(queryWithoutFilter, query);
     }
 
+    public void testDisjunctionScoring() {
+        var queryWithoutFilter = String.format(Locale.ROOT, """
+            FROM test
+            METADATA _score
+            | WHERE %s OR length(content) < 20
+            | KEEP id, _score
+            | SORT _score DESC, id ASC
+            """, matchingClause);
+        var query = String.format(Locale.ROOT, """
+            FROM test
+            METADATA _score
+            | WHERE %s
+            | KEEP id, _score
+            | SORT _score DESC, id ASC
+            """, matchingClause);
+
+        checkSameScores(queryWithoutFilter, query);
+
+        try (var resp = run(queryWithoutFilter)) {
+            List<List<Object>> values = getValuesList(resp);
+            assertThat(values.size(), equalTo(3));
+
+            assertThat(values.get(0).get(0), equalTo(1));
+            assertThat(values.get(1).get(0), equalTo(6));
+            assertThat(values.get(2).get(0), equalTo(2));
+
+            // Matches full text query and non pushable query
+            assertThat((Double) values.get(0).get(1), greaterThan(0.0));
+            assertThat((Double) values.get(1).get(1), greaterThan(0.0));
+            // Matches just non pushable query
+            assertThat((Double) values.get(2).get(1), equalTo(0.0));
+        }
+    }
+
+    public void testDisjunctionScoringPushableFunctions() {
+        var query = String.format(Locale.ROOT, """
+            FROM test METADATA _score
+            | WHERE %s OR match(content, "quick")
+            | KEEP id, _score
+            | SORT _score DESC, id ASC
+            """, matchingClause);
+
+        try (var resp = run(query)) {
+            List<List<Object>> values = getValuesList(resp);
+            assertThat(values.size(), equalTo(2));
+
+            assertThat(values.get(0).get(0), equalTo(6));
+            assertThat(values.get(1).get(0), equalTo(1));
+
+            // Matches both conditions
+            assertThat((Double) values.get(0).get(1), greaterThan(2.0));
+            // Matches a single condition
+            assertThat((Double) values.get(1).get(1), greaterThan(1.0));
+        }
+    }
+
+    public void testDisjunctionScoringMultipleNonPushableFunctions() {
+        var query = String.format(Locale.ROOT, """
+            FROM test METADATA _score
+            | WHERE %s
+            | KEEP id, _score
+            | SORT _score DESC
+            """, matchingClause);
+        var queryWithoutFilter = String.format(Locale.ROOT, """
+            FROM test METADATA _score
+            | WHERE %s OR length(content) < 20 AND id > 2
+            | KEEP id, _score
+            | SORT _score DESC
+            """, matchingClause);
+
+        checkSameScores(queryWithoutFilter, query);
+
+        try (var resp = run(queryWithoutFilter)) {
+            List<List<Object>> values = getValuesList(resp);
+            assertThat(values.size(), equalTo(2));
+
+            assertThat(values.get(0).get(0), equalTo(1));
+            assertThat(values.get(1).get(0), equalTo(6));
+
+            // Matches the full text query and the two pushable query
+            assertThat((Double) values.get(0).get(1), greaterThan(0.0));
+            // Matches just the match function
+            assertThat((Double) values.get(1).get(1), lessThan(1.0));
+            assertThat((Double) values.get(1).get(1), greaterThan(0.1));
+        }
+    }
+
+    public void testDisjunctionScoringWithNot() {
+        var query = String.format(Locale.ROOT, """
+            FROM test METADATA _score
+            | WHERE NOT(%s) OR length(content) > 50
+            | KEEP id, _score
+            | SORT _score DESC, id ASC
+            """, matchingClause);
+
+        try (var resp = run(query)) {
+            // Matches NOT gets 0.0
+            assertThat(getValuesList(resp), equalTo(List.of(
+                List.of(2, 0.0),
+                List.of(3, 0.0),
+                List.of(4, 0.0),
+                List.of(5, 0.0)
+            )));
+        }
+    }
+
     private void checkSameScores(String queryWithoutFilter, String query) {
         Map<Integer, Double> expectedScores = new HashMap<>();
         try (var respWithoutFilter = run(queryWithoutFilter)) {

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/expression/function/fulltext/QueryStringTests.java

@@ -79,7 +79,7 @@ protected Expression build(Source source, List<Expression> args) {
         // We need to add the QueryBuilder to the match expression, as it is used to implement equals() and hashCode() and
         // thus test the serialization methods. But we can only do this if the parameters make sense .
         if (args.get(0).foldable()) {
-            QueryBuilder queryBuilder = TRANSLATOR_HANDLER.asQuery(qstr).asBuilder();
+            QueryBuilder queryBuilder = TRANSLATOR_HANDLER.asQuery(qstr).toQueryBuilder();
             qstr.replaceQueryBuilder(queryBuilder);
         }
         return qstr;