Use custom code for counting dense node degrees

Using visitors was causing regressions

community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionCountingStateVisitor.java

@@ -79,8 +79,8 @@ private void decrementCountForLabelsAndRelationships( NodeItem node )
             return false;
         } );
 
-        storeLayer.degrees( statement, node, ALWAYS_TRUE_INT,
-                ( type, out, in, loop ) -> updateRelationshipsCountsFromDegrees( labelIds, type, -out, -in, -loop ) );
+        storeLayer.degrees( statement, node,
+                ( type, out, in ) -> updateRelationshipsCountsFromDegrees( labelIds, type, -out, -in ) );
     }
 
     @Override
@@ -125,40 +125,37 @@ public void visitNodeLabelChanges( long id, final Set<Integer> added, final Set<
             // get the relationship counts from *before* this transaction,
             // the relationship changes will compensate for what happens during the transaction
             storeLayer.nodeCursor( statement, id, null )
-                    .forAll( node -> storeLayer.degrees( statement, node, ALWAYS_TRUE_INT, ( type, out, in, loop ) ->
+                    .forAll( node -> storeLayer.degrees( statement, node, ( type, out, in ) ->
                     {
-                        added.forEach( label -> updateRelationshipsCountsFromDegrees( type, label, out, in, loop ) );
+                        added.forEach( label -> updateRelationshipsCountsFromDegrees( type, label, out, in ) );
                         removed.forEach(
-                                label -> updateRelationshipsCountsFromDegrees( type, label, -out, -in, -loop ) );
-                        return true;
+                                label -> updateRelationshipsCountsFromDegrees( type, label, -out, -in ) );
                     } ) );
         }
         super.visitNodeLabelChanges( id, added, removed );
     }
 
-    private boolean updateRelationshipsCountsFromDegrees( PrimitiveIntCollection labels, int type, long outgoing,
-            long incoming, long loop )
+    private void updateRelationshipsCountsFromDegrees( PrimitiveIntCollection labels, int type, long out, long in )
     {
-        labels.visitKeys( label -> updateRelationshipsCountsFromDegrees( type, label, outgoing, incoming, loop ) );
-        return true;
+        labels.visitKeys( label -> updateRelationshipsCountsFromDegrees( type, label, out, in ) );
     }
 
-    private boolean updateRelationshipsCountsFromDegrees( int type, int label, long out, long in, long loop )
+    private boolean updateRelationshipsCountsFromDegrees( int type, int label, long out, long in )
     {
         // untyped
-        counts.incrementRelationshipCount( label, ANY_RELATIONSHIP_TYPE, ANY_LABEL, out + loop );
-        counts.incrementRelationshipCount( ANY_LABEL, ANY_RELATIONSHIP_TYPE, label, in + loop );
+        counts.incrementRelationshipCount( label, ANY_RELATIONSHIP_TYPE, ANY_LABEL, out );
+        counts.incrementRelationshipCount( ANY_LABEL, ANY_RELATIONSHIP_TYPE, label, in );
         // typed
-        counts.incrementRelationshipCount( label, type, ANY_LABEL, out + loop );
-        counts.incrementRelationshipCount( ANY_LABEL, type, label, in + loop );
+        counts.incrementRelationshipCount( label, type, ANY_LABEL, out );
+        counts.incrementRelationshipCount( ANY_LABEL, type, label, in );
         return false;
     }
 
     private void updateRelationshipCount( long startNode, int type, long endNode, int delta )
     {
-        updateRelationshipsCountsFromDegrees( type, ANY_LABEL, delta, 0, 0 );
-        visitLabels( startNode, ( labelId ) -> updateRelationshipsCountsFromDegrees( type, labelId, delta, 0, 0 ) );
-        visitLabels( endNode, ( labelId ) -> updateRelationshipsCountsFromDegrees( type, labelId, 0, delta, 0 ) );
+        updateRelationshipsCountsFromDegrees( type, ANY_LABEL, delta, 0 );
+        visitLabels( startNode, ( labelId ) -> updateRelationshipsCountsFromDegrees( type, labelId, delta, 0) );
+        visitLabels( endNode, ( labelId ) -> updateRelationshipsCountsFromDegrees( type, labelId, 0, delta ) );
     }
 
     private void visitLabels( long nodeId, PrimitiveIntVisitor<RuntimeException> visitor )

community/kernel/src/main/java/org/neo4j/kernel/impl/api/DegreeVisitor.java

