public Iterable<SimpleRelationship> getSimpleRelationships(long nodeId) { NodeRecord nodeRecord = getNodeRecord(nodeId); long nextRel = nodeRecord.getNextRel(); List<SimpleRelationship> rels = new ArrayList<SimpleRelationship>(); while (nextRel != Record.NO_NEXT_RELATIONSHIP.intValue()) { RelationshipRecord relRecord = getRelationshipRecord(nextRel); RelationshipType type = new RelationshipTypeImpl(typeHolder.getName(relRecord.getType())); rels.add( new SimpleRelationship( relRecord.getId(), relRecord.getFirstNode(), relRecord.getSecondNode(), type)); long firstNode = relRecord.getFirstNode(); long secondNode = relRecord.getSecondNode(); if (firstNode == nodeId) { nextRel = relRecord.getFirstNextRel(); } else if (secondNode == nodeId) { nextRel = relRecord.getSecondNextRel(); } else { throw new InvalidRecordException( "Node[" + nodeId + "] not part of firstNode[" + firstNode + "] or secondNode[" + secondNode + "]"); } } return rels; }
@Override public Iterable<Long> getRelationshipIds(long nodeId) { NodeRecord nodeRecord = getNodeRecord(nodeId); long nextRel = nodeRecord.getNextRel(); List<Long> ids = new ArrayList<Long>(); while (nextRel != Record.NO_NEXT_RELATIONSHIP.intValue()) { RelationshipRecord relRecord = getRelationshipRecord(nextRel); ids.add(relRecord.getId()); long firstNode = relRecord.getFirstNode(); long secondNode = relRecord.getSecondNode(); if (firstNode == nodeId) { nextRel = relRecord.getFirstNextRel(); } else if (secondNode == nodeId) { nextRel = relRecord.getSecondNextRel(); } else { throw new InvalidRecordException( "Node[" + nodeId + "] not part of firstNode[" + firstNode + "] or secondNode[" + secondNode + "]"); } } return ids; }
@Override public void invalidateCache(CacheAccessBackDoor cacheAccess) { cacheAccess.removeRelationshipFromCache(getKey()); /* * If isRecovered() then beforeUpdate is the correct one UNLESS this is the second time this command * is executed, where it might have been actually written out to disk so the fields are already -1. So * we still need to check. * If !isRecovered() then beforeUpdate is the same as record, so we are still ok. * We don't check for !inUse() though because that is implicit in the call of this method. * The above is a hand waiving proof that the conditions that lead to the patchDeletedRelationshipNodes() * in the if below are the same as in RelationshipCommand.execute() so it should be safe. */ if (beforeUpdate.getFirstNode() != -1 || beforeUpdate.getSecondNode() != -1) { cacheAccess.patchDeletedRelationshipNodes( getKey(), beforeUpdate.getFirstNode(), beforeUpdate.getFirstNextRel(), beforeUpdate.getSecondNode(), beforeUpdate.getSecondNextRel()); } if (record.getFirstNode() != -1 || record.getSecondNode() != -1) { cacheAccess.removeNodeFromCache(record.getFirstNode()); cacheAccess.removeNodeFromCache(record.getSecondNode()); } }
@Override long get(RelationshipRecord rel) { return rel.getFirstNextRel(); }