Examples with ValueIndexEntryUpdate org.neo4j.storageengine.api.ValueIndexEntryUpdate used on opensource projects

Example 1 with ValueIndexEntryUpdate

use of org.neo4j.storageengine.api.ValueIndexEntryUpdate in project neo4j by neo4j.

the class IndexPopulationStressTest method updater.

private Runnable updater(AtomicReferenceArray<List<ValueIndexEntryUpdate<?>>> lastBatches, CountDownLatch insertersDone, ReadWriteLock updateLock, Collection<ValueIndexEntryUpdate<?>> updates) {
    return throwing(() -> {
        // Entity ids that have been removed, so that additions can reuse them
        List<Long> removed = new ArrayList<>();
        RandomValues randomValues = RandomValues.create(new Random(random.seed() + THREADS));
        while (insertersDone.getCount() > 0) {
            // Do updates now and then
            Thread.sleep(10);
            updateLock.writeLock().lock();
            try (IndexUpdater updater = populator.newPopulatingUpdater(nodePropertyAccessor, NULL)) {
                for (int i = 0; i < THREADS; i++) {
                    List<ValueIndexEntryUpdate<?>> batch = lastBatches.get(i);
                    if (batch != null) {
                        ValueIndexEntryUpdate<?> update = null;
                        switch(randomValues.nextInt(3)) {
                            case // add
                            0:
                                if (!removed.isEmpty()) {
                                    Long id = removed.remove(randomValues.nextInt(removed.size()));
                                    update = add(id, descriptor, valueGenerator.apply(randomValues));
                                }
                                break;
                            case // remove
                            1:
                                ValueIndexEntryUpdate<?> removal = batch.get(randomValues.nextInt(batch.size()));
                                update = remove(removal.getEntityId(), descriptor, removal.values());
                                removed.add(removal.getEntityId());
                                break;
                            case // change
                            2:
                                removal = batch.get(randomValues.nextInt(batch.size()));
                                change(removal.getEntityId(), descriptor, removal.values(), toArray(valueGenerator.apply(randomValues)));
                                break;
                            default:
                                throw new IllegalArgumentException();
                        }
                        if (update != null) {
                            updater.process(update);
                            updates.add(update);
                        }
                    }
                }
            } finally {
                updateLock.writeLock().unlock();
            }
        }
    });
}

Example 2 with ValueIndexEntryUpdate

use of org.neo4j.storageengine.api.ValueIndexEntryUpdate in project neo4j by neo4j.

the class DeferredConflictCheckingIndexUpdaterTest method shouldQueryAboutAddedAndChangedValueTuples.

@Test
void shouldQueryAboutAddedAndChangedValueTuples() throws Exception {
    // given
    IndexUpdater actual = mock(IndexUpdater.class);
    ValueIndexReader reader = mock(ValueIndexReader.class);
    doAnswer(new NodeIdsIndexReaderQueryAnswer(descriptor, 0)).when(reader).query(any(), any(), any(), any(), any());
    long nodeId = 0;
    List<ValueIndexEntryUpdate<IndexDescriptor>> updates = new ArrayList<>();
    updates.add(add(nodeId++, descriptor, tuple(10, 11)));
    updates.add(change(nodeId++, descriptor, tuple("abc", "def"), tuple("ghi", "klm")));
    updates.add(remove(nodeId++, descriptor, tuple(1001L, 1002L)));
    updates.add(change(nodeId++, descriptor, tuple((byte) 2, (byte) 3), tuple((byte) 4, (byte) 5)));
    updates.add(add(nodeId, descriptor, tuple(5, "5")));
    try (DeferredConflictCheckingIndexUpdater updater = new DeferredConflictCheckingIndexUpdater(actual, () -> reader, descriptor, NULL)) {
        // when
        for (ValueIndexEntryUpdate<IndexDescriptor> update : updates) {
            updater.process(update);
            verify(actual).process(update);
        }
    }
    // then
    for (ValueIndexEntryUpdate<IndexDescriptor> update : updates) {
        if (update.updateMode() == UpdateMode.ADDED || update.updateMode() == UpdateMode.CHANGED) {
            Value[] tuple = update.values();
            PropertyIndexQuery[] query = new PropertyIndexQuery[tuple.length];
            for (int i = 0; i < tuple.length; i++) {
                query[i] = PropertyIndexQuery.exact(propertyKeyIds[i], tuple[i]);
            }
            verify(reader).query(any(), any(), any(), eq(query[0]), eq(query[1]));
        }
    }
    verify(reader).close();
    verifyNoMoreInteractions(reader);
}

