From 0c4a9f3d6e378d9fb2485ab8146555b14e0d56b8 Mon Sep 17 00:00:00 2001 From: Paul Horn Date: Mon, 17 Aug 2015 13:56:55 +0200 Subject: [PATCH] Reuse document instances --- ...erificationUniqueLuceneIndexPopulator.java | 10 +- .../impl/index/LuceneDocumentStructure.java | 345 ++++++++++++------ .../api/impl/index/LuceneIndexAccessor.java | 10 +- .../index/NonUniqueLuceneIndexPopulator.java | 26 +- .../index/UniqueLuceneIndexPopulator.java | 3 +- .../index/LuceneDocumentStructureTest.java | 12 +- .../index/LuceneIndexAccessorReaderTest.java | 2 - .../index/ReservingLuceneIndexWriterTest.java | 5 +- .../index/TrackingLuceneIndexWriterTest.java | 12 +- 9 files changed, 259 insertions(+), 166 deletions(-) diff --git a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/DeferredConstraintVerificationUniqueLuceneIndexPopulator.java b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/DeferredConstraintVerificationUniqueLuceneIndexPopulator.java index fcc58c3bd550..e2bdd28edd9c 100644 --- a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/DeferredConstraintVerificationUniqueLuceneIndexPopulator.java +++ b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/DeferredConstraintVerificationUniqueLuceneIndexPopulator.java @@ -21,7 +21,6 @@ import org.apache.lucene.document.Document; import org.apache.lucene.index.Fields; -import org.apache.lucene.index.IndexableField; import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.Term; @@ -113,8 +112,7 @@ public void add( long nodeId, Object propertyValue ) throws IndexEntryConflictException, IOException, IndexCapacityExceededException { sampler.increment( 1 ); - IndexableField encodedValue = documentStructure.encodeAsFieldable( propertyValue ); - Document doc = documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ); + Document doc = documentStructure.documentRepresentingProperty( nodeId, propertyValue ); writer.addDocument( doc ); } @@ -194,9 +192,8 @@ public void process( NodePropertyUpdate update ) sampler.increment( 1 ); // add new value // We don't look at the "before" value, so adding and changing idempotently is done the same way. - IndexableField encodedValue = documentStructure.encodeAsFieldable( update.getValueAfter() ); writer.updateDocument( documentStructure.newTermForChangeOrRemove( nodeId ), - documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ) ); + documentStructure.documentRepresentingProperty( nodeId, update.getValueAfter() ) ); updatedPropertyValues.add( update.getValueAfter() ); break; case CHANGED: @@ -205,9 +202,8 @@ public void process( NodePropertyUpdate update ) // sampler.increment( 1 ); // add new value // We don't look at the "before" value, so adding and changing idempotently is done the same way. - IndexableField encodedValueAfter = documentStructure.encodeAsFieldable( update.getValueAfter() ); writer.updateDocument( documentStructure.newTermForChangeOrRemove( nodeId ), - documentStructure.newDocumentRepresentingProperty( nodeId, encodedValueAfter ) ); + documentStructure.documentRepresentingProperty( nodeId, update.getValueAfter() ) ); updatedPropertyValues.add( update.getValueAfter() ); break; case REMOVED: diff --git a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructure.java b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructure.java index 05ff96cd9143..55f5fdd4c993 100644 --- a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructure.java +++ b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructure.java @@ -33,7 +33,10 @@ import org.apache.lucene.search.TermQuery; import org.apache.lucene.search.TermRangeQuery; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.NumericUtils; + +import java.util.EnumMap; +import java.util.Iterator; +import java.util.Map; import org.neo4j.kernel.api.index.ArrayEncoder; @@ -45,127 +48,168 @@ public class LuceneDocumentStructure { static final String NODE_ID_KEY = "id"; - Document newDocument( long nodeId ) + private final ThreadLocal perThreadDocument = new ThreadLocal() + { + @Override + protected DocWithId initialValue() + { + return new DocWithId( NODE_ID_KEY ); + } + }; + + DocWithId reuseDocument( long nodeId ) { - Document document = new Document(); - document.add( field( NODE_ID_KEY, "" + nodeId, YES ) ); - document.add( new NumericDocValuesField( NODE_ID_KEY, nodeId ) ); - return document; + DocWithId doc = perThreadDocument.get(); + doc.setId( nodeId ); + return doc; + } + + Document reusedDocument( long nodeId ) + { + return reuseDocument( nodeId ).document; } enum ValueEncoding { Number - { - @Override - String key() - { - return "number"; - } - - @Override - boolean canEncode( Object value ) - { - return value instanceof Number; - } - - @Override - IndexableField encodeField( Object value ) - { - return new DoubleField( key(), ((Number) value).doubleValue(), NO ); - } - - @Override - NumericRangeQuery encodeQuery( Object value ) - { - final Double doubleValue = ((Number) value).doubleValue(); - return NumericRangeQuery.newDoubleRange( key(), doubleValue, doubleValue, true, true ); - } - }, + { + @Override + String key() + { + return "number"; + } + + @Override + boolean canEncode( Object value ) + { + return value instanceof Number; + } + + @Override + Field encodeField( Object value ) + { + return new DoubleField( key(), ((Number) value).doubleValue(), NO ); + } + + @Override + void setFieldValue( Object value, Field field ) + { + field.setDoubleValue( ((Number) value).doubleValue() ); + } + + @Override + NumericRangeQuery encodeQuery( Object value ) + { + final Double doubleValue = ((Number) value).doubleValue(); + return NumericRangeQuery.newDoubleRange( key(), doubleValue, doubleValue, true, true ); + } + }, Array - { - @Override - String key() - { - return "array"; - } - - @Override - boolean canEncode( Object value ) - { - return value.getClass().isArray(); - } - - @Override - IndexableField encodeField( Object value ) - { - return field( key(), ArrayEncoder.encode( value ) ); - } - - @Override - TermQuery encodeQuery( Object value ) - { - return new TermQuery( new Term( key(), ArrayEncoder.encode( value ) ) ); - } - }, + { + @Override + String key() + { + return "array"; + } + + @Override + boolean canEncode( Object value ) + { + return value.getClass().isArray(); + } + + @Override + Field encodeField( Object value ) + { + return field( key(), ArrayEncoder.encode( value ) ); + } + + @Override + void setFieldValue( Object value, Field field ) + { + field.setStringValue( ArrayEncoder.encode( value ) ); + } + + @Override + TermQuery encodeQuery( Object value ) + { + return new TermQuery( new Term( key(), ArrayEncoder.encode( value ) ) ); + } + }, Bool - { - @Override - String key() - { - return "bool"; - } - - @Override - boolean canEncode( Object value ) - { - return value instanceof Boolean; - } - - @Override - IndexableField encodeField( Object value ) - { - return field( key(), value.toString() ); - } - - @Override - TermQuery encodeQuery( Object value ) - { - return new TermQuery( new Term( key(), value.toString() ) ); - } - }, + { + @Override + String key() + { + return "bool"; + } + + @Override + boolean canEncode( Object value ) + { + return value instanceof Boolean; + } + + @Override + Field encodeField( Object value ) + { + return field( key(), value.toString() ); + } + + @Override + void setFieldValue( Object value, Field field ) + { + field.setStringValue( value.toString() ); + } + + @Override + TermQuery encodeQuery( Object value ) + { + return new TermQuery( new Term( key(), value.toString() ) ); + } + }, String - { - @Override - String key() - { - return "string"; - } + { + @Override + String key() + { + return "string"; + } + + @Override + boolean canEncode( Object value ) + { + // Any other type can be safely serialised as a string + return true; + } + + @Override + Field encodeField( Object value ) + { + return field( key(), value.toString() ); + } + + @Override + void setFieldValue( Object value, Field field ) + { + field.setStringValue( value.toString() ); + } + + @Override + TermQuery encodeQuery( Object value ) + { + return new TermQuery( new Term( key(), value.toString() ) ); + } + }; - @Override - boolean canEncode( Object value ) - { - // Any other type can be safely serialised as a string - return true; - } + abstract String key(); - @Override - IndexableField encodeField( Object value ) - { - return field( key(), value.toString() ); - } + abstract boolean canEncode( Object value ); - @Override - TermQuery encodeQuery( Object value ) - { - return new TermQuery( new Term( key(), value.toString() ) ); - } - }; + abstract Field encodeField( Object value ); - abstract String key(); + abstract void setFieldValue( Object value, Field field ); - abstract boolean canEncode( Object value ); - abstract IndexableField encodeField( Object value ); abstract Query encodeQuery( Object value ); public static ValueEncoding fromKey( String key ) @@ -185,26 +229,31 @@ public static ValueEncoding fromKey( String key ) } } - public Document newDocumentRepresentingProperty( long nodeId, IndexableField encodedValue ) + public Document documentRepresentingProperty( long nodeId, Object value ) { - Document document = newDocument( nodeId ); - document.add( encodedValue ); - return document; + DocWithId document = reuseDocument( nodeId ); + document.setValue( valueEncodingForValue( value ), value ); + return document.document; } - public IndexableField encodeAsFieldable( Object value ) + public ValueEncoding valueEncodingForValue( Object value ) { for ( ValueEncoding encoding : ValueEncoding.values() ) { if ( encoding.canEncode( value ) ) { - return encoding.encodeField( value ); + return encoding; } } throw new IllegalStateException( "Unable to encode the value " + value ); } + public String encodedStringValue( Object value ) + { + return valueEncodingForValue( value ).encodeField( value ).stringValue(); + } + private static Field field( String fieldIdentifier, String value ) { return field( fieldIdentifier, value, NO ); @@ -236,14 +285,15 @@ public Query newSeekQuery( Object value ) * Range queries are always inclusive, in order to do exclusive range queries the result must be filtered after the * fact. The reason we can't do inclusive range queries is that longs are coerced to doubles in the index. */ - public NumericRangeQuery newInclusiveNumericRangeSeekQuery( Number lower, Number upper ) { + public NumericRangeQuery newInclusiveNumericRangeSeekQuery( Number lower, Number upper ) + { Double min = lower != null ? lower.doubleValue() : null; Double max = upper != null ? upper.doubleValue() : null; return NumericRangeQuery.newDoubleRange( ValueEncoding.Number.key(), min, max, true, true ); } public TermRangeQuery newRangeSeekByStringQuery( String lower, boolean includeLower, - String upper, boolean upperInclusive ) + String upper, boolean upperInclusive ) { BytesRef chosenLower = lower != null ? new BytesRef( lower ) : null; boolean includeChosenLower = lower == null || includeLower; @@ -272,4 +322,67 @@ public long getNodeId( Document from ) { return Long.parseLong( from.get( NODE_ID_KEY ) ); } + + private static class DocWithId + { + private final Document document; + + private final String idFieldName; + private final Field idField; + private final Field idValueField; + + private final Map valueFields = new EnumMap<>( ValueEncoding.class ); + + private DocWithId( String idFieldName ) + { + this.idFieldName = idFieldName; + idField = new StringField( idFieldName, "", YES ); + idValueField = new NumericDocValuesField( idFieldName, 0L ); + document = new Document(); + document.add( idField ); + document.add( idValueField ); + } + + private void setId( long id ) + { + idField.setStringValue( "" + id ); + idValueField.setLongValue( id ); + } + + private void setValue( ValueEncoding encoding, Object value ) + { + removeAllValueFields(); + Field reusableField = getFieldWithValue( encoding, value ); + document.add( reusableField ); + } + + private void removeAllValueFields() + { + Iterator it = document.getFields().iterator(); + while ( it.hasNext() ) + { + IndexableField field = it.next(); + String fieldName = field.name(); + if ( !fieldName.equals( idFieldName ) ) + { + it.remove(); + } + } + } + + private Field getFieldWithValue( ValueEncoding encoding, Object value ) + { + Field reusableField = valueFields.get( encoding ); + if ( reusableField == null ) + { + reusableField = encoding.encodeField( value ); + valueFields.put( encoding, reusableField ); + } + else + { + encoding.setFieldValue( value, reusableField ); + } + return reusableField; + } + } } diff --git a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessor.java b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessor.java index 3da959824184..3ec27628d335 100644 --- a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessor.java +++ b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessor.java @@ -19,7 +19,6 @@ */ package org.neo4j.kernel.api.impl.index; -import org.apache.lucene.index.IndexableField; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.ReferenceManager; import org.apache.lucene.store.Directory; @@ -243,22 +242,19 @@ public ResourceIterator snapshotFiles() throws IOException private void addRecovered( long nodeId, Object value ) throws IOException, IndexCapacityExceededException { - IndexableField encodedValue = documentStructure.encodeAsFieldable( value ); writer.updateDocument( documentStructure.newTermForChangeOrRemove( nodeId ), - documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ) ); + documentStructure.documentRepresentingProperty( nodeId, value ) ); } protected void add( long nodeId, Object value ) throws IOException, IndexCapacityExceededException { - IndexableField encodedValue = documentStructure.encodeAsFieldable( value ); - writer.addDocument( documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ) ); + writer.addDocument( documentStructure.documentRepresentingProperty( nodeId, value ) ); } protected void change( long nodeId, Object value ) throws IOException, IndexCapacityExceededException { - IndexableField encodedValue = documentStructure.encodeAsFieldable( value ); writer.updateDocument( documentStructure.newTermForChangeOrRemove( nodeId ), - documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ) ); + documentStructure.documentRepresentingProperty( nodeId, value ) ); } protected void remove( long nodeId ) throws IOException diff --git a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/NonUniqueLuceneIndexPopulator.java b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/NonUniqueLuceneIndexPopulator.java index 0fca6e07e04d..5cc053b66445 100644 --- a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/NonUniqueLuceneIndexPopulator.java +++ b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/NonUniqueLuceneIndexPopulator.java @@ -19,8 +19,6 @@ */ package org.neo4j.kernel.api.impl.index; -import org.apache.lucene.index.IndexableField; - import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -58,9 +56,8 @@ class NonUniqueLuceneIndexPopulator extends LuceneIndexPopulator @Override public void add( long nodeId, Object propertyValue ) throws IOException, IndexCapacityExceededException { - IndexableField encodedValue = documentStructure.encodeAsFieldable( propertyValue ); - sampler.include( encodedValue.stringValue() ); - writer.addDocument( documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ) ); + sampler.include( documentStructure.encodedStringValue( propertyValue ) ); + writer.addDocument( documentStructure.documentRepresentingProperty( nodeId, propertyValue ) ); } @Override @@ -87,19 +84,19 @@ public void process( NodePropertyUpdate update ) throws IOException, IndexEntryC { case ADDED: // We don't look at the "before" value, so adding and changing idempotently is done the same way. - IndexableField encodedValue = documentStructure.encodeAsFieldable( update.getValueAfter() ); - sampler.include( encodedValue.stringValue() ); + String encodedValue = documentStructure.encodedStringValue( update.getValueAfter() ); + sampler.include( encodedValue ); break; case CHANGED: // We don't look at the "before" value, so adding and changing idempotently is done the same way. - IndexableField encodedValueBefore = documentStructure.encodeAsFieldable( update.getValueBefore() ); - sampler.exclude( encodedValueBefore.stringValue() ); - IndexableField encodedValueAfter = documentStructure.encodeAsFieldable( update.getValueAfter() ); - sampler.include( encodedValueAfter.stringValue() ); + String encodedValueBefore = documentStructure.encodedStringValue( update.getValueBefore() ); + sampler.exclude( encodedValueBefore ); + String encodedValueAfter = documentStructure.encodedStringValue( update.getValueAfter() ); + sampler.include( encodedValueAfter ); break; case REMOVED: - IndexableField removedValue = documentStructure.encodeAsFieldable( update.getValueBefore() ); - sampler.exclude( removedValue.stringValue() ); + String removedValue = documentStructure.encodedStringValue( update.getValueBefore() ); + sampler.exclude( removedValue ); break; default: throw new IllegalStateException( "Unknown update mode " + update.getUpdateMode() ); @@ -144,9 +141,8 @@ protected void flush() throws IOException, IndexCapacityExceededException case ADDED: case CHANGED: // We don't look at the "before" value, so adding and changing idempotently is done the same way. - IndexableField encodedValue = documentStructure.encodeAsFieldable( update.getValueAfter() ); writer.updateDocument( documentStructure.newTermForChangeOrRemove( nodeId ), - documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ) ); + documentStructure.documentRepresentingProperty( nodeId, update.getValueAfter() ) ); break; case REMOVED: writer.deleteDocuments( documentStructure.newTermForChangeOrRemove( nodeId ) ); diff --git a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/UniqueLuceneIndexPopulator.java b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/UniqueLuceneIndexPopulator.java index d94cc033de68..1324463c31c7 100644 --- a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/UniqueLuceneIndexPopulator.java +++ b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/UniqueLuceneIndexPopulator.java @@ -117,8 +117,7 @@ public void add( long nodeId, Object propertyValue ) else { currentBatch.put( propertyValue, nodeId ); - IndexableField encodedValue = documentStructure.encodeAsFieldable( propertyValue ); - writer.addDocument( documentStructure.newDocumentRepresentingProperty( nodeId, encodedValue ) ); + writer.addDocument( documentStructure.documentRepresentingProperty( nodeId, propertyValue ) ); if ( currentBatch.size() >= batchSize ) { startNewBatch(); diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructureTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructureTest.java index 08abbe2506d7..cdf2d46ee289 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructureTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneDocumentStructureTest.java @@ -44,8 +44,7 @@ public class LuceneDocumentStructureTest public void shouldBuildDocumentRepresentingStringProperty() throws Exception { // given - IndexableField fieldable = documentStructure.encodeAsFieldable( "hello" ); - Document document = documentStructure.newDocumentRepresentingProperty( 123, fieldable ); + Document document = documentStructure.documentRepresentingProperty( 123, "hello" ); // then assertEquals("123", document.get( NODE_ID_KEY )); @@ -56,8 +55,7 @@ public void shouldBuildDocumentRepresentingStringProperty() throws Exception public void shouldBuildDocumentRepresentingBoolProperty() throws Exception { // given - IndexableField fieldable = documentStructure.encodeAsFieldable( true ); - Document document = documentStructure.newDocumentRepresentingProperty( 123, fieldable ); + Document document = documentStructure.documentRepresentingProperty( 123, true ); // then assertEquals("123", document.get( NODE_ID_KEY )); @@ -68,8 +66,7 @@ public void shouldBuildDocumentRepresentingBoolProperty() throws Exception public void shouldBuildDocumentRepresentingNumberProperty() throws Exception { // given - IndexableField fieldable = documentStructure.encodeAsFieldable( 12 ); - Document document = documentStructure.newDocumentRepresentingProperty( 123, fieldable ); + Document document = documentStructure.documentRepresentingProperty( 123, 12 ); // then assertEquals("123", document.get( NODE_ID_KEY )); @@ -80,8 +77,7 @@ public void shouldBuildDocumentRepresentingNumberProperty() throws Exception public void shouldBuildDocumentRepresentingArrayProperty() throws Exception { // given - IndexableField fieldable = documentStructure.encodeAsFieldable( new Integer[]{1, 2, 3} ); - Document document = documentStructure.newDocumentRepresentingProperty( 123, fieldable ); + Document document = documentStructure.documentRepresentingProperty( 123, new Integer[]{1, 2, 3} ); // then assertEquals("123", document.get( NODE_ID_KEY )); diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessorReaderTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessorReaderTest.java index a0b2b68345fd..90aa9996870d 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessorReaderTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneIndexAccessorReaderTest.java @@ -59,8 +59,6 @@ public PrimitiveLongIterator query( Query query ) }; when( searcher.getIndexReader() ).thenReturn( reader ); - // TODO: -// when( reader.terms() ).thenReturn( terms ); } @Test diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/ReservingLuceneIndexWriterTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/ReservingLuceneIndexWriterTest.java index 4c60f1c67fdf..5ff7bac31083 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/ReservingLuceneIndexWriterTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/ReservingLuceneIndexWriterTest.java @@ -21,7 +21,6 @@ import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.store.Directory; -import org.apache.lucene.util.Version; import org.junit.Rule; import org.junit.Test; @@ -72,7 +71,7 @@ public void shouldWorkIfSumOfMaxDocAndReservedIsLessThanLimit() throws Exception // When for ( int i = 0; i < toAdd; i++ ) { - indexWriter.addDocument( documentStructure.newDocument( i ) ); + indexWriter.addDocument( documentStructure.reusedDocument( i ) ); } indexWriter.reserveInsertions( toReserve ); @@ -117,7 +116,7 @@ public void shouldThrowWhenSumOfMaxDocAndReservedIsGreaterThanLimit() throws Exc indexWriter.reserveInsertions( toAdd ); for ( int i = 0; i < toAdd; i++ ) { - indexWriter.addDocument( documentStructure.newDocument( i ) ); + indexWriter.addDocument( documentStructure.reusedDocument( i ) ); } try diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/TrackingLuceneIndexWriterTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/TrackingLuceneIndexWriterTest.java index 5c8310463d9d..a0960c59ba83 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/TrackingLuceneIndexWriterTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/TrackingLuceneIndexWriterTest.java @@ -22,7 +22,6 @@ import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.index.Term; import org.apache.lucene.store.Directory; -import org.apache.lucene.util.Version; import org.junit.Rule; import org.junit.Test; @@ -56,7 +55,7 @@ public void shouldSilentlyAddDocumentsWhenMaxDocIsLessThanLimit() throws Excepti // When for ( int i = 0; i < toAdd; i++ ) { - indexWriter.addDocument( documentStructure.newDocument( i ) ); + indexWriter.addDocument( documentStructure.reusedDocument( i ) ); } // Then @@ -74,13 +73,13 @@ public void shouldThrowExceptionWhenTooManyDocumentsAreAdded() throws Exception for ( int i = 0; i < maxDocLimit; i++ ) { - indexWriter.addDocument( documentStructure.newDocument( i ) ); + indexWriter.addDocument( documentStructure.reusedDocument( i ) ); } try { // When - indexWriter.addDocument( documentStructure.newDocument( maxDocLimit + 42 ) ); + indexWriter.addDocument( documentStructure.reusedDocument( maxDocLimit + 42 ) ); fail( "Should have thrown " + IndexCapacityExceededException.class.getSimpleName() ); } catch ( IndexCapacityExceededException e ) @@ -101,13 +100,14 @@ public void shouldThrowExceptionWhenTooManyDocumentsAreUpdated() throws Exceptio for ( int i = 0; i < maxDocLimit; i++ ) { - indexWriter.updateDocument( new Term( "foo", "bar" ), documentStructure.newDocument( i ) ); + indexWriter.updateDocument( new Term( "foo", "bar" ), documentStructure.reusedDocument( i ) ); } try { // When - indexWriter.updateDocument( new Term( "foo", "bar" ), documentStructure.newDocument( maxDocLimit + 42 ) ); + indexWriter.updateDocument( new Term( "foo", "bar" ), documentStructure.reusedDocument( maxDocLimit + 42 + ) ); fail( "Should have thrown " + IndexCapacityExceededException.class.getSimpleName() ); } catch ( IndexCapacityExceededException e )