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

Example 96 with NodeCursor

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

the class SchemaCalculator method scanEverythingBelongingToNodes.

private void scanEverythingBelongingToNodes(NodeMappings nodeMappings, CursorContext cursorContext, MemoryTracker memoryTracker) {
    try (NodeCursor nodeCursor = cursors.allocateNodeCursor(cursorContext);
        PropertyCursor propertyCursor = cursors.allocatePropertyCursor(cursorContext, memoryTracker)) {
        dataRead.allNodesScan(nodeCursor);
        while (nodeCursor.next()) {
            // each node
            SortedLabels labels = SortedLabels.from(nodeCursor.labels());
            nodeCursor.properties(propertyCursor);
            MutableIntSet propertyIds = IntSets.mutable.empty();
            while (propertyCursor.next()) {
                Value currentValue = propertyCursor.propertyValue();
                int propertyKeyId = propertyCursor.propertyKey();
                Pair<SortedLabels, Integer> key = Pair.of(labels, propertyKeyId);
                updateValueTypeInMapping(currentValue, key, nodeMappings.labelSetANDNodePropertyKeyIdToValueType);
                propertyIds.add(propertyKeyId);
            }
            propertyCursor.close();
            MutableIntSet oldPropertyKeySet = nodeMappings.labelSetToPropertyKeys.getOrDefault(labels, emptyPropertyIdSet);
            // find out which old properties we did not visited and mark them as nullable
            if (oldPropertyKeySet == emptyPropertyIdSet) {
                if (propertyIds.size() == 0) {
                    // Even if we find property key on other nodes with those labels, set all of them nullable
                    nodeMappings.nullableLabelSets.add(labels);
                }
                propertyIds.addAll(oldPropertyKeySet);
            } else {
                MutableIntSet currentPropertyIdsHelperSet = new IntHashSet(propertyIds.size());
                currentPropertyIdsHelperSet.addAll(propertyIds);
                // only the brand new ones in propIds now
                propertyIds.removeAll(oldPropertyKeySet);
                // only the old ones that are not on the new node
                oldPropertyKeySet.removeAll(currentPropertyIdsHelperSet);
                propertyIds.addAll(oldPropertyKeySet);
                propertyIds.forEach(id -> {
                    Pair<SortedLabels, Integer> key = Pair.of(labels, id);
                    nodeMappings.labelSetANDNodePropertyKeyIdToValueType.get(key).setNullable();
                });
                propertyIds.addAll(currentPropertyIdsHelperSet);
            }
            nodeMappings.labelSetToPropertyKeys.put(labels, propertyIds);
        }
    }
}

Example 97 with NodeCursor

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

the class CachingExpandIntoTest method shouldBeAbleToPreformAllCursorMethodsFromReused.

