Revert "Small improvements"

community/kernel/src/main/java/org/neo4j/kernel/api/cursor/NodeItemHelper.java

@@ -0,0 +1,97 @@
+/*
+ * 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.api.cursor;
+
+import java.util.Arrays;
+
+import org.neo4j.collection.primitive.PrimitiveIntIterator;
+import org.neo4j.cursor.Cursor;
+import org.neo4j.kernel.impl.api.store.CursorRelationshipIterator;
+import org.neo4j.kernel.impl.api.store.RelationshipIterator;
+import org.neo4j.kernel.impl.util.Cursors;
+import org.neo4j.storageengine.api.Direction;
+import org.neo4j.storageengine.api.LabelItem;
+import org.neo4j.storageengine.api.NodeItem;
+
+public abstract class NodeItemHelper
+        extends EntityItemHelper
+        implements NodeItem
+{
+    @Override
+    public boolean hasLabel( int labelId )
+    {
+        try ( Cursor<LabelItem> labelCursor = label( labelId ) )
+        {
+            return labelCursor.next();
+        }
+    }
+
+    @Override
+    public PrimitiveIntIterator getLabels()
+    {
+        return Cursors.intIterator( labels(), GET_LABEL );
+    }
+
+    @Override
+    public RelationshipIterator getRelationships( Direction direction, int[] relTypes )
+    {
+        relTypes = deduplicate( relTypes );
+
+        return new CursorRelationshipIterator( relationships( direction, relTypes ) );
+    }
+
+    @Override
+    public RelationshipIterator getRelationships( Direction direction )
+    {
+        return new CursorRelationshipIterator( relationships( direction ) );
+    }
+
+    @Override
+    public PrimitiveIntIterator getRelationshipTypes()
+    {
+        return Cursors.intIterator( relationshipTypes(), GET_RELATIONSHIP_TYPE );
+    }
+
+    private static int[] deduplicate( int[] types )
+    {
+        int unique = 0;
+        for ( int i = 0; i < types.length; i++ )
+        {
+            int type = types[i];
+            for ( int j = 0; j < unique; j++ )
+            {
+                if ( type == types[j] )
+                {
+                    type = -1; // signal that this relationship is not unique
+                    break; // we will not find more than one conflict
+                }
+            }
+            if ( type != -1 )
+            { // this has to be done outside the inner loop, otherwise we'd never accept a single one...
+                types[unique++] = types[i];
+            }
+        }
+        if ( unique < types.length )
+        {
+            types = Arrays.copyOf( types, unique );
+        }
+        return types;
+    }
+}

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

@@ -20,17 +20,15 @@
 package org.neo4j.kernel.api.txstate;
 
 import java.util.Set;
-import java.util.function.Consumer;
 
-import org.neo4j.collection.primitive.Primitive;
-import org.neo4j.collection.primitive.PrimitiveIntCollection;
-import org.neo4j.collection.primitive.PrimitiveIntSet;
+import org.neo4j.collection.primitive.PrimitiveIntCollections;
+import org.neo4j.collection.primitive.PrimitiveIntIterator;
 import org.neo4j.cursor.Cursor;
 import org.neo4j.kernel.api.exceptions.EntityNotFoundException;
 import org.neo4j.kernel.api.exceptions.schema.ConstraintValidationKernelException;
 import org.neo4j.kernel.impl.api.CountsRecordState;
 import org.neo4j.kernel.impl.api.RelationshipDataExtractor;
-import org.neo4j.storageengine.api.LabelItem;
+import org.neo4j.storageengine.api.DegreeItem;
 import org.neo4j.storageengine.api.NodeItem;
 import org.neo4j.storageengine.api.StorageStatement;
 import org.neo4j.storageengine.api.StoreReadLayer;
@@ -48,7 +46,8 @@ public class TransactionCountingStateVisitor extends TxStateVisitor.Delegator
     private final CountsRecordState counts;
     private final ReadableTransactionState txState;
 
-    public TransactionCountingStateVisitor( TxStateVisitor next, StoreReadLayer storeLayer, StorageStatement statement,
+    public TransactionCountingStateVisitor( TxStateVisitor next,
+            StoreReadLayer storeLayer, StorageStatement statement,
             ReadableTransactionState txState, CountsRecordState counts )
     {
         super( next );
@@ -69,22 +68,36 @@ public void visitCreatedNode( long id )
     public void visitDeletedNode( long id )
     {
         counts.incrementNodeCount( ANY_LABEL, -1 );
-        statement.acquireSingleNodeCursor( id ).forAll( this::decrementCountForLabelsAndRelationships );
-        super.visitDeletedNode( id );
-    }
-
-    private void decrementCountForLabelsAndRelationships( NodeItem node )
-    {
-        PrimitiveIntSet labelIds = node.labels().collect( Primitive.intSet(), ( label ) ->
+        try ( Cursor<NodeItem> node = statement.acquireSingleNodeCursor( id ) )
         {
-            int labelId = label.getAsInt();
-            counts.incrementNodeCount( labelId, -1 );
-            return labelId;
-        } );
-
-        node.degrees().forAll(
-                degree -> updateRelationshipsCountsFromDegrees( labelIds, degree.type(), -degree.outgoing(),
-                        -degree.incoming() ) );
+            if ( node.next() )
+            {
+                // TODO Rewrite this to use cursors directly instead of iterator
+                PrimitiveIntIterator labels = node.get().getLabels();
+                if ( labels.hasNext() )
+                {
+                    final int[] removed = PrimitiveIntCollections.asArray( labels );
+                    for ( int label : removed )
+                    {
+                        counts.incrementNodeCount( label, -1 );
+                    }
+
+                    try ( Cursor<DegreeItem> degrees = node.get().degrees() )
+                    {
+                        while ( degrees.next() )
+                        {
+                            DegreeItem degree = degrees.get();
+                            for ( int label : removed )
+                            {
+                                updateRelationshipsCountsFromDegrees( degree.type(), label, -degree.outgoing(),
+                                        -degree.incoming() );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        super.visitDeletedNode( id );
     }
 
     @Override
@@ -105,7 +118,8 @@ public void visitDeletedRelationship( long id )
         }
         catch ( EntityNotFoundException e )
         {
-            throw new IllegalStateException( "Relationship being deleted should exist along with its nodes.", e );
+            throw new IllegalStateException(
+                    "Relationship being deleted should exist along with its nodes.", e );
         }
         super.visitDeletedRelationship( id );
     }
@@ -127,52 +141,72 @@ 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
-            statement.acquireSingleNodeCursor( id ).forAll( node -> node.degrees().forAll( degree ->
+            try ( Cursor<NodeItem> node = statement.acquireSingleNodeCursor( id ) )
             {
-                for ( Integer label : added )
-                {
-                    updateRelationshipsCountsFromDegrees( degree.type(), label, degree.outgoing(), degree.incoming() );
-                }
-                for ( Integer label : removed )
+                if ( node.next() )
                 {
-                    updateRelationshipsCountsFromDegrees( degree.type(), label, -degree.outgoing(),
-                            -degree.incoming() );
+                    try ( Cursor<DegreeItem> degrees = node.get().degrees() )
+                    {
+                        while ( degrees.next() )
+                        {
+                            DegreeItem degree = degrees.get();
+
+                            for ( Integer label : added )
+                            {
+                                updateRelationshipsCountsFromDegrees( degree.type(), label, degree.outgoing(),
+                                        degree.incoming() );
+                            }
+                            for ( Integer label : removed )
+                            {
+                                updateRelationshipsCountsFromDegrees( degree.type(), label, -degree.outgoing(),
+                                        -degree.incoming() );
+                            }
+                        }
+                    }
                 }
-            } ) );
+            }
         }
         super.visitNodeLabelChanges( id, added, removed );
     }
 
-    private void updateRelationshipsCountsFromDegrees( PrimitiveIntCollection labels, int type, long outgoing,
-            long incoming )
-    {
-        labels.visitKeys( (label) -> updateRelationshipsCountsFromDegrees( type, label, outgoing, incoming ) );
-    }
-    private boolean updateRelationshipsCountsFromDegrees( int type, int label, long outgoing, long incoming )
+    private void updateRelationshipsCountsFromDegrees( int type, int label, long outgoing, long incoming )
     {
         // untyped
         counts.incrementRelationshipCount( label, ANY_RELATIONSHIP_TYPE, ANY_LABEL, outgoing );
         counts.incrementRelationshipCount( ANY_LABEL, ANY_RELATIONSHIP_TYPE, label, incoming );
         // typed
         counts.incrementRelationshipCount( label, type, ANY_LABEL, outgoing );
         counts.incrementRelationshipCount( ANY_LABEL, type, label, incoming );
-        return true;
     }
 
     private void updateRelationshipCount( long startNode, int type, long endNode, int delta )
     {
         updateRelationshipsCountsFromDegrees( type, ANY_LABEL, delta, 0 );
-        visitLabels( startNode, ( label ) -> updateRelationshipsCountsFromDegrees( type, label.getAsInt(), delta, 0 ) );
-        visitLabels( endNode, ( label ) -> updateRelationshipsCountsFromDegrees( type, label.getAsInt(), 0, delta ) );
+        for ( PrimitiveIntIterator startLabels = labelsOf( startNode ); startLabels.hasNext(); )
+        {
+            updateRelationshipsCountsFromDegrees( type, startLabels.next(), delta, 0 );
+        }
+        for ( PrimitiveIntIterator endLabels = labelsOf( endNode ); endLabels.hasNext(); )
+        {
+            updateRelationshipsCountsFromDegrees( type, endLabels.next(), 0, delta );
+        }
     }
 
-    private void visitLabels( long nodeId, Consumer<LabelItem> consumer )
+    private PrimitiveIntIterator labelsOf( long nodeId )
     {
-        nodeCursor( statement, nodeId ).forAll( node -> node.labels().forAll( consumer ) );
+        try ( Cursor<NodeItem> node = nodeCursor( statement, nodeId ) )
+        {
+            if ( node.next() )
+            {
+                return node.get().getLabels();
+            }
+            return PrimitiveIntCollections.emptyIterator();
+        }
     }
 
     private Cursor<NodeItem> nodeCursor( StorageStatement statement, long nodeId )
     {
-        return txState.augmentSingleNodeCursor( statement.acquireSingleNodeCursor( nodeId ), nodeId );
+        Cursor<NodeItem> cursor = statement.acquireSingleNodeCursor( nodeId );
+        return txState.augmentSingleNodeCursor( cursor, nodeId );
     }
 }

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

@@ -19,13 +19,11 @@
  */
 package org.neo4j.kernel.impl.api;
 