Example 3 with ValueIndexEntryUpdate

use of org.neo4j.storageengine.api.ValueIndexEntryUpdate in project neo4j by neo4j.

the class SimpleIndexAccessorCompatibility method shouldRangeSeekInOrderWithExpectedSize.

private void shouldRangeSeekInOrderWithExpectedSize(IndexOrder order, RangeSeekMode rangeSeekMode, int expectedSize, Object... objects) throws Exception {
    PropertyIndexQuery range;
    switch(rangeSeekMode) {
        case CLOSED:
            range = range(100, Values.of(objects[0]), true, Values.of(objects[objects.length - 1]), true);
            break;
        case OPEN_END:
            range = range(100, Values.of(objects[0]), true, null, false);
            break;
        case OPEN_START:
            range = range(100, null, false, Values.of(objects[objects.length - 1]), true);
            break;
        default:
            throw new IllegalStateException();
    }
    IndexOrderCapability indexOrders = orderCapability(range);
    if (order == IndexOrder.ASCENDING) {
        Assume.assumeTrue("Assume support for order " + order, indexOrders.supportsAsc());
    } else if (order == IndexOrder.DESCENDING) {
        Assume.assumeTrue("Assume support for order " + order, indexOrders.supportsDesc());
    }
    List<ValueIndexEntryUpdate<?>> additions = Arrays.stream(objects).map(o -> add(1, descriptor.schema(), o)).collect(Collectors.toList());
    Collections.shuffle(additions, random.random());
    updateAndCommit(additions);
    SimpleEntityValueClient client = new SimpleEntityValueClient();
    try (AutoCloseable ignored = query(client, order, range)) {
        List<Long> seenIds = assertClientReturnValuesInOrder(client, order);
        assertThat(seenIds.size()).isEqualTo(expectedSize);
    }
}

Example 4 with ValueIndexEntryUpdate

use of org.neo4j.storageengine.api.ValueIndexEntryUpdate in project neo4j by neo4j.

the class NativeIndexAccessorTests method shouldNotSeeFilteredEntries.

@Test
void shouldNotSeeFilteredEntries() throws Exception {
    // given
    ValueIndexEntryUpdate<IndexDescriptor>[] updates = someUpdatesSingleTypeNoDuplicates(supportedTypesExcludingNonOrderable());
    processAll(updates);
    ValueCreatorUtil.sort(updates);
    var reader = accessor.newValueReader();
    // when
    try (NodeValueIterator iter = new NodeValueIterator()) {
        PropertyIndexQuery.ExactPredicate filter = PropertyIndexQuery.exact(0, valueOf(updates[1]));
        PropertyIndexQuery rangeQuery = ValueCreatorUtil.rangeQuery(valueOf(updates[0]), true, valueOf(updates[2]), true);
        IndexProgressor.EntityValueClient filterClient = filterClient(iter, filter);
        reader.query(NULL_CONTEXT, filterClient, unconstrained(), rangeQuery);
        // then
        assertTrue(iter.hasNext());
        assertEquals(entityIdOf(updates[1]), iter.next());
        assertFalse(iter.hasNext());
    }
}

Example 5 with ValueIndexEntryUpdate

use of org.neo4j.storageengine.api.ValueIndexEntryUpdate in project neo4j by neo4j.

the class NativeIndexAccessorTests method shouldSampleIndex.

@Test
void shouldSampleIndex() throws Exception {
    // given
    ValueIndexEntryUpdate<IndexDescriptor>[] updates = someUpdatesSingleType();
    processAll(updates);
    try (var reader = accessor.newValueReader();
        IndexSampler sampler = reader.createSampler()) {
        // when
        IndexSample sample = sampler.sampleIndex(NULL);
        // then
        assertEquals(updates.length, sample.indexSize());
        assertEquals(updates.length, sample.sampleSize());
        assertEquals(countUniqueValues(updates), sample.uniqueValues());
    }
}