final synchronized BufferManager bufferManager() { if (bufferMgr == null) { bufferMgr = new BufferManager(this.context); } return bufferMgr; }
@After @Override public void afterEach() { this.bufferMgr.close(); }
@Override public QueueBuffer<BufferedRow> get() { if (buffer == null) { buffer = bufferMgr.createQueueBuffer(rowSerializer).useHeap(false).make(); } return buffer; }
if (allowDuplicates) { @SuppressWarnings( "rawtypes" ) Serializer<? extends Comparable> keySerializer = (Serializer<? extends Comparable<?>>)bufferMgr.serializerFor(keyType); buffer = bufferMgr.createSortingWithDuplicatesBuffer(keySerializer, extractor.getType().getComparator(), (BufferedRowFactory<BufferedRow>)rowFactory).keepSize(true) .useHeap(useHeap).make(); } else { BTreeKeySerializer<Object> keySerializer = (BTreeKeySerializer<Object>)bufferMgr.bTreeKeySerializerFor(keyType, pack); if (keySerializer instanceof KeySerializerWithComparator) { keySerializer = ((KeySerializerWithComparator<Object>)keySerializer).withComparator(extractor.getType() .getComparator()); buffer = bufferMgr.createSortingBuffer(keySerializer, (BufferedRowFactory<BufferedRow>)rowFactory).keepSize(true) .useHeap(useHeap).make();
@SuppressWarnings( "unchecked" ) @Test public void shouldCreateSortBufferOffHeap() { TypeFactory<String> stringType = types.getStringFactory(); BTreeKeySerializer<String> strKeySerializer = (BTreeKeySerializer<String>)mgr.bTreeKeySerializerFor(stringType, false); Serializer<String> strSerializer = (Serializer<String>)mgr.serializerFor(stringType); try (SortingBuffer<String, String> buffer = mgr.createSortingBuffer(strKeySerializer, strSerializer).useHeap(false) .keepSize(true).make()) { buffer.put("value1", "first"); buffer.put("value2", "first"); buffer.put("value3", "first"); buffer.put("value1", "second"); buffer.put("value3", "second"); buffer.put("value1", "third"); assertThat(buffer.size(), is(3L)); Iterator<String> iter = buffer.ascending(); assertThat(iter.next(), is("third")); assertThat(iter.next(), is("first")); assertThat(iter.next(), is("second")); assertThat(iter.hasNext(), is(false)); iter = buffer.descending(); assertThat(iter.next(), is("second")); assertThat(iter.next(), is("first")); assertThat(iter.next(), is("third")); assertThat(iter.hasNext(), is(false)); iter = buffer.getAll("value1"); assertThat(iter.next(), is("third")); assertThat(iter.hasNext(), is(false)); } }
@SuppressWarnings( "unchecked" ) public HashJoinSequence( String workspaceName, NodeSequence left, NodeSequence right, ExtractFromRow leftExtractor, ExtractFromRow rightExtractor, JoinType joinType, BufferManager bufferMgr, CachedNodeSupplier nodeCache, RangeProducer<?> rangeProducer, boolean pack, boolean useHeap ) { super(workspaceName, left, right, leftExtractor, rightExtractor, joinType, bufferMgr, nodeCache, pack, useHeap, true); this.rangeProducer = (RangeProducer<Object>)rangeProducer; if (useNonMatchingRightRows()) { TypeFactory<?> keyType = rightExtractor.getType(); Serializer<?> keySerializer = bufferMgr.serializerFor(keyType); rightMatchedRowKeys = (DistinctBuffer<Object>)bufferMgr.createDistinctBuffer(keySerializer).keepSize(true) .useHeap(useHeap).make(); Serializer<BufferedRow> rowSerializer = (Serializer<BufferedRow>)BufferedRows.serializer(nodeCache, width); rightRowsWithNullKey = bufferMgr.createDistinctBuffer(rowSerializer).keepSize(true).useHeap(useHeap).make(); } else { rightMatchedRowKeys = null; rightRowsWithNullKey = null; } }
public void shouldCreateSortWithDuplicateKeysBufferOnHeap() { TypeFactory<String> stringType = types.getStringFactory(); Serializer<String> strSerializer = (Serializer<String>)mgr.serializerFor(stringType); Comparator<String> keyComparator = stringType.getComparator(); try (SortingBuffer<String, String> buffer = mgr.createSortingWithDuplicatesBuffer(strSerializer, keyComparator, strSerializer).useHeap(true) .keepSize(true).make()) {
this.keyExtractor = RowExtractors.extractUniqueKey(delegate.width(), types); TypeFactory<?> keyType = types.getNodeKeyFactory(); Serializer<?> keySerializer = bufferMgr.nullSafeSerializerFor(keyType); Serializer<?> serializer = Tuples.serializer(keySerializer, delegate.width()); final DistinctBuffer<Object> rowsSeen = (DistinctBuffer<Object>)bufferMgr.createDistinctBuffer(serializer).keepSize(true) .useHeap(useHeap).make(); this.filter = new RowFilter() {
protected final void delete( String name, boolean onHeap ) { db(onHeap).delete(name); }
@SuppressWarnings( {"unchecked"} ) public SortingSequence( String workspaceName, NodeSequence delegate, ExtractFromRow extractor, BufferManager bufferMgr, CachedNodeSupplier nodeCache, boolean pack, boolean useHeap, boolean allowDuplicates, NullOrder nullOrder ) { super(workspaceName, delegate, extractor, bufferMgr, nodeCache, pack, useHeap, allowDuplicates); this.nullOrder = nullOrder; // Create the buffer into which we'll place the rows with null keys ... Serializer<BufferedRow> rowSerializer = (Serializer<BufferedRow>)BufferedRows.serializer(nodeCache, width); rowsWithNullKey = bufferMgr.createDistinctBuffer(rowSerializer).keepSize(true).useHeap(useHeap).make(); }
@Override public void close() { BufferManager.this.delete(name, onHeap); } }
if (allowDuplicates) { @SuppressWarnings( "rawtypes" ) Serializer<? extends Comparable> keySerializer = (Serializer<? extends Comparable<?>>)bufferMgr.serializerFor(keyType); buffer = bufferMgr.createSortingWithDuplicatesBuffer(keySerializer, extractor.getType().getComparator(), (BufferedRowFactory<BufferedRow>)rowFactory).keepSize(true) .useHeap(useHeap).make(); } else { BTreeKeySerializer<Object> keySerializer = (BTreeKeySerializer<Object>)bufferMgr.bTreeKeySerializerFor(keyType, pack); if (keySerializer instanceof KeySerializerWithComparator) { keySerializer = ((KeySerializerWithComparator<Object>)keySerializer).withComparator(extractor.getType() .getComparator()); buffer = bufferMgr.createSortingBuffer(keySerializer, (BufferedRowFactory<BufferedRow>)rowFactory).keepSize(true) .useHeap(useHeap).make();
@SuppressWarnings( "unchecked" ) @Test public void shouldCreateSortBufferOnHeap() { TypeFactory<String> stringType = types.getStringFactory(); BTreeKeySerializer<String> strKeySerializer = (BTreeKeySerializer<String>)mgr.bTreeKeySerializerFor(stringType, false); Serializer<String> strSerializer = (Serializer<String>)mgr.serializerFor(stringType); try (SortingBuffer<String, String> buffer = mgr.createSortingBuffer(strKeySerializer, strSerializer).useHeap(true) .keepSize(true).make()) { buffer.put("value1", "first"); buffer.put("value2", "first"); buffer.put("value3", "first"); buffer.put("value1", "second"); buffer.put("value3", "second"); buffer.put("value1", "third"); assertThat(buffer.size(), is(3L)); Iterator<String> iter = buffer.ascending(); assertThat(iter.next(), is("third")); assertThat(iter.next(), is("first")); assertThat(iter.next(), is("second")); assertThat(iter.hasNext(), is(false)); iter = buffer.descending(); assertThat(iter.next(), is("second")); assertThat(iter.next(), is("first")); assertThat(iter.next(), is("third")); assertThat(iter.hasNext(), is(false)); iter = buffer.getAll("value1"); assertThat(iter.next(), is("third")); assertThat(iter.hasNext(), is(false)); } }
@SuppressWarnings( "unchecked" ) public HashJoinSequence( String workspaceName, NodeSequence left, NodeSequence right, ExtractFromRow leftExtractor, ExtractFromRow rightExtractor, JoinType joinType, BufferManager bufferMgr, CachedNodeSupplier nodeCache, RangeProducer<?> rangeProducer, boolean pack, boolean useHeap ) { super(workspaceName, left, right, leftExtractor, rightExtractor, joinType, bufferMgr, nodeCache, pack, useHeap, true); this.rangeProducer = (RangeProducer<Object>)rangeProducer; if (useNonMatchingRightRows()) { TypeFactory<?> keyType = rightExtractor.getType(); Serializer<?> keySerializer = bufferMgr.serializerFor(keyType); rightMatchedRowKeys = (DistinctBuffer<Object>)bufferMgr.createDistinctBuffer(keySerializer).keepSize(true) .useHeap(useHeap).make(); Serializer<BufferedRow> rowSerializer = (Serializer<BufferedRow>)BufferedRows.serializer(nodeCache, width); rightRowsWithNullKey = bufferMgr.createDistinctBuffer(rowSerializer).keepSize(true).useHeap(useHeap).make(); } else { rightMatchedRowKeys = null; rightRowsWithNullKey = null; } }
protected final void delete( String name, boolean onHeap ) { db(onHeap).delete(name); }
@SuppressWarnings( {"unchecked"} ) public SortingSequence( String workspaceName, NodeSequence delegate, ExtractFromRow extractor, BufferManager bufferMgr, CachedNodeSupplier nodeCache, boolean pack, boolean useHeap, boolean allowDuplicates, NullOrder nullOrder ) { super(workspaceName, delegate, extractor, bufferMgr, nodeCache, pack, useHeap, allowDuplicates); this.nullOrder = nullOrder; // Create the buffer into which we'll place the rows with null keys ... Serializer<BufferedRow> rowSerializer = (Serializer<BufferedRow>)BufferedRows.serializer(nodeCache, width); rowsWithNullKey = bufferMgr.createDistinctBuffer(rowSerializer).keepSize(true).useHeap(useHeap).make(); }
@Override public void close() { BufferManager.this.delete(name, onHeap); } }
final synchronized BufferManager bufferManager() { if (bufferMgr == null) { bufferMgr = new BufferManager(this.context); } return bufferMgr; }
this.keyExtractor = RowExtractors.extractUniqueKey(delegate.width(), types); TypeFactory<?> keyType = types.getNodeKeyFactory(); Serializer<?> keySerializer = bufferMgr.serializerFor(keyType); Serializer<?> serializer = Tuples.serializer(keySerializer, delegate.width()); final DistinctBuffer<Object> rowsSeen = (DistinctBuffer<Object>)bufferMgr.createDistinctBuffer(serializer).keepSize(true) .useHeap(useHeap).make(); this.filter = new RowFilter() {
@Override public QueueBuffer<T> make() { HTreeMap<Long, T> values = db(useHeap).createHashMap(name).valueSerializer(serializer).counterEnable().make(); return new CloseableQueueBuffer<T>(name, useHeap, values); } }