-import java.util.Arrays;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
-import java.util.function.IntSupplier;
 import java.util.stream.Stream;
 
 import org.neo4j.collection.RawIterator;
@@ -97,16 +95,12 @@
 import org.neo4j.kernel.impl.api.operations.SchemaStateOperations;
 import org.neo4j.kernel.impl.api.security.OverriddenAccessMode;
 import org.neo4j.kernel.impl.api.security.RestrictedAccessMode;
-import org.neo4j.kernel.impl.api.store.CursorRelationshipIterator;
 import org.neo4j.kernel.impl.api.store.RelationshipIterator;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.query.QuerySource;
-import org.neo4j.kernel.impl.util.Cursors;
 import org.neo4j.register.Register.DoubleLongRegister;
-import org.neo4j.storageengine.api.LabelItem;
 import org.neo4j.storageengine.api.NodeItem;
 import org.neo4j.storageengine.api.RelationshipItem;
-import org.neo4j.storageengine.api.RelationshipTypeItem;
 import org.neo4j.storageengine.api.Token;
 import org.neo4j.storageengine.api.lock.ResourceType;
 import org.neo4j.storageengine.api.schema.PopulationProgress;
@@ -325,7 +319,7 @@ public PrimitiveIntIterator nodeGetLabels( long nodeId ) throws EntityNotFoundEx
         statement.assertOpen();
         try ( Cursor<NodeItem> node = dataRead().nodeCursorById( statement, nodeId ) )
         {
-            return Cursors.intIterator( node.get().labels(), LabelItem::getAsInt );
+            return node.get().getLabels();
         }
     }
 
