From 1b9894b10dfddcf124b192d790922aebcda1e743 Mon Sep 17 00:00:00 2001 From: fickludd Date: Tue, 14 Feb 2017 15:21:25 +0100 Subject: [PATCH] Adapted lucene to new index population --- .../api/impl/schema/LuceneIndexAccessor.java | 14 ++-- .../populator/UniqueLuceneIndexPopulator.java | 4 +- .../index/LuceneSchemaIndexPopulationIT.java | 9 +- .../schema/AccessUniqueDatabaseIndexTest.java | 21 +++-- .../schema/DatabaseIndexAccessorTest.java | 21 +++-- .../api/impl/schema/LuceneSchemaIndexIT.java | 10 ++- .../LuceneSchemaIndexPopulatorTest.java | 32 +++---- ...queDatabaseIndexPopulatingUpdaterTest.java | 77 +++++++++-------- .../NonUniqueDatabaseIndexPopulatorTest.java | 29 ++++--- ...queDatabaseIndexPopulatingUpdaterTest.java | 84 ++++++++++--------- .../UniqueDatabaseIndexPopulatorTest.java | 59 ++++++------- 11 files changed, 192 insertions(+), 168 deletions(-) diff --git a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/LuceneIndexAccessor.java b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/LuceneIndexAccessor.java index d26dca0d4bdff..9bc4b3903b973 100644 --- a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/LuceneIndexAccessor.java +++ b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/LuceneIndexAccessor.java @@ -29,8 +29,8 @@ import org.neo4j.kernel.api.impl.schema.reader.LuceneAllEntriesIndexAccessorReader; import org.neo4j.kernel.api.impl.schema.writer.LuceneIndexWriter; import org.neo4j.kernel.api.index.IndexAccessor; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.index.IndexUpdater; -import org.neo4j.kernel.api.index.NodePropertyUpdate; import org.neo4j.kernel.impl.api.index.IndexUpdateMode; import org.neo4j.storageengine.api.schema.IndexReader; @@ -127,25 +127,25 @@ private LuceneIndexUpdater( LuceneIndexWriter indexWriter, boolean isRecovery ) } @Override - public void process( NodePropertyUpdate update ) throws IOException + public void process( IndexEntryUpdate update ) throws IOException { - switch ( update.getUpdateMode() ) + switch ( update.updateMode() ) { case ADDED: if ( isRecovery ) { - addRecovered( update.getNodeId(), update.getValueAfter() ); + addRecovered( update.getEntityId(), update.values()[0] ); } else { - add( update.getNodeId(), update.getValueAfter() ); + add( update.getEntityId(), update.values()[0] ); } break; case CHANGED: - change( update.getNodeId(), update.getValueAfter() ); + change( update.getEntityId(), update.values()[0] ); break; case REMOVED: - remove( update.getNodeId() ); + remove( update.getEntityId() ); break; default: throw new UnsupportedOperationException(); diff --git a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/populator/UniqueLuceneIndexPopulator.java b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/populator/UniqueLuceneIndexPopulator.java index d6ba5db985446..30c9e25fe7411 100644 --- a/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/populator/UniqueLuceneIndexPopulator.java +++ b/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/populator/UniqueLuceneIndexPopulator.java @@ -23,9 +23,9 @@ import org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException; import org.neo4j.kernel.api.impl.schema.SchemaIndex; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.schema.IndexDescriptor; import org.neo4j.kernel.api.index.IndexUpdater; -import org.neo4j.kernel.api.index.NodePropertyUpdate; import org.neo4j.kernel.api.index.PropertyAccessor; import org.neo4j.kernel.impl.api.index.sampling.UniqueIndexSampler; import org.neo4j.storageengine.api.schema.IndexSample; @@ -62,7 +62,7 @@ public IndexUpdater newPopulatingUpdater( final PropertyAccessor accessor ) thro } @Override - public void includeSample( NodePropertyUpdate update ) + public void includeSample( IndexEntryUpdate update ) { sampler.increment( 1 ); } diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneSchemaIndexPopulationIT.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneSchemaIndexPopulationIT.java index 0feb279d4ceae..c5e9b06153b32 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneSchemaIndexPopulationIT.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/index/LuceneSchemaIndexPopulationIT.java @@ -35,8 +35,10 @@ import org.neo4j.kernel.api.impl.schema.LuceneIndexAccessor; import org.neo4j.kernel.api.impl.schema.LuceneSchemaIndexBuilder; import org.neo4j.kernel.api.impl.schema.SchemaIndex; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.index.IndexUpdater; -import org.neo4j.kernel.api.index.NodePropertyUpdate; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.impl.api.index.IndexUpdateMode; import org.neo4j.storageengine.api.schema.IndexReader; import org.neo4j.storageengine.api.schema.IndexSample; @@ -58,6 +60,7 @@ public class LuceneSchemaIndexPopulationIT public final DefaultFileSystemRule fileSystemRule = new DefaultFileSystemRule(); private int affectedNodes; + private NewIndexDescriptor index = NewIndexDescriptorFactory.forLabel( 0, 0 ); @Before public void before() throws Exception @@ -132,8 +135,8 @@ private void generateUpdates( LuceneIndexAccessor indexAccessor, int nodesToUpda } } - private NodePropertyUpdate add( long nodeId, Object value ) + private IndexEntryUpdate add( long nodeId, Object value ) { - return NodePropertyUpdate.add( nodeId, 0, value, new long[0] ); + return IndexEntryUpdate.add( nodeId, index, value ); } } diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/AccessUniqueDatabaseIndexTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/AccessUniqueDatabaseIndexTest.java index 34b4b87f1734f..2693e0f667fa1 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/AccessUniqueDatabaseIndexTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/AccessUniqueDatabaseIndexTest.java @@ -31,8 +31,10 @@ import org.neo4j.kernel.api.impl.index.storage.IndexStorageFactory; import org.neo4j.kernel.api.impl.index.storage.PartitionedIndexStorage; import org.neo4j.kernel.api.index.IndexAccessor; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.index.IndexUpdater; -import org.neo4j.kernel.api.index.NodePropertyUpdate; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.impl.api.index.IndexUpdateMode; import org.neo4j.test.rule.fs.EphemeralFileSystemRule; @@ -46,6 +48,7 @@ public class AccessUniqueDatabaseIndexTest public final EphemeralFileSystemRule fileSystemRule = new EphemeralFileSystemRule(); private final DirectoryFactory directoryFactory = new DirectoryFactory.InMemoryDirectoryFactory(); private final File indexDirectory = new File( "index1" ); + private final NewIndexDescriptor index = NewIndexDescriptorFactory.forLabel( 1000, 100 ); @Test public void shouldAddUniqueEntries() throws Exception @@ -145,19 +148,19 @@ private PartitionedIndexStorage getIndexStorage() throws IOException return storageFactory.indexStorageOf( 1, false ); } - private NodePropertyUpdate add( long nodeId, Object propertyValue ) + private IndexEntryUpdate add( long nodeId, Object propertyValue ) { - return NodePropertyUpdate.add( nodeId, 100, propertyValue, new long[]{1000} ); + return IndexEntryUpdate.add( nodeId, index, propertyValue ); } - private NodePropertyUpdate change( long nodeId, Object oldValue, Object newValue ) + private IndexEntryUpdate change( long nodeId, Object oldValue, Object newValue ) { - return NodePropertyUpdate.change( nodeId, 100, oldValue, new long[]{1000}, newValue, new long[]{1000} ); + return IndexEntryUpdate.change( nodeId, index, oldValue, newValue ); } - private NodePropertyUpdate remove( long nodeId, Object oldValue ) + private IndexEntryUpdate remove( long nodeId, Object oldValue ) { - return NodePropertyUpdate.remove( nodeId, 100, oldValue, new long[]{1000} ); + return IndexEntryUpdate.remove( nodeId, index, oldValue ); } private List getAllNodes( PartitionedIndexStorage indexStorage, String propertyValue ) throws IOException @@ -166,12 +169,12 @@ private List getAllNodes( PartitionedIndexStorage indexStorage, String pro propertyValue ); } - private void updateAndCommit( IndexAccessor accessor, Iterable updates ) + private void updateAndCommit( IndexAccessor accessor, Iterable updates ) throws IOException, IndexEntryConflictException { try ( IndexUpdater updater = accessor.newUpdater( IndexUpdateMode.ONLINE ) ) { - for ( NodePropertyUpdate update : updates ) + for ( IndexEntryUpdate update : updates ) { updater.process( update ); } diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/DatabaseIndexAccessorTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/DatabaseIndexAccessorTest.java index d7a7e09cba515..727c42c69d50e 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/DatabaseIndexAccessorTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/DatabaseIndexAccessorTest.java @@ -41,8 +41,10 @@ import org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException; import org.neo4j.kernel.api.exceptions.index.IndexNotFoundKernelException; import org.neo4j.kernel.api.impl.index.storage.DirectoryFactory; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.index.IndexUpdater; -import org.neo4j.kernel.api.index.NodePropertyUpdate; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.impl.api.index.IndexUpdateMode; import org.neo4j.storageengine.api.schema.IndexReader; import org.neo4j.storageengine.api.schema.IndexSampler; @@ -73,6 +75,7 @@ public class DatabaseIndexAccessorTest private final long nodeId = 1, nodeId2 = 2; private final Object value = "value", value2 = 40; private DirectoryFactory.InMemoryDirectoryFactory dirFactory; + private NewIndexDescriptor index = NewIndexDescriptorFactory.forLabel( 0, 0 ); @Parameterized.Parameters( name = "{0}" ) public static Collection[]> implementations() @@ -319,27 +322,27 @@ public Void apply( Void nothing ) throws IOException } } - private NodePropertyUpdate add( long nodeId, Object value ) + private IndexEntryUpdate add( long nodeId, Object value ) { - return NodePropertyUpdate.add( nodeId, 0, value, new long[0] ); + return IndexEntryUpdate.add( nodeId, index, value ); } - private NodePropertyUpdate remove( long nodeId, Object value ) + private IndexEntryUpdate remove( long nodeId, Object value ) { - return NodePropertyUpdate.remove( nodeId, 0, value, new long[0] ); + return IndexEntryUpdate.remove( nodeId, index, value ); } - private NodePropertyUpdate change( long nodeId, Object valueBefore, Object valueAfter ) + private IndexEntryUpdate change( long nodeId, Object valueBefore, Object valueAfter ) { - return NodePropertyUpdate.change( nodeId, 0, valueBefore, new long[0], valueAfter, new long[0] ); + return IndexEntryUpdate.change( nodeId, index, valueBefore, valueAfter ); } - private void updateAndCommit( List nodePropertyUpdates ) + private void updateAndCommit( List nodePropertyUpdates ) throws IOException, IndexEntryConflictException { try ( IndexUpdater updater = accessor.newUpdater( IndexUpdateMode.ONLINE ) ) { - for ( NodePropertyUpdate update : nodePropertyUpdates ) + for ( IndexEntryUpdate update : nodePropertyUpdates ) { updater.process( update ); } diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexIT.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexIT.java index c94089f744da7..3176fc7d25364 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexIT.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexIT.java @@ -39,8 +39,10 @@ import org.neo4j.helpers.collection.Iterators; import org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException; import org.neo4j.kernel.api.impl.index.LuceneAllDocumentsReader; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.index.IndexUpdater; -import org.neo4j.kernel.api.index.NodePropertyUpdate; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.impl.api.index.IndexUpdateMode; import org.neo4j.test.rule.TestDirectory; import org.neo4j.test.rule.fs.DefaultFileSystemRule; @@ -61,6 +63,8 @@ public class LuceneSchemaIndexIT @Rule public final DefaultFileSystemRule fileSystemRule = new DefaultFileSystemRule(); + private NewIndexDescriptor index = NewIndexDescriptorFactory.forLabel( 0, 0 ); + @Before public void before() throws Exception { @@ -302,9 +306,9 @@ private void generateUpdates( LuceneIndexAccessor indexAccessor, int nodesToUpda } } - private NodePropertyUpdate add( long nodeId, Object value ) + private IndexEntryUpdate add( long nodeId, Object value ) { - return NodePropertyUpdate.add( nodeId, 0, value, new long[0] ); + return IndexEntryUpdate.add( nodeId, index, value ); } } diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexPopulatorTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexPopulatorTest.java index 2d678d6d708a4..cf49cc2ebebc7 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexPopulatorTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexPopulatorTest.java @@ -39,13 +39,14 @@ import org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException; import org.neo4j.kernel.api.impl.index.storage.DirectoryFactory; import org.neo4j.kernel.api.index.IndexConfiguration; -import org.neo4j.kernel.api.schema.IndexDescriptor; -import org.neo4j.kernel.api.schema.IndexDescriptorFactory; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.index.IndexPopulator; import org.neo4j.kernel.api.index.IndexUpdater; import org.neo4j.kernel.api.index.InternalIndexState; -import org.neo4j.kernel.api.index.NodePropertyUpdate; import org.neo4j.kernel.api.index.PropertyAccessor; +import org.neo4j.kernel.api.schema_new.index.IndexBoundary; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.impl.api.index.IndexStoreView; import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig; @@ -67,7 +68,6 @@ public class LuceneSchemaIndexPopulatorTest @Rule public TestDirectory testDir = TestDirectory.testDirectory(); - private IndexDescriptor indexDescriptor; private IndexStoreView indexStoreView; private LuceneSchemaIndexProvider provider; private Directory directory; @@ -75,7 +75,8 @@ public class LuceneSchemaIndexPopulatorTest private IndexReader reader; private IndexSearcher searcher; private final long indexId = 0; - private final int propertyKeyId = 666; + private final static int propertyKeyId = 666; + private final static NewIndexDescriptor index = NewIndexDescriptorFactory.forLabel( 42, propertyKeyId ); @Before public void before() throws Exception @@ -85,11 +86,10 @@ public void before() throws Exception new DirectoryFactory.UncloseableDirectory( directory ) ); provider = new LuceneSchemaIndexProvider( fs.get(), directoryFactory, testDir.directory( "folder" ), NullLogProvider.getInstance(), Config.empty(), OperationalMode.single ); - indexDescriptor = IndexDescriptorFactory.of( 42, propertyKeyId ); indexStoreView = mock( IndexStoreView.class ); IndexConfiguration indexConfig = IndexConfiguration.NON_UNIQUE; IndexSamplingConfig samplingConfig = new IndexSamplingConfig( Config.empty() ); - indexPopulator = provider.getPopulator( indexId, indexDescriptor, indexConfig, samplingConfig ); + indexPopulator = provider.getPopulator( indexId, IndexBoundary.map( index ), indexConfig, samplingConfig ); indexPopulator.create(); indexPopulator.configureSampling( true ); } @@ -256,19 +256,19 @@ private static class Hit } } - private NodePropertyUpdate add( long nodeId, Object value ) + private IndexEntryUpdate add( long nodeId, Object value ) { - return NodePropertyUpdate.add( nodeId, 0, value, new long[0] ); + return IndexEntryUpdate.add( nodeId, index, value ); } - private NodePropertyUpdate change( long nodeId, Object valueBefore, Object valueAfter ) + private IndexEntryUpdate change( long nodeId, Object valueBefore, Object valueAfter ) { - return NodePropertyUpdate.change( nodeId, 0, valueBefore, new long[0], valueAfter, new long[0] ); + return IndexEntryUpdate.change( nodeId, index, valueBefore, valueAfter ); } - private NodePropertyUpdate remove( long nodeId, Object removedValue ) + private IndexEntryUpdate remove( long nodeId, Object removedValue ) { - return NodePropertyUpdate.remove( nodeId, 0, removedValue, new long[0] ); + return IndexEntryUpdate.remove( nodeId, index, removedValue ); } private void assertIndexedValues( Hit... expectedHits ) throws IOException @@ -300,18 +300,18 @@ private void switchToVerification() throws IOException private static void addUpdate( IndexPopulator populator, long nodeId, Object value ) throws IOException, IndexEntryConflictException { - populator.add( Collections.singletonList( NodePropertyUpdate.add( nodeId, 0, value, new long[]{0} ) ) ); + populator.add( Collections.singletonList( IndexEntryUpdate.add( nodeId, index, value ) ) ); } private static void updatePopulator( IndexPopulator populator, - Iterable updates, + Iterable updates, PropertyAccessor accessor ) throws IOException, IndexEntryConflictException { try ( IndexUpdater updater = populator.newPopulatingUpdater( accessor ) ) { - for ( NodePropertyUpdate update : updates ) + for ( IndexEntryUpdate update : updates ) { updater.process( update ); } diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatingUpdaterTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatingUpdaterTest.java index 25eb11696f801..6c5fe7df93c3b 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatingUpdaterTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatingUpdaterTest.java @@ -23,6 +23,8 @@ import org.neo4j.collection.primitive.PrimitiveLongCollections; import org.neo4j.kernel.api.impl.schema.writer.LuceneIndexWriter; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.impl.api.index.sampling.DefaultNonUniqueIndexSampler; import org.neo4j.kernel.impl.api.index.sampling.NonUniqueIndexSampler; import org.neo4j.storageengine.api.schema.IndexSample; @@ -35,14 +37,15 @@ import static org.mockito.Mockito.verify; import static org.neo4j.kernel.api.impl.schema.LuceneDocumentStructure.documentRepresentingProperty; import static org.neo4j.kernel.api.impl.schema.LuceneDocumentStructure.newTermForChangeOrRemove; -import static org.neo4j.kernel.api.index.NodePropertyUpdate.add; -import static org.neo4j.kernel.api.index.NodePropertyUpdate.change; -import static org.neo4j.kernel.api.index.NodePropertyUpdate.remove; +import static org.neo4j.kernel.api.index.IndexEntryUpdate.add; +import static org.neo4j.kernel.api.index.IndexEntryUpdate.change; +import static org.neo4j.kernel.api.index.IndexEntryUpdate.remove; public class NonUniqueDatabaseIndexPopulatingUpdaterTest { private static final int PROPERTY_KEY = 42; private static final int SAMPLING_BUFFER_SIZE_LIMIT = 100; + private static final NewIndexDescriptor index = NewIndexDescriptorFactory.forLabel( 1, PROPERTY_KEY ); @Test public void removeNotSupported() @@ -66,10 +69,10 @@ public void addedNodePropertiesIncludedInSample() throws Exception NonUniqueIndexSampler sampler = newSampler(); NonUniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "baz", new long[]{1} ) ); - updater.process( add( 4, PROPERTY_KEY, "bar", new long[]{1} ) ); + updater.process( add( 1, index, "foo" ) ); + updater.process( add( 2, index, "bar" ) ); + updater.process( add( 3, index, "baz" ) ); + updater.process( add( 4, index, "bar" ) ); verifySamplingResult( sampler, 4, 3, 4 ); } @@ -80,12 +83,12 @@ public void changedNodePropertiesIncludedInSample() throws Exception NonUniqueIndexSampler sampler = newSampler(); NonUniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( add( 1, PROPERTY_KEY, "initial1", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "initial2", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "new2", new long[]{1} ) ); + updater.process( add( 1, index, "initial1" ) ); + updater.process( add( 2, index, "initial2" ) ); + updater.process( add( 3, index, "new2" ) ); - updater.process( change( 1, PROPERTY_KEY, "initial1", new long[]{1}, "new1", new long[]{1} ) ); - updater.process( change( 1, PROPERTY_KEY, "initial2", new long[]{1}, "new2", new long[]{1} ) ); + updater.process( change( 1, index, "initial1", "new1" ) ); + updater.process( change( 1, index, "initial2", "new2" ) ); verifySamplingResult( sampler, 3, 2, 3 ); } @@ -96,14 +99,14 @@ public void removedNodePropertyIncludedInSample() throws Exception NonUniqueIndexSampler sampler = newSampler(); NonUniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "baz", new long[]{1} ) ); - updater.process( add( 4, PROPERTY_KEY, "qux", new long[]{1} ) ); + updater.process( add( 1, index, "foo" ) ); + updater.process( add( 2, index, "bar" ) ); + updater.process( add( 3, index, "baz" ) ); + updater.process( add( 4, index, "qux" ) ); - updater.process( remove( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( remove( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( remove( 4, PROPERTY_KEY, "qux", new long[]{1} ) ); + updater.process( remove( 1, index, "foo" ) ); + updater.process( remove( 2, index, "bar" ) ); + updater.process( remove( 4, index, "qux" ) ); verifySamplingResult( sampler, 1, 1, 1 ); } @@ -114,19 +117,19 @@ public void nodePropertyUpdatesIncludedInSample() throws Exception NonUniqueIndexSampler sampler = newSampler(); NonUniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( change( 1, PROPERTY_KEY, "foo", new long[]{1}, "newFoo1", new long[]{1} ) ); + updater.process( add( 1, index, "foo" ) ); + updater.process( change( 1, index, "foo", "newFoo1" ) ); - updater.process( add( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( remove( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); + updater.process( add( 2, index, "bar" ) ); + updater.process( remove( 2, index, "bar" ) ); - updater.process( change( 1, PROPERTY_KEY, "newFoo1", new long[]{1}, "newFoo2", new long[]{1} ) ); + updater.process( change( 1, index, "newFoo1", "newFoo2" ) ); - updater.process( add( 42, PROPERTY_KEY, "qux", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( add( 4, PROPERTY_KEY, "baz", new long[]{1} ) ); - updater.process( add( 5, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( remove( 42, PROPERTY_KEY, "qux", new long[]{1} ) ); + updater.process( add( 42, index, "qux" ) ); + updater.process( add( 3, index, "bar" ) ); + updater.process( add( 4, index, "baz" ) ); + updater.process( add( 5, index, "bar" ) ); + updater.process( remove( 42, index, "qux" ) ); verifySamplingResult( sampler, 4, 3, 4 ); } @@ -137,9 +140,9 @@ public void additionsDeliveredToIndexWriter() throws Exception LuceneIndexWriter writer = mock( LuceneIndexWriter.class ); NonUniqueLuceneIndexPopulatingUpdater updater = newUpdater( writer ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "qux", new long[]{1} ) ); + updater.process( add( 1, index, "foo" ) ); + updater.process( add( 2, index, "bar" ) ); + updater.process( add( 3, index, "qux" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 1 ), documentRepresentingProperty( 1, "foo" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 2 ), documentRepresentingProperty( 2, "bar" ) ); @@ -152,8 +155,8 @@ public void changesDeliveredToIndexWriter() throws Exception LuceneIndexWriter writer = mock( LuceneIndexWriter.class ); NonUniqueLuceneIndexPopulatingUpdater updater = newUpdater( writer ); - updater.process( change( 1, PROPERTY_KEY, "before1", new long[]{1}, "after1", new long[]{1} ) ); - updater.process( change( 2, PROPERTY_KEY, "before2", new long[]{1}, "after2", new long[]{1} ) ); + updater.process( change( 1, index, "before1", "after1" ) ); + updater.process( change( 2, index, "before2", "after2" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 1 ), documentRepresentingProperty( 1, "after1" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 2 ), documentRepresentingProperty( 2, "after2" ) ); @@ -165,9 +168,9 @@ public void removalsDeliveredToIndexWriter() throws Exception LuceneIndexWriter writer = mock( LuceneIndexWriter.class ); NonUniqueLuceneIndexPopulatingUpdater updater = newUpdater( writer ); - updater.process( remove( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( remove( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( remove( 3, PROPERTY_KEY, "baz", new long[]{1} ) ); + updater.process( remove( 1, index, "foo" ) ); + updater.process( remove( 2, index, "bar" ) ); + updater.process( remove( 3, index, "baz" ) ); verify( writer ).deleteDocuments( newTermForChangeOrRemove( 1 ) ); verify( writer ).deleteDocuments( newTermForChangeOrRemove( 2 ) ); diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatorTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatorTest.java index c91b1ba4b84bc..96a6f481729e1 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatorTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/NonUniqueDatabaseIndexPopulatorTest.java @@ -35,7 +35,9 @@ import org.neo4j.kernel.api.impl.index.storage.PartitionedIndexStorage; import org.neo4j.kernel.api.impl.schema.LuceneSchemaIndexBuilder; import org.neo4j.kernel.api.impl.schema.SchemaIndex; -import org.neo4j.kernel.api.index.NodePropertyUpdate; +import org.neo4j.kernel.api.index.IndexEntryUpdate; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig; import org.neo4j.storageengine.api.schema.IndexReader; @@ -57,6 +59,7 @@ public class NonUniqueDatabaseIndexPopulatorTest private SchemaIndex index; private NonUniqueLuceneIndexPopulator populator; + private NewIndexDescriptor indexDescriptor = NewIndexDescriptorFactory.forLabel( 0, 0 ); @Before public void setUp() throws Exception @@ -95,10 +98,10 @@ public void sampleIncludedUpdates() throws Exception { populator = newPopulator(); - List updates = Arrays.asList( - NodePropertyUpdate.add( 1, 1, "aaa", new long[]{1} ), - NodePropertyUpdate.add( 2, 1, "bbb", new long[]{1} ), - NodePropertyUpdate.add( 3, 1, "ccc", new long[]{1} ) ); + List updates = Arrays.asList( + IndexEntryUpdate.add( 1, indexDescriptor, "aaa" ), + IndexEntryUpdate.add( 2, indexDescriptor, "bbb" ), + IndexEntryUpdate.add( 3, indexDescriptor, "ccc" ) ); updates.forEach( populator::includeSample ); @@ -112,10 +115,10 @@ public void sampleIncludedUpdatesWithDuplicates() throws Exception { populator = newPopulator(); - List updates = Arrays.asList( - NodePropertyUpdate.add( 1, 1, "foo", new long[]{1} ), - NodePropertyUpdate.add( 2, 1, "bar", new long[]{1} ), - NodePropertyUpdate.add( 3, 1, "foo", new long[]{1} ) ); + List updates = Arrays.asList( + IndexEntryUpdate.add( 1, indexDescriptor, "foo" ), + IndexEntryUpdate.add( 2, indexDescriptor, "bar" ), + IndexEntryUpdate.add( 3, indexDescriptor, "foo" ) ); updates.forEach( populator::includeSample ); @@ -129,10 +132,10 @@ public void addUpdates() throws Exception { populator = newPopulator(); - List updates = Arrays.asList( - NodePropertyUpdate.add( 1, 1, "foo", new long[]{1} ), - NodePropertyUpdate.add( 2, 1, "bar", new long[]{1} ), - NodePropertyUpdate.add( 42, 1, "bar", new long[]{1} ) ); + List updates = Arrays.asList( + IndexEntryUpdate.add( 1, indexDescriptor, "foo" ), + IndexEntryUpdate.add( 2, indexDescriptor, "bar" ), + IndexEntryUpdate.add( 42, indexDescriptor, "bar" ) ); populator.add( updates ); diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatingUpdaterTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatingUpdaterTest.java index 8ee7a03cbc223..f8528ecb8f238 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatingUpdaterTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatingUpdaterTest.java @@ -28,6 +28,8 @@ import org.neo4j.kernel.api.impl.schema.SchemaIndex; import org.neo4j.kernel.api.impl.schema.writer.LuceneIndexWriter; import org.neo4j.kernel.api.index.PropertyAccessor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.kernel.impl.api.index.sampling.UniqueIndexSampler; import org.neo4j.storageengine.api.schema.IndexSample; @@ -42,13 +44,13 @@ import static org.mockito.Mockito.verifyZeroInteractions; import static org.neo4j.kernel.api.impl.schema.LuceneDocumentStructure.documentRepresentingProperty; import static org.neo4j.kernel.api.impl.schema.LuceneDocumentStructure.newTermForChangeOrRemove; -import static org.neo4j.kernel.api.index.NodePropertyUpdate.add; -import static org.neo4j.kernel.api.index.NodePropertyUpdate.change; -import static org.neo4j.kernel.api.index.NodePropertyUpdate.remove; +import static org.neo4j.kernel.api.index.IndexEntryUpdate.add; +import static org.neo4j.kernel.api.index.IndexEntryUpdate.change; +import static org.neo4j.kernel.api.index.IndexEntryUpdate.remove; public class UniqueDatabaseIndexPopulatingUpdaterTest { - private static final int PROPERTY_KEY = 42; + private static final NewIndexDescriptor descriptor = NewIndexDescriptorFactory.forLabel( 1, 42 ); @Test public void removeNotSupported() @@ -72,14 +74,14 @@ public void closeVerifiesUniquenessOfAddedValues() throws Exception SchemaIndex index = mock( SchemaIndex.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( index ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( add( 1, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( add( 1, PROPERTY_KEY, "baz", new long[]{1} ) ); + updater.process( add( 1, descriptor, "foo" ) ); + updater.process( add( 1, descriptor, "bar" ) ); + updater.process( add( 1, descriptor, "baz" ) ); verifyZeroInteractions( index ); updater.close(); - verify( index ).verifyUniqueness( any(), eq( PROPERTY_KEY ), eq( Arrays.asList( "foo", "bar", "baz" ) ) ); + verify( index ).verifyUniqueness( any(), eq( descriptor.schema().getPropertyId() ), eq( Arrays.asList( "foo", "bar", "baz" ) ) ); } @Test @@ -88,14 +90,14 @@ public void closeVerifiesUniquenessOfChangedValues() throws Exception SchemaIndex index = mock( SchemaIndex.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( index ); - updater.process( change( 1, PROPERTY_KEY, "foo1", new long[]{1, 2}, "foo2", new long[]{1} ) ); - updater.process( change( 1, PROPERTY_KEY, "bar1", new long[]{1, 2}, "bar2", new long[]{1} ) ); - updater.process( change( 1, PROPERTY_KEY, "baz1", new long[]{1, 2}, "baz2", new long[]{1} ) ); + updater.process( change( 1, descriptor, "foo1", "foo2" ) ); + updater.process( change( 1, descriptor, "bar1", "bar2" ) ); + updater.process( change( 1, descriptor, "baz1", "baz2" ) ); verifyZeroInteractions( index ); updater.close(); - verify( index ).verifyUniqueness( any(), eq( PROPERTY_KEY ), eq( Arrays.asList( "foo2", "bar2", "baz2" ) ) ); + verify( index ).verifyUniqueness( any(), eq( descriptor.schema().getPropertyId() ), eq( Arrays.asList( "foo2", "bar2", "baz2" ) ) ); } @Test @@ -104,18 +106,18 @@ public void closeVerifiesUniquenessOfAddedAndChangedValues() throws Exception SchemaIndex index = mock( SchemaIndex.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( index ); - updater.process( add( 1, PROPERTY_KEY, "added1", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "added2", new long[]{1} ) ); - updater.process( change( 3, PROPERTY_KEY, "before1", new long[]{1, 2}, "after1", new long[]{2} ) ); - updater.process( change( 4, PROPERTY_KEY, "before2", new long[]{1}, "after2", new long[]{1, 2, 3} ) ); - updater.process( remove( 5, PROPERTY_KEY, "removed1", new long[]{1, 2} ) ); + updater.process( add( 1, descriptor, "added1" ) ); + updater.process( add( 2, descriptor, "added2" ) ); + updater.process( change( 3, descriptor, "before1", "after1" ) ); + updater.process( change( 4, descriptor, "before2", "after2" ) ); + updater.process( remove( 5, descriptor, "removed1" ) ); verifyZeroInteractions( index ); updater.close(); List toBeVerified = Arrays.asList( "added1", "added2", "after1", "after2" ); - verify( index ).verifyUniqueness( any(), eq( PROPERTY_KEY ), eq( toBeVerified ) ); + verify( index ).verifyUniqueness( any(), eq( descriptor.schema().getPropertyId() ), eq( toBeVerified ) ); } @Test @@ -124,10 +126,10 @@ public void addedNodePropertiesIncludedInSample() throws Exception UniqueIndexSampler sampler = new UniqueIndexSampler(); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "baz", new long[]{1} ) ); - updater.process( add( 4, PROPERTY_KEY, "qux", new long[]{1} ) ); + updater.process( add( 1, descriptor, "foo" ) ); + updater.process( add( 2, descriptor, "bar" ) ); + updater.process( add( 3, descriptor, "baz" ) ); + updater.process( add( 4, descriptor, "qux" ) ); verifySamplingResult( sampler, 4 ); } @@ -138,8 +140,8 @@ public void changedNodePropertiesDoNotInfluenceSample() throws Exception UniqueIndexSampler sampler = new UniqueIndexSampler(); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( change( 1, PROPERTY_KEY, "before1", new long[]{1}, "after1", new long[]{1} ) ); - updater.process( change( 2, PROPERTY_KEY, "before2", new long[]{1}, "after2", new long[]{1} ) ); + updater.process( change( 1, descriptor, "before1", "after1" ) ); + updater.process( change( 2, descriptor, "before2", "after2" ) ); verifySamplingResult( sampler, 0 ); } @@ -153,8 +155,8 @@ public void removedNodePropertyIncludedInSample() throws Exception UniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( remove( 1, PROPERTY_KEY, "removed1", new long[]{1} ) ); - updater.process( remove( 2, PROPERTY_KEY, "removed2", new long[]{1} ) ); + updater.process( remove( 1, descriptor, "removed1" ) ); + updater.process( remove( 2, descriptor, "removed2" ) ); verifySamplingResult( sampler, initialValue - 2 ); } @@ -165,11 +167,11 @@ public void nodePropertyUpdatesIncludedInSample() throws Exception UniqueIndexSampler sampler = new UniqueIndexSampler(); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( sampler ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( change( 1, PROPERTY_KEY, "foo", new long[]{1}, "bar", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "baz", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "qux", new long[]{1} ) ); - updater.process( remove( 4, PROPERTY_KEY, "qux", new long[]{1} ) ); + updater.process( add( 1, descriptor, "foo" ) ); + updater.process( change( 1, descriptor, "foo", "bar" ) ); + updater.process( add( 2, descriptor, "baz" ) ); + updater.process( add( 3, descriptor, "qux" ) ); + updater.process( remove( 4, descriptor, "qux" ) ); verifySamplingResult( sampler, 2 ); } @@ -180,9 +182,9 @@ public void additionsDeliveredToIndexWriter() throws Exception LuceneIndexWriter writer = mock( LuceneIndexWriter.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( writer ); - updater.process( add( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( add( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( add( 3, PROPERTY_KEY, "qux", new long[]{1} ) ); + updater.process( add( 1, descriptor, "foo" ) ); + updater.process( add( 2, descriptor, "bar" ) ); + updater.process( add( 3, descriptor, "qux" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 1 ), documentRepresentingProperty( 1, "foo" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 2 ), documentRepresentingProperty( 2, "bar" ) ); @@ -195,8 +197,8 @@ public void changesDeliveredToIndexWriter() throws Exception LuceneIndexWriter writer = mock( LuceneIndexWriter.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( writer ); - updater.process( change( 1, PROPERTY_KEY, "before1", new long[]{1}, "after1", new long[]{1} ) ); - updater.process( change( 2, PROPERTY_KEY, "before2", new long[]{1}, "after2", new long[]{1} ) ); + updater.process( change( 1, descriptor, "before1", "after1" ) ); + updater.process( change( 2, descriptor, "before2", "after2" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 1 ), documentRepresentingProperty( 1, "after1" ) ); verify( writer ).updateDocument( newTermForChangeOrRemove( 2 ), documentRepresentingProperty( 2, "after2" ) ); @@ -208,9 +210,9 @@ public void removalsDeliveredToIndexWriter() throws Exception LuceneIndexWriter writer = mock( LuceneIndexWriter.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( writer ); - updater.process( remove( 1, PROPERTY_KEY, "foo", new long[]{1} ) ); - updater.process( remove( 2, PROPERTY_KEY, "bar", new long[]{1} ) ); - updater.process( remove( 3, PROPERTY_KEY, "baz", new long[]{1} ) ); + updater.process( remove( 1, descriptor, "foo" ) ); + updater.process( remove( 2, descriptor, "bar" ) ); + updater.process( remove( 3, descriptor, "baz" ) ); verify( writer ).deleteDocuments( newTermForChangeOrRemove( 1 ) ); verify( writer ).deleteDocuments( newTermForChangeOrRemove( 2 ) ); @@ -249,7 +251,7 @@ private static UniqueLuceneIndexPopulatingUpdater newUpdater( UniqueIndexSampler private static UniqueLuceneIndexPopulatingUpdater newUpdater( SchemaIndex index, LuceneIndexWriter writer, UniqueIndexSampler sampler ) { - return new UniqueLuceneIndexPopulatingUpdater( writer, PROPERTY_KEY, index, mock( PropertyAccessor.class ), - sampler ); + return new UniqueLuceneIndexPopulatingUpdater( writer, descriptor.schema().getPropertyId(), index, + mock( PropertyAccessor.class ), sampler ); } } diff --git a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatorTest.java b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatorTest.java index 9084748adfb11..e176a3371420d 100644 --- a/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatorTest.java +++ b/community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/populator/UniqueDatabaseIndexPopulatorTest.java @@ -39,12 +39,13 @@ import org.neo4j.kernel.api.impl.index.storage.PartitionedIndexStorage; import org.neo4j.kernel.api.impl.schema.LuceneSchemaIndexBuilder; import org.neo4j.kernel.api.impl.schema.SchemaIndex; -import org.neo4j.kernel.api.schema.IndexDescriptor; -import org.neo4j.kernel.api.schema.IndexDescriptorFactory; +import org.neo4j.kernel.api.index.IndexEntryUpdate; import org.neo4j.kernel.api.index.IndexUpdater; -import org.neo4j.kernel.api.index.NodePropertyUpdate; import org.neo4j.kernel.api.index.PreexistingIndexEntryConflictException; import org.neo4j.kernel.api.index.PropertyAccessor; +import org.neo4j.kernel.api.schema_new.index.IndexBoundary; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptor; +import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory; import org.neo4j.storageengine.api.schema.IndexReader; import org.neo4j.storageengine.api.schema.IndexSample; import org.neo4j.test.OtherThreadExecutor; @@ -79,7 +80,7 @@ public class UniqueDatabaseIndexPopulatorTest private static final String INDEX_IDENTIFIER = "42"; private final DirectoryFactory directoryFactory = new DirectoryFactory.InMemoryDirectoryFactory(); - private final IndexDescriptor descriptor = IndexDescriptorFactory.of( LABEL_ID, PROPERTY_KEY_ID ); + private static final NewIndexDescriptor descriptor = NewIndexDescriptorFactory.forLabel( LABEL_ID, PROPERTY_KEY_ID ); private final PropertyAccessor propertyAccessor = mock( PropertyAccessor.class ); @@ -145,7 +146,7 @@ public void shouldUpdateEntryForNodeThatHasAlreadyBeenIndexed() throws Exception // when IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); - updater.process( NodePropertyUpdate.change( 1, PROPERTY_KEY_ID, "value1", new long[]{}, "value2", new long[]{} ) ); + updater.process( IndexEntryUpdate.change( 1, descriptor, "value1", "value2" ) ); populator.close( true ); @@ -165,8 +166,8 @@ public void shouldUpdateEntryForNodeThatHasPropertyRemovedAndThenAddedAgain() th // when IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); - updater.process( NodePropertyUpdate.remove( 1, PROPERTY_KEY_ID, "value1", new long[]{} ) ); - updater.process( NodePropertyUpdate.add( 1, PROPERTY_KEY_ID, "value1", new long[]{} ) ); + updater.process( IndexEntryUpdate.remove( 1, descriptor, "value1" ) ); + updater.process( IndexEntryUpdate.add( 1, descriptor, "value1" ) ); populator.close( true ); @@ -185,7 +186,7 @@ public void shouldRemoveEntryForNodeThatHasAlreadyBeenIndexed() throws Exception // when IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); - updater.process( NodePropertyUpdate.remove( 1, PROPERTY_KEY_ID, "value1", new long[]{} ) ); + updater.process( IndexEntryUpdate.remove( 1, descriptor, "value1" ) ); populator.close( true ); @@ -205,8 +206,8 @@ public void shouldBeAbleToHandleSwappingOfIndexValues() throws Exception // when IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); - updater.process( NodePropertyUpdate.change( 1, PROPERTY_KEY_ID, "value1", new long[]{}, "value2", new long[]{} ) ); - updater.process( NodePropertyUpdate.change( 2, PROPERTY_KEY_ID, "value2", new long[]{}, "value1", new long[]{} ) ); + updater.process( IndexEntryUpdate.change( 1, descriptor, "value1", "value2" ) ); + updater.process( IndexEntryUpdate.change( 2, descriptor, "value2", "value1" ) ); populator.close( true ); @@ -294,7 +295,7 @@ public void shouldRejectDuplicateEntryWhenUsingPopulatingUpdater() throws Except try { IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); - updater.process( NodePropertyUpdate.add( 3, PROPERTY_KEY_ID, "value1", new long[]{} ) ); + updater.process( IndexEntryUpdate.add( 3, descriptor, "value1" ) ); updater.close(); fail( "should have thrown exception" ); @@ -316,7 +317,7 @@ public void shouldRejectDuplicateEntryAfterUsingPopulatingUpdater() throws Excep String value = "value1"; IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); - updater.process( NodePropertyUpdate.add( 1, PROPERTY_KEY_ID, value, new long[]{} ) ); + updater.process( IndexEntryUpdate.add( 1, descriptor, value ) ); addUpdate( populator, 2, value ); when( propertyAccessor.getProperty( 1, PROPERTY_KEY_ID ) ).thenReturn( @@ -350,8 +351,8 @@ public void shouldNotRejectDuplicateEntryOnSameNodeIdAfterUsingPopulatingUpdater stringProperty( PROPERTY_KEY_ID, "value1" ) ); IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); - updater.process( NodePropertyUpdate.add( 1, PROPERTY_KEY_ID, "value1", new long[]{} ) ); - updater.process( NodePropertyUpdate.change( 1, PROPERTY_KEY_ID, "value1", new long[]{}, "value1", new long[]{} ) ); + updater.process( IndexEntryUpdate.add( 1, descriptor, "value1" ) ); + updater.process( IndexEntryUpdate.change( 1, descriptor, "value1", "value1" ) ); updater.close(); addUpdate( populator, 2, "value2" ); addUpdate( populator, 3, "value3" ); @@ -394,18 +395,17 @@ public void shouldCheckAllCollisionsFromPopulatorAdd() throws Exception populator = newPopulator(); int iterations = 228; // This value has to be high enough to stress the EntrySet implementation - long[] labels = new long[0]; IndexUpdater updater = populator.newPopulatingUpdater( propertyAccessor ); for ( int nodeId = 0; nodeId < iterations; nodeId++ ) { - updater.process( NodePropertyUpdate.add( nodeId, PROPERTY_KEY_ID, 1, labels ) ); + updater.process( IndexEntryUpdate.add( nodeId, descriptor, 1 ) ); when( propertyAccessor.getProperty( nodeId, PROPERTY_KEY_ID ) ).thenReturn( intProperty( PROPERTY_KEY_ID, nodeId ) ); } // ... and the actual conflicting property: - updater.process( NodePropertyUpdate.add( iterations, PROPERTY_KEY_ID, 1, labels ) ); + updater.process( IndexEntryUpdate.add( iterations, descriptor, 1 ) ); when( propertyAccessor.getProperty( iterations, PROPERTY_KEY_ID ) ).thenReturn( intProperty( PROPERTY_KEY_ID, 1 ) ); // This collision is real!!! @@ -507,12 +507,13 @@ public void sampleEmptyIndex() throws Exception @Test public void sampleIncludedUpdates() throws Exception { + NewIndexDescriptor indexDescriptor = NewIndexDescriptorFactory.forLabel( 1, 1 ); populator = newPopulator(); - List updates = Arrays.asList( - NodePropertyUpdate.add( 1, 1, "foo", new long[]{1} ), - NodePropertyUpdate.add( 2, 1, "bar", new long[]{1} ), - NodePropertyUpdate.add( 3, 1, "baz", new long[]{1} ), - NodePropertyUpdate.add( 4, 1, "qux", new long[]{1} ) ); + List updates = Arrays.asList( + IndexEntryUpdate.add( 1, indexDescriptor, "foo" ), + IndexEntryUpdate.add( 2, indexDescriptor, "bar" ), + IndexEntryUpdate.add( 3, indexDescriptor, "baz" ), + IndexEntryUpdate.add( 4, indexDescriptor, "qux" ) ); updates.forEach( populator::includeSample ); @@ -524,12 +525,13 @@ public void sampleIncludedUpdates() throws Exception @Test public void addUpdates() throws Exception { + NewIndexDescriptor indexDescriptor = NewIndexDescriptorFactory.forLabel( 1, 1 ); populator = newPopulator(); - List updates = Arrays.asList( - NodePropertyUpdate.add( 1, 1, "aaa", new long[]{1} ), - NodePropertyUpdate.add( 2, 1, "bbb", new long[]{1} ), - NodePropertyUpdate.add( 3, 1, "ccc", new long[]{1} ) ); + List updates = Arrays.asList( + IndexEntryUpdate.add( 1, indexDescriptor, "aaa" ), + IndexEntryUpdate.add( 2, indexDescriptor, "bbb" ), + IndexEntryUpdate.add( 3, indexDescriptor, "ccc" ) ); populator.add( updates ); @@ -542,7 +544,7 @@ public void addUpdates() throws Exception private UniqueLuceneIndexPopulator newPopulator() throws IOException { - UniqueLuceneIndexPopulator populator = new UniqueLuceneIndexPopulator( index, descriptor ); + UniqueLuceneIndexPopulator populator = new UniqueLuceneIndexPopulator( index, IndexBoundary.map( descriptor ) ); populator.create(); return populator; } @@ -550,7 +552,8 @@ private UniqueLuceneIndexPopulator newPopulator() throws IOException private static void addUpdate( UniqueLuceneIndexPopulator populator, long nodeId, Object value ) throws IOException, IndexEntryConflictException { - NodePropertyUpdate update = NodePropertyUpdate.add( nodeId, 0, value, new long[]{0} ); + NewIndexDescriptor indexDescriptor = NewIndexDescriptorFactory.forLabel( 0, 0 ); + IndexEntryUpdate update = IndexEntryUpdate.add( nodeId, indexDescriptor, value ); populator.add( Collections.singletonList( update ) ); } }