Revert "Don't allow field caps to use semantic queries as index filters"

server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesRequest.java

@@ -18,13 +18,7 @@
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
-import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.index.query.BoostingQueryBuilder;
-import org.elasticsearch.index.query.ConstantScoreQueryBuilder;
-import org.elasticsearch.index.query.DisMaxQueryBuilder;
-import org.elasticsearch.index.query.NestedQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
 import org.elasticsearch.tasks.CancellableTask;
 import org.elasticsearch.tasks.Task;
 import org.elasticsearch.tasks.TaskId;
@@ -290,53 +284,9 @@ public ActionRequestValidationException validate() {
         if (fields == null || fields.length == 0) {
             validationException = ValidateActions.addValidationError("no fields specified", validationException);
         }
-
-        // Band-aid fix for https://github.com/elastic/elasticsearch/issues/116106.
-        // Semantic queries are high-recall queries, making them poor filters and effectively the same as an exists query when used in that
-        // context.
-        if (containsSemanticQuery(indexFilter)) {
-            validationException = ValidateActions.addValidationError(
-                "index filter cannot contain semantic queries. Use an exists query instead.",
-                validationException
-            );
-        }
-
         return validationException;
     }
 
-    /**
-     * Recursively checks if a query builder contains any semantic queries
-     */
-    private static boolean containsSemanticQuery(QueryBuilder queryBuilder) {
-        boolean containsSemanticQuery = false;
-
-        if (queryBuilder == null) {
-            return containsSemanticQuery;
-        }
-
-        if ("semantic".equals(queryBuilder.getWriteableName())) {
-            containsSemanticQuery = true;
-        } else if (queryBuilder instanceof BoolQueryBuilder boolQuery) {
-            containsSemanticQuery = boolQuery.must().stream().anyMatch(FieldCapabilitiesRequest::containsSemanticQuery)
-                || boolQuery.mustNot().stream().anyMatch(FieldCapabilitiesRequest::containsSemanticQuery)
-                || boolQuery.should().stream().anyMatch(FieldCapabilitiesRequest::containsSemanticQuery)
-                || boolQuery.filter().stream().anyMatch(FieldCapabilitiesRequest::containsSemanticQuery);
-        } else if (queryBuilder instanceof DisMaxQueryBuilder disMaxQuery) {
-            containsSemanticQuery = disMaxQuery.innerQueries().stream().anyMatch(FieldCapabilitiesRequest::containsSemanticQuery);
-        } else if (queryBuilder instanceof NestedQueryBuilder nestedQuery) {
-            containsSemanticQuery = containsSemanticQuery(nestedQuery.query());
-        } else if (queryBuilder instanceof BoostingQueryBuilder boostingQuery) {
-            containsSemanticQuery = containsSemanticQuery(boostingQuery.positiveQuery())
-                || containsSemanticQuery(boostingQuery.negativeQuery());
-        } else if (queryBuilder instanceof ConstantScoreQueryBuilder constantScoreQuery) {
-            containsSemanticQuery = containsSemanticQuery(constantScoreQuery.innerQuery());
-        } else if (queryBuilder instanceof FunctionScoreQueryBuilder functionScoreQuery) {
-            containsSemanticQuery = containsSemanticQuery(functionScoreQuery.query());
-        }
-
-        return containsSemanticQuery;
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;