[8.x] Rollback Semantic Query Inner Hits (#113986)

x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/mapper/SemanticTextFieldMapper.java

@@ -40,7 +40,6 @@
 import org.elasticsearch.index.mapper.ValueFetcher;
 import org.elasticsearch.index.mapper.vectors.DenseVectorFieldMapper;
 import org.elasticsearch.index.mapper.vectors.SparseVectorFieldMapper;
-import org.elasticsearch.index.query.InnerHitBuilder;
 import org.elasticsearch.index.query.MatchNoneQueryBuilder;
 import org.elasticsearch.index.query.NestedQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
@@ -55,7 +54,6 @@
 import org.elasticsearch.xcontent.XContentParserConfiguration;
 import org.elasticsearch.xpack.core.ml.inference.results.MlTextEmbeddingResults;
 import org.elasticsearch.xpack.core.ml.inference.results.TextExpansionResults;
-import org.elasticsearch.xpack.inference.queries.SemanticQueryInnerHitBuilder;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -470,12 +468,7 @@ public boolean fieldHasValue(FieldInfos fieldInfos) {
             return fieldInfos.fieldInfo(getEmbeddingsFieldName(name())) != null;
         }
 
-        public QueryBuilder semanticQuery(
-            InferenceResults inferenceResults,
-            float boost,
-            String queryName,
-            SemanticQueryInnerHitBuilder semanticInnerHitBuilder
-        ) {
+        public QueryBuilder semanticQuery(InferenceResults inferenceResults, float boost, String queryName) {
             String nestedFieldPath = getChunksFieldName(name());
             String inferenceResultsFieldName = getEmbeddingsFieldName(name());
             QueryBuilder childQueryBuilder;
@@ -531,10 +524,7 @@ public QueryBuilder semanticQuery(
                 };
             }
 
-            InnerHitBuilder innerHitBuilder = semanticInnerHitBuilder != null ? semanticInnerHitBuilder.toInnerHitBuilder() : null;
-            return new NestedQueryBuilder(nestedFieldPath, childQueryBuilder, ScoreMode.Max).boost(boost)
-                .queryName(queryName)
-                .innerHit(innerHitBuilder);
+            return new NestedQueryBuilder(nestedFieldPath, childQueryBuilder, ScoreMode.Max).boost(boost).queryName(queryName);
         }
 
         private String generateQueryInferenceResultsTypeMismatchMessage(InferenceResults inferenceResults, String expectedResultsType) {

x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/queries/SemanticQueryBuilder.java

@@ -16,7 +16,6 @@
 import org.elasticsearch.cluster.metadata.InferenceFieldMetadata;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
-import org.elasticsearch.core.Nullable;
 import org.elasticsearch.features.NodeFeature;
 import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.index.query.AbstractQueryBuilder;
@@ -46,9 +45,7 @@
 import java.util.Map;
 import java.util.Objects;
 
-import static org.elasticsearch.TransportVersions.SEMANTIC_QUERY_INNER_HITS;
 import static org.elasticsearch.xcontent.ConstructingObjectParser.constructorArg;
-import static org.elasticsearch.xcontent.ConstructingObjectParser.optionalConstructorArg;
 import static org.elasticsearch.xpack.core.ClientHelper.ML_ORIGIN;
 import static org.elasticsearch.xpack.core.ClientHelper.executeAsyncWithOrigin;
 
@@ -59,33 +56,26 @@ public class SemanticQueryBuilder extends AbstractQueryBuilder<SemanticQueryBuil
 
     private static final ParseField FIELD_FIELD = new ParseField("field");
     private static final ParseField QUERY_FIELD = new ParseField("query");
-    private static final ParseField INNER_HITS_FIELD = new ParseField("inner_hits");
 
     private static final ConstructingObjectParser<SemanticQueryBuilder, Void> PARSER = new ConstructingObjectParser<>(
         NAME,
         false,
-        args -> new SemanticQueryBuilder((String) args[0], (String) args[1], (SemanticQueryInnerHitBuilder) args[2])
+        args -> new SemanticQueryBuilder((String) args[0], (String) args[1])
     );
 
     static {
         PARSER.declareString(constructorArg(), FIELD_FIELD);
         PARSER.declareString(constructorArg(), QUERY_FIELD);
-        PARSER.declareObject(optionalConstructorArg(), (p, c) -> SemanticQueryInnerHitBuilder.fromXContent(p), INNER_HITS_FIELD);
         declareStandardFields(PARSER);
     }
 
     private final String fieldName;
     private final String query;
-    private final SemanticQueryInnerHitBuilder innerHitBuilder;
     private final SetOnce<InferenceServiceResults> inferenceResultsSupplier;
     private final InferenceResults inferenceResults;
     private final boolean noInferenceResults;
 
     public SemanticQueryBuilder(String fieldName, String query) {
-        this(fieldName, query, null);
-    }
-
-    public SemanticQueryBuilder(String fieldName, String query, @Nullable SemanticQueryInnerHitBuilder innerHitBuilder) {
         if (fieldName == null) {
             throw new IllegalArgumentException("[" + NAME + "] requires a " + FIELD_FIELD.getPreferredName() + " value");
         }
@@ -94,25 +84,15 @@ public SemanticQueryBuilder(String fieldName, String query, @Nullable SemanticQu
         }
         this.fieldName = fieldName;
         this.query = query;
-        this.innerHitBuilder = innerHitBuilder;
         this.inferenceResults = null;
         this.inferenceResultsSupplier = null;
         this.noInferenceResults = false;
-
-        if (this.innerHitBuilder != null) {
-            this.innerHitBuilder.setFieldName(fieldName);
-        }
     }
 
     public SemanticQueryBuilder(StreamInput in) throws IOException {
         super(in);
         this.fieldName = in.readString();
         this.query = in.readString();
-        if (in.getTransportVersion().onOrAfter(SEMANTIC_QUERY_INNER_HITS)) {
-            this.innerHitBuilder = in.readOptionalWriteable(SemanticQueryInnerHitBuilder::new);
-        } else {
-            this.innerHitBuilder = null;
-        }
         this.inferenceResults = in.readOptionalNamedWriteable(InferenceResults.class);
         this.noInferenceResults = in.readBoolean();
         this.inferenceResultsSupplier = null;
@@ -125,21 +105,6 @@ protected void doWriteTo(StreamOutput out) throws IOException {
         }
         out.writeString(fieldName);
         out.writeString(query);
-        if (out.getTransportVersion().onOrAfter(SEMANTIC_QUERY_INNER_HITS)) {
-            out.writeOptionalWriteable(innerHitBuilder);
-        } else if (innerHitBuilder != null) {
-            throw new IllegalStateException(
-                "Transport version must be at least ["
-                    + SEMANTIC_QUERY_INNER_HITS.toReleaseVersion()
-                    + "] to use [ "
-                    + INNER_HITS_FIELD.getPreferredName()
-                    + "] in ["
-                    + NAME
-                    + "], current transport version is ["
-                    + out.getTransportVersion().toReleaseVersion()
-                    + "]. Are you running a mixed-version cluster?"
-            );
-        }
         out.writeOptionalNamedWriteable(inferenceResults);
         out.writeBoolean(noInferenceResults);
     }
@@ -152,18 +117,13 @@ private SemanticQueryBuilder(
     ) {
         this.fieldName = other.fieldName;
         this.query = other.query;
-        this.innerHitBuilder = other.innerHitBuilder;
         this.boost = other.boost;
         this.queryName = other.queryName;
         this.inferenceResultsSupplier = inferenceResultsSupplier;
         this.inferenceResults = inferenceResults;
         this.noInferenceResults = noInferenceResults;
     }
 
-    public SemanticQueryInnerHitBuilder innerHit() {
-        return innerHitBuilder;
-    }
-
     @Override
     public String getWriteableName() {
         return NAME;
@@ -183,9 +143,6 @@ protected void doXContent(XContentBuilder builder, Params params) throws IOExcep
         builder.startObject(NAME);
         builder.field(FIELD_FIELD.getPreferredName(), fieldName);
         builder.field(QUERY_FIELD.getPreferredName(), query);
-        if (innerHitBuilder != null) {
-            builder.field(INNER_HITS_FIELD.getPreferredName(), innerHitBuilder);
-        }
         boostAndQueryNameToXContent(builder);
         builder.endObject();
     }
@@ -212,7 +169,7 @@ private QueryBuilder doRewriteBuildSemanticQuery(SearchExecutionContext searchEx
                 );
             }
 
-            return semanticTextFieldType.semanticQuery(inferenceResults, boost(), queryName(), innerHitBuilder);
+            return semanticTextFieldType.semanticQuery(inferenceResults, boost(), queryName());
         } else {
             throw new IllegalArgumentException(
                 "Field [" + fieldName + "] of type [" + fieldType.typeName() + "] does not support " + NAME + " queries"
@@ -347,12 +304,11 @@ private static String getInferenceIdForForField(Collection<IndexMetadata> indexM
     protected boolean doEquals(SemanticQueryBuilder other) {
         return Objects.equals(fieldName, other.fieldName)
             && Objects.equals(query, other.query)
-            && Objects.equals(innerHitBuilder, other.innerHitBuilder)
             && Objects.equals(inferenceResults, other.inferenceResults);
     }
 
     @Override
     protected int doHashCode() {
-        return Objects.hash(fieldName, query, innerHitBuilder, inferenceResults);
+        return Objects.hash(fieldName, query, inferenceResults);
     }
 }