refactor: simplified storage level index logic

core/src/main/java/com/orientechnologies/orient/core/config/IndexEngineData.java

@@ -1,5 +1,7 @@
 package com.orientechnologies.orient.core.config;
 
+import com.orientechnologies.orient.core.index.OIndexDefinition;
+import com.orientechnologies.orient.core.index.OIndexMetadata;
 import com.orientechnologies.orient.core.metadata.schema.OType;
 import java.util.Collections;
 import java.util.HashMap;
@@ -16,7 +18,11 @@ public final class IndexEngineData {
   private final Boolean durableInNonTxMode;
 
   private final int version;
-  private final int apiVersion;
+
+  @Deprecated
+  // Needed only for disk backward compatibility
+  private int apiVersion = 1;
+
   private final boolean multivalue;
   private final byte valueSerializerId;
   private final byte keySerializedId;
@@ -28,6 +34,37 @@ public final class IndexEngineData {
   private final String encryption;
   private final String encryptionOptions;
 
+  public IndexEngineData(
+      int indexId,
+      final OIndexMetadata metadata,
+      final Boolean durableInNonTxMode,
+      final byte valueSerializerId,
+      final byte keySerializedId,
+      final OType[] keyTypes,
+      final int keySize,
+      final String encryption,
+      final String encryptionOptions,
+      final Map<String, String> engineProperties) {
+    this.indexId = indexId;
+    OIndexDefinition definition = metadata.getIndexDefinition();
+    this.name = metadata.getName();
+    this.algorithm = metadata.getAlgorithm();
+    this.indexType = metadata.getType();
+    this.durableInNonTxMode = durableInNonTxMode;
+    this.version = metadata.getVersion();
+    this.multivalue = metadata.isMultivalue();
+    this.valueSerializerId = valueSerializerId;
+    this.keySerializedId = keySerializedId;
+    this.isAutomatic = definition.isAutomatic();
+    this.keyTypes = keyTypes;
+    this.nullValuesSupport = !definition.isNullValuesIgnored();
+    this.keySize = keySize;
+    this.encryption = encryption;
+    this.encryptionOptions = encryptionOptions;
+    if (engineProperties == null) this.engineProperties = null;
+    else this.engineProperties = new HashMap<>(engineProperties);
+  }
+
   public IndexEngineData(
       int indexId,
       final String name,
@@ -82,6 +119,7 @@ public String getAlgorithm() {
     return algorithm;
   }
 
+  @Deprecated
   public Boolean getDurableInNonTxMode() {
     return durableInNonTxMode;
   }
@@ -90,6 +128,7 @@ public int getVersion() {
     return version;
   }
 
+  @Deprecated
   public int getApiVersion() {
     return apiVersion;
   }

core/src/main/java/com/orientechnologies/orient/core/index/OIndexes.java

@@ -18,6 +18,7 @@
 import static com.orientechnologies.common.util.OClassLoaderHelper.lookupProviderWithOrientClassLoader;
 
 import com.orientechnologies.common.util.OCollections;
+import com.orientechnologies.orient.core.config.IndexEngineData;
 import com.orientechnologies.orient.core.exception.OConfigurationException;
 import com.orientechnologies.orient.core.index.engine.OBaseIndexEngine;
 import com.orientechnologies.orient.core.metadata.schema.OClass;
@@ -172,17 +173,18 @@ private static OIndexFactory findFactoryByAlgorithmAndType(String algorithm, Str
   }
 
   public static OBaseIndexEngine createIndexEngine(
-      int indexId,
-      final String name,
-      final String algorithm,
-      final String type,
-      final OStorage storage,
-      final int version,
-      boolean multivalue) {
-
-    final OIndexFactory factory = findFactoryByAlgorithmAndType(algorithm, type);
-
-    return factory.createIndexEngine(indexId, algorithm, name, storage, version, multivalue);
+      final OStorage storage, final IndexEngineData metadata) {
+
+    final OIndexFactory factory =
+        findFactoryByAlgorithmAndType(metadata.getAlgorithm(), metadata.getIndexType());
+
+    return factory.createIndexEngine(
+        metadata.getIndexId(),
+        metadata.getAlgorithm(),
+        metadata.getName(),
+        storage,
+        metadata.getVersion(),
+        metadata.isMultivalue());
   }
 
   public static String chooseDefaultIndexAlgorithm(String type) {

core/src/main/java/com/orientechnologies/orient/core/index/engine/OBaseIndexEngine.java

@@ -1,16 +1,12 @@
 package com.orientechnologies.orient.core.index.engine;
 
-import com.orientechnologies.common.serialization.types.OBinarySerializer;
 import com.orientechnologies.common.util.ORawPair;
 import com.orientechnologies.orient.core.config.IndexEngineData;
-import com.orientechnologies.orient.core.encryption.OEncryption;
 import com.orientechnologies.orient.core.id.ORID;
 import com.orientechnologies.orient.core.index.OIndexDefinition;
-import com.orientechnologies.orient.core.metadata.schema.OType;
 import com.orientechnologies.orient.core.record.impl.ODocument;
 import com.orientechnologies.orient.core.storage.impl.local.paginated.atomicoperations.OAtomicOperation;
 import java.io.IOException;
-import java.util.Map;
 import java.util.stream.Stream;
 
 public interface OBaseIndexEngine {
@@ -25,17 +21,7 @@ void init(
 
   void flush();
 
-  void create(
-      OAtomicOperation atomicOperation,
-      OBinarySerializer valueSerializer,
-      boolean isAutomatic,
-      OType[] keyTypes,
-      boolean nullPointerSupport,
-      OBinarySerializer keySerializer,
-      int keySize,
-      Map<String, String> engineProperties,
-      OEncryption encryption)
-      throws IOException;
+  void create(OAtomicOperation atomicOperation, IndexEngineData data) throws IOException;
 
   void load(IndexEngineData data);
 

core/src/main/java/com/orientechnologies/orient/core/index/engine/v1/OCellBTreeMultiValueIndexEngine.java

@@ -26,7 +26,6 @@
 import com.orientechnologies.orient.core.storage.index.sbtree.singlevalue.v3.CellBTreeSingleValueV3;
 import java.io.IOException;
 import java.util.List;
-import java.util.Map;
 import java.util.Spliterators;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
@@ -103,28 +102,27 @@ public String getName() {
     return name;
   }
 
-  @Override
-  public void create(
-      OAtomicOperation atomicOperation,
-      @SuppressWarnings("rawtypes") OBinarySerializer valueSerializer,
-      boolean isAutomatic,
-      OType[] keyTypes,
-      boolean nullPointerSupport,
-      @SuppressWarnings("rawtypes") OBinarySerializer keySerializer,
-      int keySize,
-      Map<String, String> engineProperties,
-      OEncryption encryption) {
+  public void create(OAtomicOperation atomicOperation, IndexEngineData data) throws IOException {
+
+    OBinarySerializer keySerializer = storage.resolveObjectSerializer(data.getKeySerializedId());
+
+    final OEncryption encryption =
+        OAbstractPaginatedStorage.loadEncryption(data.getEncryption(), data.getEncryptionOptions());
     try {
       if (mvTree != null) {
-        //noinspection unchecked
-        mvTree.create(keySerializer, keyTypes, keySize, encryption, atomicOperation);
+        mvTree.create(
+            keySerializer, data.getKeyTypes(), data.getKeySize(), encryption, atomicOperation);
       } else {
-        final OType[] sbTypes = calculateTypes(keyTypes);
+        final OType[] sbTypes = calculateTypes(data.getKeyTypes());
         assert svTree != null;
         assert nullTree != null;
 
         svTree.create(
-            atomicOperation, new CompositeKeySerializer(), sbTypes, keySize + 1, encryption);
+            atomicOperation,
+            new CompositeKeySerializer(),
+            sbTypes,
+            data.getKeySize() + 1,
+            encryption);
         nullTree.create(
             atomicOperation, OCompactedLinkSerializer.INSTANCE, new OType[] {OType.LINK}, 1, null);
       }

core/src/main/java/com/orientechnologies/orient/core/index/engine/v1/OCellBTreeSingleValueIndexEngine.java

@@ -21,7 +21,6 @@
 import com.orientechnologies.orient.core.storage.index.versionmap.OVersionPositionMap;
 import com.orientechnologies.orient.core.storage.index.versionmap.OVersionPositionMapV0;
 import java.io.IOException;
-import java.util.Map;
 import java.util.stream.Stream;
 
 public final class OCellBTreeSingleValueIndexEngine
@@ -78,20 +77,16 @@ public String getName() {
     return name;
   }
 
-  @Override
-  public void create(
-      OAtomicOperation atomicOperation,
-      OBinarySerializer valueSerializer,
-      boolean isAutomatic,
-      OType[] keyTypes,
-      boolean nullPointerSupport,
-      OBinarySerializer keySerializer,
-      int keySize,
-      Map<String, String> engineProperties,
-      OEncryption encryption) {
+  public void create(OAtomicOperation atomicOperation, IndexEngineData data) throws IOException {
+
+    OBinarySerializer keySerializer = storage.resolveObjectSerializer(data.getKeySerializedId());
+
+    final OEncryption encryption =
+        OAbstractPaginatedStorage.loadEncryption(data.getEncryption(), data.getEncryptionOptions());
+
     try {
-      //noinspection unchecked
-      sbTree.create(atomicOperation, keySerializer, keyTypes, keySize, encryption);
+      sbTree.create(
+          atomicOperation, keySerializer, data.getKeyTypes(), data.getKeySize(), encryption);
       versionPositionMap.create(atomicOperation);
     } catch (IOException e) {
       throw OException.wrapException(new OIndexException("Error of creation of index " + name), e);

core/src/main/java/com/orientechnologies/orient/core/sharding/auto/OAutoShardingIndexEngine.java

@@ -36,7 +36,6 @@
 import com.orientechnologies.orient.core.index.engine.IndexEngineValuesTransformer;
 import com.orientechnologies.orient.core.index.engine.OIndexEngine;
 import com.orientechnologies.orient.core.iterator.OEmptyIterator;
-import com.orientechnologies.orient.core.metadata.schema.OType;
 import com.orientechnologies.orient.core.record.impl.ODocument;
 import com.orientechnologies.orient.core.storage.impl.local.OAbstractPaginatedStorage;
 import com.orientechnologies.orient.core.storage.impl.local.paginated.atomicoperations.OAtomicOperation;
@@ -48,6 +47,7 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -99,30 +99,25 @@ public OAutoShardingStrategy getStrategy() {
     return strategy;
   }
 
-  @Override
-  public void create(
-      OAtomicOperation atomicOperation,
-      final OBinarySerializer valueSerializer,
-      final boolean isAutomatic,
-      final OType[] keyTypes,
-      final boolean nullPointerSupport,
-      final OBinarySerializer keySerializer,
-      final int keySize,
-      final Map<String, String> engineProperties,
-      OEncryption encryption) {
+  public void create(OAtomicOperation atomicOperation, IndexEngineData data) throws IOException {
+
+    OBinarySerializer valueSerializer =
+        storage.resolveObjectSerializer(data.getValueSerializerId());
+    OBinarySerializer keySerializer = storage.resolveObjectSerializer(data.getKeySerializedId());
+
+    final OEncryption encryption =
+        OAbstractPaginatedStorage.loadEncryption(data.getEncryption(), data.getEncryptionOptions());
 
     this.strategy = new OAutoShardingMurmurStrategy(keySerializer);
 
     final OHashFunction<Object> hashFunction;
 
     if (encryption != null) {
-      //noinspection unchecked
       hashFunction = new OSHA256HashFunction<>(keySerializer);
     } else {
-      //noinspection unchecked
       hashFunction = new OMurmurHash3HashFunction<>(keySerializer);
     }
-
+    Map<String, String> engineProperties = data.getEngineProperties();
     final String partitionsProperty = engineProperties.get("partitions");
     if (partitionsProperty != null) {
       try {
@@ -132,23 +127,22 @@ public void create(
             .error(
                 this, "Invalid value of 'partitions' property : `" + partitionsProperty + "`", e);
       }
+      engineProperties = new HashMap<>();
+      engineProperties.put("partitions", String.valueOf(partitionSize));
     }
 
-    engineProperties.put("partitions", String.valueOf(partitionSize));
-
     init();
 
     try {
       for (OHashTable<Object, Object> p : partitions) {
-        //noinspection unchecked
         p.create(
             atomicOperation,
             keySerializer,
             valueSerializer,
-            keyTypes,
+            data.getKeyTypes(),
             encryption,
             hashFunction,
-            nullPointerSupport);
+            data.isNullValuesSupport());
       }
     } catch (IOException e) {
       throw OException.wrapException(