Examples with NodeValueIndexCursor org.neo4j.internal.kernel.api.NodeValueIndexCursor used on opensource projects

Example 6 with NodeValueIndexCursor

use of org.neo4j.internal.kernel.api.NodeValueIndexCursor in project neo4j by neo4j.

the class MultipleOpenCursorsTest method multipleIteratorsNestedInnerNewRange.

@ParameterizedTest
@MethodSource(value = "params")
void multipleIteratorsNestedInnerNewRange(IndexCoordinator indexCoordinator) throws Exception {
    assumeTrue(indexCoordinator.supportRangeQuery());
    indexCoordinator.init(db);
    try (Transaction tx = db.beginTx()) {
        // when
        KernelTransaction ktx = ((InternalTransaction) tx).kernelTransaction();
        try (NodeValueIndexCursor cursor1 = indexCoordinator.queryRange(ktx)) {
            List<Long> actual1 = new ArrayList<>();
            while (cursor1.next()) {
                actual1.add(cursor1.nodeReference());
                try (NodeValueIndexCursor cursor2 = indexCoordinator.queryRange(ktx)) {
                    List<Long> actual2 = asList(cursor2);
                    indexCoordinator.assertRangeResult(actual2);
                }
            }
            // then
            indexCoordinator.assertRangeResult(actual1);
        }
        tx.commit();
    }
}

Example 7 with NodeValueIndexCursor

use of org.neo4j.internal.kernel.api.NodeValueIndexCursor in project neo4j by neo4j.

the class MultipleOpenCursorsTest method multipleCursorsNotNestedExists.

@ParameterizedTest
@MethodSource(value = "params")
void multipleCursorsNotNestedExists(IndexCoordinator indexCoordinator) throws Exception {
    indexCoordinator.init(db);
    try (Transaction tx = db.beginTx()) {
        KernelTransaction ktx = ((InternalTransaction) tx).kernelTransaction();
        // when
        try (NodeValueIndexCursor cursor1 = indexCoordinator.queryExists(ktx);
            NodeValueIndexCursor cursor2 = indexCoordinator.queryExists(ktx)) {
            List<Long> actual1 = asList(cursor1);
            List<Long> actual2 = asList(cursor2);
            // then
            indexCoordinator.assertExistsResult(actual1);
            indexCoordinator.assertExistsResult(actual2);
        }
        tx.commit();
    }
}

Example 8 with NodeValueIndexCursor

use of org.neo4j.internal.kernel.api.NodeValueIndexCursor in project neo4j by neo4j.

the class MultipleOpenCursorsTest method multipleCursorsNotNestedExact.

@ParameterizedTest
@MethodSource(value = "params")
void multipleCursorsNotNestedExact(IndexCoordinator indexCoordinator) throws Exception {
    indexCoordinator.init(db);
    try (Transaction tx = db.beginTx()) {
        // when
        KernelTransaction ktx = ((InternalTransaction) tx).kernelTransaction();
        try (NodeValueIndexCursor cursor1 = indexCoordinator.queryExact(ktx);
            NodeValueIndexCursor cursor2 = indexCoordinator.queryExact(ktx)) {
            List<Long> actual1 = asList(cursor1);
            List<Long> actual2 = asList(cursor2);
            // then
            indexCoordinator.assertExactResult(actual1);
            indexCoordinator.assertExactResult(actual2);
        }
        tx.commit();
    }
}

Example 9 with NodeValueIndexCursor

use of org.neo4j.internal.kernel.api.NodeValueIndexCursor in project neo4j by neo4j.

the class ConstraintIndexConcurrencyTest method shouldNotAllowConcurrentViolationOfConstraint.

