private Iterator<UniquenessConstraint> applyConstraintsDiff( KernelStatement state, Iterator<UniquenessConstraint> constraints) { if (state.hasTxStateWithChanges()) { return state.txState().constraintsChanges().apply(constraints); } return constraints; }
@Override public PrimitiveLongIterator graphGetPropertyKeys(KernelStatement state) { if (state.hasTxStateWithChanges()) { return new PropertyKeyIdIterator(graphGetAllProperties(state)); } return storeLayer.graphGetPropertyKeys(state); }
@Override public Iterator<DefinedProperty> graphGetAllProperties(KernelStatement state) { if (state.hasTxStateWithChanges()) { return state.txState().augmentGraphProperties(storeLayer.graphGetAllProperties()); } return storeLayer.graphGetAllProperties(); }
@Override public Iterator<IndexDescriptor> uniqueIndexesGetAll(KernelStatement state) { if (state.hasTxStateWithChanges()) { return state.txState().constraintIndexChanges().apply(storeLayer.uniqueIndexesGetAll()); } return storeLayer.uniqueIndexesGetAll(); }
@Override public PrimitiveIntIterator nodeGetLabels(KernelStatement state, long nodeId) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { return nodeGetLabels(storeLayer, state.txState(), nodeId); } return storeLayer.nodeGetLabels(nodeId); }
@Override public PrimitiveLongIterator relationshipGetPropertyKeys( KernelStatement state, long relationshipId) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { return new PropertyKeyIdIterator(relationshipGetAllProperties(state, relationshipId)); } return storeLayer.relationshipGetPropertyKeys(relationshipId); }
@Override public Iterator<IndexDescriptor> uniqueIndexesGetForLabel(KernelStatement state, int labelId) { if (state.hasTxStateWithChanges()) { return state .txState() .constraintIndexDiffSetsByLabel(labelId) .apply(storeLayer.uniqueIndexesGetForLabel(labelId)); } return storeLayer.uniqueIndexesGetForLabel(labelId); }
private PrimitiveLongIterator filterIndexStateChanges( KernelStatement state, IndexDescriptor index, Object value, PrimitiveLongIterator nodeIds) { if (state.hasTxStateWithChanges()) { ReadableDiffSets<Long> labelPropertyChanges = state.txState().indexUpdates(index, value); ReadableDiffSets<Long> nodes = state.txState().addedAndRemovedNodes(); // Apply to actual index lookup return nodes.augmentWithRemovals(labelPropertyChanges.augment(nodeIds)); } return nodeIds; }
// <Legacy index> @Override public <EXCEPTION extends Exception> void relationshipVisit( KernelStatement statement, long relId, RelationshipVisitor<EXCEPTION> visitor) throws EntityNotFoundException, EXCEPTION { if (statement.hasTxStateWithChanges()) { if (statement.txState().relationshipVisit(relId, visitor)) { return; } } storeLayer.relationshipVisit(relId, visitor); }
private Iterator<UniquenessConstraint> applyConstraintsDiff( KernelStatement state, Iterator<UniquenessConstraint> constraints) { if (state.hasTxStateWithChanges()) { DiffSets<UniquenessConstraint> diff = state.txState().constraintsChanges(); if (diff != null) { return diff.apply(constraints); } } return constraints; }
@Override public PrimitiveLongIterator nodesGetForLabel(KernelStatement state, int labelId) { if (state.hasTxStateWithChanges()) { PrimitiveLongIterator wLabelChanges = state .txState() .nodesWithLabelChanged(labelId) .augment(storeLayer.nodesGetForLabel(state, labelId)); return state.txState().addedAndRemovedNodes().augmentWithRemovals(wLabelChanges); } return storeLayer.nodesGetForLabel(state, labelId); }
private Iterator<UniquenessConstraint> applyConstraintsDiff( KernelStatement state, Iterator<UniquenessConstraint> constraints, int labelId, int propertyKeyId) { if (state.hasTxStateWithChanges()) { return state .txState() .constraintsChangesForLabelAndProperty(labelId, propertyKeyId) .apply(constraints); } return constraints; }
@Override public boolean nodeExists(KernelStatement state, long nodeId) { if (state.hasTxStateWithChanges()) { if (state.txState().nodeIsDeletedInThisTx(nodeId)) { return false; } if (state.txState().nodeIsAddedInThisTx(nodeId)) { return true; } } return storeLayer.nodeExists(nodeId); }
@Override public boolean relationshipExists(KernelStatement state, long relId) { if (state.hasTxStateWithChanges()) { if (state.txState().relationshipIsDeletedInThisTx(relId)) { return false; } if (state.txState().relationshipIsAddedInThisTx(relId)) { return true; } } return storeLayer.relationshipExists(relId); }
@Override public IndexDescriptor indexesGetForLabelAndPropertyKey( KernelStatement state, int labelId, int propertyKey) { IndexDescriptor indexDescriptor = storeLayer.indexesGetForLabelAndPropertyKey(labelId, propertyKey); Iterator<IndexDescriptor> rules = iterator(indexDescriptor); if (state.hasTxStateWithChanges()) { rules = filterByPropertyKeyId( state.txState().indexDiffSetsByLabel(labelId).apply(rules), propertyKey); } return singleOrNull(rules); }
@Override public PrimitiveLongIterator nodeGetRelationships( KernelStatement state, long nodeId, Direction direction) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { ReadableTxState txState = state.txState(); PrimitiveLongIterator stored; if (txState.nodeIsAddedInThisTx(nodeId)) { stored = PrimitiveLongCollections.emptyIterator(); } else { stored = storeLayer.nodeListRelationships(nodeId, direction); } return txState.augmentRelationships(nodeId, direction, stored); } return storeLayer.nodeListRelationships(nodeId, direction); }
@Override public Property relationshipGetProperty( KernelStatement state, long relationshipId, int propertyKeyId) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { Iterator<DefinedProperty> properties = relationshipGetAllProperties(state, relationshipId); while (properties.hasNext()) { Property property = properties.next(); if (property.propertyKeyId() == propertyKeyId) { return property; } } return Property.noRelationshipProperty(relationshipId, propertyKeyId); } return storeLayer.relationshipGetProperty(relationshipId, propertyKeyId); }
@Override public InternalIndexState indexGetState(KernelStatement state, IndexDescriptor descriptor) throws IndexNotFoundKernelException { // If index is in our state, then return populating if (state.hasTxStateWithChanges()) { if (checkIndexState( descriptor, state.txState().indexDiffSetsByLabel(descriptor.getLabelId()))) { return InternalIndexState.POPULATING; } if (checkIndexState( descriptor, state.txState().constraintIndexDiffSetsByLabel(descriptor.getLabelId()))) { return InternalIndexState.POPULATING; } } return storeLayer.indexGetState(descriptor); }
@Override public int nodeGetDegree(KernelStatement state, long nodeId, Direction direction) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { int degree = 0; if (state.txState().nodeIsDeletedInThisTx(nodeId)) { return 0; } if (!state.txState().nodeIsAddedInThisTx(nodeId)) { degree = storeLayer.nodeGetDegree(nodeId, direction); } return state.txState().augmentNodeDegree(nodeId, degree, direction); } else { return storeLayer.nodeGetDegree(nodeId, direction); } }
@Override public Iterator<DefinedProperty> nodeGetAllProperties(KernelStatement state, long nodeId) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { if (state.txState().nodeIsAddedInThisTx(nodeId)) { return state.txState().addedAndChangedNodeProperties(nodeId); } if (state.txState().nodeIsDeletedInThisTx(nodeId)) { // TODO Throw IllegalStateException to conform with beans API. We may want to introduce // EntityDeletedException instead and use it instead of returning empty values in similar // places throw new IllegalStateException("Node " + nodeId + " has been deleted"); } return state.txState().augmentNodeProperties(nodeId, storeLayer.nodeGetAllProperties(nodeId)); } return storeLayer.nodeGetAllProperties(nodeId); }
@Override public IndexDescriptor indexesGetForLabelAndPropertyKey( KernelStatement state, int labelId, int propertyKey) { Iterable<IndexDescriptor> committedRules; try { committedRules = option(storeLayer.indexesGetForLabelAndPropertyKey(labelId, propertyKey)); } catch (SchemaRuleNotFoundException e) { committedRules = emptyList(); } DiffSets<IndexDescriptor> ruleDiffSet = state.txState().indexDiffSetsByLabel(labelId); boolean hasTxStateWithChanges = state.hasTxStateWithChanges(); Iterator<IndexDescriptor> rules = hasTxStateWithChanges ? filterByPropertyKeyId(ruleDiffSet.apply(committedRules.iterator()), propertyKey) : committedRules.iterator(); return singleOrNull(rules); }
@Override public PrimitiveIntIterator nodeGetLabels(KernelStatement state, long nodeId) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { if (state.txState().nodeIsDeletedInThisTx(nodeId)) { return PrimitiveIntCollections.emptyIterator(); } if (state.txState().nodeIsAddedInThisTx(nodeId)) { return PrimitiveIntCollections.toPrimitiveIterator( state.txState().nodeStateLabelDiffSets(nodeId).getAdded().iterator()); } return state .txState() .nodeStateLabelDiffSets(nodeId) .augment(storeLayer.nodeGetLabels(nodeId)); } return storeLayer.nodeGetLabels(nodeId); }
@Override public boolean nodeHasLabel(KernelStatement state, long nodeId, int labelId) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { if (state.txState().nodeIsDeletedInThisTx(nodeId)) { return false; } if (state.txState().nodeIsAddedInThisTx(nodeId)) { TxState.UpdateTriState labelState = state.txState().labelState(nodeId, labelId); return labelState.isTouched() && labelState.isAdded(); } TxState.UpdateTriState labelState = state.txState().labelState(nodeId, labelId); if (labelState.isTouched()) { return labelState.isAdded(); } } return storeLayer.nodeHasLabel(nodeId, labelId); }
public static KernelStatement mockedState(final TransactionState txState) { KernelStatement state = mock(KernelStatement.class); Locks.Client lockHolder = mock(Locks.Client.class); try { IndexReader indexReader = mock(IndexReader.class); when(indexReader.lookup(Matchers.any())).thenReturn(PrimitiveLongCollections.emptyIterator()); when(state.getIndexReader(anyLong())).thenReturn(indexReader); } catch (IndexNotFoundKernelException e) { throw new Error(e); } when(state.txState()).thenReturn(txState); when(state.hasTxStateWithChanges()) .thenAnswer( new Answer<Boolean>() { @Override public Boolean answer(InvocationOnMock invocation) throws Throwable { return txState.hasChanges(); } }); when(state.locks()).thenReturn(lockHolder); return state; }
@Override public boolean nodeHasLabel(KernelStatement state, long nodeId, int labelId) throws EntityNotFoundException { if (state.hasTxStateWithChanges()) { if (state.txState().nodeIsDeletedInThisTx(nodeId)) { return false; } switch (state.txState().labelState(nodeId, labelId)) { case ADDED: return true; case REMOVED: return false; default: // i.e. UNTOUCHED if (state.txState().nodeIsAddedInThisTx(nodeId)) { return false; } // else fall through and return from the store layer } } return storeLayer.nodeHasLabel(nodeId, labelId); }
@Override public Cursor expand( KernelStatement statement, Cursor inputCursor, NeoRegister.Node.In nodeId, Register.Object.In<int[]> types, Register.Object.In<Direction> expandDirection, NeoRegister.Relationship.Out relId, NeoRegister.RelType.Out relType, Register.Object.Out<Direction> direction, NeoRegister.Node.Out startNodeId, NeoRegister.Node.Out neighborNodeId) { if (statement.hasTxStateWithChanges()) { return new AugmentWithLocalStateExpandCursor( storeLayer, statement.txState(), inputCursor, nodeId, types, expandDirection, relId, relType, direction, startNodeId, neighborNodeId); } return storeLayer.expand( inputCursor, nodeId, types, expandDirection, relId, relType, direction, startNodeId, neighborNodeId); }
@Override public PrimitiveIntIterator nodeGetRelationshipTypes(KernelStatement state, long nodeId) throws EntityNotFoundException { if (state.hasTxStateWithChanges() && state.txState().nodeModifiedInThisTx(nodeId)) { ReadableTxState tx = state.txState(); if (tx.nodeIsDeletedInThisTx(nodeId)) { return PrimitiveIntCollections.emptyIterator(); } if (tx.nodeIsAddedInThisTx(nodeId)) { return tx.nodeRelationshipTypes(nodeId); } Set<Integer> types = new HashSet<>(); // Add types in the current transaction PrimitiveIntIterator typesInTx = tx.nodeRelationshipTypes(nodeId); while (typesInTx.hasNext()) { types.add(typesInTx.next()); } // Augment with types stored on disk, minus any types where all rels of that type are deleted // in current tx. PrimitiveIntIterator committedTypes = storeLayer.nodeGetRelationshipTypes(nodeId); while (committedTypes.hasNext()) { int current = committedTypes.next(); if (!types.contains(current) && nodeGetDegree(state, nodeId, Direction.BOTH, current) > 0) { types.add(current); } } return PrimitiveIntCollections.toPrimitiveIterator(types.iterator()); } else { return storeLayer.nodeGetRelationshipTypes(nodeId); } }