Merge branch 'main' into esql-function-auto-complete-hints

Author: afoucret

docs/changelog/138723.yaml

@@ -0,0 +1,20 @@
+pr: 138723
+summary: Remove DOC_VALUES_SKIPPER feature flag
+area: Mapping
+type: feature
+issues: []
+highlight:
+  title: Enable doc_values skippers
+  body: |-
+    Doc_values skippers add a sparse index to doc_values fields, allowing efficient
+    querying and filtering on a field without having to build a separate BKD or terms
+    index.  These are now enabled automatically on any field configured with
+    index=false and doc_values=true if the index setting `index.mapping.use_doc_values_skipper`
+    is set to `true` (default `false`, or `true` for TSDB indexes).
+
+    TSDB indexes now default to using skippers in place of indexes for their
+    @timestamp, dimension and  _tsid fields, greatly reducing their on-disk
+    footprint.  To disable skippers in TSDB indexes, set `index.mapping.use_doc_values_skipper`
+    to `false`.
+
+  notable: true

docs/changelog/138989.yaml

@@ -0,0 +1,5 @@
+pr: 138989
+summary: Auto prefiltering for queries on dense `semantic_text` fields
+area: Vector Search
+type: bug
+issues: []

docs/changelog/139409.yaml

@@ -0,0 +1,5 @@
+pr: 139409
+summary: Use new bulk scoring dot product for max inner product
+area: Vector Search
+type: enhancement
+issues: []

docs/changelog/139420.yaml

@@ -0,0 +1,5 @@
+pr: 139420
+summary: Fix offset maths bug in `InetAddress` parsing
+area: Mapping
+type: bug
+issues: []

docs/reference/elasticsearch/index-settings/slow-log.md

@@ -270,6 +270,37 @@ float scoreFromSegments(MemorySegment a, float aOffset, MemorySegment b, float b
             return adjustedDistance + 1;
         }
 
+        @Override
+        protected void bulkScoreFromSegment(
+            MemorySegment vectors,
+            int vectorLength,
+            int vectorPitch,
+            int firstOrd,
+            MemorySegment ordinals,
+            MemorySegment scores,
+            int numNodes
+        ) {
+            long firstByteOffset = (long) firstOrd * vectorPitch;
+            var firstVector = vectors.asSlice(firstByteOffset, vectorPitch);
+            Similarities.dotProduct7uBulkWithOffsets(vectors, firstVector, dims, vectorPitch, ordinals, numNodes, scores);
+
+            // Java-side adjustment
+            var aOffset = Float.intBitsToFloat(
+                vectors.asSlice(firstByteOffset + vectorLength, Float.BYTES).getAtIndex(ValueLayout.JAVA_INT_UNALIGNED, 0)
+            );
+            for (int i = 0; i < numNodes; ++i) {
+                var dotProduct = scores.getAtIndex(ValueLayout.JAVA_FLOAT, i);
+                var secondOrd = ordinals.getAtIndex(ValueLayout.JAVA_INT, i);
+                long secondByteOffset = (long) secondOrd * vectorPitch;
+                var bOffset = Float.intBitsToFloat(
+                    vectors.asSlice(secondByteOffset + vectorLength, Float.BYTES).getAtIndex(ValueLayout.JAVA_INT_UNALIGNED, 0)
+                );
+                float adjustedDistance = dotProduct * scoreCorrectionConstant + aOffset + bOffset;
+                adjustedDistance = adjustedDistance < 0 ? 1 / (1 + -1 * adjustedDistance) : adjustedDistance + 1;
+                scores.setAtIndex(ValueLayout.JAVA_FLOAT, i, adjustedDistance);
+            }
+        }
+
         @Override
         public MaxInnerProductSupplier copy() {
             return new MaxInnerProductSupplier(input.clone(), values, scoreCorrectionConstant);

libs/simdvec/src/main21/java/org/elasticsearch/simdvec/internal/Int7SQVectorScorerSupplier.java

@@ -168,6 +168,30 @@ public float score(int node) throws IOException {
             }
             return adjustedDistance + 1;
         }
+
+        @Override
+        public void bulkScore(int[] nodes, float[] scores, int numNodes) throws IOException {
+            MemorySegment vectorsSeg = input.segmentSliceOrNull(0, input.length());
+            if (vectorsSeg == null) {
+                super.bulkScore(nodes, scores, numNodes);
+            } else {
+                var ordinalsSeg = MemorySegment.ofArray(nodes);
+                var scoresSeg = MemorySegment.ofArray(scores);
+
+                var vectorPitch = vectorByteSize + Float.BYTES;
+                dotProduct7uBulkWithOffsets(vectorsSeg, query, vectorByteSize, vectorPitch, ordinalsSeg, numNodes, scoresSeg);
+
+                for (int i = 0; i < numNodes; ++i) {
+                    var dotProduct = scores[i];
+                    var secondOrd = nodes[i];
+                    long secondByteOffset = (long) secondOrd * vectorPitch;
+                    var nodeCorrection = Float.intBitsToFloat(input.readInt(secondByteOffset + vectorByteSize));
+                    float adjustedDistance = dotProduct * scoreCorrectionConstant + queryCorrection + nodeCorrection;
+                    adjustedDistance = adjustedDistance < 0 ? 1 / (1 + -1 * adjustedDistance) : adjustedDistance + 1;
+                    scores[i] = adjustedDistance;
+                }
+            }
+        }
     }
 
     static void checkDimensions(int queryLen, int fieldLen) {