@Override public PrimitiveLongResourceIterator nodesWithAnyOfLabels( long fromId, int... labelIds ) { List<PrimitiveLongResourceIterator> iterators = iteratorsForLabels( fromId, labelIds ); return new CompositeLabelScanValueIterator( iterators, false ); }
/** * @return {@link LabelScanReader} capable of finding node ids with given label ids. * Readers will immediately see updates made by {@link LabelScanWriter}, although {@link LabelScanWriter} * may internally batch updates so functionality isn't reliable. The only given is that readers will * see at least updates from closed {@link LabelScanWriter writers}. */ @Override public LabelScanReader newReader() { return new NativeLabelScanReader( index ); }
@Override public void prepareRemove( long txId, int offset ) { prepare( TYPE_PREPARE_REMOVE, txId, offset ); }
private static Hit<LabelScanKey,LabelScanValue> hit( long baseNodeId, long bits ) { LabelScanKey key = new LabelScanKey( LABEL_ID, baseNodeId ); LabelScanValue value = new LabelScanValue(); value.bits = bits; return new MutableHit<>( key, value ); }
private void shouldIterateCorrectlyOver( Labels... data ) throws Exception { // GIVEN try ( AllEntriesLabelScanReader reader = new NativeAllEntriesLabelScanReader( store( data ), highestLabelId( data ) ) ) { // WHEN/THEN assertRanges( reader, data ); } }
NativeLabelScanWriter( int batchSize, WriteMonitor monitor ) { this.pendingUpdates = new NodeLabelUpdate[batchSize]; this.addMerger = ( existingKey, newKey, existingValue, newValue ) -> { monitor.mergeAdd( existingValue, newValue ); return existingValue.add( newValue ); }; this.removeMerger = ( existingKey, newKey, existingValue, newValue ) -> { monitor.mergeRemove( existingValue, newValue ); return existingValue.remove( newValue ); }; this.monitor = monitor; }
private RawCursor<Hit<LabelScanKey,LabelScanValue>,IOException> seekerForLabel( long startId, int labelId ) throws IOException { LabelScanKey from = new LabelScanKey( labelId, rangeOf( startId ) ); LabelScanKey to = new LabelScanKey( labelId, Long.MAX_VALUE ); return index.seek( from, to ); }
private static void dumpPrepare( Dumper dumper, byte type, ReadableChannel channel, long range, int labelId, TxFilter txFilter, long session, long flush ) throws IOException { long txId = channel.getLong(); int offset = channel.get(); long nodeId = range * 64 + offset; if ( txFilter == null || txFilter.contains( txId ) ) { // I.e. if the txId this update comes from is within the txFilter dumper.prepare( type == TYPE_PREPARE_ADD, session, flush, txId, nodeId, labelId ); } }
@Override public LabelScanValue newValue() { return new LabelScanValue(); }
@Override public LabelScanKey newKey() { return new LabelScanKey(); }
@Override public void mergeRemove( LabelScanValue existingValue, LabelScanValue newValue ) { merge( TYPE_MERGE_REMOVE, existingValue, newValue ); }
@Override public boolean hasNext() { if ( !hasNextDecided ) { hasNext = fetchNext(); hasNextDecided = true; } return hasNext; }
@Override public void close() throws Exception { closeCursors(); }
@Override public void drop() throws IOException { try { dropStrict(); } catch ( NoSuchFileException e ) { // Even better, it didn't even exist } }
private void exhaust( LabelScanValueIndexProgressor pro ) { while ( pro.next() ) { //do nothing } } }
@Override public PrimitiveLongResourceIterator nodesWithAllLabels( int... labelIds ) { List<PrimitiveLongResourceIterator> iterators = iteratorsForLabels( NO_ID, labelIds ); return new CompositeLabelScanValueIterator( iterators, true ); }
private static LabelScanValue clone( LabelScanValue value ) { LabelScanValue result = new LabelScanValue(); result.bits = value.bits; return result; }
private static LabelScanKey clone( LabelScanKey key ) { return new LabelScanKey( key.labelId, key.idRange ); }
@Override public void prepareAdd( long txId, int offset ) { prepare( TYPE_PREPARE_ADD, txId, offset ); }
@Override public void mergeAdd( LabelScanValue existingValue, LabelScanValue newValue ) { merge( TYPE_MERGE_ADD, existingValue, newValue ); }