More

Author: Tim-Brooks

server/src/main/java/org/elasticsearch/common/io/stream/RecyclerBytesStreamOutput.java

@@ -111,6 +111,66 @@ private void writeAdditionalPages(byte[] b, int offset, int length) {
         }
     }
 
+    public void writeUTF8String(String str) throws IOException {
+        final int charCount = str.length();
+        if (charCount == 0) {
+            writeVInt(0);
+            return;
+        }
+
+        // Optimistically write length assuming all ASCII (1 byte per char)
+        long startPosition = position();
+        writeVInt(charCount);
+
+        // Ensure we have at least enough capacity for ASCII representation
+        if (charCount > (pageSize - currentPageOffset)) {
+            ensureCapacity(charCount);
+        }
+
+        if (writeAsciiChars(str, charCount) == false) {
+            seek(startPosition);
+            handleNonAsciiString(str);
+        }
+    }
+
+    /**
+     * Fast path for writing ASCII characters. Returns true if all characters
+     * were ASCII, false if a non-ASCII character was encountered.
+     */
+    private boolean writeAsciiChars(String str, int charCount) {
+        int charIndex = 0;
+
+        while (charIndex < charCount) {
+            int remainingInPage = pageSize - currentPageOffset;
+            int charsToWrite = Math.min(remainingInPage, charCount - charIndex);
+
+            for (int i = 0; i < charsToWrite; i++) {
+                char c = str.charAt(charIndex + i);
+                if (c > 0x7F) {
+                    return false;
+                }
+                bytesRefBytes[bytesRefOffset + currentPageOffset + i] = (byte) c;
+            }
+
+            // Update positions for what we wrote
+            currentPageOffset += charsToWrite;
+            charIndex += charsToWrite;
+
+            // Check if we need to move to next page AFTER writing
+            if (currentPageOffset == pageSize && charIndex < charCount) {
+                nextPage();
+            }
+        }
+
+        return true; // All characters were ASCII
+    }
+
+    private void handleNonAsciiString(String str) throws IOException {
+        byte[] utf8Bytes = str.getBytes(java.nio.charset.StandardCharsets.UTF_8);
+        writeVInt(utf8Bytes.length);
+        writeBytes(utf8Bytes, 0, utf8Bytes.length);
+    }
+
     @Override
     public void writeInt(int i) throws IOException {
         final int currentPageOffset = this.currentPageOffset;

server/src/main/java/org/elasticsearch/index/mapper/DotExpandingXContentParser.java

@@ -10,7 +10,6 @@
 package org.elasticsearch.index.mapper;
 
 import org.elasticsearch.core.CheckedFunction;
-import org.elasticsearch.ingest.ESONXContentParser;
 import org.elasticsearch.xcontent.FilterXContentParser;
 import org.elasticsearch.xcontent.FilterXContentParserWrapper;
 import org.elasticsearch.xcontent.XContentLocation;
@@ -74,9 +73,7 @@ public Token nextToken() throws IOException {
         }
 
         private static Token getNextToken(XContentParser parser) throws IOException {
-            if (parser instanceof ESONXContentParser eson) {
-                return eson.nextToken();
-            } else if (parser instanceof DotExpandingXContentParser dot) {
+            if (parser instanceof DotExpandingXContentParser dot) {
                 return dot.nextToken();
             } else {
                 return parser.nextToken();

server/src/main/java/org/elasticsearch/ingest/ESONFlat.java

@@ -74,10 +74,11 @@ public BytesReference getSerializedKeyBytes() {
             try (RecyclerBytesStreamOutput streamOutput = new RecyclerBytesStreamOutput(getBytesRefRecycler())) {
                 streamOutput.writeVInt(keys.size());
                 for (ESONEntry entry : keys) {
-                    String key = entry.key();
-                    byte[] bytes = key == null ? EMPTY_KEY : key.getBytes(StandardCharsets.UTF_8);
-                    streamOutput.writeVInt(bytes.length);
-                    streamOutput.writeBytes(bytes, 0, bytes.length);
+                    String key = entry.key() == null ? "" : entry.key();
+//                    byte[] bytes = key == null ? EMPTY_KEY : key.getBytes(StandardCharsets.UTF_8);
+//                    streamOutput.writeVInt(bytes.length);
+//                    streamOutput.writeBytes(bytes, 0, bytes.length);
+                    streamOutput.writeUTF8String(key);
                     streamOutput.writeByte(entry.type());
                     streamOutput.writeInt(entry.offsetOrCount());
                 }