@@ -22,13 +22,5 @@
 @FunctionalInterface
 public interface DegreeVisitor
 {
-    interface Visitable extends AutoCloseable
-    {
-        void accept( DegreeVisitor visitor );
-
-        @Override
-        void close();
-    }
-
-    boolean visitDegree( int type, long outgoing, long incoming, long loop );
+    void visitDegree( int type, long outgoing, long incoming );
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java

@@ -1650,30 +1650,14 @@ public PrimitiveIntSet relationshipTypes( KernelStatement statement, NodeItem no
     @Override
     public int degree( KernelStatement statement, NodeItem node, Direction direction )
     {
-        int degree = statement.hasTxStateWithChanges() && statement.txState().nodeIsAddedInThisTx( node.id() )
-                     ? 0
-                     : countDegrees( statement, node, new CountingDegreeVisitor( direction, false ) );
-
-        return statement.hasTxStateWithChanges()
-                ? statement.txState().getNodeState( node.id() ).augmentDegree( direction, degree )
-                : degree;
+        ReadableTransactionState state = statement.hasTxStateWithChanges() ? statement.txState() : null;
+        return storeLayer.countDegrees( statement.getStoreStatement(), node, direction, state );
     }
 
     @Override
     public int degree( KernelStatement statement, NodeItem node, Direction direction, int relType )
     {
-        int degree = statement.hasTxStateWithChanges() && statement.txState().nodeIsAddedInThisTx( node.id() )
-                     ? 0
-                     : countDegrees( statement, node, new CountingDegreeVisitor( direction, relType, node.isDense() ) );
-
-        return statement.hasTxStateWithChanges()
-               ? statement.txState().getNodeState( node.id() ).augmentDegree( direction, degree, relType )
-               : degree;
-    }
-
-    private int countDegrees( KernelStatement statement, NodeItem node, CountingDegreeVisitor countingDegreeVisitor )
-    {
-        storeLayer.degrees( statement.getStoreStatement(), node, countingDegreeVisitor, countingDegreeVisitor );
-        return countingDegreeVisitor.count();
+        ReadableTransactionState state = statement.hasTxStateWithChanges() ? statement.txState() : null;
+        return storeLayer.countDegrees( statement.getStoreStatement(), node, direction, relType, state );
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/DegreeVisitable.java → community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/DenseNodeDegreeCounter.java

@@ -20,38 +20,35 @@
 package org.neo4j.kernel.impl.api.store;
 
 import java.util.function.Consumer;
-import java.util.function.IntPredicate;
 
-import org.neo4j.function.Disposable;
 import org.neo4j.io.pagecache.PageCursor;
 import org.neo4j.kernel.api.StatementConstants;
 import org.neo4j.kernel.impl.api.DegreeVisitor;
 import org.neo4j.kernel.impl.store.InvalidRecordException;
 import org.neo4j.kernel.impl.store.RelationshipGroupStore;
 import org.neo4j.kernel.impl.store.RelationshipStore;
-import org.neo4j.kernel.impl.store.record.Record;
 import org.neo4j.kernel.impl.store.record.RelationshipGroupRecord;
 import org.neo4j.kernel.impl.store.record.RelationshipRecord;
+import org.neo4j.storageengine.api.Direction;
 
 import static org.neo4j.kernel.impl.store.record.Record.NO_NEXT_RELATIONSHIP;
 import static org.neo4j.kernel.impl.store.record.RecordLoad.FORCE;
 
-public class DegreeVisitable implements DegreeVisitor.Visitable, Disposable
+public class DenseNodeDegreeCounter implements NodeDegreeCounter
 {
     private final RelationshipStore relationshipStore;
     private final RelationshipRecord relationshipRecord;
     private final PageCursor relationshipCursor;
     private final RelationshipGroupStore groupStore;
     private final RelationshipGroupRecord groupRecord;
     private final PageCursor groupCursor;
-    private final Consumer<DegreeVisitable> cache;
+    private final Consumer<DenseNodeDegreeCounter> cache;
 
     private long nodeId;
     private long groupId;
-    private IntPredicate types;
 
-    DegreeVisitable( RelationshipStore relationshipStore, RelationshipGroupStore groupStore,
-            Consumer<DegreeVisitable> cache )
+    DenseNodeDegreeCounter( RelationshipStore relationshipStore, RelationshipGroupStore groupStore,
+            Consumer<DenseNodeDegreeCounter> cache )
     {
         this.relationshipStore = relationshipStore;
         this.relationshipRecord = relationshipStore.newRecord();
@@ -62,39 +59,45 @@ public class DegreeVisitable implements DegreeVisitor.Visitable, Disposable
         this.cache = cache;
     }
 
-    public DegreeVisitable init( long nodeId, long firstGroupId, IntPredicate types )
+    public DenseNodeDegreeCounter init( long nodeId, long firstGroupId )
     {
         this.nodeId = nodeId;
         this.groupId = firstGroupId;
-        this.types = types;
         return this;
     }
 
     @Override
     public void accept( DegreeVisitor visitor )
     {
-        boolean keepGoing = true;
-        while ( keepGoing && groupId != NO_NEXT_RELATIONSHIP.longValue() )
+        while ( !NO_NEXT_RELATIONSHIP.is( groupId ) )
         {
             RelationshipGroupRecord record = groupStore.readRecord( groupId, groupRecord, FORCE, groupCursor );
             if ( record.inUse() )
             {
                 int type = record.getType();
-                if ( types.test( type ) )
-                {
-                    long loop = countByFirstPrevPointer( record.getFirstLoop() );
-                    long outgoing = countByFirstPrevPointer( record.getFirstOut() );
-                    long incoming = countByFirstPrevPointer( record.getFirstIn() );
-                    keepGoing = visitor.visitDegree( type, outgoing, incoming, loop );
-                }
+                long loop = countByFirstPrevPointer( record.getFirstLoop() );
+                long outgoing = countByFirstPrevPointer( record.getFirstOut() ) + loop;
+                long incoming = countByFirstPrevPointer( record.getFirstIn() ) + loop;
+                visitor.visitDegree( type, outgoing, incoming );
             }
             groupId = record.getNext();
         }
     }
 
+    @Override
+    public int count( Direction direction )
+    {
+        return countRelationshipsInGroup( direction, -1 );
+    }
+
+    public int count( Direction direction, int relType )
+    {
+        return countRelationshipsInGroup( direction, relType );
+    }
+
     private long countByFirstPrevPointer( long relationshipId )
     {
-        if ( Record.NO_NEXT_RELATIONSHIP.is( relationshipId ) )
+        if ( NO_NEXT_RELATIONSHIP.is( relationshipId ) )
         {
             return 0;
         }
@@ -111,12 +114,59 @@ private long countByFirstPrevPointer( long relationshipId )
         throw new InvalidRecordException( "Node " + nodeId + " neither start nor end node of " + record );
     }
 
+    private int countRelationshipsInGroup( Direction direction, int type )
+    {
+        int count = 0;
+        while ( !NO_NEXT_RELATIONSHIP.is( groupId ) )
+        {
+            RelationshipGroupRecord record = groupStore.readRecord( groupId, groupRecord, FORCE, groupCursor );
+            if ( record.inUse() && ( type == -1 || groupRecord.getType() == type ) )
+            {
+                count += nodeDegreeByDirection( direction );
+                if ( type != -1 )
+                {
+                    // we have read the only type we were interested on, so break the look
+                    break;
+                }
+            }
+            groupId = groupRecord.getNext();
+        }
+        return count;
+    }
+
+    private long nodeDegreeByDirection( Direction direction )
+    {
+        long firstLoop = groupRecord.getFirstLoop();
+        long loopCount = countByFirstPrevPointer( firstLoop );
+        switch ( direction )
+        {
+        case OUTGOING:
+        {
+            long firstOut = groupRecord.getFirstOut();
+            return countByFirstPrevPointer( firstOut ) + loopCount;
+        }
+        case INCOMING:
+        {
+            long firstIn = groupRecord.getFirstIn();
+            return countByFirstPrevPointer( firstIn ) + loopCount;
+        }
+        case BOTH:
+        {
+            long firstOut = groupRecord.getFirstOut();
+            long firstIn = groupRecord.getFirstIn();
+            return countByFirstPrevPointer( firstOut ) +
+                    countByFirstPrevPointer( firstIn ) + loopCount;
+        }
+        default:
+            throw new IllegalArgumentException( direction.name() );
+        }
+    }
+
     @Override
     public void close()
     {
         nodeId = StatementConstants.NO_SUCH_NODE;
         groupId = StatementConstants.NO_SUCH_RELATIONSHIP;
-        types = null;
         cache.accept( this );
     }
 

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.impl.api.store;
+
+import org.neo4j.function.Disposable;
+import org.neo4j.kernel.impl.api.DegreeVisitor;
+import org.neo4j.storageengine.api.Direction;
+
+public interface NodeDegreeCounter extends AutoCloseable, Disposable
+{
+    void accept( DegreeVisitor visitor );
+
+    int count( Direction direction );
+
+    int count( Direction direction, int relType );
+
+    @Override
+    void close();
+
+}