Cleanup & tests

Author: kderusso

server/src/main/java/org/elasticsearch/index/mapper/vectors/DenseVectorFieldMapper.java

@@ -88,7 +88,6 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.Set;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
@@ -128,18 +127,6 @@ public static boolean isNotUnitVector(float magnitude) {
     public static final int MAGNITUDE_BYTES = 4;
     public static final int NUM_CANDS_OVERSAMPLE_LIMIT = 10_000; // Max oversample allowed for k and num_candidates
 
-    // Supported types for index options for dense_vector field and semantic_text fields based on dense inference IDs
-    public static final Set<String> SUPPORTED_TYPES = Set.of(
-        "hnsw",
-        "int8_hnsw",
-        "int4_hnsw",
-        "bbq_hnsw",
-        "flat",
-        "int8_flat",
-        "int4_flat",
-        "bbq_flat"
-    );
-
     private static DenseVectorFieldMapper toType(FieldMapper in) {
         return (DenseVectorFieldMapper) in;
     }

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

@@ -222,6 +222,11 @@ public String type() {
             return type;
         }
 
+        @Override
+        public String toString() {
+            return asMap().toString();
+        }
+
         public abstract Map<String, Object> asMap();
     }
 
@@ -238,6 +243,18 @@ public DenseVectorIndexOptions(String type, Integer m, Integer efConstruction, I
             this.confidenceInterval = confidenceInterval;
         }
 
+        public Integer m() {
+            return m;
+        }
+
+        public Integer efConstruction() {
+            return efConstruction;
+        }
+
+        public Integer confidenceInterval() {
+            return confidenceInterval;
+        }
+
         public Map<String, Object> asMap() {
             Map<String, Object> map = new HashMap<>();
             if (type != null) {
@@ -254,6 +271,22 @@ public Map<String, Object> asMap() {
             }
             return map;
         }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            DenseVectorIndexOptions that = (DenseVectorIndexOptions) o;
+            return Objects.equals(type, that.type)
+                && Objects.equals(m, that.m)
+                && Objects.equals(efConstruction, that.efConstruction)
+                && Objects.equals(confidenceInterval, that.confidenceInterval);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(type, m, efConstruction, confidenceInterval);
+        }
     }
 
     public static String getOriginalTextFieldName(String fieldName) {
@@ -314,7 +347,7 @@ static IndexOptions parseIndexOptionsFromMap(String fieldName, Object node) {
             );
             IndexOptions indexOptions = INDEX_OPTIONS_PARSER.parse(parser, null);
 
-            if (indexOptions.type != null && DenseVectorFieldMapper.SUPPORTED_TYPES.contains(indexOptions.type)) {
+            if (indexOptions.type != null && isDenseVectorIndexType(indexOptions.type)) {
                 // Run dense vector index options through the dense vector field mapper validation
                 // so we error on invalid options at index creation time
                 DenseVectorFieldMapper.parseIndexOptions(fieldName, node);
@@ -326,6 +359,10 @@ static IndexOptions parseIndexOptionsFromMap(String fieldName, Object node) {
         }
     }
 
+    private static boolean isDenseVectorIndexType(String type) {
+        return DenseVectorFieldMapper.VectorIndexType.fromString(type).isPresent();
+    }
+
     @Override
     public List<String> originalValues() {
         return originalValues != null ? originalValues : Collections.emptyList();
@@ -437,7 +474,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         true,
         args -> {
             String type = (String) args[0];
-            if (type != null && DenseVectorFieldMapper.SUPPORTED_TYPES.contains(type)) {
+            if (type != null && isDenseVectorIndexType(type)) {
                 Integer m = (Integer) args[1];
                 Integer efConstruction = (Integer) args[2];
                 Integer confidenceInterval = (Integer) args[3];

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

@@ -88,10 +88,13 @@
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.CHUNKED_EMBEDDINGS_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.CHUNKED_OFFSET_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.CHUNKS_FIELD;
+import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.CONFIDENCE_INTERVAL_FIELD;
+import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.EF_CONSTRUCTION_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.INDEX_OPTIONS_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.INFERENCE_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.INFERENCE_ID_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.MODEL_SETTINGS_FIELD;
+import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.M_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.SEARCH_INFERENCE_ID_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.TEXT_FIELD;
 import static org.elasticsearch.xpack.inference.mapper.SemanticTextField.TYPE_FIELD;
@@ -986,7 +989,49 @@ private static boolean canMergeIndexOptions(
         if (previous == null || current == null) {
             return true;
         }
+
+        if (previous.getClass() != current.getClass()) {
+            conflicts.addConflict(INDEX_OPTIONS_FIELD, "Incompatible classes");
+            return false;
+        }
+
+        if (current instanceof SemanticTextField.DenseVectorIndexOptions) {
+            return canMergeDenseVectorIndexOptions(
+                (SemanticTextField.DenseVectorIndexOptions) previous,
+                (SemanticTextField.DenseVectorIndexOptions) current,
+                conflicts
+            );
+        }
+
         conflicts.addConflict(INDEX_OPTIONS_FIELD, "");
         return false;
     }
+
+    private static boolean canMergeDenseVectorIndexOptions(
+        SemanticTextField.DenseVectorIndexOptions previous,
+        SemanticTextField.DenseVectorIndexOptions current,
+        Conflicts conflicts
+    ) {
+        if (Objects.equals(previous.type(), current.type()) == false) {
+            conflicts.addConflict(TYPE_FIELD, "");
+            return false;
+        }
+
+        if (previous.m() != null && Objects.equals(previous.m(), current.m()) == false) {
+            conflicts.addConflict(M_FIELD, "");
+            return false;
+        }
+
+        if (previous.efConstruction() != null && Objects.equals(previous.efConstruction(), current.efConstruction()) == false) {
+            conflicts.addConflict(EF_CONSTRUCTION_FIELD, "");
+            return false;
+        }
+
+        if (previous.confidenceInterval() != null && Objects.equals(previous.confidenceInterval(), current.confidenceInterval()) == false) {
+            conflicts.addConflict(CONFIDENCE_INTERVAL_FIELD, "");
+            return false;
+        }
+
+        return true;
+    }
 }