Cleaned up SchemaStorage

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

@@ -131,43 +131,9 @@ public Function<NodeRecord,Check<NodeRecord,ConsistencyReport.NodeConsistencyRep
         };
     }
 
-    /**
-     * The iterators returned by the SchemaStorage will throw a `MalformedSchemaRuleException` wrapped in a
-     * `RuntimeException` if it encounters malformed schema rules. As the iterator implementation is prefetching this
-     * will manifest in the hasNext() call. Attempting again will actually attempt to read the schema rule after the
-     * malformed one. This method will therefore execute `hasNext()` until 1) it reads a complete schema rule, 2) all
-     * schema rules are read, or 3) it get's an exception that is not wrapping a `MalformedSchemaRuleException`.
-     */
     private Iterable<ConstraintRule> constraintsIgnoringMalformed( SchemaStorage schemaStorage )
     {
-        final Iterator<ConstraintRule> ruleIterator = schemaStorage.allConstraintRules();
-        return () -> new Iterator<ConstraintRule>()
-            {
-                @Override
-                public boolean hasNext()
-                {
-                    while ( true )
-                    {
-                        try
-                        {
-                            return ruleIterator.hasNext();
-                        }
-                        catch ( Exception e )
-                        {
-                            if ( !MalformedSchemaRuleException.class.isInstance( e.getCause() ) )
-                            {
-                                throw e;
-                            }
-                        }
-                    }
-                }
-
-                @Override
-                public ConstraintRule next()
-                {
-                    return ruleIterator.next();
-                }
-            };
+        return schemaStorage::constraintsGetAllIgnoreMalformed;
     }
 
     private static void recordConstraint( int labelOrRelType, int propertyKey, PrimitiveIntObjectMap<int[]> storage )

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

@@ -35,7 +35,7 @@ public static Iterable<IndexRule> loadAllIndexRules( final RecordStore<DynamicRe
             @Override
             public Iterator<IndexRule> iterator()
             {
-                return new SchemaStorage( schemaStore ).allIndexRules();
+                return new SchemaStorage( schemaStore ).indexesGetAll();
             }
         };
     }

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

@@ -410,7 +410,7 @@ public void shouldNotReportIndexInconsistenciesIfIndexIsFailed() throws Exceptio
         DirectStoreAccess storeAccess = fixture.directStoreAccess();
 
         // fail all indexes
-        Iterator<IndexRule> rules = new SchemaStorage( storeAccess.nativeStores().getSchemaStore() ).allIndexRules();
+        Iterator<IndexRule> rules = new SchemaStorage( storeAccess.nativeStores().getSchemaStore() ).indexesGetAll();
         while ( rules.hasNext() )
         {
             IndexRule rule = rules.next();

community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/SchemaDescriptor.java

@@ -34,4 +34,19 @@ public interface SchemaDescriptor
      * @return a user friendly description of what this index indexes.
      */
     String userDescription( TokenNameLookup tokenNameLookup );
+
+    /**
+     * Checks whether a schema descriptor Supplier supplies this schema descriptor.
+     * @param supplier supplier to get a schema descriptor from
+     * @return true if the supplied schema descriptor equals this schema descriptor
+     */
+    default boolean isSame( Supplier supplier )
+    {
+        return this.equals( supplier.getSchemaDescriptor() );
+    }
+
+    interface Supplier
+    {
+        SchemaDescriptor getSchemaDescriptor();
+    }
 }

community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/SchemaDescriptorPredicates.java