@Test
void shouldNotAllowConcurrentViolationOfConstraint() throws Exception {
    // Given
    Label label = label("Foo");
    String propertyKey = "bar";
    String conflictingValue = "baz";
    String constraintName = "MyConstraint";
    // a constraint
    try (Transaction tx = db.beginTx()) {
        tx.schema().constraintFor(label).assertPropertyIsUnique(propertyKey).withName(constraintName).create();
        tx.commit();
    }
    // When
    try (Transaction tx = db.beginTx()) {
        KernelTransaction ktx = ((InternalTransaction) tx).kernelTransaction();
        int labelId = ktx.tokenRead().nodeLabel(label.name());
        int propertyKeyId = ktx.tokenRead().propertyKey(propertyKey);
        Read read = ktx.dataRead();
        try (NodeValueIndexCursor cursor = ktx.cursors().allocateNodeValueIndexCursor(ktx.cursorContext(), ktx.memoryTracker())) {
            IndexDescriptor index = ktx.schemaRead().indexGetForName(constraintName);
            IndexReadSession indexSession = ktx.dataRead().indexReadSession(index);
            read.nodeIndexSeek(indexSession, cursor, unconstrained(), PropertyIndexQuery.exact(propertyKeyId, "The value is irrelevant, we just want to perform some sort of lookup against this " + "index"));
        }
        // then let another thread come in and create a node
        threads.execute(db -> {
            try (Transaction transaction = db.beginTx()) {
                transaction.createNode(label).setProperty(propertyKey, conflictingValue);
                transaction.commit();
            }
            return null;
        }, db).get();
        // before we create a node with the same property ourselves - using the same statement that we have
        // already used for lookup against that very same index
        long node = ktx.dataWrite().nodeCreate();
        ktx.dataWrite().nodeAddLabel(node, labelId);
        var e = assertThrows(UniquePropertyValueValidationException.class, () -> ktx.dataWrite().nodeSetProperty(node, propertyKeyId, Values.of(conflictingValue)));
        assertEquals(ConstraintDescriptorFactory.uniqueForLabel(labelId, propertyKeyId), e.constraint());
        IndexEntryConflictException conflict = Iterators.single(e.conflicts().iterator());
        assertEquals(Values.stringValue(conflictingValue), conflict.getSinglePropertyValue());
        tx.commit();
    }
}

Example 10 with NodeValueIndexCursor

use of org.neo4j.internal.kernel.api.NodeValueIndexCursor in project neo4j by neo4j.

the class NonUniqueIndexTest method concurrentIndexPopulationAndInsertsShouldNotProduceDuplicates.

@Test
void concurrentIndexPopulationAndInsertsShouldNotProduceDuplicates() throws Exception {
    // Given
    GraphDatabaseService db = newEmbeddedGraphDatabaseWithSlowJobScheduler();
    try {
        // When
        try (Transaction tx = db.beginTx()) {
            tx.schema().indexFor(label(LABEL)).on(KEY).withName(INDEX_NAME).create();
            tx.commit();
        }
        Node node;
        try (Transaction tx = db.beginTx()) {
            node = tx.createNode(label(LABEL));
            node.setProperty(KEY, VALUE);
            tx.commit();
        }
        try (Transaction tx = db.beginTx()) {
            tx.schema().awaitIndexesOnline(2, MINUTES);
            tx.commit();
        }
        // Then
        try (Transaction tx = db.beginTx()) {
            KernelTransaction ktx = ((InternalTransaction) tx).kernelTransaction();
            IndexDescriptor index = ktx.schemaRead().indexGetForName(INDEX_NAME);
            IndexReadSession indexSession = ktx.dataRead().indexReadSession(index);
            try (NodeValueIndexCursor cursor = ktx.cursors().allocateNodeValueIndexCursor(ktx.cursorContext(), ktx.memoryTracker())) {
                ktx.dataRead().nodeIndexSeek(indexSession, cursor, unconstrained(), PropertyIndexQuery.exact(1, VALUE));
                assertTrue(cursor.next());
                assertEquals(node.getId(), cursor.nodeReference());
                assertFalse(cursor.next());
            }
            tx.commit();
        }
    } finally {
        managementService.shutdown();
    }
}