From e00c3639fba93d50a8d08410ceacf5a239b8bde0 Mon Sep 17 00:00:00 2001 From: Anton Persson Date: Tue, 28 Mar 2017 11:45:19 +0200 Subject: [PATCH] Use interface 'AssertOpen' instead of Runnable to assert transaction is open This makes the 'assertOpen' more explicit by avoiding the indirection of a runnable. --- .../java/org/neo4j/kernel/api/AssertOpen.java | 46 +++++++++++++++++++ .../TransactionCountingStateVisitor.java | 7 +-- .../kernel/impl/api/KernelStatement.java | 6 ++- .../api/StateHandlingStatementOperations.java | 24 +++++----- .../api/store/StoreAbstractNodeCursor.java | 16 +++---- .../StoreAbstractRelationshipCursor.java | 12 ++--- .../api/store/StoreIteratorNodeCursor.java | 5 +- .../StoreIteratorRelationshipCursor.java | 5 +- .../store/StoreNodeRelationshipCursor.java | 9 ++-- .../impl/api/store/StorePropertyCursor.java | 9 ++-- .../impl/api/store/StoreSingleNodeCursor.java | 5 +- .../api/store/StoreSinglePropertyCursor.java | 5 +- .../store/StoreSingleRelationshipCursor.java | 5 +- .../kernel/impl/api/store/StoreStatement.java | 28 ++++++----- .../TxStateTransactionDataSnapshot.java | 9 ++-- .../participant/StoreMigrator.java | 3 +- .../internal/TransactionEventHandlers.java | 1 - .../storageengine/api/StorageStatement.java | 25 +++++----- .../internal/BatchRelationshipIterable.java | 5 +- .../state/IndexQueryTransactionStateTest.java | 21 +++++---- .../api/state/LabelTransactionStateTest.java | 11 +++-- .../api/state/SchemaTransactionStateTest.java | 3 +- .../StateHandlingStatementOperationsTest.java | 12 +++-- .../StateOperationsAutoIndexingTest.java | 17 +++---- .../impl/api/store/DiskLayerLabelTest.java | 3 +- .../api/store/DiskLayerNodeAndRelTest.java | 5 +- .../impl/api/store/DiskLayerPropertyTest.java | 3 +- .../StoreIteratorRelationshipCursorTest.java | 5 +- .../StoreNodeRelationshipCursorTest.java | 13 +++--- .../api/store/StorePropertyCursorTest.java | 40 ++++++++-------- .../api/store/StoreSingleNodeCursorTest.java | 3 +- .../StoreSingleRelationshipCursorTest.java | 5 +- .../TxStateTransactionDataViewTest.java | 23 +++++----- .../kernel/impl/store/NeoStoresTest.java | 19 ++++---- .../enterprise/PropertyExistenceEnforcer.java | 5 +- 35 files changed, 244 insertions(+), 169 deletions(-) create mode 100644 community/kernel/src/main/java/org/neo4j/kernel/api/AssertOpen.java diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/AssertOpen.java b/community/kernel/src/main/java/org/neo4j/kernel/api/AssertOpen.java new file mode 100644 index 000000000000..b7f4a24cd26a --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/AssertOpen.java @@ -0,0 +1,46 @@ +/* + * 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 . + */ +package org.neo4j.kernel.api; + +/** + * Used to verify that some source of operation is still open when operation is performed. + * E.g. verify that transaction is still open when lazily reading property values from store. + */ +public interface AssertOpen +{ + /** + * Assert that source tied to instance is open. + * Should throw exception with reason if source is not open. + */ + void assertOpen(); + + AssertOpen ALWAYS_OPEN = AlwaysOpen.INSTANCE; + + enum AlwaysOpen implements AssertOpen + { + INSTANCE + { + @Override + public void assertOpen() + { // no-op + } + } + } +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionCountingStateVisitor.java b/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionCountingStateVisitor.java index 7b9a91963e66..1e42bc29a10d 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionCountingStateVisitor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionCountingStateVisitor.java @@ -24,6 +24,7 @@ import org.neo4j.collection.primitive.PrimitiveIntCollections; import org.neo4j.collection.primitive.PrimitiveIntIterator; import org.neo4j.cursor.Cursor; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.exceptions.EntityNotFoundException; import org.neo4j.kernel.api.exceptions.schema.ConstraintValidationKernelException; import org.neo4j.kernel.impl.api.CountsRecordState; @@ -68,7 +69,7 @@ public void visitCreatedNode( long id ) public void visitDeletedNode( long id ) { counts.incrementNodeCount( ANY_LABEL, -1 ); - try ( Cursor node = statement.acquireSingleNodeCursor( id, () -> {} ) ) + try ( Cursor node = statement.acquireSingleNodeCursor( id, AssertOpen.ALWAYS_OPEN ) ) { if ( node.next() ) { @@ -141,7 +142,7 @@ public void visitNodeLabelChanges( long id, final Set added, final Set< } // get the relationship counts from *before* this transaction, // the relationship changes will compensate for what happens during the transaction - try ( Cursor node = statement.acquireSingleNodeCursor( id, () -> {} ) ) + try ( Cursor node = statement.acquireSingleNodeCursor( id, AssertOpen.ALWAYS_OPEN ) ) { if ( node.next() ) { @@ -206,7 +207,7 @@ private PrimitiveIntIterator labelsOf( long nodeId ) private Cursor nodeCursor( StorageStatement statement, long nodeId ) { - Cursor cursor = statement.acquireSingleNodeCursor( nodeId, () -> {} ); + Cursor cursor = statement.acquireSingleNodeCursor( nodeId, AssertOpen.ALWAYS_OPEN ); return txState.augmentSingleNodeCursor( cursor, nodeId ); } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java index 46d94216486c..05e4149cf6f2 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java @@ -25,6 +25,7 @@ import org.neo4j.graphdb.TransactionTerminatedException; import org.neo4j.kernel.api.DataWriteOperations; import org.neo4j.kernel.api.ExecutingQuery; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.ProcedureCallOperations; import org.neo4j.kernel.api.QueryRegistryOperations; import org.neo4j.kernel.api.ReadOperations; @@ -61,7 +62,7 @@ * instance again, when it's initialized. * */ -public class KernelStatement implements TxStateHolder, Statement +public class KernelStatement implements TxStateHolder, Statement, AssertOpen { private final TxStateHolder txStateHolder; private final StorageStatement storeStatement; @@ -164,7 +165,8 @@ public void close() } } - void assertOpen() + @Override + public void assertOpen() { if ( referenceCount == 0 ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java index feefb8111c65..f66e0aed773a 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java @@ -147,7 +147,7 @@ public Cursor nodeCursorById( KernelStatement statement, long nodeId ) @Override public Cursor nodeCursor( KernelStatement statement, long nodeId ) { - Cursor cursor = statement.getStoreStatement().acquireSingleNodeCursor( nodeId, statement::assertOpen ); + Cursor cursor = statement.getStoreStatement().acquireSingleNodeCursor( nodeId, statement ); if ( statement.hasTxStateWithChanges() ) { return statement.txState().augmentSingleNodeCursor( cursor, nodeId ); @@ -172,7 +172,7 @@ public Cursor relationshipCursorById( KernelStatement statemen public Cursor relationshipCursor( KernelStatement statement, long relationshipId ) { Cursor cursor = statement.getStoreStatement().acquireSingleRelationshipCursor( - relationshipId, statement::assertOpen ); + relationshipId, statement ); if ( statement.hasTxStateWithChanges() ) { return statement.txState().augmentSingleRelationshipCursor( cursor, relationshipId ); @@ -183,7 +183,7 @@ public Cursor relationshipCursor( KernelStatement statement, l @Override public Cursor nodeCursorGetAll( KernelStatement statement ) { - Cursor cursor = statement.getStoreStatement().nodesGetAllCursor( statement::assertOpen ); + Cursor cursor = statement.getStoreStatement().nodesGetAllCursor( statement ); if ( statement.hasTxStateWithChanges() ) { return statement.txState().augmentNodesGetAllCursor( cursor ); @@ -195,7 +195,7 @@ public Cursor nodeCursorGetAll( KernelStatement statement ) public Cursor relationshipCursorGetAll( KernelStatement statement ) { Cursor cursor = - statement.getStoreStatement().relationshipsGetAllCursor( statement::assertOpen ); + statement.getStoreStatement().relationshipsGetAllCursor( statement ); if ( statement.hasTxStateWithChanges() ) { return statement.txState().augmentRelationshipsGetAllCursor( cursor ); @@ -209,7 +209,7 @@ public Cursor nodeCursorGetForLabel( KernelStatement statement, int la // TODO Filter this properly StorageStatement storeStatement = statement.getStoreStatement(); return storeStatement.acquireIteratorNodeCursor( - storeLayer.nodesGetForLabel( storeStatement, labelId ), statement::assertOpen ); + storeLayer.nodesGetForLabel( storeStatement, labelId ), statement ); } @Override @@ -219,7 +219,7 @@ public Cursor nodeCursorGetFromIndexSeek( KernelStatement statement, I // TODO Filter this properly StorageStatement storeStatement = statement.getStoreStatement(); IndexReader reader = storeStatement.getIndexReader( index ); - return storeStatement.acquireIteratorNodeCursor( reader.seek( value ), statement::assertOpen ); + return storeStatement.acquireIteratorNodeCursor( reader.seek( value ), statement ); } @Override @@ -229,7 +229,7 @@ public Cursor nodeCursorGetFromIndexScan( KernelStatement statement, I // TODO Filter this properly StorageStatement storeStatement = statement.getStoreStatement(); IndexReader reader = storeStatement.getIndexReader( index ); - return storeStatement.acquireIteratorNodeCursor( reader.scan(), statement::assertOpen ); + return storeStatement.acquireIteratorNodeCursor( reader.scan(), statement ); } @Override @@ -240,7 +240,7 @@ public Cursor nodeCursorGetFromIndexSeekByPrefix( KernelStatement stat // TODO Filter this properly StorageStatement storeStatement = statement.getStoreStatement(); IndexReader reader = storeStatement.getIndexReader( index ); - return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement::assertOpen ); + return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement ); } @Override @@ -256,7 +256,7 @@ public Cursor nodeCursorGetFromIndexRangeSeekByNumber( KernelStatement IndexReader reader = storeStatement.getIndexReader( index ); return COMPARE_NUMBERS.isEmptyRange( lower, includeLower, upper, includeUpper ) ? Cursors.empty() : storeStatement.acquireIteratorNodeCursor( - reader.rangeSeekByNumberInclusive( lower, upper ), statement::assertOpen ); + reader.rangeSeekByNumberInclusive( lower, upper ), statement ); } @Override @@ -271,7 +271,7 @@ public Cursor nodeCursorGetFromIndexRangeSeekByString( KernelStatement StorageStatement storeStatement = statement.getStoreStatement(); IndexReader reader = storeStatement.getIndexReader( index ); return storeStatement.acquireIteratorNodeCursor( - reader.rangeSeekByString( lower, includeLower, upper, includeUpper ), statement::assertOpen ); + reader.rangeSeekByString( lower, includeLower, upper, includeUpper ), statement ); } @Override @@ -282,7 +282,7 @@ public Cursor nodeCursorGetFromIndexRangeSeekByPrefix( KernelStatement // TODO Filter this properly StorageStatement storeStatement = statement.getStoreStatement(); IndexReader reader = storeStatement.getIndexReader( index ); - return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement::assertOpen ); + return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement ); } @Override @@ -294,7 +294,7 @@ public Cursor nodeCursorGetFromUniqueIndexSeek( KernelStatement statem StorageStatement storeStatement = statement.getStoreStatement(); IndexReader reader = storeStatement.getFreshIndexReader( index ); PrimitiveLongIterator seekResult = PrimitiveLongCollections.resourceIterator( reader.seek( value ), reader ); - return storeStatement.acquireIteratorNodeCursor( seekResult, statement::assertOpen ); + return storeStatement.acquireIteratorNodeCursor( seekResult, statement ); } // diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractNodeCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractNodeCursor.java index 837a946572bf..499e00b27ce1 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractNodeCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractNodeCursor.java @@ -27,6 +27,7 @@ import org.neo4j.collection.primitive.PrimitiveIntSet; import org.neo4j.cursor.Cursor; import org.neo4j.cursor.IntValue; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.cursor.NodeItemHelper; import org.neo4j.kernel.impl.locking.Lock; import org.neo4j.kernel.impl.locking.LockService; @@ -71,7 +72,7 @@ public abstract class StoreAbstractNodeCursor extends NodeItemHelper implements private final InstanceCache singlePropertyCursor; private final InstanceCache allPropertyCursor; protected final RecordCursors cursors; - private Runnable assertOnPropertyValueFetch; + private AssertOpen assertOpen; public StoreAbstractNodeCursor( NodeRecord nodeRecord, final NeoStores neoStores, @@ -130,9 +131,9 @@ protected StorePropertyCursor create() }; } - protected void initialize( Runnable assertOnPropertyValueFetch ) + protected void initialize( AssertOpen assertOpen ) { - this.assertOnPropertyValueFetch = assertOnPropertyValueFetch; + this.assertOpen = assertOpen; } @Override @@ -193,29 +194,28 @@ private Lock shortLivedReadLock() @Override public Cursor properties() { - return allPropertyCursor.get().init( nodeRecord.getNextProp(), shortLivedReadLock(), - assertOnPropertyValueFetch ); + return allPropertyCursor.get().init( nodeRecord.getNextProp(), shortLivedReadLock(), assertOpen ); } @Override public Cursor property( int propertyKeyId ) { return singlePropertyCursor.get().init( nodeRecord.getNextProp(), propertyKeyId, shortLivedReadLock(), - assertOnPropertyValueFetch ); + assertOpen ); } @Override public Cursor relationships( Direction direction ) { return nodeRelationshipCursor.get().init( nodeRecord.isDense(), nodeRecord.getNextRel(), nodeRecord.getId(), - direction, assertOnPropertyValueFetch ); + direction, assertOpen ); } @Override public Cursor relationships( Direction direction, int... relTypes ) { return nodeRelationshipCursor.get().init( nodeRecord.isDense(), nodeRecord.getNextRel(), nodeRecord.getId(), - direction, assertOnPropertyValueFetch, relTypes ); + direction, assertOpen, relTypes ); } @Override diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractRelationshipCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractRelationshipCursor.java index 5be898c3ceda..de90b9942e31 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractRelationshipCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractRelationshipCursor.java @@ -20,6 +20,7 @@ package org.neo4j.kernel.impl.api.store; import org.neo4j.cursor.Cursor; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.cursor.EntityItemHelper; import org.neo4j.kernel.impl.locking.Lock; import org.neo4j.kernel.impl.locking.LockService; @@ -46,7 +47,7 @@ public abstract class StoreAbstractRelationshipCursor extends EntityItemHelper private final InstanceCache singlePropertyCursor; private final InstanceCache allPropertyCursor; - private Runnable assertOnPropertyValueFetch; + private AssertOpen assertOpen; public StoreAbstractRelationshipCursor( RelationshipRecord relationshipRecord, RecordCursors cursors, LockService lockService ) @@ -73,9 +74,9 @@ protected StorePropertyCursor create() }; } - protected void initialize( Runnable assertOnPropertyValueFetch ) + protected void initialize( AssertOpen assertOpen ) { - this.assertOnPropertyValueFetch = assertOnPropertyValueFetch; + this.assertOpen = assertOpen; } @Override @@ -150,14 +151,13 @@ private Lock shortLivedReadLock() public Cursor properties() { return allPropertyCursor.get() - .init( relationshipRecord.getNextProp(), shortLivedReadLock(), assertOnPropertyValueFetch ); + .init( relationshipRecord.getNextProp(), shortLivedReadLock(), assertOpen ); } @Override public Cursor property( int propertyKeyId ) { return singlePropertyCursor.get() - .init( relationshipRecord.getNextProp(), propertyKeyId, shortLivedReadLock(), - assertOnPropertyValueFetch ); + .init( relationshipRecord.getNextProp(), propertyKeyId, shortLivedReadLock(), assertOpen ); } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorNodeCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorNodeCursor.java index fdfcb9e0f1e4..711bf012ac87 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorNodeCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorNodeCursor.java @@ -23,6 +23,7 @@ import org.neo4j.collection.primitive.PrimitiveLongIterator; import org.neo4j.graphdb.Resource; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.locking.LockService; import org.neo4j.kernel.impl.store.NeoStores; import org.neo4j.kernel.impl.store.RecordCursors; @@ -50,9 +51,9 @@ public StoreIteratorNodeCursor( NodeRecord nodeRecord, this.instanceCache = instanceCache; } - public StoreIteratorNodeCursor init( PrimitiveLongIterator iterator, Runnable assertOnPropertyValueFetch ) + public StoreIteratorNodeCursor init( PrimitiveLongIterator iterator, AssertOpen assertOpen ) { - initialize( assertOnPropertyValueFetch ); + initialize( assertOpen ); this.iterator = iterator; return this; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursor.java index d8c6ed43b57b..ee0248fca590 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursor.java @@ -21,6 +21,7 @@ import org.neo4j.collection.primitive.PrimitiveLongIterator; import org.neo4j.graphdb.Resource; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.locking.LockService; import org.neo4j.kernel.impl.store.RecordCursors; import org.neo4j.kernel.impl.store.record.RelationshipRecord; @@ -45,9 +46,9 @@ public StoreIteratorRelationshipCursor( RelationshipRecord relationshipRecord, this.instanceCache = instanceCache; } - public StoreIteratorRelationshipCursor init( PrimitiveLongIterator iterator, Runnable assertOnPropertyValueFetch ) + public StoreIteratorRelationshipCursor init( PrimitiveLongIterator iterator, AssertOpen assertOpen ) { - initialize( assertOnPropertyValueFetch ); + initialize( assertOpen ); this.iterator = iterator; return this; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursor.java index f8536891083c..9eaf2129342d 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursor.java @@ -21,6 +21,7 @@ import java.util.function.Consumer; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.locking.LockService; import org.neo4j.kernel.impl.store.InvalidRecordException; import org.neo4j.kernel.impl.store.RecordCursors; @@ -67,16 +68,16 @@ public StoreNodeRelationshipCursor init( boolean isDense, long firstRelId, long fromNodeId, Direction direction, - Runnable assertOnPropertyValueFetch ) + AssertOpen assertOpen ) { - return init( isDense, firstRelId, fromNodeId, direction, assertOnPropertyValueFetch, null ); + return init( isDense, firstRelId, fromNodeId, direction, assertOpen, null ); } public final StoreNodeRelationshipCursor init( boolean isDense, long firstRelId, long fromNodeId, Direction direction, - Runnable assertOnPropertyValueFetch, + AssertOpen assertOpen, int... relTypes ) { this.isDense = isDense; @@ -85,7 +86,7 @@ public final StoreNodeRelationshipCursor init( boolean isDense, this.direction = direction; this.relTypes = relTypes; this.end = false; - initialize( assertOnPropertyValueFetch ); + initialize( assertOpen ); if ( isDense && relationshipId != Record.NO_NEXT_RELATIONSHIP.intValue() ) { cursors.relationshipGroup().next( firstRelId, groupRecord, FORCE ); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StorePropertyCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StorePropertyCursor.java index 5a1b5b4ac684..6bcfe098f6ad 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StorePropertyCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StorePropertyCursor.java @@ -22,6 +22,7 @@ import java.util.function.Consumer; import org.neo4j.cursor.Cursor; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.locking.Lock; import org.neo4j.kernel.impl.store.RecordCursor; import org.neo4j.kernel.impl.store.RecordCursors; @@ -41,7 +42,7 @@ public class StorePropertyCursor implements Cursor, PropertyItem private final RecordCursor recordCursor; private Lock lock; - private Runnable assertOnValueFetch; + private AssertOpen assertOpen; public StorePropertyCursor( RecordCursors cursors, Consumer instanceCache ) { @@ -50,12 +51,12 @@ public StorePropertyCursor( RecordCursors cursors, Consumer this.recordCursor = cursors.property(); } - public StorePropertyCursor init( long firstPropertyId, Lock readLock, Runnable assertOnValueFetch ) + public StorePropertyCursor init( long firstPropertyId, Lock readLock, AssertOpen assertOpen ) { recordCursor.placeAt( firstPropertyId, FORCE ); payload.clear(); lock = readLock; - this.assertOnValueFetch = assertOnValueFetch; + this.assertOpen = assertOpen; return this; } @@ -102,7 +103,7 @@ public int propertyKeyId() public Object value() { Object value = payload.value(); - assertOnValueFetch.run(); + assertOpen.assertOpen(); return value; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursor.java index 9a7fe6848faa..ed84acea07d6 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursor.java @@ -21,6 +21,7 @@ import java.util.function.Consumer; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.StatementConstants; import org.neo4j.kernel.impl.locking.LockService; import org.neo4j.kernel.impl.store.NeoStores; @@ -48,9 +49,9 @@ public StoreSingleNodeCursor( NodeRecord nodeRecord, this.instanceCache = instanceCache; } - public StoreSingleNodeCursor init( long nodeId, Runnable assertOnPropertyValueFetch ) + public StoreSingleNodeCursor init( long nodeId, AssertOpen assertOpen ) { - initialize( assertOnPropertyValueFetch ); + initialize( assertOpen ); this.nodeId = nodeId; return this; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSinglePropertyCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSinglePropertyCursor.java index f2e4606f60df..8529e2df7dc9 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSinglePropertyCursor.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreSinglePropertyCursor.java @@ -21,6 +21,7 @@ import java.util.function.Consumer; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.StatementConstants; import org.neo4j.kernel.impl.locking.Lock; import org.neo4j.kernel.impl.store.RecordCursors; @@ -38,9 +39,9 @@ public StoreSinglePropertyCursor( RecordCursors cursors, Consumer acquireSingleNodeCursor( long nodeId, Runnable assertOnPropertyValueFetch ) + public Cursor acquireSingleNodeCursor( long nodeId, AssertOpen assertOpen ) { neoStores.assertOpen(); - return singleNodeCursor.get().init( nodeId, assertOnPropertyValueFetch ); + return singleNodeCursor.get().init( nodeId, assertOpen ); } @Override - public Cursor acquireIteratorNodeCursor( PrimitiveLongIterator nodeIdIterator, - Runnable assertOnPropertyValueFetch ) + public Cursor acquireIteratorNodeCursor( PrimitiveLongIterator nodeIdIterator, AssertOpen assertOpen ) { neoStores.assertOpen(); - return iteratorNodeCursor.get().init( nodeIdIterator, assertOnPropertyValueFetch ); + return iteratorNodeCursor.get().init( nodeIdIterator, assertOpen ); } @Override - public Cursor acquireSingleRelationshipCursor( long relId, Runnable assertOnPropertyValueFetch ) + public Cursor acquireSingleRelationshipCursor( long relId, AssertOpen assertOpen ) { neoStores.assertOpen(); - return singleRelationshipCursor.get().init( relId, assertOnPropertyValueFetch ); + return singleRelationshipCursor.get().init( relId, assertOpen ); } @Override - public Cursor acquireIteratorRelationshipCursor( PrimitiveLongIterator iterator, - Runnable assertOnPropertyValueFetch ) + public Cursor acquireIteratorRelationshipCursor( PrimitiveLongIterator iterator, AssertOpen assertOpen ) { neoStores.assertOpen(); - return iteratorRelationshipCursor.get().init( iterator, assertOnPropertyValueFetch ); + return iteratorRelationshipCursor.get().init( iterator, assertOpen ); } @Override - public Cursor nodesGetAllCursor( Runnable assertOnPropertyValueFetch ) + public Cursor nodesGetAllCursor( AssertOpen assertOpen ) { - return acquireIteratorNodeCursor( new AllStoreIdIterator( nodeStore ), assertOnPropertyValueFetch ); + return acquireIteratorNodeCursor( new AllStoreIdIterator( nodeStore ), assertOpen ); } @Override - public Cursor relationshipsGetAllCursor( Runnable assertOnPropertyValueFetch ) + public Cursor relationshipsGetAllCursor( AssertOpen assertOpen ) { - return acquireIteratorRelationshipCursor( new AllStoreIdIterator( relationshipStore ), - assertOnPropertyValueFetch ); + return acquireIteratorRelationshipCursor( new AllStoreIdIterator( relationshipStore ), assertOpen ); } @Override diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataSnapshot.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataSnapshot.java index 886ff661ec00..ac9a01e398f7 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataSnapshot.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataSnapshot.java @@ -36,6 +36,7 @@ import org.neo4j.graphdb.event.TransactionData; import org.neo4j.helpers.collection.IterableWrapper; import org.neo4j.kernel.api.KernelTransaction; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.exceptions.EntityNotFoundException; import org.neo4j.kernel.api.exceptions.LabelNotFoundKernelException; import org.neo4j.kernel.api.exceptions.PropertyKeyIdNotFoundKernelException; @@ -203,7 +204,7 @@ private void takeSnapshot() { for ( Long nodeId : state.addedAndRemovedNodes().getRemoved() ) { - try ( Cursor node = storeStatement.acquireSingleNodeCursor( nodeId, () -> {} ) ) + try ( Cursor node = storeStatement.acquireSingleNodeCursor( nodeId, AssertOpen.ALWAYS_OPEN ) ) { if ( node.next() ) { @@ -232,7 +233,7 @@ private void takeSnapshot() { Relationship relationshipProxy = relationship( relId ); try ( Cursor relationship = - storeStatement.acquireSingleRelationshipCursor( relId, () -> {} ) ) + storeStatement.acquireSingleRelationshipCursor( relId, AssertOpen.ALWAYS_OPEN ) ) { if ( relationship.next() ) { @@ -360,7 +361,7 @@ private Object committedValue( NodeState nodeState, int property ) return null; } - try ( Cursor node = storeStatement.acquireSingleNodeCursor( nodeState.getId(), () -> {} ) ) + try ( Cursor node = storeStatement.acquireSingleNodeCursor( nodeState.getId(), AssertOpen.ALWAYS_OPEN ) ) { if ( !node.next() ) { @@ -387,7 +388,7 @@ private Object committedValue( StoreReadLayer storeReadLayer, RelationshipState } try ( Cursor relationship = storeStatement.acquireSingleRelationshipCursor( - relState.getId(), () -> {} ) ) + relState.getId(), AssertOpen.ALWAYS_OPEN ) ) { if ( !relationship.next() ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java index 8627740bfe0f..226faee8ae09 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java @@ -48,6 +48,7 @@ import org.neo4j.io.pagecache.PageCache; import org.neo4j.io.pagecache.PageCursor; import org.neo4j.io.pagecache.PagedFile; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.index.SchemaIndexProvider; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.impl.api.store.StorePropertyCursor; @@ -689,7 +690,7 @@ private BiConsumer< final List scratch = new ArrayList<>(); return ( ENTITY entity, RECORD record ) -> { - cursor.init( record.getNextProp(), LockService.NO_LOCK, () -> {} ); + cursor.init( record.getNextProp(), LockService.NO_LOCK, AssertOpen.ALWAYS_OPEN ); scratch.clear(); while ( cursor.next() ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/internal/TransactionEventHandlers.java b/community/kernel/src/main/java/org/neo4j/kernel/internal/TransactionEventHandlers.java index c61070b3602c..92798b40856f 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/internal/TransactionEventHandlers.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/internal/TransactionEventHandlers.java @@ -24,7 +24,6 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; -import java.util.Optional; import java.util.concurrent.CopyOnWriteArraySet; import org.neo4j.graphdb.Node; diff --git a/community/kernel/src/main/java/org/neo4j/storageengine/api/StorageStatement.java b/community/kernel/src/main/java/org/neo4j/storageengine/api/StorageStatement.java index 88fe1e116042..def85eb44da6 100644 --- a/community/kernel/src/main/java/org/neo4j/storageengine/api/StorageStatement.java +++ b/community/kernel/src/main/java/org/neo4j/storageengine/api/StorageStatement.java @@ -21,6 +21,7 @@ import org.neo4j.collection.primitive.PrimitiveLongIterator; import org.neo4j.cursor.Cursor; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.exceptions.index.IndexNotFoundKernelException; import org.neo4j.kernel.api.index.IndexDescriptor; import org.neo4j.storageengine.api.schema.IndexReader; @@ -68,10 +69,10 @@ public interface StorageStatement extends AutoCloseable * to place the cursor over the first item and then more calls to move the cursor through the selection. * * @param nodeId id of node to get cursor for. - * @param assertOnPropertyValueFetch assertion to be invoked on each property value fetch + * @param assertOpen to check if source transaction is still open on each property value fetch * @return a {@link Cursor} over {@link NodeItem} for the given {@code nodeId}. */ - Cursor acquireSingleNodeCursor( long nodeId, Runnable assertOnPropertyValueFetch ); + Cursor acquireSingleNodeCursor( long nodeId, AssertOpen assertOpen ); /** * Acquires {@link Cursor} capable of {@link Cursor#get() serving} {@link NodeItem} for selected nodes. @@ -79,10 +80,10 @@ public interface StorageStatement extends AutoCloseable * to place the cursor over the first item and then more calls to move the cursor through the selection. * * @param nodeIds ids of nodes to get cursor for. - * @param assertOnPropertyValueFetch assertion to be invoked on each property value fetch + * @param assertOpen to check if source transaction is still open on each property value fetch * @return a {@link Cursor} over {@link NodeItem} for the given node ids. */ - Cursor acquireIteratorNodeCursor( PrimitiveLongIterator nodeIds, Runnable assertOnPropertyValueFetch ); + Cursor acquireIteratorNodeCursor( PrimitiveLongIterator nodeIds, AssertOpen assertOpen ); /** * Acquires {@link Cursor} capable of {@link Cursor#get() serving} {@link RelationshipItem} for selected @@ -91,11 +92,11 @@ public interface StorageStatement extends AutoCloseable * through the selection. * * @param relationshipId id of relationship to get cursor for. - * @param assertOnPropertyValueFetch assertion to be invoked on each property value fetch + * @param assertOpen to check if source transaction is still open on each property value fetch * @return a {@link Cursor} over {@link RelationshipItem} for the given {@code relationshipId}. */ Cursor acquireSingleRelationshipCursor( long relationshipId, - Runnable assertOnPropertyValueFetch ); + AssertOpen assertOpen ); /** * Acquires {@link Cursor} capable of {@link Cursor#get() serving} {@link RelationshipItem} for selected @@ -104,21 +105,21 @@ Cursor acquireSingleRelationshipCursor( long relationshipId, * through the selection. * * @param relationshipIds ids of relationships to get cursor for. - * @param assertOnPropertyValueFetch assertion to be invoked on each property value fetch + * @param assertOpen to check if source transaction is still open on each property value fetch * @return a {@link Cursor} over {@link RelationshipItem} for the given relationship ids. */ Cursor acquireIteratorRelationshipCursor( PrimitiveLongIterator relationshipIds, - Runnable assertOnPropertyValueFetch ); + AssertOpen assertOpen ); /** * Acquires {@link Cursor} capable of {@link Cursor#get() serving} {@link NodeItem} for selected nodes. * No node is selected when this method returns, a call to {@link Cursor#next()} will have to be made * to place the cursor over the first item and then more calls to move the cursor through the selection. * - * @param assertOnPropertyValueFetch assertion to be invoked on each property value fetch + * @param assertOpen to check if source transaction is still open on each property value fetch * @return {@link Cursor} over all stored nodes. */ - Cursor nodesGetAllCursor( Runnable assertOnPropertyValueFetch ); + Cursor nodesGetAllCursor( AssertOpen assertOpen ); /** * Acquires {@link Cursor} capable of {@link Cursor#get() serving} {@link RelationshipItem} for selected @@ -126,10 +127,10 @@ Cursor acquireIteratorRelationshipCursor( PrimitiveLongIterato * will have to be made to place the cursor over the first item and then more calls to move the cursor * through the selection. * - * @param assertOnPropertyValueFetch assertion to be invoked on each property value fetch + * @param assertOpen to check if source transaction is still open on each property value fetch * @return a {@link Cursor} over all stored relationships. */ - Cursor relationshipsGetAllCursor( Runnable assertOnPropertyValueFetch ); + Cursor relationshipsGetAllCursor( AssertOpen assertOpen ); /** * @return {@link LabelScanReader} capable of reading nodes for specific label ids. diff --git a/community/kernel/src/main/java/org/neo4j/unsafe/batchinsert/internal/BatchRelationshipIterable.java b/community/kernel/src/main/java/org/neo4j/unsafe/batchinsert/internal/BatchRelationshipIterable.java index 19a8f39172c1..9b147b1b0eef 100644 --- a/community/kernel/src/main/java/org/neo4j/unsafe/batchinsert/internal/BatchRelationshipIterable.java +++ b/community/kernel/src/main/java/org/neo4j/unsafe/batchinsert/internal/BatchRelationshipIterable.java @@ -33,10 +33,11 @@ import org.neo4j.kernel.impl.store.record.NodeRecord; 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.api.AssertOpen.ALWAYS_OPEN; import static org.neo4j.kernel.impl.locking.LockService.NO_LOCK_SERVICE; import static org.neo4j.kernel.impl.store.record.RecordLoad.NORMAL; +import static org.neo4j.storageengine.api.Direction.BOTH; abstract class BatchRelationshipIterable implements Iterable { @@ -57,7 +58,7 @@ public BatchRelationshipIterable( NeoStores neoStores, long nodeId, RecordCursor { NodeStore nodeStore = neoStores.getNodeStore(); NodeRecord nodeRecord = nodeStore.getRecord( nodeId, nodeStore.newRecord(), NORMAL ); - relationshipCursor.init( nodeRecord.isDense(), nodeRecord.getNextRel(), nodeId, Direction.BOTH, () -> {} ); + relationshipCursor.init( nodeRecord.isDense(), nodeRecord.getNextRel(), nodeId, BOTH, ALWAYS_OPEN ); } catch ( InvalidRecordException e ) { diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/IndexQueryTransactionStateTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/IndexQueryTransactionStateTest.java index 41d11669168b..54cdf1c869ea 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/IndexQueryTransactionStateTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/IndexQueryTransactionStateTest.java @@ -28,6 +28,7 @@ import org.neo4j.collection.primitive.PrimitiveLongIterator; import org.neo4j.collection.primitive.PrimitiveLongResourceIterator; import org.neo4j.graphdb.Resource; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.constraints.NodePropertyConstraint; import org.neo4j.kernel.api.index.IndexDescriptor; import org.neo4j.kernel.api.index.InternalIndexState; @@ -118,7 +119,7 @@ public void shouldExcludeRemovedNodesFromIndexQuery() throws Exception long nodeId = 2L; when( indexReader.seek( value ) ).then( answerAsPrimitiveLongIteratorFrom( asList( 1L, nodeId, 3L ) ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ) + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( nodeId ) ); txContext.nodeDelete( state, nodeId ); @@ -137,7 +138,7 @@ public void shouldExcludeRemovedNodeFromUniqueIndexQuery() throws Exception long nodeId = 1L; when( indexReader.seek( value ) ).thenReturn( asPrimitiveResourceIterator( nodeId ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ) + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( nodeId ) ); txContext.nodeDelete( state, nodeId ); @@ -190,7 +191,7 @@ public void shouldIncludeCreatedNodesWithCorrectLabelAndProperty() throws Except state.txState().nodeDoReplaceProperty( nodeId, noNodeProperty( nodeId, propertyKeyId ), stringProperty( propertyKeyId, value ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor( stringProperty( propertyKeyId, value ) ), Cursors.empty() ) ); @@ -214,7 +215,7 @@ public void shouldIncludeUniqueCreatedNodeWithCorrectLabelAndProperty() throws E state.txState().nodeDoReplaceProperty( nodeId, noNodeProperty( nodeId, propertyKeyId ), stringProperty( propertyKeyId, value ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor( stringProperty( propertyKeyId, value ) ), Cursors.empty() ) ); @@ -236,7 +237,7 @@ public void shouldIncludeExistingNodesWithCorrectPropertyAfterAddingLabel() thro long nodeId = 1L; - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor( stringProperty( propertyKeyId, value ) ), asLabelCursor() ) ); @@ -258,7 +259,7 @@ public void shouldIncludeExistingUniqueNodeWithCorrectPropertyAfterAddingLabel() long nodeId = 2L; - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor( stringProperty( propertyKeyId, value ) ), asLabelCursor() ) ); @@ -279,7 +280,7 @@ public void shouldExcludeExistingNodesWithCorrectPropertyAfterRemovingLabel() th long nodeId = 1L; when( indexReader.seek( value ) ).then( answerAsPrimitiveLongIteratorFrom( asList( nodeId, 2L, 3L ) ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor( stringProperty( propertyKeyId, value ) ), asLabelCursor( labelId ) ) ); @@ -300,7 +301,7 @@ public void shouldExcludeExistingUniqueNodeWithCorrectPropertyAfterRemovingLabel long nodeId = 1L; when( indexReader.seek( value ) ).thenReturn( asPrimitiveResourceIterator( nodeId ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor( stringProperty( propertyKeyId, value ) ), asLabelCursor( labelId ) ) ); @@ -324,7 +325,7 @@ public void shouldExcludeNodesWithRemovedProperty() throws Exception state.txState().nodeDoReplaceProperty( nodeId, Property.noNodeProperty( nodeId, propertyKeyId ), Property.intProperty( propertyKeyId, 10 ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor(), asLabelCursor( labelId ) ) ); @@ -345,7 +346,7 @@ public void shouldExcludeUniqueNodeWithRemovedProperty() throws Exception long nodeId = 1L; when( indexReader.seek( value ) ).thenReturn( asPrimitiveResourceIterator( nodeId ) ); - when( statement.acquireSingleNodeCursor( eq( nodeId ), any( Runnable.class ) ) ).thenReturn( + when( statement.acquireSingleNodeCursor( eq( nodeId ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( nodeId, asPropertyCursor( stringProperty( propertyKeyId, value ) ), asLabelCursor( labelId ) ) ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/LabelTransactionStateTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/LabelTransactionStateTest.java index a4f39a14f25f..ad6d5ae19ff4 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/LabelTransactionStateTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/LabelTransactionStateTest.java @@ -31,6 +31,7 @@ import org.neo4j.collection.primitive.PrimitiveIntCollections; import org.neo4j.collection.primitive.PrimitiveLongCollections; import org.neo4j.cursor.Cursor; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.exceptions.EntityNotFoundException; import org.neo4j.kernel.api.index.IndexDescriptor; import org.neo4j.kernel.api.txstate.TransactionState; @@ -246,7 +247,7 @@ public void removingNonExistentLabelFromNodeShouldRespondFalse() throws Exceptio public void should_return_true_when_adding_new_label() throws Exception { // GIVEN - when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( 1337 ) ); // WHEN @@ -260,7 +261,7 @@ public void should_return_true_when_adding_new_label() throws Exception public void should_return_false_when_adding_existing_label() throws Exception { // GIVEN - when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( 1337, asPropertyCursor(), asLabelCursor( 12 ) ) ); @@ -275,7 +276,7 @@ public void should_return_false_when_adding_existing_label() throws Exception public void should_return_true_when_removing_existing_label() throws Exception { // GIVEN - when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( 1337, asPropertyCursor(), asLabelCursor( 12 ) ) ); // WHEN @@ -289,7 +290,7 @@ public void should_return_true_when_removing_existing_label() throws Exception public void should_return_true_when_removing_non_existant_label() throws Exception { // GIVEN - when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( 1337 ) ); // WHEN @@ -333,7 +334,7 @@ private void commitLabels( Labels... labels ) throws Exception Map> allLabels = new HashMap<>(); for ( Labels nodeLabels : labels ) { - when( storeStatement.acquireSingleNodeCursor( eq( nodeLabels.nodeId ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleNodeCursor( eq( nodeLabels.nodeId ), any( AssertOpen.class ) ) ) .thenReturn( StubCursors.asNodeCursor( nodeLabels.nodeId, asPropertyCursor(), asLabelCursor( nodeLabels.labelIds ) ) ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/SchemaTransactionStateTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/SchemaTransactionStateTest.java index 38206e86ba39..7a729bcbcf9e 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/SchemaTransactionStateTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/SchemaTransactionStateTest.java @@ -32,6 +32,7 @@ import java.util.Map; import org.neo4j.helpers.collection.Iterators; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.index.IndexDescriptor; import org.neo4j.kernel.api.index.InternalIndexState; import org.neo4j.kernel.api.txstate.TransactionState; @@ -266,7 +267,7 @@ private void commitLabels( Labels... labels ) throws Exception Map> allLabels = new HashMap<>(); for ( Labels nodeLabels : labels ) { - when( storeStatement.acquireSingleNodeCursor( eq( nodeLabels.nodeId ), any( Runnable.class ) ) ).thenReturn( + when( storeStatement.acquireSingleNodeCursor( eq( nodeLabels.nodeId ), any( AssertOpen.class ) ) ).thenReturn( StubCursors.asNodeCursor( nodeLabels.nodeId, Cursors.empty(), StubCursors.asLabelCursor( nodeLabels.labelIds ) ) ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java index 720971d1444d..5e6116094aaf 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateHandlingStatementOperationsTest.java @@ -32,6 +32,7 @@ import org.neo4j.helpers.collection.Iterables; import org.neo4j.helpers.collection.Iterators; import org.neo4j.kernel.api.DataWriteOperations; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.constraints.NodePropertyConstraint; import org.neo4j.kernel.api.constraints.PropertyConstraint; import org.neo4j.kernel.api.constraints.UniquenessConstraint; @@ -98,7 +99,7 @@ public void shouldNeverDelegateWrites() throws Exception when( state.txState() ).thenReturn( new TxState() ); StoreStatement storeStatement = mock( StoreStatement.class ); when( state.getStoreStatement() ).thenReturn( storeStatement ); - when( storeStatement.acquireSingleNodeCursor( anyLong(), any( Runnable.class ) ) ). + when( storeStatement.acquireSingleNodeCursor( anyLong(), any( AssertOpen.class ) ) ). thenReturn( asNodeCursor( 0 ) ); StateHandlingStatementOperations ctx = newTxStateOps( inner ); @@ -110,7 +111,7 @@ public void shouldNeverDelegateWrites() throws Exception ctx.nodeRemoveLabel( state, 0, 0 ); // one for add and one for remove - verify( storeStatement, times( 2 ) ).acquireSingleNodeCursor( eq( 0L ), any( Runnable.class ) ); + verify( storeStatement, times( 2 ) ).acquireSingleNodeCursor( eq( 0L ), any( AssertOpen.class ) ); verifyNoMoreInteractions( storeStatement ); } @@ -338,7 +339,7 @@ public Cursor answer( InvocationOnMock invocationOnMock ) throws Throw when( indexReader.rangeSeekByNumberInclusive( lower, upper ) ).thenReturn( PrimitiveLongCollections.resourceIterator( PrimitiveLongCollections.iterator( 43L, 44L, 46L ), null ) ); - when( storageStatement.acquireSingleNodeCursor( anyLong(), any( Runnable.class ) ) ).thenAnswer( + when( storageStatement.acquireSingleNodeCursor( anyLong(), any( AssertOpen.class ) ) ).thenAnswer( new Answer>() { @Override @@ -442,7 +443,7 @@ public void shouldNotRecordNodeSetPropertyOnSameValue() throws Exception KernelStatement kernelStatement = mock( KernelStatement.class ); StoreStatement storeStatement = mock( StoreStatement.class ); Cursor ourNode = nodeCursorWithProperty( propertyKeyId, value ); - when( storeStatement.acquireSingleNodeCursor( nodeId ) ).thenReturn( ourNode ); + when( storeStatement.acquireSingleNodeCursor( nodeId, kernelStatement ) ).thenReturn( ourNode ); when( kernelStatement.getStoreStatement() ).thenReturn( storeStatement ); InternalAutoIndexing autoIndexing = mock( InternalAutoIndexing.class ); AutoIndexOperations autoIndexOps = mock( AutoIndexOperations.class ); @@ -471,7 +472,8 @@ public void shouldNotRecordRelationshipSetPropertyOnSameValue() throws Exception KernelStatement kernelStatement = mock( KernelStatement.class ); StoreStatement storeStatement = mock( StoreStatement.class ); Cursor ourRelationship = relationshipCursorWithProperty( propertyKeyId, value ); - when( storeStatement.acquireSingleRelationshipCursor( relationshipId ) ).thenReturn( ourRelationship ); + when( storeStatement.acquireSingleRelationshipCursor( relationshipId, kernelStatement ) ) + .thenReturn( ourRelationship ); when( kernelStatement.getStoreStatement() ).thenReturn( storeStatement ); InternalAutoIndexing autoIndexing = mock( InternalAutoIndexing.class ); AutoIndexOperations autoIndexOps = mock( AutoIndexOperations.class ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateOperationsAutoIndexingTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateOperationsAutoIndexingTest.java index bbd245f9a0de..c13b3c79d040 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateOperationsAutoIndexingTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/StateOperationsAutoIndexingTest.java @@ -23,6 +23,7 @@ import org.junit.Test; import org.neo4j.kernel.api.DataWriteOperations; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.exceptions.InvalidTransactionTypeKernelException; import org.neo4j.kernel.api.legacyindex.AutoIndexing; import org.neo4j.kernel.api.properties.DefinedProperty; @@ -72,7 +73,7 @@ public void setup() throws InvalidTransactionTypeKernelException public void shouldSignalNodeRemovedToAutoIndex() throws Exception { // Given - when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( mock( NodeItem.class ) ) ); // When @@ -86,7 +87,7 @@ public void shouldSignalNodeRemovedToAutoIndex() throws Exception public void shouldSignalRelationshipRemovedToAutoIndex() throws Exception { // Given - when( storeStmt.acquireSingleRelationshipCursor( eq(1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleRelationshipCursor( eq(1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( mock( RelationshipItem.class ) ) ); // When @@ -105,7 +106,7 @@ public void shouldSignalNodePropertyAddedToAutoIndex() throws Exception NodeItem node = mock( NodeItem.class ); when( node.property( property.propertyKeyId() )).thenReturn( Cursors.empty() ); when( node.labels() ).thenReturn( Cursors.empty() ); - when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( node ) ); // When @@ -123,7 +124,7 @@ public void shouldSignalRelationshipPropertyAddedToAutoIndex() throws Exception RelationshipItem rel = mock( RelationshipItem.class ); when( rel.property( property.propertyKeyId() )).thenReturn( Cursors.empty() ); - when( storeStmt.acquireSingleRelationshipCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleRelationshipCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( rel ) ); // When @@ -146,7 +147,7 @@ public void shouldSignalNodePropertyChangedToAutoIndex() throws Exception NodeItem node = mock( NodeItem.class ); when( node.property( property.propertyKeyId() )).thenReturn( Cursors.cursor( existingProperty ) ); when( node.labels() ).thenReturn( Cursors.empty() ); - when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( node ) ); // When @@ -168,7 +169,7 @@ public void shouldSignalRelationshipPropertyChangedToAutoIndex() throws Exceptio RelationshipItem rel = mock( RelationshipItem.class ); when( rel.property( property.propertyKeyId() )).thenReturn( Cursors.cursor( existingProperty ) ); - when( storeStmt.acquireSingleRelationshipCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleRelationshipCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( rel ) ); // When @@ -190,7 +191,7 @@ public void shouldSignalNodePropertyRemovedToAutoIndex() throws Exception NodeItem node = mock( NodeItem.class ); when( node.property( existingProperty.propertyKeyId() )).thenReturn( Cursors.cursor( existingProperty ) ); when( node.labels() ).thenReturn( Cursors.empty() ); - when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleNodeCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( node ) ); // When @@ -211,7 +212,7 @@ public void shouldSignalRelationshipPropertyRemovedToAutoIndex() throws Exceptio RelationshipItem rel = mock( RelationshipItem.class ); when( rel.property( existingProperty.propertyKeyId() )).thenReturn( Cursors.cursor( existingProperty ) ); - when( storeStmt.acquireSingleRelationshipCursor( eq( 1337L ), any( Runnable.class ) ) ) + when( storeStmt.acquireSingleRelationshipCursor( eq( 1337L ), any( AssertOpen.class ) ) ) .thenReturn( Cursors.cursor( rel ) ); // When diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerLabelTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerLabelTest.java index 05b28b3f9ebd..4a034c07bd0c 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerLabelTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerLabelTest.java @@ -31,6 +31,7 @@ import org.neo4j.graphdb.GraphDatabaseService; import org.neo4j.graphdb.Node; import org.neo4j.graphdb.Transaction; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.storageengine.api.NodeItem; import org.neo4j.test.TestGraphDatabaseFactory; @@ -63,7 +64,7 @@ public void should_be_able_to_list_labels_for_node() throws Exception } // THEN - Cursor node = disk.newStatement().acquireSingleNodeCursor( nodeId, () -> {} ); + Cursor node = disk.newStatement().acquireSingleNodeCursor( nodeId, AssertOpen.ALWAYS_OPEN ); node.next(); PrimitiveIntIterator readLabels = node.get().getLabels(); assertEquals( new HashSet<>( asList( labelId1, labelId2 ) ), diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerNodeAndRelTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerNodeAndRelTest.java index c01f5b523679..e96891744ef5 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerNodeAndRelTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerNodeAndRelTest.java @@ -31,6 +31,7 @@ import static junit.framework.TestCase.assertTrue; import static org.neo4j.graphdb.RelationshipType.withName; import static org.neo4j.helpers.collection.MapUtil.map; +import static org.neo4j.kernel.api.AssertOpen.ALWAYS_OPEN; /** * Test reading committed node and relationships from disk. @@ -89,7 +90,7 @@ private boolean nodeExists( long id ) { try ( StorageStatement statement = disk.newStatement() ) { - try ( Cursor node = statement.acquireSingleNodeCursor( id, () -> {} ) ) + try ( Cursor node = statement.acquireSingleNodeCursor( id, ALWAYS_OPEN ) ) { return node.next(); } @@ -100,7 +101,7 @@ private boolean relationshipExists( long id ) { try ( StorageStatement statement = disk.newStatement() ) { - try ( Cursor relationship = statement.acquireSingleRelationshipCursor( id, () -> {} ) ) + try ( Cursor relationship = statement.acquireSingleRelationshipCursor( id, ALWAYS_OPEN ) ) { return relationship.next(); } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerPropertyTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerPropertyTest.java index f83705714a03..714e0ed606c3 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerPropertyTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerPropertyTest.java @@ -24,6 +24,7 @@ import java.lang.reflect.Array; import org.neo4j.cursor.Cursor; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.properties.Property; import org.neo4j.kernel.impl.api.operations.KeyReadOperations; import org.neo4j.storageengine.api.NodeItem; @@ -95,7 +96,7 @@ public void should_get_all_node_properties() throws Exception long nodeId = createLabeledNode( db, singletonMap( "prop", value ), label1 ).getId(); // when - try ( Cursor node = statement.acquireSingleNodeCursor( nodeId, () -> {} ) ) + try ( Cursor node = statement.acquireSingleNodeCursor( nodeId, AssertOpen.ALWAYS_OPEN ) ) { node.next(); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursorTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursorTest.java index f9aa57be2549..53bc92f8c69e 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursorTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursorTest.java @@ -24,6 +24,7 @@ import org.mockito.stubbing.Answer; import org.neo4j.collection.primitive.PrimitiveLongCollections; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.locking.LockService; import org.neo4j.kernel.impl.store.DynamicArrayStore; import org.neo4j.kernel.impl.store.DynamicStringStore; @@ -64,7 +65,7 @@ public void retrieveUsedRelationship() throws Exception try ( StoreIteratorRelationshipCursor cursor = createRelationshipCursor( relationshipRecord, relationshipStore ) ) { - cursor.init( PrimitiveLongCollections.iterator( RELATIONSHIP_ID ), () -> {} ); + cursor.init( PrimitiveLongCollections.iterator( RELATIONSHIP_ID ), AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); assertEquals( RELATIONSHIP_ID, cursor.get().id() ); } @@ -82,7 +83,7 @@ public void retrieveUnusedRelationship() try ( StoreIteratorRelationshipCursor cursor = createRelationshipCursor( relationshipRecord, relationshipStore ) ) { - cursor.init( PrimitiveLongCollections.iterator( RELATIONSHIP_ID ), () -> {} ); + cursor.init( PrimitiveLongCollections.iterator( RELATIONSHIP_ID ), AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); assertEquals( RELATIONSHIP_ID, cursor.get().id() ); } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursorTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursorTest.java index 45eecff48d89..0b7f9e26dc46 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursorTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreNodeRelationshipCursorTest.java @@ -32,6 +32,7 @@ import java.util.function.Consumer; import org.neo4j.io.pagecache.PageCache; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.impl.pagecache.ConfiguringPageCacheFactory; import org.neo4j.kernel.impl.store.NeoStores; @@ -118,13 +119,13 @@ public void retrieveNodeRelationships() throws Exception try ( StoreNodeRelationshipCursor cursor = getNodeRelationshipCursor() ) { - cursor.init( dense, 1L, FIRST_OWNING_NODE, direction, () -> {} ); + cursor.init( dense, 1L, FIRST_OWNING_NODE, direction, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); - cursor.init( dense, 2, FIRST_OWNING_NODE, direction, () -> {} ); + cursor.init( dense, 2, FIRST_OWNING_NODE, direction, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); - cursor.init( dense, 3, FIRST_OWNING_NODE, direction, () -> {} ); + cursor.init( dense, 3, FIRST_OWNING_NODE, direction, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); } } @@ -136,7 +137,7 @@ public void retrieveUsedRelationshipChain() long expectedNodeId = 1; try ( StoreNodeRelationshipCursor cursor = getNodeRelationshipCursor() ) { - cursor.init( dense, 1, FIRST_OWNING_NODE, direction, () -> {} ); + cursor.init( dense, 1, FIRST_OWNING_NODE, direction, AssertOpen.ALWAYS_OPEN ); while ( cursor.next() ) { assertEquals( "Should load next relationship in a sequence", expectedNodeId++, cursor.get().id() ); @@ -154,7 +155,7 @@ public void retrieveRelationshipChainWithUnusedLink() int relationshipIndex = 0; try ( StoreNodeRelationshipCursor cursor = getNodeRelationshipCursor() ) { - cursor.init( dense, 1, FIRST_OWNING_NODE, direction, () -> {} ); + cursor.init( dense, 1, FIRST_OWNING_NODE, direction, AssertOpen.ALWAYS_OPEN ); while ( cursor.next() ) { assertEquals( "Should load next relationship in a sequence", @@ -173,7 +174,7 @@ public void shouldHandleDenseNodeWithNoRelationships() throws Exception try ( StoreNodeRelationshipCursor cursor = getNodeRelationshipCursor() ) { // WHEN - cursor.init( dense, NO_NEXT_RELATIONSHIP.intValue(), FIRST_OWNING_NODE, direction, () -> {} ); + cursor.init( dense, NO_NEXT_RELATIONSHIP.intValue(), FIRST_OWNING_NODE, direction, AssertOpen.ALWAYS_OPEN ); // THEN assertFalse( cursor.next() ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StorePropertyCursorTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StorePropertyCursorTest.java index 1c10da287438..dbda204ee2e9 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StorePropertyCursorTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StorePropertyCursorTest.java @@ -19,7 +19,6 @@ */ package org.neo4j.kernel.impl.api.store; -import org.apache.commons.lang3.mutable.MutableBoolean; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -39,6 +38,7 @@ import org.neo4j.cursor.Cursor; import org.neo4j.graphdb.mockfs.EphemeralFileSystemAbstraction; import org.neo4j.io.pagecache.PageCache; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.store.DynamicArrayStore; import org.neo4j.kernel.impl.store.DynamicRecordAllocator; import org.neo4j.kernel.impl.store.DynamicStringStore; @@ -251,7 +251,7 @@ public void shouldReturnTheCursorToTheCacheOnClose() throws Throwable { // given StorePropertyCursor storePropertyCursor = newStorePropertyCursor( propertyStore, cache ); - storePropertyCursor.init( 0, NO_LOCK, () -> {} ); + storePropertyCursor.init( 0, NO_LOCK, AssertOpen.ALWAYS_OPEN ); // when storePropertyCursor.close(); @@ -330,7 +330,7 @@ public void shouldReturnAProperty() throws Throwable StorePropertyCursor storePropertyCursor = newStorePropertyCursor( propertyStore ); // when - try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, () -> {} ) ) + try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, AssertOpen.ALWAYS_OPEN ) ) { // then assertTrue( cursor.next() ); @@ -351,14 +351,14 @@ public void shouldCallAssertWhenFetchingAValue() throws Throwable long recordId = createSinglePropertyValue( propertyStore, keyId, expectedValue ).getId(); StorePropertyCursor storePropertyCursor = newStorePropertyCursor( propertyStore ); - MutableBoolean called = new MutableBoolean(); - try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, called::setTrue ) ) + AssertOpen assertOpen = mock( AssertOpen.class ); + try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, assertOpen ) ) { // then - assertFalse( called.booleanValue() ); + verify( assertOpen, times( 0 ) ).assertOpen(); cursor.next(); cursor.get().value(); - assertTrue( called.booleanValue() ); + verify( assertOpen, times( 1 ) ).assertOpen(); } } } @@ -414,7 +414,7 @@ public void shouldReturnAPropertyBySkippingOne() throws Throwable StorePropertyCursor storePropertyCursor = newStorePropertyCursor( propertyStore ); // when - try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, () -> {} ) ) + try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, AssertOpen.ALWAYS_OPEN ) ) { // then assertTrue( cursor.next() ); @@ -446,7 +446,7 @@ public void shouldReturnTwoProperties() throws Throwable StorePropertyCursor storePropertyCursor = newStorePropertyCursor( propertyStore ); // when - try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, () -> {} ) ) + try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, AssertOpen.ALWAYS_OPEN ) ) { PropertyItem item; @@ -492,7 +492,7 @@ public void shouldReuseCorrectlyCursor() throws Throwable StorePropertyCursor storePropertyCursor = newStorePropertyCursor( propertyStore ); - try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, () -> {} ) ) + try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, AssertOpen.ALWAYS_OPEN ) ) { assertTrue( cursor.next() ); PropertyItem item = cursor.get(); @@ -502,7 +502,7 @@ public void shouldReuseCorrectlyCursor() throws Throwable } // when using it - try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, () -> {} ) ) + try ( Cursor cursor = storePropertyCursor.init( recordId, NO_LOCK, AssertOpen.ALWAYS_OPEN ) ) { // then assertTrue( cursor.next() ); @@ -526,7 +526,7 @@ public void readPropertyChainWithMultipleEntries() try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( firstPropertyId, NO_LOCK, () -> {} ); + cursor.init( firstPropertyId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); List valuesFromCursor = asPropertyValuesList( cursor ); assertEquals( asList( propertyValues ), valuesFromCursor ); @@ -542,7 +542,7 @@ public void callNextAfterReadingPropertyChain() try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( firstPropertyId, NO_LOCK, () -> {} ); + cursor.init( firstPropertyId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); assertEquals( "1", cursor.value() ); @@ -568,7 +568,7 @@ public void skipUnusedRecordsInChain() try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( firstPropertyId, NO_LOCK, () -> {} ); + cursor.init( firstPropertyId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); List valuesFromCursor = asPropertyValuesList( cursor ); assertEquals( asList( "1", 3, 5L, '7', "9 and 10" ), valuesFromCursor ); @@ -587,7 +587,7 @@ public void skipUnusedConsecutiveRecordsInChain() try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( firstPropertyId, NO_LOCK, () -> {} ); + cursor.init( firstPropertyId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); List valuesFromCursor = asPropertyValuesList( cursor ); assertEquals( asList( "1", "2", 6L, '7', '8', "9 and 10" ), valuesFromCursor ); @@ -607,7 +607,7 @@ public void skipAllRecordsWhenWholeChainNotInUse() try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( firstPropertyId, NO_LOCK, () -> {} ); + cursor.init( firstPropertyId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); List valuesFromCursor = asPropertyValuesList( cursor ); assertEquals( Collections.emptyList(), valuesFromCursor ); @@ -626,7 +626,7 @@ public void readPropertyChainWithLongStringDynamicRecordsNotInUse() try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( chainStartId, NO_LOCK, () -> {} ); + cursor.init( chainStartId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); List valuesFromCursor = asPropertyValuesList( cursor ); assertEquals( asList( values ), valuesFromCursor ); @@ -692,7 +692,7 @@ public void readPropertyChainWithLongArrayDynamicRecordsNotInUse() try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( chainStartId, NO_LOCK, () -> {} ); + cursor.init( chainStartId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); List valuesFromCursor = asPropertyValuesList( cursor ); for ( int i = 0; i < valuesFromCursor.size(); i++ ) @@ -730,7 +730,7 @@ private void verifyPropertyValue( String expectedValue, long recordId ) { try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( recordId, NO_LOCK, () -> {} ); + cursor.init( recordId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); assertEquals( expectedValue, cursor.value() ); assertFalse( cursor.next() ); @@ -741,7 +741,7 @@ private void verifyPropertyValue( byte[] expectedValue, long recordId ) { try ( StorePropertyCursor cursor = newStorePropertyCursor( propertyStore ) ) { - cursor.init( recordId, NO_LOCK, () -> {} ); + cursor.init( recordId, NO_LOCK, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); assertArrayEquals( expectedValue, (byte[]) cursor.value() ); assertFalse( cursor.next() ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursorTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursorTest.java index 6f1f5ad0f00e..d029780adc21 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursorTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleNodeCursorTest.java @@ -36,6 +36,7 @@ import org.neo4j.graphdb.RelationshipType; import org.neo4j.graphdb.Transaction; import org.neo4j.graphdb.factory.GraphDatabaseSettings; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.core.RelationshipTypeTokenHolder; import org.neo4j.kernel.impl.core.TokenNotFoundException; import org.neo4j.kernel.impl.storageengine.impl.recordstorage.RecordStorageEngine; @@ -623,7 +624,7 @@ private StoreSingleNodeCursor newCursor( long nodeId ) mock( StoreStatement.class ), mock( Consumer.class ), new RecordCursors( resolveNeoStores() ), NO_LOCK_SERVICE ); - cursor.init( nodeId, () -> {} ); + cursor.init( nodeId, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); return cursor; diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleRelationshipCursorTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleRelationshipCursorTest.java index 8be4376796f1..633b00b38561 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleRelationshipCursorTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/StoreSingleRelationshipCursorTest.java @@ -25,6 +25,7 @@ import org.junit.Test; import org.junit.rules.RuleChain; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.impl.locking.LockService; import org.neo4j.kernel.impl.store.NeoStores; import org.neo4j.kernel.impl.store.RecordCursors; @@ -80,7 +81,7 @@ public void retrieveUsedRelationship() throws Exception try ( StoreSingleRelationshipCursor cursor = createRelationshipCursor() ) { - cursor.init( RELATIONSHIP_ID, () -> {} ); + cursor.init( RELATIONSHIP_ID, AssertOpen.ALWAYS_OPEN ); assertTrue( cursor.next() ); assertEquals( RELATIONSHIP_ID, cursor.get().id() ); } @@ -95,7 +96,7 @@ public void retrieveUnusedRelationship() try ( StoreSingleRelationshipCursor cursor = createRelationshipCursor() ) { - cursor.init( RELATIONSHIP_ID, () -> {} ); + cursor.init( RELATIONSHIP_ID, AssertOpen.ALWAYS_OPEN ); assertFalse( cursor.next() ); } } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataViewTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataViewTest.java index 45fa5b577cca..f98a7d1d1012 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataViewTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/coreapi/TxStateTransactionDataViewTest.java @@ -31,6 +31,7 @@ import org.neo4j.graphdb.event.LabelEntry; import org.neo4j.graphdb.event.PropertyEntry; import org.neo4j.kernel.api.KernelTransaction; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.Statement; import org.neo4j.kernel.api.properties.DefinedProperty; import org.neo4j.kernel.api.properties.Property; @@ -99,10 +100,10 @@ public void showsDeletedNodes() throws Exception state.nodeDoDelete( 1L ); state.nodeDoDelete( 2L ); - when( storeStatement.acquireSingleNodeCursor( eq( 2L ), any( Runnable.class ) ) ). + when( storeStatement.acquireSingleNodeCursor( eq( 2L ), any( AssertOpen.class ) ) ). thenReturn( asNodeCursor( 2L, asPropertyCursor( stringProperty( 1, "p" ) ), asLabelCursor( 15 ) ) ); - when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( Runnable.class ) ) ). + when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( AssertOpen.class ) ) ). thenReturn( asNodeCursor( 1L, asPropertyCursor(), asLabelCursor() ) ); when( ops.propertyKeyGetName( 1 ) ).thenReturn( "key" ); @@ -133,9 +134,9 @@ public void showsRemovedRelationships() throws Exception state.relationshipDoDelete( 1L, 1, 1L, 2L ); state.relationshipDoDelete( 2L, 1, 1L, 1L ); - when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( Runnable.class ) ) ). + when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( AssertOpen.class ) ) ). thenReturn( asRelationshipCursor( 1L, 1, 1L, 2L, asPropertyCursor() ) ); - when( storeStatement.acquireSingleRelationshipCursor( eq( 2L ), any( Runnable.class ) ) ). + when( storeStatement.acquireSingleRelationshipCursor( eq( 2L ), any( AssertOpen.class ) ) ). thenReturn( asRelationshipCursor( 2L, 1, 1L, 1L, asPropertyCursor( Property.stringProperty( 1, "p" ) ) ) ); when( ops.propertyKeyGetName( 1 ) ).thenReturn( "key" ); @@ -155,7 +156,7 @@ public void correctlySaysNodeIsDeleted() throws Exception state.nodeDoDelete( nodeId ); Node node = mock( Node.class ); when( node.getId() ).thenReturn( 1L ); - when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( 1 ) ); // when( ops.nodeGetLabels( storeStatement, 1L ) ).thenReturn( PrimitiveIntCollections.emptyIterator() ); @@ -171,7 +172,7 @@ public void correctlySaysRelIsDeleted() throws Exception Relationship rel = mock( Relationship.class ); when( rel.getId() ).thenReturn( 1L ); - when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( AssertOpen.class ) ) ) .thenReturn( asRelationshipCursor( 1L, 1, 1L, 2L, asPropertyCursor() ) ); // When & Then @@ -185,7 +186,7 @@ public void shouldListAddedNodePropertiesProperties() throws Exception DefinedProperty prevProp = stringProperty( 1, "prevValue" ); state.nodeDoReplaceProperty( 1L, prevProp, stringProperty( 1, "newValue" ) ); when( ops.propertyKeyGetName( 1 ) ).thenReturn( "theKey" ); - when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( Runnable.class ) ) ).thenReturn( + when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( 1L, asPropertyCursor( prevProp ), asLabelCursor() ) ); // When @@ -206,7 +207,7 @@ public void shouldListRemovedNodeProperties() throws Exception DefinedProperty prevProp = stringProperty( 1, "prevValue" ); state.nodeDoRemoveProperty( 1L, prevProp ); when( ops.propertyKeyGetName( 1 ) ).thenReturn( "theKey" ); - when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( Runnable.class ) ) ).thenReturn( + when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( AssertOpen.class ) ) ).thenReturn( asNodeCursor( 1L, asPropertyCursor( prevProp ), asLabelCursor() ) ); // When @@ -226,7 +227,7 @@ public void shouldListRemovedRelationshipProperties() throws Exception DefinedProperty prevValue = stringProperty( 1, "prevValue" ); state.relationshipDoRemoveProperty( 1L, prevValue ); when( ops.propertyKeyGetName( 1 ) ).thenReturn( "theKey" ); - when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( Runnable.class ) ) ).thenReturn( + when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( AssertOpen.class ) ) ).thenReturn( StubCursors.asRelationshipCursor( 1, 0, 0, 0, asPropertyCursor( prevValue ) ) ); @@ -248,7 +249,7 @@ public void shouldListAddedRelationshipProperties() throws Exception state.relationshipDoReplaceProperty( 1L, prevProp, stringProperty( 1, "newValue" ) ); when( ops.propertyKeyGetName( 1 ) ).thenReturn( "theKey" ); - when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( Runnable.class ) ) ).thenReturn( + when( storeStatement.acquireSingleRelationshipCursor( eq( 1L ), any( AssertOpen.class ) ) ).thenReturn( StubCursors.asRelationshipCursor( 1, 0, 0, 0, asPropertyCursor( prevProp ) ) ); @@ -269,7 +270,7 @@ public void shouldListAddedLabels() throws Exception // Given state.nodeDoAddLabel( 2, 1L ); when( ops.labelGetName( 2 ) ).thenReturn( "theLabel" ); - when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( Runnable.class ) ) ) + when( storeStatement.acquireSingleNodeCursor( eq( 1L ), any( AssertOpen.class ) ) ) .thenReturn( asNodeCursor( 1 ) ); // When diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java index c19930076742..da429de81da1 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java @@ -100,6 +100,7 @@ import static org.junit.Assert.fail; import static org.neo4j.graphdb.factory.GraphDatabaseSettings.counts_store_rotation_timeout; import static org.neo4j.helpers.collection.MapUtil.stringMap; +import static org.neo4j.kernel.api.AssertOpen.ALWAYS_OPEN; import static org.neo4j.kernel.api.security.SecurityContext.AUTH_DISABLED; import static org.neo4j.kernel.impl.store.RecordStore.getRecord; import static org.neo4j.kernel.impl.store.format.standard.MetaDataRecordFormat.FIELD_NOT_PRESENT; @@ -292,7 +293,7 @@ private DefinedProperty nodeAddProperty( long nodeId, int key, Object value ) DefinedProperty property = Property.property( key, value ); Property oldProperty = Property.noNodeProperty( nodeId, key ); try ( StorageStatement statement = storeLayer.newStatement(); - Cursor cursor = statement.acquireSingleNodeCursor( nodeId, () -> {} ) ) + Cursor cursor = statement.acquireSingleNodeCursor( nodeId, ALWAYS_OPEN ) ) { if ( cursor.next() ) { @@ -313,7 +314,8 @@ private DefinedProperty relAddProperty( long relationshipId, int key, Object val DefinedProperty property = Property.property( key, value ); Property oldProperty = Property.noRelationshipProperty( relationshipId, key ); try ( StorageStatement statement = storeLayer.newStatement(); - Cursor cursor = statement.acquireSingleRelationshipCursor( relationshipId, () -> {} ) ) + Cursor cursor = statement.acquireSingleRelationshipCursor( relationshipId, + ALWAYS_OPEN ) ) { if ( cursor.next() ) { @@ -947,7 +949,7 @@ private int validateAndCountRelationships( long node, long rel1, long rel2, int { int count = 0; try ( KernelStatement statement = (KernelStatement) tx.acquireStatement(); - Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( node, () -> {} ) ) + Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( node, statement ) ) { nodeCursor.next(); @@ -1029,7 +1031,7 @@ else if ( data.propertyKeyId() == prop3.propertyKeyId() ) count = 0; try ( KernelStatement statement = (KernelStatement) tx.acquireStatement(); - Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( node, () -> {} ) ) + Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( node, statement ) ) { nodeCursor.next(); @@ -1064,7 +1066,7 @@ private boolean nodeExists( long nodeId ) { try ( StorageStatement statement = storeLayer.newStatement() ) { - try ( Cursor node = statement.acquireSingleNodeCursor( nodeId, () -> {} ) ) + try ( Cursor node = statement.acquireSingleNodeCursor( nodeId, ALWAYS_OPEN ) ) { return node.next(); } @@ -1327,7 +1329,7 @@ private void assertHasRelationships( long node ) { try ( KernelStatement statement = (KernelStatement) tx.acquireStatement(); - Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( node, () -> {} ) ) + Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( node, statement ) ) { nodeCursor.next(); PrimitiveLongIterator rels = nodeCursor.get().getRelationships( Direction.BOTH ); @@ -1435,7 +1437,8 @@ private void testGetRels( long[] relIds ) { for ( long relId : relIds ) { - try ( Cursor relationship = statement.acquireSingleRelationshipCursor( relId, () -> {} ) ) + try ( Cursor relationship = statement.acquireSingleRelationshipCursor( relId, + ALWAYS_OPEN ) ) { assertFalse( relationship.next() ); } @@ -1446,7 +1449,7 @@ private void testGetRels( long[] relIds ) private void deleteRelationships( long nodeId ) throws Exception { try ( KernelStatement statement = (KernelStatement) tx.acquireStatement(); - Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( nodeId, () -> {} ) ) + Cursor nodeCursor = statement.getStoreStatement().acquireSingleNodeCursor( nodeId, statement ) ) { nodeCursor.next(); PrimitiveLongIterator relationships = nodeCursor.get().getRelationships( Direction.BOTH ); diff --git a/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/PropertyExistenceEnforcer.java b/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/PropertyExistenceEnforcer.java index 045f49dcfb1c..7fe57410d209 100644 --- a/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/PropertyExistenceEnforcer.java +++ b/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/PropertyExistenceEnforcer.java @@ -25,6 +25,7 @@ import org.neo4j.collection.primitive.Primitive; import org.neo4j.collection.primitive.PrimitiveIntSet; import org.neo4j.cursor.Cursor; +import org.neo4j.kernel.api.AssertOpen; import org.neo4j.kernel.api.constraints.NodePropertyExistenceConstraint; import org.neo4j.kernel.api.constraints.PropertyConstraint; import org.neo4j.kernel.api.constraints.RelationshipPropertyConstraint; @@ -149,7 +150,7 @@ private void validateNode( long nodeId ) throws ConstraintValidationKernelExcept private Cursor nodeCursor( long id ) { - Cursor cursor = storeStatement().acquireSingleNodeCursor( id, () -> {} ); + Cursor cursor = storeStatement().acquireSingleNodeCursor( id, AssertOpen.ALWAYS_OPEN ); return txState.augmentSingleNodeCursor( cursor, id ); } @@ -213,7 +214,7 @@ private void validateRelationship( long id ) throws ConstraintValidationKernelEx private Cursor relationshipCursor( long id ) { - Cursor cursor = storeStatement().acquireSingleRelationshipCursor( id, () -> {} ); + Cursor cursor = storeStatement().acquireSingleRelationshipCursor( id, AssertOpen.ALWAYS_OPEN ); return txState.augmentSingleRelationshipCursor( cursor, id ); } }