@Test
void shouldBeAbleToPreformAllCursorMethodsFromReused() throws KernelException {
    // given
    long start, end, r1, r2, r3;
    int t1, t2, t3;
    int prop;
    try (KernelTransaction tx = transaction()) {
        start = nodeWithDegree(tx, 43);
        end = nodeWithDegree(tx, 11);
        TokenWrite tokenWrite = tx.tokenWrite();
        t1 = tokenWrite.relationshipTypeGetOrCreateForName("R1");
        t2 = tokenWrite.relationshipTypeGetOrCreateForName("R2");
        t3 = tokenWrite.relationshipTypeGetOrCreateForName("R3");
        prop = tokenWrite.propertyKeyGetOrCreateForName("prop");
        Write write = tx.dataWrite();
        r1 = write.relationshipCreate(start, t1, end);
        r2 = write.relationshipCreate(start, t2, end);
        r3 = write.relationshipCreate(end, t3, start);
        write.relationshipSetProperty(r1, prop, stringValue("Relationship 1"));
        write.relationshipSetProperty(r2, prop, stringValue("Relationship 2"));
        write.relationshipSetProperty(r3, prop, stringValue("Relationship 3"));
        tx.commit();
    }
    try (KernelTransaction tx = transaction();
        NodeCursor nodes = tx.cursors().allocateNodeCursor(tx.cursorContext());
        RelationshipTraversalCursor traversal = tx.cursors().allocateRelationshipTraversalCursor(tx.cursorContext());
        PropertyCursor properties = tx.cursors().allocatePropertyCursor(tx.cursorContext(), tx.memoryTracker())) {
        int[] types = { t2, t3 };
        CachingExpandInto expandInto = new CachingExpandInto(tx.dataRead(), INCOMING, MEMORY_TRACKER);
        // Find r3 first time
        RelationshipTraversalCursor cursor = expandInto.connectingRelationships(nodes, traversal, start, types, end);
        assertTrue(cursor.next());
        assertThat(cursor.relationshipReference()).isEqualTo(r3);
        assertThat(cursor.sourceNodeReference()).isEqualTo(end);
        assertThat(cursor.targetNodeReference()).isEqualTo(start);
        assertThat(cursor.otherNodeReference()).isEqualTo(start);
        assertThat(cursor.type()).isEqualTo(t3);
        cursor.properties(properties);
        assertTrue(properties.next());
        assertThat(properties.propertyValue()).isEqualTo(stringValue("Relationship 3"));
        assertFalse(properties.next());
        assertFalse(cursor.next());
        // Find r3 second time
        cursor = expandInto.connectingRelationships(nodes, traversal, start, types, end);
        assertTrue(cursor.next());
        assertThat(cursor.relationshipReference()).isEqualTo(r3);
        assertThat(cursor.sourceNodeReference()).isEqualTo(end);
        assertThat(cursor.targetNodeReference()).isEqualTo(start);
        assertThat(cursor.otherNodeReference()).isEqualTo(start);
        assertThat(cursor.type()).isEqualTo(t3);
        cursor.properties(properties);
        assertTrue(properties.next());
        assertThat(properties.propertyValue()).isEqualTo(stringValue("Relationship 3"));
        assertFalse(properties.next());
        assertFalse(cursor.next());
        // Find r2 first time
        cursor = expandInto.connectingRelationships(nodes, traversal, end, types, start);
        assertTrue(cursor.next());
        assertThat(cursor.relationshipReference()).isEqualTo(r2);
        assertThat(cursor.sourceNodeReference()).isEqualTo(start);
        assertThat(cursor.targetNodeReference()).isEqualTo(end);
        assertThat(cursor.otherNodeReference()).isEqualTo(end);
        assertThat(cursor.type()).isEqualTo(t2);
        cursor.properties(properties);
        assertTrue(properties.next());
        assertThat(properties.propertyValue()).isEqualTo(stringValue("Relationship 2"));
        assertFalse(properties.next());
        assertFalse(cursor.next());
        // Find r2 second time
        cursor = expandInto.connectingRelationships(nodes, traversal, end, types, start);
        assertTrue(cursor.next());
        assertThat(cursor.relationshipReference()).isEqualTo(r2);
        assertThat(cursor.sourceNodeReference()).isEqualTo(start);
        assertThat(cursor.targetNodeReference()).isEqualTo(end);
        assertThat(cursor.otherNodeReference()).isEqualTo(end);
        assertThat(cursor.type()).isEqualTo(t2);
        cursor.properties(properties);
        assertTrue(properties.next());
        assertThat(properties.propertyValue()).isEqualTo(stringValue("Relationship 2"));
        assertFalse(properties.next());
        assertFalse(cursor.next());
    }
}

Example 98 with NodeCursor

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

the class CachingExpandIntoTest method shouldBeAbleToReuseWithoutTypes.