@@ -25,19 +25,19 @@
 
 public class SchemaDescriptorPredicates
 {
-    public static boolean hasLabel( SchemaDescriptorSupplier supplier, int labelId )
+    public static boolean hasLabel( SchemaDescriptor.Supplier supplier, int labelId )
     {
         Optional<Integer> labelOpt = getLabel.compute( supplier.getSchemaDescriptor() );
         return labelOpt.isPresent() && labelOpt.get() == labelId;
     }
 
-    public static boolean hasRelType( SchemaDescriptorSupplier supplier, int relTypeId )
+    public static boolean hasRelType( SchemaDescriptor.Supplier supplier, int relTypeId )
     {
         Optional<Integer> relTypeOpt = getRelType.compute( supplier.getSchemaDescriptor() );
         return relTypeOpt.isPresent() && relTypeOpt.get() == relTypeId;
     }
 
-    public static boolean hasProperty( SchemaDescriptorSupplier supplier, int propertyId )
+    public static boolean hasProperty( SchemaDescriptor.Supplier supplier, int propertyId )
     {
         List<Integer> properties = getProperties.compute( supplier.getSchemaDescriptor() );
         return properties.contains( propertyId );

community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/constaints/ConstraintDescriptor.java

@@ -35,4 +35,19 @@ enum Type { UNIQUE, EXISTS }
      * @return a user friendly description of what this index indexes.
      */
     String userDescription( TokenNameLookup tokenNameLookup );
+
+    /**
+     * Checks whether a constraint descriptor Supplier supplies this constraint descriptor.
+     * @param supplier supplier to get a constraint descriptor from
+     * @return true if the supplied constraint descriptor equals this constraint descriptor
+     */
+    default boolean isSame( Supplier supplier )
+    {
+        return this.equals( supplier.getConstraintDescriptor() );
+    }
+
+    interface Supplier
+    {
+        ConstraintDescriptor getConstraintDescriptor();
+    }
 }

community/kernel/src/main/java/org/neo4j/kernel/api/schema_new/index/NewIndexDescriptor.java

@@ -39,4 +39,19 @@ enum Type { GENERAL, UNIQUE }
      * @return a user friendly description of what this index indexes.
      */
     String userDescription( TokenNameLookup tokenNameLookup );
+
+    /**
+     * Checks whether a constraint descriptor Supplier supplies this constraint descriptor.
+     * @param supplier supplier to get a constraint descriptor from
+     * @return true if the supplied constraint descriptor equals this constraint descriptor
+     */
+    default boolean isSame( Supplier supplier )
+    {
+        return this.equals( supplier.getNewIndexDescriptor() );
+    }
+
+    interface Supplier
+    {
+        NewIndexDescriptor getNewIndexDescriptor();
+    }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/DiskLayer.java

@@ -45,6 +45,7 @@
 import org.neo4j.kernel.api.index.InternalIndexState;
 import org.neo4j.kernel.api.properties.PropertyKeyIdIterator;
 import org.neo4j.kernel.api.schema_new.LabelSchemaDescriptor;
+import org.neo4j.kernel.api.schema_new.RelationTypeSchemaDescriptor;
 import org.neo4j.kernel.api.schema_new.SchemaDescriptorFactory;
 import org.neo4j.kernel.api.schema_new.SchemaDescriptorPredicates;
 import org.neo4j.kernel.api.schema_new.constaints.ConstraintBoundary;
@@ -95,6 +96,9 @@ public class DiskLayer implements StoreReadLayer
     private static final Function<ConstraintRule,RelationshipPropertyConstraint> RULE_TO_REL_CONSTRAINT =
             constraintRule -> ConstraintBoundary.mapRelationship( constraintRule.getConstraintDescriptor() );
 
+    private static final Predicate<IndexRule> INDEX_RULES = rule -> !rule.canSupportUniqueConstraint();
+    private static final Predicate<IndexRule> UNIQUENESS_INDEX_RULES = rule -> rule.canSupportUniqueConstraint();
+
     // These token holders should perhaps move to the cache layer.. not really any reason to have them here?
     private final PropertyKeyTokenHolder propertyKeyTokenHolder;
     private final LabelTokenHolder labelTokenHolder;
@@ -181,7 +185,7 @@ public PrimitiveLongIterator nodesGetForLabel( StorageStatement statement, int l
     @Override
     public IndexDescriptor indexGetForLabelAndPropertyKey( NodePropertyDescriptor descriptor )
     {
-        return descriptor( schemaStorage.indexRule(
+        return descriptor( schemaStorage.indexGetForSchema(
                 SchemaDescriptorFactory.forLabel( descriptor.getLabelId(), descriptor.getPropertyKeyId() ) ) );
     }
 
@@ -213,38 +217,35 @@ public Iterator<IndexDescriptor> uniquenessIndexesGetForLabel( int labelId )
     @Override
     public Iterator<IndexDescriptor> uniquenessIndexesGetAll()
     {
-        return getIndexDescriptorsFor( CONSTRAINT_INDEX_RULES );
+        return getIndexDescriptorsFor( UNIQUENESS_INDEX_RULES );
     }
 
-    private static final Predicate<IndexRule> INDEX_RULES = rule -> !rule.canSupportUniqueConstraint();
-    private static final Predicate<IndexRule> CONSTRAINT_INDEX_RULES = rule -> rule.canSupportUniqueConstraint();
-
     private Iterator<IndexDescriptor> getIndexDescriptorsFor( Predicate<IndexRule> filter )
     {
-        Iterator<IndexRule> filtered = Iterators.filter( filter, schemaStorage.allIndexRules() );
+        Iterator<IndexRule> filtered = Iterators.filter( filter, schemaStorage.indexesGetAll() );
 
         return Iterators.map( DiskLayer::descriptor, filtered );
     }
 
     @Override
     public Long indexGetOwningUniquenessConstraintId( IndexDescriptor index ) throws SchemaRuleNotFoundException
     {
-        return schemaStorage.indexRule(
+        return schemaStorage.indexGetForSchema(
                 SchemaDescriptorFactory.forLabel( index.getLabelId(), index.getPropertyKeyId() ) ).getOwningConstraint();
     }
 
     @Override
     public IndexRule indexRule( IndexDescriptor index, Predicate<IndexRule> filter )
     {
-        return schemaStorage.indexRule(
+        return schemaStorage.indexGetForSchema(
                 SchemaDescriptorFactory.forLabel( index.getLabelId(), index.getPropertyKeyId() ), filter );
     }
 
     @Override
     public long indexGetCommittedId( IndexDescriptor index, Predicate<IndexRule> filter )
             throws SchemaRuleNotFoundException
     {
-        return schemaStorage.indexRule(
+        return schemaStorage.indexGetForSchema(
                 SchemaDescriptorFactory.forLabel( index.getLabelId(), index.getPropertyKeyId() ) ).getId();
     }
 
@@ -285,40 +286,36 @@ public Iterator<NodePropertyConstraint> constraintsGetForLabelAndPropertyKey( No
     {
         LabelSchemaDescriptor schemaDescriptor =
                 SchemaDescriptorFactory.forLabel( descriptor.getLabelId(), descriptor.getPropertyKeyId() );
-        return schemaStorage.mapConstraintRulesFor(
-                rule -> rule.getSchemaDescriptor().equals( schemaDescriptor ),
-                RULE_TO_NODE_CONSTRAINT );
+
+        return Iterators.map( RULE_TO_NODE_CONSTRAINT, schemaStorage.constraintsGetForSchema( schemaDescriptor ) );
     }
 
     @Override
     public Iterator<NodePropertyConstraint> constraintsGetForLabel( int labelId )
     {
-        return schemaStorage.mapConstraintRulesFor(
-                rule -> SchemaDescriptorPredicates.hasLabel( rule, labelId ),
-                RULE_TO_NODE_CONSTRAINT );
+        return Iterators.map( RULE_TO_NODE_CONSTRAINT, schemaStorage.constraintsGetForLabel( labelId ) );
     }
 
     @Override
     public Iterator<RelationshipPropertyConstraint> constraintsGetForRelationshipTypeAndPropertyKey(
             RelationshipPropertyDescriptor descriptor )
     {
-        return schemaStorage.mapConstraintRulesFor(
-                rule -> rule.getSchemaDescriptor().equals( descriptor ),
-                RULE_TO_REL_CONSTRAINT );
+        RelationTypeSchemaDescriptor schemaDescriptor =
+                SchemaDescriptorFactory.forRelType( descriptor.getRelationshipTypeId(), descriptor.getPropertyKeyId() );
+
+        return Iterators.map( RULE_TO_REL_CONSTRAINT, schemaStorage.constraintsGetForSchema( schemaDescriptor ) );
     }
 
     @Override
     public Iterator<RelationshipPropertyConstraint> constraintsGetForRelationshipType( int typeId )
     {
-        return schemaStorage.mapConstraintRulesFor(
-                rule -> SchemaDescriptorPredicates.hasRelType( rule, typeId ),
-                RULE_TO_REL_CONSTRAINT );
+        return Iterators.map( RULE_TO_REL_CONSTRAINT, schemaStorage.constraintsGetForRelType( typeId ) );
     }
 
     @Override
     public Iterator<PropertyConstraint> constraintsGetAll()
     {
-        return schemaStorage.mapConstraintRulesFor( always -> true, RULE_TO_CONSTRAINT );
+        return Iterators.map( RULE_TO_CONSTRAINT, schemaStorage.constraintsGetAll() );
     }
 
     @Override

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

@@ -225,7 +225,7 @@ public RecordStorageEngine(
             indexStoreView = new DynamicIndexStoreView( labelScanStore, lockService, neoStores, logProvider );
             indexingService = IndexingServiceFactory.createIndexingService( config, scheduler, schemaIndexProviderMap,
                     indexStoreView, tokenNameLookup,
-                    Iterators.asList( new SchemaStorage( neoStores.getSchemaStore() ).allIndexRules() ), logProvider,
+                    Iterators.asList( new SchemaStorage( neoStores.getSchemaStore() ).indexesGetAll() ), logProvider,
                     indexingServiceMonitor, schemaStateChangeCallback );
 
             integrityValidator = new IntegrityValidator( neoStores, indexingService );

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

@@ -208,7 +208,7 @@ public void visitRemovedIndex( IndexDescriptor desc, boolean isConstraintIndex )
         SchemaStorage.IndexRuleKind kind = isConstraintIndex ?
                 SchemaStorage.IndexRuleKind.CONSTRAINT
                 : SchemaStorage.IndexRuleKind.INDEX;
-        IndexRule rule = schemaStorage.indexRule(
+        IndexRule rule = schemaStorage.indexGetForSchema(
                 SchemaDescriptorFactory.forLabel( desc.getLabelId(), desc.getPropertyKeyId() ), kind );
         recordState.dropSchemaRule( rule );
     }
@@ -220,7 +220,7 @@ public void visitAddedUniquePropertyConstraint( UniquenessConstraint element )
         long constraintId = schemaStorage.newRuleId();
         int propertyKeyId = element.descriptor().getPropertyKeyId();
 
-        IndexRule indexRule = schemaStorage.indexRule(
+        IndexRule indexRule = schemaStorage.indexGetForSchema(
                 SchemaDescriptorFactory.forLabel( element.label(), propertyKeyId ),
                 SchemaStorage.IndexRuleKind.CONSTRAINT );
         recordState.createSchemaRule(
@@ -237,7 +237,7 @@ public void visitRemovedUniquePropertyConstraint( UniquenessConstraint element )
             clearSchemaState = true;
             int propertyKeyId = element.descriptor().getPropertyKeyId();
 
-            recordState.dropSchemaRule( schemaStorage.singleConstraintRule(
+            recordState.dropSchemaRule( schemaStorage.constraintsGetSingle(
                     ConstraintDescriptorFactory.uniqueForLabel( element.label(), propertyKeyId )
                 ) );
         }
@@ -272,7 +272,7 @@ public void visitRemovedNodePropertyExistenceConstraint( NodePropertyExistenceCo
             clearSchemaState = true;
             int propertyKeyId = element.descriptor().getPropertyKeyId();
 
-            recordState.dropSchemaRule( schemaStorage.singleConstraintRule(
+            recordState.dropSchemaRule( schemaStorage.constraintsGetSingle(
                     ConstraintDescriptorFactory.existsForLabel( element.label(), propertyKeyId )
                 ) );
         }
@@ -306,7 +306,7 @@ public void visitRemovedRelationshipPropertyExistenceConstraint( RelationshipPro
             //TODO: Support composite indexes
             clearSchemaState = true;
 
-            recordState.dropSchemaRule( schemaStorage.singleConstraintRule(
+            recordState.dropSchemaRule( schemaStorage.constraintsGetSingle(
                     ConstraintDescriptorFactory.existsForRelType(
                             element.descriptor().getRelationshipTypeId(), element.descriptor().getPropertyKeyId() )
                 ) );