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;
}
@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);
}
@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);
}
private Iterator<UniquenessConstraint> applyConstraintsDiff(
KernelStatement state, Iterator<UniquenessConstraint> constraints) {
if (state.hasTxStateWithChanges()) {
return state.txState().constraintsChanges().apply(constraints);
}
return constraints;
}
@Override
public void relationshipDelete(final KernelStatement state, long relationshipId)
throws EntityNotFoundException {
assertRelationshipExists(state, relationshipId);
// NOTE: We implicitly delegate to neoStoreTransaction via txState.legacyState here. This is
// because that
// call returns modified properties, which node manager uses to update legacy tx state. This
// will be cleaned up
// once we've removed legacy tx state.
legacyPropertyTrackers.relationshipDelete(relationshipId);
final TransactionState txState = state.txState();
if (txState.relationshipIsAddedInThisTx(relationshipId)) {
txState.relationshipDoDeleteAddedInThisTx(relationshipId);
} else {
try {
storeLayer.relationshipVisit(
relationshipId,
new RelationshipVisitor<RuntimeException>() {
@Override
public void visit(long relId, int type, long startNode, long endNode) {
txState.relationshipDoDelete(relId, type, startNode, endNode);
}
});
} catch (EntityNotFoundException e) {
// If it doesn't exist, it doesn't exist, and the user got what she wanted.
return;
}
}
}
@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 Iterator<DefinedProperty> graphGetAllProperties(KernelStatement state) {
if (state.hasTxStateWithChanges()) {
return state.txState().augmentGraphProperties(storeLayer.graphGetAllProperties());
}
return storeLayer.graphGetAllProperties();
}
@Override
public Property graphRemoveProperty(KernelStatement state, int propertyKeyId) {
Property existingProperty = graphGetProperty(state, propertyKeyId);
if (existingProperty.isDefined()) {
state.txState().graphDoRemoveProperty((DefinedProperty) existingProperty);
}
return existingProperty;
}
@Override
public Iterator<IndexDescriptor> uniqueIndexesGetAll(KernelStatement state) {
if (state.hasTxStateWithChanges()) {
return state.txState().constraintIndexChanges().apply(storeLayer.uniqueIndexesGetAll());
}
return storeLayer.uniqueIndexesGetAll();
}
@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 PrimitiveIntIterator nodeGetLabels(KernelStatement state, long nodeId)
throws EntityNotFoundException {
if (state.hasTxStateWithChanges()) {
return nodeGetLabels(storeLayer, state.txState(), nodeId);
}
return storeLayer.nodeGetLabels(nodeId);
}
@Override
public void relationshipRemoveFromLegacyIndex(
KernelStatement statement, String indexName, long relationship, String key, Object value)
throws LegacyIndexNotFoundKernelException {
statement
.txState()
.getRelationshipLegacyIndexChanges(indexName)
.remove(relationship, key, value);
}
@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 long relationshipCreate(
KernelStatement state, int relationshipTypeId, long startNodeId, long endNodeId)
throws EntityNotFoundException {
assertNodeExists(state, startNodeId);
assertNodeExists(state, endNodeId);
long id = storeLayer.reserveRelationship();
state.txState().relationshipDoCreate(id, relationshipTypeId, startNodeId, endNodeId);
return id;
}
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 long countsForNode(KernelStatement statement, int labelId) {
long count = storeLayer.countsForNode(labelId);
if (statement.hasTxState()) {
if (labelId != ReadOperations.ANY_LABEL) {
throw new UnsupportedOperationException("not implemented");
}
count += statement.txState().addedAndRemovedNodes().delta();
}
return count;
}
// <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);
}
@Override
public Property nodeRemoveProperty(KernelStatement state, long nodeId, int propertyKeyId)
throws EntityNotFoundException {
Property existingProperty = nodeGetProperty(state, nodeId, propertyKeyId);
if (existingProperty.isDefined()) {
legacyPropertyTrackers.nodeRemoveStoreProperty(nodeId, (DefinedProperty) existingProperty);
state.txState().nodeDoRemoveProperty(nodeId, (DefinedProperty) existingProperty);
indexesUpdateProperty(state, nodeId, propertyKeyId, (DefinedProperty) existingProperty, null);
}
return existingProperty;
}
@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 void indexUpdateProperty(
KernelStatement state,
long nodeId,
int labelId,
int propertyKey,
Object valueBefore,
Object valueAfter) {
IndexDescriptor descriptor = indexesGetForLabelAndPropertyKey(state, labelId, propertyKey);
if (descriptor != null) {
state.txState().indexUpdateProperty(descriptor, nodeId, valueBefore, valueAfter);
}
}
private void indexUpdateProperty(
KernelStatement state,
long nodeId,
int labelId,
int propertyKey,
DefinedProperty before,
DefinedProperty after) {
IndexDescriptor descriptor = indexesGetForLabelAndPropertyKey(state, labelId, propertyKey);
if (descriptor != null) {
state.txState().indexDoUpdateProperty(descriptor, nodeId, before, after);
}
}
@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);
}
@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);
}
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 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 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 Property relationshipRemoveProperty(
KernelStatement state, long relationshipId, int propertyKeyId)
throws EntityNotFoundException {
Property existingProperty = relationshipGetProperty(state, relationshipId, propertyKeyId);
if (existingProperty.isDefined()) {
legacyPropertyTrackers.relationshipRemoveStoreProperty(
relationshipId, (DefinedProperty) existingProperty);
state
.txState()
.relationshipDoRemoveProperty(relationshipId, (DefinedProperty) existingProperty);
}
return existingProperty;
}
@Override
public LegacyIndexHits relationshipLegacyIndexQuery(
KernelStatement statement,
String indexName,
Object queryOrQueryObject,
long startNode,
long endNode)
throws LegacyIndexNotFoundKernelException {
LegacyIndex index = statement.txState().getRelationshipLegacyIndexChanges(indexName);
if (startNode != -1 || endNode != -1) {
return index.query(queryOrQueryObject, startNode, endNode);
}
return index.query(queryOrQueryObject);
}
@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);
}
}