@@ -368,8 +362,7 @@ public RelationshipIterator nodeGetRelationships( long nodeId, Direction directi
         statement.assertOpen();
         try ( Cursor<NodeItem> node = dataRead().nodeCursorById( statement, nodeId ) )
         {
-            return new CursorRelationshipIterator(
-                    node.get().relationships( direction( direction ), deduplicate( relTypes ) ) );
+            return node.get().getRelationships( direction( direction ), relTypes );
         }
     }
 
@@ -384,40 +377,15 @@ private org.neo4j.storageengine.api.Direction direction( Direction direction )
         }
     }
 
-    private static int[] deduplicate( int[] types )
-    {
-        int unique = 0;
-        for ( int i = 0; i < types.length; i++ )
-        {
-            int type = types[i];
-            for ( int j = 0; j < unique; j++ )
-            {
-                if ( type == types[j] )
-                {
-                    type = -1; // signal that this relationship is not unique
-                    break; // we will not find more than one conflict
-                }
-            }
-            if ( type != -1 )
-            { // this has to be done outside the inner loop, otherwise we'd never accept a single one...
-                types[unique++] = types[i];
-            }
-        }
-        if ( unique < types.length )
-        {
-            types = Arrays.copyOf( types, unique );
-        }
-        return types;
-    }
-
     @Override
     public RelationshipIterator nodeGetRelationships( long nodeId, Direction direction )
             throws EntityNotFoundException
     {
         statement.assertOpen();
+
         try ( Cursor<NodeItem> node = dataRead().nodeCursorById( statement, nodeId ) )
         {
-            return new CursorRelationshipIterator( node.get().relationships( direction( direction ) ) );
+            return node.get().getRelationships( direction( direction ) );
         }
     }
 
@@ -457,7 +425,7 @@ public PrimitiveIntIterator nodeGetRelationshipTypes( long nodeId ) throws Entit
         statement.assertOpen();
         try ( Cursor<NodeItem> node = dataRead().nodeCursorById( statement, nodeId ) )
         {
-            return Cursors.intIterator( node.get().relationshipTypes(), RelationshipTypeItem::getAsInt );
+            return node.get().getRelationshipTypes();
         }
     }