IGNITE-25525 ExceptionInInitializerError in BinaryTupleParser since JDK 17 (#5931)

Author: vldpyatkov

modules/binary-tuple/src/main/java/org/apache/ignite/internal/binarytuple/BinaryTupleParser.java

@@ -28,8 +28,8 @@
 import java.time.LocalTime;
 import java.time.Period;
 import java.util.UUID;
+import java.util.function.Function;
 import org.apache.ignite.internal.util.ByteUtils;
-import org.apache.ignite.internal.util.GridUnsafe;
 
 /**
  * Binary tuple parser allows to get bytes of individual elements from entirety of tuple bytes.
@@ -52,9 +52,6 @@ public interface Sink {
     /** Byte order of ByteBuffers that contain the tuple. */
     public static final ByteOrder ORDER = ByteOrder.LITTLE_ENDIAN;
 
-    /** Whether the byte order of the underlying buffer is reversed compared to the native byte order. */
-    private static final boolean REVERSE_BYTE_ORDER = GridUnsafe.NATIVE_BYTE_ORDER != ORDER;
-
     /** UUID size in bytes. */
     private static final int UUID_SIZE = 16;
 
@@ -75,19 +72,29 @@ public interface Sink {
     /** Binary tuple. */
     protected final ByteBuffer buffer;
 
+    /**
+     * This constructor uses a default `PlainByteBufferAccessor` for accessing the buffer.
+     *
+     * @param numElements The number of elements in the binary tuple.
+     * @param buffer The `ByteBuffer` containing the binary tuple data.
+     */
+    public BinaryTupleParser(int numElements, ByteBuffer buffer) {
+        this(numElements, buffer, PlainByteBufferAccessor::new);
+    }
+
     /**
      * Constructor.
      *
      * @param numElements Number of tuple elements.
      * @param buffer Buffer with a binary tuple.
      */
-    public BinaryTupleParser(int numElements, ByteBuffer buffer) {
+    public BinaryTupleParser(int numElements, ByteBuffer buffer, Function<ByteBuffer, ByteBufferAccessor> byteBufferAccessorFactory) {
         this.numElements = numElements;
 
         assert buffer.order() == ORDER : "Buffer order must be LITTLE_ENDIAN, actual: " + buffer.order();
         assert buffer.position() == 0 : "Buffer position must be 0, actual: " + buffer.position();
         this.buffer = buffer;
-        byteBufferAccessor = new ByteBufferAccessor(buffer);
+        byteBufferAccessor = byteBufferAccessorFactory.apply(buffer);
 
         byte flags = byteBufferAccessor.get(0);
 
@@ -658,107 +665,49 @@ private LocalTime getTime(int offset, int length) {
     }
 
     /**
-     * An interface for accessing a byte buffer with methods to read various data types
-     * at specific positions. This interface abstracts the underlying implementation
-     * for handling data in either direct or heap-based byte buffers.
+     * A plain implementation of the `ByteBufferAccessor` interface.
+     * This class provides methods to access various data types from a `ByteBuffer`.
      */
-    public static class ByteBufferAccessor {
-        private final byte[] bytes;
-        private final long addr;
-        private final int capacity;
-
-        ByteBufferAccessor(ByteBuffer buff) {
-            if (buff.isDirect()) {
-                bytes = null;
-                addr = GridUnsafe.bufferAddress(buff);
-            } else {
-                bytes = buff.array();
-                addr = GridUnsafe.BYTE_ARR_OFF + buff.arrayOffset();
-            }
+    private static class PlainByteBufferAccessor implements ByteBufferAccessor {
+        private final ByteBuffer buffer;
 
-            capacity = buff.capacity();
+        PlainByteBufferAccessor(ByteBuffer buffer) {
+            this.buffer = buffer;
         }
 
-        /**
-         * Retrieves the byte value from the underlying byte buffer at the specified index.
-         *
-         * @param p the index in the underlying byte buffer to retrieve the byte from.
-         * @return the byte value located at the specified index in the byte buffer.
-         */
-        public byte get(int p) {
-            return GridUnsafe.getByte(bytes, addr + p);
+        @Override
+        public byte get(int index) {
+            return buffer.get(index);
         }
 
-        /**
-         * Reads a 32-bit integer value from the underlying byte buffer at the specified index.
-         *
-         * @param p the index in the underlying byte buffer to start reading the 32-bit integer value from.
-         * @return the 32-bit integer value located at the specified index in the byte buffer.
-         */
-        public int getInt(int p) {
-            int value = GridUnsafe.getInt(bytes, addr + p);
-
-            return REVERSE_BYTE_ORDER ? Integer.reverseBytes(value) : value;
+        @Override
+        public short getShort(int index) {
+            return buffer.getShort(index);
         }
 
-        /**
-         * Reads a 64-bit long value from the underlying byte buffer at the specified index.
-         *
-         * @param p the index in the underlying byte buffer to start reading the 64-bit long value from.
-         * @return the 64-bit long value located at the specified index in the byte buffer.
-         */
-        public long getLong(int p) {
-            long value = GridUnsafe.getLong(bytes, addr + p);
-
-            return REVERSE_BYTE_ORDER ? Long.reverseBytes(value) : value;
+        @Override
+        public int getInt(int index) {
+            return buffer.getInt(index);
         }
 
-        /**
-         * Reads a 16-bit short value from the underlying byte buffer at the specified index.
-         *
-         * @param p the index in the underlying byte buffer to start reading the 16-bit short value from.
-         * @return the 16-bit short value located at the specified index in the byte buffer.
-         */
-        public short getShort(int p) {
-            short value = GridUnsafe.getShort(bytes, addr + p);
-
-            return REVERSE_BYTE_ORDER ? Short.reverseBytes(value) : value;
+        @Override
+        public long getLong(int index) {
+            return buffer.getLong(index);
         }
 
-        /**
-         * Reads a 32-bit floating-point value from the underlying byte buffer at the specified index.
-         *
-         * @param p the index in the underlying byte buffer to start reading the 32-bit floating-point value from.
-         * @return the 32-bit floating-point value located at the specified index in the byte buffer.
-         */
-        public float getFloat(int p) {
-            float value = GridUnsafe.getFloat(bytes, addr + p);
-
-            return REVERSE_BYTE_ORDER ? Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(value))) : value;
+        @Override
+        public float getFloat(int index) {
+            return buffer.getFloat(index);
         }
 
-        /**
-         * Reads a 64-bit double-precision floating-point value from the underlying
-         * byte buffer at the specified index.
-         *
-         * @param p the index in the underlying byte buffer to start reading the
-         *          64-bit double-precision floating-point value from.
-         * @return the 64-bit double-precision floating-point value located at
-         *         the specified index in the byte buffer.
-         */
-        public double getDouble(int p) {
-            double value = GridUnsafe.getDouble(bytes, addr + p);
-
-            return REVERSE_BYTE_ORDER ? Double.longBitsToDouble(Long.reverseBytes(Double.doubleToLongBits(value))) : value;
+        @Override
+        public double getDouble(int index) {
+            return buffer.getDouble(index);
         }
 
-        /**
-         * Returns the capacity of the underlying byte buffer, representing the total number of bytes it can hold.
-         *
-         * @return the total capacity of the byte buffer.
-         */
+        @Override
         public int capacity() {
-            return capacity;
+            return buffer.capacity();
         }
     }
 }

modules/binary-tuple/src/main/java/org/apache/ignite/internal/binarytuple/BinaryTupleReader.java

@@ -28,6 +28,7 @@
 import java.time.LocalTime;
 import java.time.Period;
 import java.util.UUID;
+import java.util.function.Function;
 import org.jetbrains.annotations.Nullable;
 
 /**
@@ -60,6 +61,17 @@ public BinaryTupleReader(int numElements, ByteBuffer buffer) {
         super(numElements, buffer);
     }
 
+    /**
+     * Constructor with a specific factory function for creating a `ByteBufferAccessor`.
+     *
+     * @param numElements Number of tuple elements.
+     * @param buffer Buffer with a binary tuple.
+     * @param byteBufferAccessorFactory A factory function to create a `ByteBufferAccessor` for accessing the buffer.
+     */
+    public BinaryTupleReader(int numElements, ByteBuffer buffer, Function<ByteBuffer, ByteBufferAccessor> byteBufferAccessorFactory) {
+        super(numElements, buffer, byteBufferAccessorFactory);
+    }
+
     /** {@inheritDoc} */
     @Override
     public final void nextElement(int index, int begin, int end) {

modules/binary-tuple/src/main/java/org/apache/ignite/internal/binarytuple/ByteBufferAccessor.java

@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.binarytuple;
+
+/**
+ * An interface for accessing a byte buffer with methods to read various data types
+ * at specific positions. This interface abstracts the underlying implementation
+ * for handling data in either direct or heap-based byte buffers.
+ */
+public interface ByteBufferAccessor {
+    /**
+     * Retrieves the byte value from the underlying byte buffer at the specified index.
+     *
+     * @param p the index in the underlying byte buffer to retrieve the byte from.
+     * @return the byte value located at the specified index in the byte buffer.
+     */
+    byte get(int p);
+
+    /**
+     * Reads a 32-bit integer value from the underlying byte buffer at the specified index.
+     *
+     * @param p the index in the underlying byte buffer to start reading the 32-bit integer value from.
+     * @return the 32-bit integer value located at the specified index in the byte buffer.
+     */
+    int getInt(int p);
+
+    /**
+     * Reads a 64-bit long value from the underlying byte buffer at the specified index.
+     *
+     * @param p the index in the underlying byte buffer to start reading the 64-bit long value from.
+     * @return the 64-bit long value located at the specified index in the byte buffer.
+     */
+    long getLong(int p);
+
+    /**
+     * Reads a 16-bit short value from the underlying byte buffer at the specified index.
+     *
+     * @param p the index in the underlying byte buffer to start reading the 16-bit short value from.
+     * @return the 16-bit short value located at the specified index in the byte buffer.
+     */
+    short getShort(int p);
+
+    /**
+     * Reads a 32-bit floating-point value from the underlying byte buffer at the specified index.
+     *
+     * @param p the index in the underlying byte buffer to start reading the 32-bit floating-point value from.
+     * @return the 32-bit floating-point value located at the specified index in the byte buffer.
+     */
+    float getFloat(int p);
+
+    /**
+     * Reads a 64-bit double-precision floating-point value from the underlying
+     * byte buffer at the specified index.
+     *
+     * @param p the index in the underlying byte buffer to start reading the
+     *          64-bit double-precision floating-point value from.
+     * @return the 64-bit double-precision floating-point value located at
+     *         the specified index in the byte buffer.
+     */
+    double getDouble(int p);
+
+    /**
+     * Returns the capacity of the underlying byte buffer, representing the total number of bytes it can hold.
+     *
+     * @return the total capacity of the byte buffer.
+     */
+    int capacity();
+}

modules/schema/src/main/java/org/apache/ignite/internal/schema/BinaryTuple.java

@@ -18,8 +18,10 @@
 package org.apache.ignite.internal.schema;
 
 import java.nio.ByteBuffer;
+import java.util.function.Function;
 import org.apache.ignite.internal.binarytuple.BinaryTupleBuilder;
 import org.apache.ignite.internal.binarytuple.BinaryTupleReader;
+import org.apache.ignite.internal.binarytuple.ByteBufferAccessor;
 
 /**
  * Utility for access to binary tuple elements as typed values and with schema knowledge that allows to read
@@ -46,6 +48,17 @@ public BinaryTuple(int elementCount, ByteBuffer buffer) {
         super(elementCount, buffer);
     }
 
+    /**
+     * Constructor with a specific factory function for creating a `ByteBufferAccessor`.
+     *
+     * @param elementCount Number of tuple elements.
+     * @param buffer Buffer with a binary tuple.
+     * @param accessorFactory A factory function to create a `ByteBufferAccessor` for accessing the buffer.
+     */
+    public BinaryTuple(int elementCount, ByteBuffer buffer, Function<ByteBuffer, ByteBufferAccessor> accessorFactory) {
+        super(elementCount, buffer, accessorFactory);
+    }
+
     @Override
     public void copyValue(BinaryTupleBuilder builder, int columnIndex) {
         copyRawValue(builder, columnIndex);

modules/schema/src/main/java/org/apache/ignite/internal/schema/BinaryTupleComparator.java

@@ -66,8 +66,10 @@ public int compare(ByteBuffer buffer1, ByteBuffer buffer2) {
 
         int numElements = columnTypes.size();
 
-        BinaryTupleReader tuple1 = isBuffer1Prefix ? new BinaryTuplePrefix(numElements, buffer1) : new BinaryTuple(numElements, buffer1);
-        BinaryTupleReader tuple2 = isBuffer2Prefix ? new BinaryTuplePrefix(numElements, buffer2) : new BinaryTuple(numElements, buffer2);
+        BinaryTupleReader tuple1 = isBuffer1Prefix ? new BinaryTuplePrefix(numElements, buffer1)
+                : new BinaryTuple(numElements, buffer1, UnsafeByteBufferAccessor::new);
+        BinaryTupleReader tuple2 = isBuffer2Prefix ? new BinaryTuplePrefix(numElements, buffer2)
+                : new BinaryTuple(numElements, buffer2, UnsafeByteBufferAccessor::new);
 
         int columnsToCompare = Math.min(tuple1.elementCount(), tuple2.elementCount());
 

modules/schema/src/main/java/org/apache/ignite/internal/schema/BinaryTupleComparatorUtils.java

@@ -24,8 +24,8 @@
 import java.math.BigDecimal;
 import java.nio.ByteBuffer;
 import org.apache.ignite.internal.binarytuple.BinaryTupleCommon;
-import org.apache.ignite.internal.binarytuple.BinaryTupleParser.ByteBufferAccessor;
 import org.apache.ignite.internal.binarytuple.BinaryTupleReader;
+import org.apache.ignite.internal.binarytuple.ByteBufferAccessor;
 import org.apache.ignite.sql.ColumnType;
 
 /**

modules/schema/src/main/java/org/apache/ignite/internal/schema/PartialBinaryTupleMatcher.java

@@ -84,9 +84,10 @@ public int match(ByteBuffer buffer1, ByteBuffer buffer2) {
 
         assert !isBuffer1Prefix : "An inline tuple must not contain a prefix.";
 
-        BinaryTupleReader tuple1 = new BinaryTuple(numElements, buffer1);
+        BinaryTupleReader tuple1 = new BinaryTuple(numElements, buffer1, UnsafeByteBufferAccessor::new);
 
-        BinaryTupleReader tuple2 = isBuffer2Prefix ? new BinaryTuplePrefix(numElements, buffer2) : new BinaryTuple(numElements, buffer2);
+        BinaryTupleReader tuple2 = isBuffer2Prefix ? new BinaryTuplePrefix(numElements, buffer2)
+                : new BinaryTuple(numElements, buffer2, UnsafeByteBufferAccessor::new);
 
         int columnsToCompare = Math.min(tuple1.elementCount(), tuple2.elementCount());