Cleanup around IndexDescriptor

community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundPlanContext.scala

@@ -29,7 +29,6 @@ import org.neo4j.internal.kernel.api.exceptions.KernelException
 import org.neo4j.internal.kernel.api.{IndexReference, InternalIndexState}
 import org.neo4j.kernel.api.schema.SchemaDescriptorFactory
 import org.neo4j.kernel.api.schema.constaints.ConstraintDescriptor
-import org.neo4j.kernel.api.schema.index.{IndexDescriptor => KernelIndexDescriptor}
 import org.neo4j.kernel.impl.transaction.log.TransactionIdStore
 
 import scala.collection.JavaConverters._

community/kernel/src/main/java/org/neo4j/kernel/api/index/IndexPopulator.java

@@ -24,7 +24,7 @@
 
 import org.neo4j.internal.kernel.api.InternalIndexState;
 import org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException;
-import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+import org.neo4j.kernel.api.schema.index.StoreIndexDescriptor;
 import org.neo4j.kernel.impl.api.index.UpdateMode;
 import org.neo4j.kernel.impl.api.index.updater.SwallowingIndexUpdater;
 import org.neo4j.storageengine.api.schema.IndexSample;
@@ -107,19 +107,19 @@ void add( Collection<? extends IndexEntryUpdate<?>> updates )
      * Close this populator and releases any resources related to it.
      * If {@code populationCompletedSuccessfully} is {@code true} then it must mark this index
      * as {@link InternalIndexState#ONLINE} so that future invocations of its parent
-     * {@link IndexProvider#getInitialState(long, IndexDescriptor)} also returns {@link InternalIndexState#ONLINE}.
+     * {@link IndexProvider#getInitialState(StoreIndexDescriptor)} also returns {@link InternalIndexState#ONLINE}.
      *
      * @param populationCompletedSuccessfully {@code true} if the index population was successful, where the index should
      * be marked as {@link InternalIndexState#ONLINE}, otherwise {@code false} where index should be marked as
      * {@link InternalIndexState#FAILED} and the failure, previously handed to this populator using {@link #markAsFailed(String)}
-     * should be stored and made available for later requests from {@link IndexProvider#getPopulationFailure(long, IndexDescriptor)}.
+     * should be stored and made available for later requests from {@link IndexProvider#getPopulationFailure(StoreIndexDescriptor)}.
      * @throws IOException on I/O error.
      */
     void close( boolean populationCompletedSuccessfully ) throws IOException;
 
     /**
      * Called then a population failed. The failure string should be stored for future retrieval by
-     * {@link IndexProvider#getPopulationFailure(long, IndexDescriptor)}. Called before {@link #close(boolean)}
+     * {@link IndexProvider#getPopulationFailure(StoreIndexDescriptor)}. Called before {@link #close(boolean)}
      * if there was a failure during population.
      *
      * @param failure the description of the failure.

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/IndexingService.java

@@ -125,7 +125,7 @@ public interface Monitor
 
         void indexPopulationScanComplete();
 
-        void awaitingPopulationOfRecoveredIndex( long indexId, IndexDescriptor descriptor );
+        void awaitingPopulationOfRecoveredIndex( StoreIndexDescriptor descriptor );
     }
 
     public static class MonitorAdapter implements Monitor
@@ -151,7 +151,7 @@ public void indexPopulationScanComplete()
         }
 
         @Override
-        public void awaitingPopulationOfRecoveredIndex( long indexId, IndexDescriptor descriptor )
+        public void awaitingPopulationOfRecoveredIndex( StoreIndexDescriptor descriptor )
         {   // Do nothing
         }
     }
@@ -326,7 +326,7 @@ public void start()
                                 "What? This index was seen during recovery just now, why isn't it available now?", e );
                     }
 
-                    monitor.awaitingPopulationOfRecoveredIndex( indexId, descriptor.getIndexDescriptor() );
+                    monitor.awaitingPopulationOfRecoveredIndex( descriptor.getIndexDescriptor() );
                     awaitOnline( proxy );
                 } );
 

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/sampling/IndexSamplingController.java

@@ -26,7 +26,7 @@
 
 import org.neo4j.collection.PrimitiveLongCollections;
 import org.neo4j.internal.kernel.api.InternalIndexState;
-import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+import org.neo4j.kernel.api.schema.index.StoreIndexDescriptor;
 import org.neo4j.kernel.impl.api.index.IndexMap;
 import org.neo4j.kernel.impl.api.index.IndexMapSnapshotProvider;
 import org.neo4j.kernel.impl.api.index.IndexProxy;
@@ -92,7 +92,7 @@ public void recoverIndexSamples()
             while ( indexIds.hasNext() )
             {
                 long indexId = indexIds.next();
-                if ( indexRecoveryCondition.test( indexId, indexMap.getIndexProxy( indexId ).getDescriptor() ) )
+                if ( indexRecoveryCondition.test( indexMap.getIndexProxy( indexId ).getDescriptor() ) )
                 {
                     sampleIndexOnCurrentThread( indexMap, indexId );
                 }
@@ -106,7 +106,7 @@ public void recoverIndexSamples()
 
     public interface RecoveryCondition
     {
-        boolean test( long indexId, IndexDescriptor descriptor );
+        boolean test( StoreIndexDescriptor descriptor );
     }
 
     private void scheduleSampling( IndexSamplingMode mode, IndexMap indexMap )

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/sampling/IndexSamplingControllerFactory.java

@@ -22,7 +22,7 @@
 import java.util.function.Predicate;
 
 import org.neo4j.internal.kernel.api.TokenNameLookup;
-import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+import org.neo4j.kernel.api.schema.index.StoreIndexDescriptor;
 import org.neo4j.kernel.impl.api.index.IndexMapSnapshotProvider;
 import org.neo4j.kernel.impl.api.index.IndexStoreView;
 import org.neo4j.scheduler.JobScheduler;
@@ -92,9 +92,9 @@ private IndexSamplingController.RecoveryCondition createIndexRecoveryCondition(
             private final DoubleLongRegister register = newDoubleLongRegister();
 
             @Override
-            public boolean test( long indexId, IndexDescriptor descriptor )
+            public boolean test( StoreIndexDescriptor descriptor )
             {
-                boolean result = storeView.indexSample( indexId, register ).readSecond() == 0;
+                boolean result = storeView.indexSample( descriptor.getId(), register ).readSecond() == 0;
                 if ( result )
                 {
                     log.debug( "Recovering index sampling for index %s",

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/DeferredConflictCheckingIndexUpdater.java

@@ -62,14 +62,14 @@ public class DeferredConflictCheckingIndexUpdater implements IndexUpdater
 {
     private final IndexUpdater actual;
     private final Supplier<IndexReader> readerSupplier;
-    private final IndexDescriptor schemaIndexDescriptor;
+    private final IndexDescriptor indexDescriptor;
     private final Set<ValueTuple> touchedTuples = new HashSet<>();
 
-    public DeferredConflictCheckingIndexUpdater( IndexUpdater actual, Supplier<IndexReader> readerSupplier, IndexDescriptor schemaIndexDescriptor )
+    public DeferredConflictCheckingIndexUpdater( IndexUpdater actual, Supplier<IndexReader> readerSupplier, IndexDescriptor indexDescriptor )
     {
         this.actual = actual;
         this.readerSupplier = readerSupplier;
-        this.schemaIndexDescriptor = schemaIndexDescriptor;
+        this.indexDescriptor = indexDescriptor;
     }
 
     @Override
@@ -113,7 +113,7 @@ public void close() throws IOException, IndexEntryConflictException
     private IndexQuery[] queryOf( ValueTuple tuple )
     {
         IndexQuery[] predicates = new IndexQuery[tuple.size()];
-        int[] propertyIds = schemaIndexDescriptor.schema().getPropertyIds();
+        int[] propertyIds = indexDescriptor.schema().getPropertyIds();
         for ( int i = 0; i < predicates.length; i++ )
         {
             predicates[i] = exact( propertyIds[i], tuple.valueAt( i ) );

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/AllStoreHolder.java

@@ -242,11 +242,8 @@ long graphPropertiesReference()
     @Override
     IndexReader indexReader( IndexReference index, boolean fresh ) throws IndexNotFoundKernelException
     {
-        IndexDescriptor schemaIndexDescriptor = index.isUnique() ?
-                                                IndexDescriptorFactory.uniqueForLabel( index.label(), index.properties() ) :
-                                                IndexDescriptorFactory.forLabel( index.label(), index.properties() );
-        return fresh ? storageReader.getFreshIndexReader( schemaIndexDescriptor ) :
-               storageReader.getIndexReader( schemaIndexDescriptor );
+        return fresh ? storageReader.getFreshIndexReader( (IndexDescriptor) index ) :
+               storageReader.getIndexReader( (IndexDescriptor) index );
     }
 
     @Override
@@ -559,14 +556,14 @@ Long indexGetOwningUniquenessConstraintId( IndexDescriptor index )
     IndexDescriptor indexGetForSchema( SchemaDescriptor descriptor )
     {
         IndexDescriptor indexDescriptor = storageReader.indexGetForSchema( descriptor );
-        Iterator<IndexDescriptor> rules = iterator( indexDescriptor );
+        Iterator<IndexDescriptor> indexes = iterator( indexDescriptor );
         if ( ktx.hasTxStateWithChanges() )
         {
-            rules = filter(
+            indexes = filter(
                     SchemaDescriptor.equalTo( descriptor ),
-                    ktx.txState().indexDiffSetsByLabel( descriptor.keyId() ).apply( rules ) );
+                    ktx.txState().indexDiffSetsByLabel( descriptor.keyId() ).apply( indexes ) );
         }
-        return singleOrNull( rules );
+        return singleOrNull( indexes );
     }
 
     private boolean checkIndexState( IndexDescriptor index, ReadableDiffSets<IndexDescriptor> diffSet )

community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageReader.java

@@ -297,11 +297,11 @@ public Iterator<CapableIndexDescriptor> indexesGetRelatedToProperty( int propert
     @Override
     public Long indexGetOwningUniquenessConstraintId( IndexDescriptor index )
     {
-        StoreIndexDescriptor rule = indexRule( index );
-        if ( rule != null )
+        StoreIndexDescriptor storeIndexDescriptor = getStoreIndexDescriptor( index );
+        if ( storeIndexDescriptor != null )
         {
             // Think of the index as being orphaned if the owning constraint is missing or broken.
-            Long owningConstraint = rule.getOwningConstraint();
+            Long owningConstraint = storeIndexDescriptor.getOwningConstraint();
             return schemaCache.hasConstraintRule( owningConstraint ) ? owningConstraint : null;
         }
         return null;
@@ -311,12 +311,12 @@ public Long indexGetOwningUniquenessConstraintId( IndexDescriptor index )
     public long indexGetCommittedId( IndexDescriptor index )
             throws SchemaRuleNotFoundException
     {
-        StoreIndexDescriptor rule = indexRule( index );
-        if ( rule == null )
+        StoreIndexDescriptor storeIndexDescriptor = getStoreIndexDescriptor( index );
+        if ( storeIndexDescriptor == null )
         {
             throw new SchemaRuleNotFoundException( SchemaRule.Kind.INDEX_RULE, index.schema() );
         }
-        return rule.getId();
+        return storeIndexDescriptor.getId();
     }
 
     @Override
@@ -671,13 +671,13 @@ public void degrees( NodeItem nodeItem, DegreeVisitor visitor )
         }
     }
 
-    private StoreIndexDescriptor indexRule( IndexDescriptor index )
+    private StoreIndexDescriptor getStoreIndexDescriptor( IndexDescriptor index )
     {
-        for ( StoreIndexDescriptor rule : schemaCache.indexRules() )
+        for ( StoreIndexDescriptor descriptor : schemaCache.indexRules() )
         {
-            if ( rule.equals( index ) )
+            if ( descriptor.equals( index ) )
             {
-                return rule;
+                return descriptor;
             }
         }
 

community/kernel/src/main/java/org/neo4j/kernel/impl/store/SchemaStorage.java

@@ -56,17 +56,17 @@ public SchemaStorage( RecordStore<DynamicRecord> schemaStore )
      */
     public StoreIndexDescriptor indexGetForSchema( final IndexDescriptor descriptor )
     {
-        Iterator<StoreIndexDescriptor> rules = loadAllSchemaRules( descriptor::equals, StoreIndexDescriptor.class, false );
+        Iterator<StoreIndexDescriptor> indexes = loadAllSchemaRules( descriptor::equals, StoreIndexDescriptor.class, false );
 
         StoreIndexDescriptor foundRule = null;
 
-        while ( rules.hasNext() )
+        while ( indexes.hasNext() )
         {
-            StoreIndexDescriptor candidate = rules.next();
+            StoreIndexDescriptor candidate = indexes.next();
             if ( foundRule != null )
             {
                 throw new IllegalStateException( String.format(
-                        "Found more than one matching index rule, %s and %s", foundRule, candidate ) );
+                        "Found more than one matching index, %s and %s", foundRule, candidate ) );
             }
             foundRule = candidate;
         }

community/kernel/src/main/java/org/neo4j/kernel/impl/store/record/SchemaRuleSerialization.java

@@ -120,21 +120,20 @@ public static SchemaRule deserialize( long id, ByteBuffer source ) throws Malfor
     /**
      * Serialize the provided IndexRule onto the target buffer
      *
-     * @param indexRule the IndexRule to serialize
-     * @throws IllegalStateException if the IndexRule is of type unique, but the owning constrain has not been set
+     * @param indexDescriptor the StoreIndexDescriptor to serialize
+     * @throws IllegalStateException if the StoreIndexDescriptor is of type unique, but the owning constrain has not been set
      */
-    public static byte[] serialize( StoreIndexDescriptor indexRule )
+    public static byte[] serialize( StoreIndexDescriptor indexDescriptor )
     {
-        ByteBuffer target = ByteBuffer.allocate( lengthOf( indexRule ) );
+        ByteBuffer target = ByteBuffer.allocate( lengthOf( indexDescriptor ) );
         target.putInt( LEGACY_LABEL_OR_REL_TYPE_ID );
         target.put( INDEX_RULE );
 
-        IndexProvider.Descriptor providerDescriptor = indexRule.providerDescriptor();
+        IndexProvider.Descriptor providerDescriptor = indexDescriptor.providerDescriptor();
         UTF8.putEncodedStringInto( providerDescriptor.getKey(), target );
         UTF8.putEncodedStringInto( providerDescriptor.getVersion(), target );
 
-        IndexDescriptor schemaIndexDescriptor = indexRule;
-        switch ( schemaIndexDescriptor.type() )
+        switch ( indexDescriptor.type() )
         {
         case GENERAL:
             target.put( GENERAL_INDEX );
@@ -144,17 +143,17 @@ public static byte[] serialize( StoreIndexDescriptor indexRule )
             target.put( UNIQUE_INDEX );
 
             // The owning constraint can be null. See IndexRule.getOwningConstraint()
-            Long owningConstraint = indexRule.getOwningConstraint();
+            Long owningConstraint = indexDescriptor.getOwningConstraint();
             target.putLong( owningConstraint == null ? NO_OWNING_CONSTRAINT_YET : owningConstraint );
             break;
 
         default:
             throw new UnsupportedOperationException( format( "Got unknown index descriptor type '%s'.",
-                    schemaIndexDescriptor.type() ) );
+                    indexDescriptor.type() ) );
         }
 
-        schemaIndexDescriptor.schema().processWith( new SchemaDescriptorSerializer( target ) );
-        UTF8.putEncodedStringInto( indexRule.getName(), target );
+        indexDescriptor.schema().processWith( new SchemaDescriptorSerializer( target ) );
+        UTF8.putEncodedStringInto( indexDescriptor.getName(), target );
         return target.array();
     }
 
@@ -198,27 +197,26 @@ public static byte[] serialize( ConstraintRule constraintRule )
 
     /**
      * Compute the byte size needed to serialize the provided IndexRule using serialize.
-     * @param indexRule the IndexRule
-     * @return the byte size of indexRule
+     * @param indexDescriptor the StoreIndexDescriptor
+     * @return the byte size of StoreIndexDescriptor
      */
-    public static int lengthOf( StoreIndexDescriptor indexRule )
+    public static int lengthOf( StoreIndexDescriptor indexDescriptor )
     {
         int length = 4; // legacy label or relType id
         length += 1;    // schema rule type
 
-        IndexProvider.Descriptor providerDescriptor = indexRule.providerDescriptor();
+        IndexProvider.Descriptor providerDescriptor = indexDescriptor.providerDescriptor();
         length += UTF8.computeRequiredByteBufferSize( providerDescriptor.getKey() );
         length += UTF8.computeRequiredByteBufferSize( providerDescriptor.getVersion() );
 
         length += 1; // index type
-        IndexDescriptor schemaIndexDescriptor = indexRule;
-        if ( schemaIndexDescriptor.type() == IndexDescriptor.Type.UNIQUE )
+        if ( indexDescriptor.type() == IndexDescriptor.Type.UNIQUE )
         {
             length += 8; // owning constraint id
         }
 
-        length += schemaIndexDescriptor.schema().computeWith( schemaSizeComputer );
-        length += UTF8.computeRequiredByteBufferSize( indexRule.getName() );
+        length += indexDescriptor.schema().computeWith( schemaSizeComputer );
+        length += UTF8.computeRequiredByteBufferSize( indexDescriptor.getName() );
         return length;
     }
 

community/kernel/src/main/java/org/neo4j/unsafe/batchinsert/internal/BatchInserterImpl.java

@@ -599,38 +599,38 @@ public ConstraintCreator createDeferredConstraint( Label label )
         return new BaseNodeConstraintCreator( new BatchSchemaActions(), label );
     }
 
-    private void createUniqueIndexAndOwningConstraint( IndexDescriptor schemaIndexDescriptor,
+    private void createUniqueIndexAndOwningConstraint( IndexDescriptor indexDescriptor,
             IndexBackedConstraintDescriptor constraintDescriptor )
     {
         // TODO: Do not create duplicate index
 
-        long indexRuleId = schemaStore.nextId();
+        long indexId = schemaStore.nextId();
         long constraintRuleId = schemaStore.nextId();
 
-        StoreIndexDescriptor indexRule =
+        StoreIndexDescriptor storeIndexDescriptor =
                 StoreIndexDescriptor.constraintIndexRule(
-                        indexRuleId,
-                        schemaIndexDescriptor,
+                        indexId,
+                        indexDescriptor,
                         this.indexProviderMap.getDefaultProvider().getProviderDescriptor(),
                         constraintRuleId
                 );
         ConstraintRule constraintRule =
                 ConstraintRule.constraintRule(
                         constraintRuleId,
                         constraintDescriptor,
-                        indexRuleId
+                        indexId
                 );
 
         for ( DynamicRecord record : schemaStore.allocateFrom( constraintRule ) )
         {
             schemaStore.updateRecord( record );
         }
         schemaCache.addSchemaRule( constraintRule );
-        for ( DynamicRecord record : schemaStore.allocateFrom( indexRule ) )
+        for ( DynamicRecord record : schemaStore.allocateFrom( storeIndexDescriptor ) )
         {
             schemaStore.updateRecord( record );
         }
-        schemaCache.addSchemaRule( indexRule );
+        schemaCache.addSchemaRule( storeIndexDescriptor );
         labelsTouched = true;
         flushStrategy.forceFlush();
     }

community/kernel/src/test/java/org/neo4j/kernel/impl/api/index/IndexingServiceTest.java

@@ -797,11 +797,11 @@ public void shouldWaitForRecoveredUniquenessConstraintIndexesToBeFullyPopulated(
         IndexingService.Monitor monitor = new IndexingService.MonitorAdapter()
         {
             @Override
-            public void awaitingPopulationOfRecoveredIndex( long index, IndexDescriptor descriptor )
+            public void awaitingPopulationOfRecoveredIndex( StoreIndexDescriptor descriptor )
             {
                 // When we see that we start to await the index to populate, notify the slow-as-heck
                 // populator that it can actually go and complete its job.
-                indexId.set( index );
+                indexId.set( descriptor.getId() );
                 latch.startAndWaitForAllToStart();
             }
         };