Skip to content

Commit

Permalink
Revert "Small improvements"
Browse files Browse the repository at this point in the history
  • Loading branch information
davidegrohmann committed Jan 11, 2017
1 parent 11c181a commit f9d2b35
Show file tree
Hide file tree
Showing 34 changed files with 1,608 additions and 1,903 deletions.
@@ -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;
}
}
Expand Up @@ -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;
Expand All @@ -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 );
Expand All @@ -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
Expand All @@ -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 );
}
Expand All @@ -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 );
}
}
Expand Up @@ -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;
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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();
}
}

Expand Down Expand Up @@ -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 );
}
}

Expand All @@ -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 ) );
}
}

Expand Down Expand Up @@ -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();
}
}

Expand Down

0 comments on commit f9d2b35

Please sign in to comment.