IGNITE-17855 Implement inline size calculation for B+tree

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

@@ -101,7 +101,7 @@ public static NativeType numberOf(int precision) {
     /**
      * Creates a STRING type with maximal length is <code>len</code>.
      *
-     * @param len Maximum length of the string.
+     * @param len Maximum length of the string, {@link Integer#MAX_VALUE} if not defined.
      * @return Native type.
      */
     public static NativeType stringOf(int len) {
@@ -111,7 +111,7 @@ public static NativeType stringOf(int len) {
     /**
      * Creates a BYTES type with maximal length is <code>len</code>.
      *
-     * @param len Maximum length of the byte array.
+     * @param len Maximum length of the byte array, {@link Integer#MAX_VALUE} if not defined.
      * @return Native type.
      */
     public static NativeType blobOf(int len) {

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

@@ -23,35 +23,33 @@
  * Variable-length native type.
  */
 public class VarlenNativeType extends NativeType {
-    /** Length of the type. */
+    /** Length of the type, {@link Integer#MAX_VALUE} if not defined. */
     private final int len;
 
     /**
      * Constructor.
      *
      * @param typeSpec Type spec.
-     * @param len      Type length.
+     * @param len Type length.
      */
     protected VarlenNativeType(NativeTypeSpec typeSpec, int len) {
         super(typeSpec);
 
         this.len = len;
     }
 
-    /** {@inheritDoc} */
     @Override
     public boolean mismatch(NativeType type) {
         return super.mismatch(type) || len < ((VarlenNativeType) type).len;
     }
 
     /**
-     * Get length of the type.
+     * Get length of the type, {@link Integer#MAX_VALUE} if not defined.
      */
     public int length() {
         return len;
     }
 
-    /** {@inheritDoc} */
     @Override
     public String toString() {
         return S.toString(VarlenNativeType.class.getSimpleName(), "name", spec(), "len", len);

modules/storage-api/src/main/java/org/apache/ignite/internal/storage/index/BinaryTupleComparator.java

@@ -29,7 +29,7 @@
 import org.apache.ignite.internal.schema.BinaryTupleSchema;
 import org.apache.ignite.internal.schema.NativeTypeSpec;
 import org.apache.ignite.internal.schema.row.InternalTuple;
-import org.apache.ignite.internal.storage.index.SortedIndexDescriptor.ColumnDescriptor;
+import org.apache.ignite.internal.storage.index.SortedIndexDescriptor.SortedIndexColumnDescriptor;
 
 /**
  * Comparator implementation for comparing {@link BinaryTuple}s on a per-column basis.
@@ -63,10 +63,10 @@ public int compare(ByteBuffer buffer1, ByteBuffer buffer2) {
 
         int columnsToCompare = Math.min(tuple1.count(), tuple2.count());
 
-        assert columnsToCompare <= descriptor.indexColumns().size();
+        assert columnsToCompare <= descriptor.columns().size();
 
         for (int i = 0; i < columnsToCompare; i++) {
-            ColumnDescriptor columnDescriptor = descriptor.indexColumns().get(i);
+            SortedIndexColumnDescriptor columnDescriptor = descriptor.columns().get(i);
 
             int compare = compareField(tuple1, tuple2, i);
 
@@ -102,7 +102,7 @@ private int compareField(InternalTuple tuple1, InternalTuple tuple2, int index)
             return 1;
         }
 
-        ColumnDescriptor columnDescriptor = descriptor.indexColumns().get(index);
+        SortedIndexColumnDescriptor columnDescriptor = descriptor.columns().get(index);
 
         NativeTypeSpec typeSpec = columnDescriptor.type().spec();
 

modules/storage-api/src/main/java/org/apache/ignite/internal/storage/index/HashIndexDescriptor.java

@@ -38,40 +38,34 @@
  *
  * @see HashIndexStorage
  */
-public class HashIndexDescriptor {
+public class HashIndexDescriptor implements IndexDescriptor {
     /**
      * Descriptor of a Hash Index column.
      */
-    public static class ColumnDescriptor {
+    public static class HashIndexColumnDescriptor implements ColumnDescriptor {
         private final String name;
 
         private final NativeType type;
 
         private final boolean nullable;
 
-        ColumnDescriptor(ColumnView tableColumnView) {
+        HashIndexColumnDescriptor(ColumnView tableColumnView) {
             this.name = tableColumnView.name();
             this.type = ConfigurationToSchemaDescriptorConverter.convert(tableColumnView.type());
             this.nullable = tableColumnView.nullable();
         }
 
-        /**
-         * Returns the name of an index column.
-         */
+        @Override
         public String name() {
             return name;
         }
 
-        /**
-         * Returns a column type.
-         */
+        @Override
         public NativeType type() {
             return type;
         }
 
-        /**
-         * Returns {@code true} if this column can contain null values or {@code false} otherwise.
-         */
+        @Override
         public boolean nullable() {
             return nullable;
         }
@@ -84,7 +78,7 @@ public String toString() {
 
     private final UUID id;
 
-    private final List<ColumnDescriptor> columns;
+    private final List<HashIndexColumnDescriptor> columns;
 
     /**
      * Creates an Index Descriptor from a given Table Configuration.
@@ -122,22 +116,18 @@ public HashIndexDescriptor(UUID indexId, TablesView tablesConfig) {
 
                     assert columnView != null : "Incorrect index column configuration. " + columnName + " column does not exist";
 
-                    return new ColumnDescriptor(columnView);
+                    return new HashIndexColumnDescriptor(columnView);
                 })
                 .collect(toUnmodifiableList());
     }
 
-    /**
-     * Returns the ID of this Index.
-     */
+    @Override
     public UUID id() {
         return id;
     }
 
-    /**
-     * Returns the Column Descriptors that comprise a row of this index.
-     */
-    public List<ColumnDescriptor> indexColumns() {
+    @Override
+    public List<HashIndexColumnDescriptor> columns() {
         return columns;
     }
 }

modules/storage-api/src/main/java/org/apache/ignite/internal/storage/index/IndexDescriptor.java

@@ -0,0 +1,57 @@
+/*
+ * 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.storage.index;
+
+import java.util.List;
+import java.util.UUID;
+import org.apache.ignite.internal.schema.NativeType;
+
+/**
+ * Index descriptor.
+ */
+public interface IndexDescriptor {
+    /**
+     * Index column descriptor.
+     */
+    interface ColumnDescriptor {
+        /**
+         * Returns the name of an index column.
+         */
+        String name();
+
+        /**
+         * Returns a column descriptor.
+         */
+        NativeType type();
+
+        /**
+         * Returns {@code true} if this column can contain null values or {@code false} otherwise.
+         */
+        boolean nullable();
+    }
+
+    /**
+     * Returns the index ID.
+     */
+    UUID id();
+
+    /**
+     * Returns index column descriptions.
+     */
+    List<? extends ColumnDescriptor> columns();
+}

modules/storage-api/src/main/java/org/apache/ignite/internal/storage/index/InlineUtils.java

@@ -0,0 +1,106 @@
+/*
+ * 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.storage.index;
+
+import static org.apache.ignite.internal.util.Constants.KiB;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.List;
+import org.apache.ignite.internal.binarytuple.BinaryTupleCommon;
+import org.apache.ignite.internal.schema.BinaryTuple;
+import org.apache.ignite.internal.schema.NativeType;
+import org.apache.ignite.internal.schema.NativeTypeSpec;
+import org.apache.ignite.internal.schema.VarlenNativeType;
+import org.apache.ignite.internal.storage.index.IndexDescriptor.ColumnDescriptor;
+
+/**
+ * Helper class for index inlining.
+ */
+public class InlineUtils {
+    /** Inline size of an undefined (not set by the user) variable length column in bytes. */
+    static final int UNDEFINED_VARLEN_INLINE_SIZE = 10;
+
+    /** Inline size for large numbers ({@link BigDecimal} and {@link BigInteger}) in bytes. */
+    static final int BIG_NUMBER_INLINE_SIZE = 4;
+
+    /** Maximum inline size for a {@link BinaryTuple}, in bytes. */
+    static final int MAX_BINARY_TUPLE_INLINE_SIZE = 2 * KiB;
+
+    /** {@link BinaryTuple} size class in bytes. */
+    static final int BINARY_TUPLE_SIZE_CLASS = 2;
+
+    /**
+     * Calculates inline size for column.
+     *
+     * @param nativeType Column type.
+     * @return Inline size in bytes.
+     */
+    static int inlineSize(NativeType nativeType) {
+        NativeTypeSpec spec = nativeType.spec();
+
+        if (spec.fixedLength()) {
+            return nativeType.sizeInBytes();
+        }
+
+        // Variable length columns.
+
+        switch (spec) {
+            case STRING: {
+                int length = ((VarlenNativeType) nativeType).length();
+
+                return length == Integer.MAX_VALUE ? UNDEFINED_VARLEN_INLINE_SIZE : length * 2;
+            }
+
+            case BYTES: {
+                int length = ((VarlenNativeType) nativeType).length();
+
+                return length == Integer.MAX_VALUE ? UNDEFINED_VARLEN_INLINE_SIZE : length;
+            }
+
+            case DECIMAL:
+            case NUMBER:
+                return BIG_NUMBER_INLINE_SIZE;
+
+            default:
+                throw new IllegalArgumentException("Unknown type " + spec);
+        }
+    }
+
+    /**
+     * Calculates inline size for {@link BinaryTuple}, given its format.
+     *
+     * @param indexDescriptor Index descriptor.
+     * @return Inline size in bytes, not more than the {@link #MAX_BINARY_TUPLE_INLINE_SIZE}.
+     */
+    static int binaryTupleInlineSize(IndexDescriptor indexDescriptor) {
+        List<? extends ColumnDescriptor> columns = indexDescriptor.columns();
+
+        boolean hasNullColumns = columns.stream().anyMatch(ColumnDescriptor::nullable);
+
+        int inlineSize = BinaryTupleCommon.HEADER_SIZE
+                + (hasNullColumns ? BinaryTupleCommon.nullMapSize(columns.size()) : 0)
+                + columns.size() * BINARY_TUPLE_SIZE_CLASS;
+
+        for (int i = 0; i < columns.size() && inlineSize < MAX_BINARY_TUPLE_INLINE_SIZE; i++) {
+            inlineSize += inlineSize(columns.get(i).type());
+        }
+
+        return Math.min(inlineSize, MAX_BINARY_TUPLE_INLINE_SIZE);
+    }
+}