@Test
void shouldBeAbleToReuseWithoutTypes() throws KernelException {
    // given
    long start, end, r1, r2, r3;
    int t1, t2, t3;
    try (KernelTransaction tx = transaction()) {
        start = nodeWithDegree(tx, 43);
        end = nodeWithDegree(tx, 11);
        TokenWrite tokenWrite = tx.tokenWrite();
        t1 = tokenWrite.relationshipTypeGetOrCreateForName("R1");
        t2 = tokenWrite.relationshipTypeGetOrCreateForName("R2");
        t3 = tokenWrite.relationshipTypeGetOrCreateForName("R3");
        Write write = tx.dataWrite();
        r1 = write.relationshipCreate(start, t1, end);
        r2 = write.relationshipCreate(start, t2, end);
        r3 = write.relationshipCreate(end, t3, start);
        tx.commit();
    }
    try (KernelTransaction tx = transaction();
        NodeCursor nodeCursor = tx.cursors().allocateNodeCursor(tx.cursorContext());
        RelationshipTraversalCursor traversalCursor = tx.cursors().allocateRelationshipTraversalCursor(tx.cursorContext())) {
        CachingExpandInto expandInto = new CachingExpandInto(tx.dataRead(), OUTGOING, MEMORY_TRACKER);
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, start, null, end))).isEqualTo(immutable.of(r1, r2));
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, end, null, start))).isEqualTo(immutable.of(r3));
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, start, null, end))).isEqualTo(immutable.of(r1, r2));
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, end, null, start))).isEqualTo(immutable.of(r3));
    }
}

Example 99 with NodeCursor

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

the class CachingExpandIntoTest method shouldComputeDegreeWithoutType.

@Test
void shouldComputeDegreeWithoutType() throws Exception {
    // GIVEN
    long node;
    try (KernelTransaction tx = transaction()) {
        Write write = tx.dataWrite();
        node = nodeWithDegree(tx, 42);
        relate(tx, node, "R1", write.nodeCreate());
        relate(tx, node, "R2", write.nodeCreate());
        relate(tx, write.nodeCreate(), "R3", node);
        relate(tx, node, "R4", node);
        tx.commit();
    }
    try (KernelTransaction tx = transaction()) {
        Read read = tx.dataRead();
        CursorFactory cursors = tx.cursors();
        try (NodeCursor nodes = cursors.allocateNodeCursor(tx.cursorContext())) {
            CachingExpandInto expand = new CachingExpandInto(tx.dataRead(), OUTGOING, MEMORY_TRACKER);
            read.singleNode(node, nodes);
            assertThat(nodes.next()).isEqualTo(true);
            assertThat(nodes.supportsFastDegreeLookup()).isEqualTo(true);
            Degrees degrees = nodes.degrees(ALL_RELATIONSHIPS);
            assertThat(degrees.outgoingDegree()).isEqualTo(45);
            assertThat(degrees.incomingDegree()).isEqualTo(2);
            assertThat(degrees.totalDegree()).isEqualTo(46);
        }
    }
}

Example 100 with NodeCursor

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

the class CachingExpandIntoTest method shouldBeAbleToReuseWithTypes.

@Test
void shouldBeAbleToReuseWithTypes() throws KernelException {
    // given
    long start, end, r1, r3;
    int t1, t2, t3;
    try (KernelTransaction tx = transaction()) {
        start = nodeWithDegree(tx, 43);
        end = nodeWithDegree(tx, 11);
        TokenWrite tokenWrite = tx.tokenWrite();
        t1 = tokenWrite.relationshipTypeGetOrCreateForName("R1");
        t2 = tokenWrite.relationshipTypeGetOrCreateForName("R2");
        t3 = tokenWrite.relationshipTypeGetOrCreateForName("R3");
        Write write = tx.dataWrite();
        r1 = write.relationshipCreate(start, t1, end);
        write.relationshipCreate(start, t2, end);
        r3 = write.relationshipCreate(end, t3, start);
        tx.commit();
    }
    try (KernelTransaction tx = transaction();
        NodeCursor nodeCursor = tx.cursors().allocateNodeCursor(tx.cursorContext());
        RelationshipTraversalCursor traversalCursor = tx.cursors().allocateRelationshipTraversalCursor(tx.cursorContext())) {
        int[] types = { t1, t3 };
        CachingExpandInto expandInto = new CachingExpandInto(tx.dataRead(), OUTGOING, MEMORY_TRACKER);
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, start, types, end))).isEqualTo(immutable.of(r1));
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, end, types, start))).isEqualTo(immutable.of(r3));
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, start, types, end))).isEqualTo(immutable.of(r1));
        assertThat(toSet(expandInto.connectingRelationships(nodeCursor, traversalCursor, end, types, start))).isEqualTo(immutable.of(r3));
    }
}