Rename

SchemaIndexDescriptor => PendingIndexDescriptor
IndexRule => IndexDescriptor
SchemaIndexDescriptorFactory => IndexDescriptorFactor

community/consistency-check/src/main/java/org/neo4j/consistency/checking/SchemaRecordCheck.java

@@ -32,7 +32,7 @@
 import org.neo4j.kernel.impl.store.SchemaRuleAccess;
 import org.neo4j.kernel.impl.store.record.ConstraintRule;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 import org.neo4j.kernel.impl.store.record.LabelTokenRecord;
 import org.neo4j.kernel.impl.store.record.PropertyKeyTokenRecord;
 import org.neo4j.kernel.impl.store.record.RelationshipTypeTokenRecord;
@@ -107,9 +107,9 @@ public void check( DynamicRecord record,
                 return;
             }
 
-            if ( rule instanceof IndexRule )
+            if ( rule instanceof IndexDescriptor )
             {
-                strategy.checkIndexRule( (IndexRule)rule, record, records, engine );
+                strategy.checkIndexRule( (IndexDescriptor)rule, record, records, engine );
             }
             else if ( rule instanceof ConstraintRule )
             {
@@ -124,8 +124,8 @@ else if ( rule instanceof ConstraintRule )
 
     private interface CheckStrategy
     {
-        void checkIndexRule( IndexRule rule, DynamicRecord record, RecordAccess records,
-                CheckerEngine<DynamicRecord,ConsistencyReport.SchemaConsistencyReport> engine );
+        void checkIndexRule( IndexDescriptor rule, DynamicRecord record, RecordAccess records,
+                             CheckerEngine<DynamicRecord,ConsistencyReport.SchemaConsistencyReport> engine );
 
         void checkConstraintRule( ConstraintRule rule, DynamicRecord record,
                 RecordAccess records, CheckerEngine<DynamicRecord,ConsistencyReport.SchemaConsistencyReport> engine );
@@ -138,8 +138,8 @@ void checkConstraintRule( ConstraintRule rule, DynamicRecord record,
     private class RulesCheckStrategy implements CheckStrategy
     {
         @Override
-        public void checkIndexRule( IndexRule rule, DynamicRecord record, RecordAccess records,
-                CheckerEngine<DynamicRecord,ConsistencyReport.SchemaConsistencyReport> engine )
+        public void checkIndexRule( IndexDescriptor rule, DynamicRecord record, RecordAccess records,
+                                    CheckerEngine<DynamicRecord,ConsistencyReport.SchemaConsistencyReport> engine )
         {
             checkSchema( rule, record, records, engine );
 
@@ -176,8 +176,8 @@ public void checkConstraintRule( ConstraintRule rule, DynamicRecord record,
     private class ObligationsCheckStrategy implements CheckStrategy
     {
         @Override
-        public void checkIndexRule( IndexRule rule, DynamicRecord record, RecordAccess records,
-                CheckerEngine<DynamicRecord,ConsistencyReport.SchemaConsistencyReport> engine )
+        public void checkIndexRule( IndexDescriptor rule, DynamicRecord record, RecordAccess records,
+                                    CheckerEngine<DynamicRecord,ConsistencyReport.SchemaConsistencyReport> engine )
         {
             if ( rule.canSupportUniqueConstraint() )
             {

community/consistency-check/src/main/java/org/neo4j/consistency/checking/full/ConsistencyCheckTasks.java

@@ -48,7 +48,7 @@
 import org.neo4j.kernel.impl.store.SchemaStorage;
 import org.neo4j.kernel.impl.store.StoreAccess;
 import org.neo4j.kernel.impl.store.record.AbstractBaseRecord;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 
 import static java.lang.String.format;
 import static org.neo4j.consistency.checking.full.MultiPassStore.ARRAYS;
@@ -190,7 +190,7 @@ public List<ConsistencyCheckerTask> createTasksForFullCheck( boolean checkLabelS
         if ( checkIndexes )
         {
             tasks.add( new IndexDirtyCheckTask() );
-            for ( IndexRule indexRule : indexes.onlineRules() )
+            for ( IndexDescriptor indexRule : indexes.onlineRules() )
             {
                 tasks.add( recordScanner( format( "Index_%d", indexRule.getId() ),
                         new IndexIterator( indexes.accessorFor( indexRule ) ),
@@ -258,7 +258,7 @@ private class IndexDirtyCheckTask extends ConsistencyCheckerTask
         @Override
         public void run()
         {
-            for ( IndexRule indexRule : indexes.onlineRules() )
+            for ( IndexDescriptor indexRule : indexes.onlineRules() )
             {
                 if ( indexes.accessorFor( indexRule ).isDirty() )
                 {

community/consistency-check/src/main/java/org/neo4j/consistency/checking/full/IndexCheck.java

@@ -24,13 +24,13 @@
 import org.neo4j.consistency.report.ConsistencyReport;
 import org.neo4j.consistency.store.RecordAccess;
 import org.neo4j.consistency.store.synthetic.IndexEntry;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 
 public class IndexCheck implements RecordCheck<IndexEntry, ConsistencyReport.IndexConsistencyReport>
 {
-    private final IndexRule indexRule;
+    private final IndexDescriptor indexRule;
 
-    public IndexCheck( IndexRule indexRule )
+    public IndexCheck( IndexDescriptor indexRule )
     {
         this.indexRule = indexRule;
     }

community/consistency-check/src/main/java/org/neo4j/consistency/checking/full/PropertyAndNodeIndexedCheck.java

@@ -42,7 +42,7 @@
 import org.neo4j.internal.kernel.api.schema.SchemaDescriptor;
 import org.neo4j.kernel.api.exceptions.index.IndexNotApplicableKernelException;
 import org.neo4j.kernel.impl.api.LookupFilter;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 import org.neo4j.kernel.impl.store.record.NodeRecord;
 import org.neo4j.kernel.impl.store.record.PropertyBlock;
 import org.neo4j.kernel.impl.store.record.PropertyRecord;
@@ -95,7 +95,7 @@ private void matchIndexesToNode(
     {
         Set<Long> labels = NodeLabelReader.getListOfLabels( record, records, engine );
         IntObjectMap<PropertyBlock> nodePropertyMap = null;
-        for ( IndexRule indexRule : indexes.onlineRules() )
+        for ( IndexDescriptor indexRule : indexes.onlineRules() )
         {
             long labelId = indexRule.schema().keyId();
             if ( labels.contains( labelId ) )
@@ -129,7 +129,7 @@ private void matchIndexesToNode(
     }
 
     private void verifyNodeCorrectlyIndexedUniquely( long nodeId, Value[] propertyValues,
-            CheckerEngine<NodeRecord,ConsistencyReport.NodeConsistencyReport> engine, IndexRule indexRule,
+            CheckerEngine<NodeRecord,ConsistencyReport.NodeConsistencyReport> engine, IndexDescriptor indexRule,
             IndexReader reader )
     {
         IndexQuery[] query = seek( indexRule.schema(), propertyValues );
@@ -155,7 +155,9 @@ private void verifyNodeCorrectlyIndexedUniquely( long nodeId, Value[] propertyVa
     }
 
     private void reportIncorrectIndexCount( Value[] propertyValues,
-            CheckerEngine<NodeRecord,ConsistencyReport.NodeConsistencyReport> engine, IndexRule indexRule, long count )
+                                            CheckerEngine<NodeRecord,ConsistencyReport.NodeConsistencyReport> engine,
+                                            IndexDescriptor indexRule,
+                                            long count )
     {
         if ( count == 0 )
         {

community/consistency-check/src/main/java/org/neo4j/consistency/checking/index/IndexAccessors.java

@@ -37,19 +37,19 @@
 import org.neo4j.kernel.impl.store.RecordStore;
 import org.neo4j.kernel.impl.store.SchemaStorage;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 
 public class IndexAccessors implements Closeable
 {
     private final MutableLongObjectMap<IndexAccessor> accessors = new LongObjectHashMap<>();
-    private final List<IndexRule> onlineIndexRules = new ArrayList<>();
-    private final List<IndexRule> notOnlineIndexRules = new ArrayList<>();
+    private final List<IndexDescriptor> onlineIndexRules = new ArrayList<>();
+    private final List<IndexDescriptor> notOnlineIndexRules = new ArrayList<>();
 
     public IndexAccessors( IndexProviderMap providers,
                            RecordStore<DynamicRecord> schemaStore,
                            IndexSamplingConfig samplingConfig ) throws IOException
     {
-        Iterator<IndexRule> rules = new SchemaStorage( schemaStore ).indexesGetAll();
+        Iterator<IndexDescriptor> rules = new SchemaStorage( schemaStore ).indexesGetAll();
         for (; ; )
         {
             try
@@ -59,7 +59,7 @@ public IndexAccessors( IndexProviderMap providers,
                     // we intentionally only check indexes that are online since
                     // - populating indexes will be rebuilt on next startup
                     // - failed indexes have to be dropped by the user anyways
-                    IndexRule indexRule = rules.next();
+                    IndexDescriptor indexRule = rules.next();
                     if ( indexRule.isIndexWithoutOwningConstraint() )
                     {
                         notOnlineIndexRules.add( indexRule );
@@ -88,30 +88,30 @@ public IndexAccessors( IndexProviderMap providers,
             }
         }
 
-        for ( IndexRule indexRule : onlineIndexRules )
+        for ( IndexDescriptor indexRule : onlineIndexRules )
         {
             long indexId = indexRule.getId();
             accessors.put( indexId, provider( providers, indexRule )
                     .getOnlineAccessor( indexId, indexRule, samplingConfig ) );
         }
     }
 
-    private IndexProvider provider( IndexProviderMap providers, IndexRule indexRule )
+    private IndexProvider provider( IndexProviderMap providers, IndexDescriptor indexRule )
     {
         return providers.apply( indexRule.providerDescriptor() );
     }
 
-    public Collection<IndexRule> notOnlineRules()
+    public Collection<IndexDescriptor> notOnlineRules()
     {
         return notOnlineIndexRules;
     }
 
-    public IndexAccessor accessorFor( IndexRule indexRule )
+    public IndexAccessor accessorFor( IndexDescriptor indexRule )
     {
         return accessors.get( indexRule.getId() );
     }
 
-    public Iterable<IndexRule> onlineRules()
+    public Iterable<IndexDescriptor> onlineRules()
     {
         return onlineIndexRules;
     }

community/consistency-check/src/main/java/org/neo4j/consistency/report/ConsistencyReport.java

@@ -31,7 +31,7 @@
 import org.neo4j.consistency.store.synthetic.LabelScanDocument;
 import org.neo4j.kernel.impl.annotations.Documented;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 import org.neo4j.kernel.impl.store.record.LabelTokenRecord;
 import org.neo4j.kernel.impl.store.record.NeoStoreRecord;
 import org.neo4j.kernel.impl.store.record.NodeRecord;
@@ -194,13 +194,13 @@ interface NodeConsistencyReport extends PrimitiveConsistencyReport
         void dynamicRecordChainCycle( DynamicRecord nextRecord );
 
         @Documented( "This node was not found in the expected index." )
-        void notIndexed( IndexRule index, Object[] propertyValues );
+        void notIndexed( IndexDescriptor index, Object[] propertyValues );
 
         @Documented( "This node was found in the expected index, although multiple times" )
-        void indexedMultipleTimes( IndexRule index, Object[] propertyValues, long count );
+        void indexedMultipleTimes( IndexDescriptor index, Object[] propertyValues, long count );
 
         @Documented( "There is another node in the unique index with the same property value(s)." )
-        void uniqueIndexNotUnique( IndexRule index, Object[] propertyValues, long duplicateNodeId );
+        void uniqueIndexNotUnique( IndexDescriptor index, Object[] propertyValues, long duplicateNodeId );
 
         @Documented( "The referenced relationship group record is not in use." )
         void relationshipGroupNotInUse( RelationshipGroupRecord group );

community/consistency-check/src/main/java/org/neo4j/consistency/store/synthetic/IndexRecord.java

@@ -20,13 +20,13 @@
 package org.neo4j.consistency.store.synthetic;
 
 import org.neo4j.kernel.impl.store.record.AbstractBaseRecord;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 
 public class IndexRecord extends AbstractBaseRecord
 {
-    private final IndexRule indexRule;
+    private final IndexDescriptor indexRule;
 
-    public IndexRecord( IndexRule indexRule )
+    public IndexRecord( IndexDescriptor indexRule )
     {
         super( indexRule.getId() );
         this.indexRule = indexRule;

community/consistency-check/src/test/java/org/neo4j/consistency/checking/SchemaRecordCheckTest.java

@@ -29,7 +29,7 @@
 import org.neo4j.kernel.impl.store.SchemaStorage;
 import org.neo4j.kernel.impl.store.record.ConstraintRule;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
-import org.neo4j.kernel.impl.store.record.IndexRule;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 import org.neo4j.kernel.impl.store.record.LabelTokenRecord;
 import org.neo4j.kernel.impl.store.record.PropertyKeyTokenRecord;
 import org.neo4j.storageengine.api.schema.SchemaRule;
@@ -88,7 +88,7 @@ public void shouldReportInvalidLabelReferences() throws Exception
 
         DynamicRecord record = inUse( dynamicRecord( schemaRuleId ) );
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
-        IndexRule rule = indexRule( schemaRuleId, labelId, propertyKeyId, providerDescriptor );
+        IndexDescriptor rule = indexRule( schemaRuleId, labelId, propertyKeyId, providerDescriptor );
         when( checker().ruleAccess.loadSingleSchemaRule( schemaRuleId ) ).thenReturn( rule );
 
         LabelTokenRecord labelTokenRecord = add( notInUse( new LabelTokenRecord( labelId ) ) );
@@ -109,7 +109,7 @@ public void shouldReportInvalidPropertyReferenceFromIndexRule() throws Exception
 
         DynamicRecord record = inUse( dynamicRecord( schemaRuleId ) );
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
-        IndexRule rule = indexRule( schemaRuleId, labelId, propertyKeyId, providerDescriptor );
+        IndexDescriptor rule = indexRule( schemaRuleId, labelId, propertyKeyId, providerDescriptor );
         when( checker().ruleAccess.loadSingleSchemaRule( schemaRuleId ) ).thenReturn( rule );
 
         add( inUse( new LabelTokenRecord( labelId ) ) );
@@ -157,7 +157,7 @@ public void shouldReportUniquenessConstraintNotReferencingBack() throws Exceptio
 
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
 
-        IndexRule rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId2 );
+        IndexDescriptor rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId2 );
         ConstraintRule rule2 = uniquenessConstraintRule( ruleId2, labelId, propertyKeyId, ruleId2 );
 
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId1 ) ).thenReturn( rule1 );
@@ -187,7 +187,7 @@ public void shouldNotReportConstraintIndexRuleWithoutBackReference() throws Exce
 
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
 
-        IndexRule rule = constraintIndexRule( ruleId, labelId, propertyKeyId, providerDescriptor );
+        IndexDescriptor rule = constraintIndexRule( ruleId, labelId, propertyKeyId, providerDescriptor );
 
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId ) ).thenReturn( rule );
 
@@ -266,7 +266,7 @@ public void shouldReportConstraintIndexNotReferencingBack() throws Exception
 
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
 
-        IndexRule rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
+        IndexDescriptor rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
         ConstraintRule rule2 = uniquenessConstraintRule( ruleId2, labelId, propertyKeyId, ruleId1 );
 
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId1 ) ).thenReturn( rule1 );
@@ -298,8 +298,8 @@ public void shouldReportTwoConstraintIndexesReferencingSameConstraint() throws E
 
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
 
-        IndexRule rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
-        IndexRule rule2 = constraintIndexRule( ruleId2, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
+        IndexDescriptor rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
+        IndexDescriptor rule2 = constraintIndexRule( ruleId2, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
 
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId1 ) ).thenReturn( rule1 );
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId2 ) ).thenReturn( rule2 );
@@ -325,7 +325,7 @@ public void shouldReportUnreferencedConstraintIndex() throws Exception
 
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
 
-        IndexRule rule = constraintIndexRule( ruleId, labelId, propertyKeyId, providerDescriptor, (long) ruleId );
+        IndexDescriptor rule = constraintIndexRule( ruleId, labelId, propertyKeyId, providerDescriptor, (long) ruleId );
 
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId ) ).thenReturn( rule );
 
@@ -353,8 +353,8 @@ public void shouldReportTwoIndexRulesWithDuplicateContent() throws Exception
 
         IndexProvider.Descriptor providerDescriptor = new IndexProvider.Descriptor( "in-memory", "1.0" );
 
-        IndexRule rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
-        IndexRule rule2 = constraintIndexRule( ruleId2, labelId, propertyKeyId, providerDescriptor, (long) ruleId2 );
+        IndexDescriptor rule1 = constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
+        IndexDescriptor rule2 = constraintIndexRule( ruleId2, labelId, propertyKeyId, providerDescriptor, (long) ruleId2 );
 
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId1 ) ).thenReturn( rule1 );
         when( checker().ruleAccess.loadSingleSchemaRule( ruleId2 ) ).thenReturn( rule2 );