@Override long compareNode( RelationshipRecord rel ) { return rel.getSecondNode(); }
@Override public long valueFrom( RelationshipRecord relationship ) { return relationship.getSecondNode(); }
@Override public long get( RelationshipRecord rel ) { return rel.getSecondNode(); } };
@Override long compareNode( RelationshipRecord rel ) { return rel.getSecondNode(); }
public RelationshipChainField fieldFor( long nodeId, RelationshipRecord rel ) { if ( rel.getFirstNode() == nodeId ) { return first; } else if ( rel.getSecondNode() == nodeId ) { return second; } throw new IllegalArgumentException( format( "%s does not reference node %d", rel, nodeId ) ); } }
private static RelationshipConnection relChain( RelationshipRecord rel, long nodeId ) { if ( rel.getFirstNode() == nodeId ) { return RelationshipConnection.START_NEXT; } if ( rel.getSecondNode() == nodeId ) { return RelationshipConnection.END_NEXT; } throw new RuntimeException( nodeId + " neither start not end node in " + rel ); } }
public static NodeField select( RelationshipRecord relationship, long nodeId ) { if ( relationship.getFirstNode() == nodeId ) { return SOURCE; } else if ( relationship.getSecondNode() == nodeId ) { return TARGET; } else { return null; } }
private boolean relIsFirstInChain( long nodeId, RelationshipRecord rel ) { return (nodeId == rel.getFirstNode() && rel.isFirstInFirstChain()) || (nodeId == rel.getSecondNode() && rel.isFirstInSecondChain()); } }
public static DirectionWrapper wrapDirection( RelationshipRecord rel, NodeRecord startNode ) { boolean isOut = rel.getFirstNode() == startNode.getId(); boolean isIn = rel.getSecondNode() == startNode.getId(); assert isOut | isIn; if ( isOut & isIn ) { return DirectionWrapper.BOTH; } return isOut ? DirectionWrapper.OUTGOING : DirectionWrapper.INCOMING; } }
@Override protected void linkEnd( RelationshipRecord record ) { int typeId = record.getType(); long secondPrevRel = cache.getAndPutRelationship( record.getSecondNode(), typeId, Direction.INCOMING, record.getId(), false ); if ( secondPrevRel == ID_NOT_FOUND ) { // First one record.setFirstInSecondChain( true ); secondPrevRel = cache.getCount( record.getSecondNode(), typeId, Direction.INCOMING ); } record.setSecondPrevRel( secondPrevRel ); }
@Override protected void linkEnd( RelationshipRecord record ) { long secondNextRel = cache.getAndPutRelationship( record.getSecondNode(), record.getType(), Direction.INCOMING, record.getId(), true ); record.setSecondNextRel( secondNextRel ); }
private RecordSet<RelationshipRecord> expandChains( RecordSet<RelationshipRecord> records, long otherNodeId ) { RecordSet<RelationshipRecord> chains = new RecordSet<>(); for ( RelationshipRecord record : records ) { chains.addAll( expandChainInBothDirections( record, record.getFirstNode() == otherNodeId ? record.getSecondNode() : record.getFirstNode() ) ); } return chains; }
@Override public BatchRelationship getRelationshipById( long relId ) { RelationshipRecord record = getRelationshipRecord( relId ).forReadingData(); return batchRelationshipOf( relId, record.getType(), record.getFirstNode(), record.getSecondNode() ); }
private void setCorrectNextRel( NodeRecord node, RelationshipRecord rel, long nextRel ) { if ( node.getId() == rel.getFirstNode() ) { rel.setFirstNextRel( nextRel ); } if ( node.getId() == rel.getSecondNode() ) { rel.setSecondNextRel( nextRel ); } }
@Override protected void forkedProcess( int id, int processors, RelationshipRecord[] batch ) { for ( RelationshipRecord record : batch ) { if ( record.inUse() ) { long startNodeId = record.getFirstNode(); long endNodeId = record.getSecondNode(); processNodeId( id, processors, startNodeId ); if ( startNodeId != endNodeId ) // avoid counting loops twice { // Loops only counts as one processNodeId( id, processors, endNodeId ); } } } }
Record( RelationshipRecord record, Record next ) { if ( record != null ) { id = record.getId(); type = record.getType(); nextProp = record.getNextProp(); firstNode = record.getFirstNode(); secondNode = record.getSecondNode(); } else { id = NO_ID; type = NO_ID; nextProp = NO_ID; firstNode = NO_ID; secondNode = NO_ID; } this.next = next; } }
@Override public <EXCEPTION extends Exception> void relationshipVisit( long relationshipId, RelationshipVisitor<EXCEPTION> relationshipVisitor ) throws EntityNotFoundException, EXCEPTION { // TODO Please don't create a record for this, it's ridiculous RelationshipRecord record = relationshipStore.getRecord( relationshipId, relationshipStore.newRecord(), CHECK ); if ( !record.inUse() ) { throw new EntityNotFoundException( EntityType.RELATIONSHIP, relationshipId ); } relationshipVisitor.visit( relationshipId, record.getType(), record.getFirstNode(), record.getSecondNode() ); }
@Override protected void assertRecordsEqual( RelationshipRecord actualRecord, RelationshipRecord expectedRecord ) { assertNotNull( "actualRecord", actualRecord ); assertNotNull( "expectedRecord", expectedRecord ); assertThat( "getFirstNextRel", actualRecord.getFirstNextRel(), is( expectedRecord.getFirstNextRel() ) ); assertThat( "getFirstNode", actualRecord.getFirstNode(), is( expectedRecord.getFirstNode() ) ); assertThat( "getFirstPrevRel", actualRecord.getFirstPrevRel(), is( expectedRecord.getFirstPrevRel() ) ); assertThat( "getSecondNextRel", actualRecord.getSecondNextRel(), is( expectedRecord.getSecondNextRel() ) ); assertThat( "getSecondNode", actualRecord.getSecondNode(), is( expectedRecord.getSecondNode() ) ); assertThat( "getSecondPrevRel", actualRecord.getSecondPrevRel(), is( expectedRecord.getSecondPrevRel() ) ); assertThat( "getType", actualRecord.getType(), is( expectedRecord.getType() ) ); assertThat( "isFirstInFirstChain", actualRecord.isFirstInFirstChain(), is( expectedRecord.isFirstInFirstChain() ) ); assertThat( "isFirstInSecondChain", actualRecord.isFirstInSecondChain(), is( expectedRecord.isFirstInSecondChain() ) ); assertThat( "getId", actualRecord.getId(), is( expectedRecord.getId() ) ); assertThat( "getLongId", actualRecord.getId(), is( expectedRecord.getId() ) ); assertThat( "getNextProp", actualRecord.getNextProp(), is( expectedRecord.getNextProp() ) ); assertThat( "inUse", actualRecord.inUse(), is( expectedRecord.inUse() ) ); }
private String diff( RelationshipRecord expected, RelationshipRecord actual ) { if ( actual.getId() == expected.getId() && actual.getFirstNode() == expected.getFirstNode() && actual.getSecondNode() == expected.getSecondNode() && actual.getType() == expected.getType() && actual.getFirstPrevRel() == expected.getFirstPrevRel() && actual.getFirstNextRel() == expected.getFirstNextRel() && actual.getSecondPrevRel() == expected.getSecondPrevRel() && actual.getSecondNextRel() == expected.getSecondNextRel() && actual.isFirstInFirstChain() == expected.isFirstInFirstChain() && actual.isFirstInSecondChain() == expected.isFirstInSecondChain() ) { return null; } return describeDiff( expected.toString(), actual.toString() ); }
@Override public RecordKey<RelationshipRecord> relationship() { return ( written, read ) -> { assertEquals( written.getNextProp(), read.getNextProp() ); assertEquals( written.getFirstNode(), read.getFirstNode() ); assertEquals( written.getSecondNode(), read.getSecondNode() ); assertEquals( written.getType(), read.getType() ); assertEquals( written.getFirstPrevRel(), read.getFirstPrevRel() ); assertEquals( written.getFirstNextRel(), read.getFirstNextRel() ); assertEquals( written.getSecondPrevRel(), read.getSecondPrevRel() ); assertEquals( written.getSecondNextRel(), read.getSecondNextRel() ); assertEquals( written.isFirstInFirstChain(), read.isFirstInFirstChain() ); assertEquals( written.isFirstInSecondChain(), read.isFirstInSecondChain() ); }; }