Examples with PrimitiveRecord org.neo4j.kernel.impl.store.record.PrimitiveRecord used on opensource projects

Example 16 with PrimitiveRecord

use of org.neo4j.kernel.impl.store.record.PrimitiveRecord in project neo4j by neo4j.

the class TransactionRecordState method extractCommands.

@Override
public void extractCommands(Collection<StorageCommand> commands, MemoryTracker memoryTracker) throws TransactionFailureException {
    assert !prepared : "Transaction has already been prepared";
    integrityValidator.validateTransactionStartKnowledge(lastCommittedTxWhenTransactionStarted);
    int noOfCommands = recordChangeSet.changeSize();
    var labelTokenChanges = recordChangeSet.getLabelTokenChanges().changes();
    memoryTracker.allocateHeap(labelTokenChanges.size() * Command.LabelTokenCommand.HEAP_SIZE);
    for (RecordProxy<LabelTokenRecord, Void> record : labelTokenChanges) {
        commands.add(new Command.LabelTokenCommand(commandSerialization, record.getBefore(), record.forReadingLinkage()));
    }
    var relationshipTypeTokenChanges = recordChangeSet.getRelationshipTypeTokenChanges().changes();
    memoryTracker.allocateHeap(relationshipTypeTokenChanges.size() * Command.RelationshipTypeTokenCommand.HEAP_SIZE);
    for (RecordProxy<RelationshipTypeTokenRecord, Void> record : relationshipTypeTokenChanges) {
        commands.add(new Command.RelationshipTypeTokenCommand(commandSerialization, record.getBefore(), record.forReadingLinkage()));
    }
    var propertyKeyTokenChanges = recordChangeSet.getPropertyKeyTokenChanges().changes();
    memoryTracker.allocateHeap(propertyKeyTokenChanges.size() * Command.PropertyKeyTokenCommand.HEAP_SIZE);
    for (RecordProxy<PropertyKeyTokenRecord, Void> record : propertyKeyTokenChanges) {
        commands.add(new Command.PropertyKeyTokenCommand(commandSerialization, record.getBefore(), record.forReadingLinkage()));
    }
    // Collect nodes, relationships, properties
    Command[] nodeCommands = EMPTY_COMMANDS;
    int skippedCommands = 0;
    var nodeChanges = recordChangeSet.getNodeRecords().changes();
    if (!nodeChanges.isEmpty()) {
        memoryTracker.allocateHeap(nodeChanges.size() * Command.NodeCommand.HEAP_SIZE);
        nodeCommands = new Command[nodeChanges.size()];
        int i = 0;
        for (RecordProxy<NodeRecord, Void> change : nodeChanges) {
            NodeRecord record = prepared(change, nodeStore);
            IntegrityValidator.validateNodeRecord(record);
            nodeCommands[i++] = new Command.NodeCommand(commandSerialization, change.getBefore(), record);
        }
        Arrays.sort(nodeCommands, COMMAND_COMPARATOR);
    }
    Command[] relCommands = EMPTY_COMMANDS;
    var relationshipChanges = recordChangeSet.getRelRecords().changes();
    if (!relationshipChanges.isEmpty()) {
        memoryTracker.allocateHeap(relationshipChanges.size() * Command.RelationshipCommand.HEAP_SIZE);
        relCommands = new Command[relationshipChanges.size()];
        int i = 0;
        for (RecordProxy<RelationshipRecord, Void> change : relationshipChanges) {
            relCommands[i++] = new Command.RelationshipCommand(commandSerialization, change.getBefore(), prepared(change, relationshipStore));
        }
        Arrays.sort(relCommands, COMMAND_COMPARATOR);
    }
    Command[] propCommands = EMPTY_COMMANDS;
    var propertyChanges = recordChangeSet.getPropertyRecords().changes();
    if (!propertyChanges.isEmpty()) {
        memoryTracker.allocateHeap(propertyChanges.size() * Command.PropertyCommand.HEAP_SIZE);
        propCommands = new Command[propertyChanges.size()];
        int i = 0;
        for (RecordProxy<PropertyRecord, PrimitiveRecord> change : propertyChanges) {
            propCommands[i++] = new Command.PropertyCommand(commandSerialization, change.getBefore(), prepared(change, propertyStore));
        }
        Arrays.sort(propCommands, COMMAND_COMPARATOR);
    }
    Command[] relGroupCommands = EMPTY_COMMANDS;
    var relationshipGroupChanges = recordChangeSet.getRelGroupRecords().changes();
    if (!relationshipGroupChanges.isEmpty()) {
        memoryTracker.allocateHeap(relationshipGroupChanges.size() * Command.RelationshipGroupCommand.HEAP_SIZE);
        relGroupCommands = new Command[relationshipGroupChanges.size()];
        int i = 0;
        for (RecordProxy<RelationshipGroupRecord, Integer> change : relationshipGroupChanges) {
            if (change.isCreated() && !change.forReadingLinkage().inUse()) {
                /*
                     * This is an edge case that may come up and which we must handle properly. Relationship groups are
                     * not managed by the tx state, since they are created as side effects rather than through
                     * direct calls. However, they differ from say, dynamic records, in that their management can happen
                     * through separate code paths. What we are interested in here is the following scenario.
                     * 0. A node has one less relationship that is required to transition to dense node. The relationships
                     *    it has belong to at least two different types
                     * 1. In the same tx, a relationship is added making the node dense and all the relationships of a type
                     *    are removed from that node. Regardless of the order these operations happen, the creation of the
                     *    relationship (and the transition of the node to dense) will happen first.
                     * 2. A relationship group will be created because of the transition to dense and then deleted because
                     *    all the relationships it would hold are no longer there. This results in a relationship group
                     *    command that appears in the tx as not in use. Depending on the final order of operations, this
                     *    can end up using an id that is higher than the highest id seen so far. This may not be a problem
                     *    for a single instance, but it can result in errors in cases where transactions are applied
                     *    externally, such as backup.
                     *
                     * The way we deal with this issue here is by not issuing a command for that offending record. This is
                     * safe, since the record is not in use and never was, so the high id is not necessary to change and
                     * the store remains consistent.
                     */
                skippedCommands++;
                continue;
            }
            relGroupCommands[i++] = new Command.RelationshipGroupCommand(commandSerialization, change.getBefore(), prepared(change, relationshipGroupStore));
        }
        relGroupCommands = i < relGroupCommands.length ? Arrays.copyOf(relGroupCommands, i) : relGroupCommands;
        Arrays.sort(relGroupCommands, COMMAND_COMPARATOR);
    }
    addFiltered(commands, Mode.CREATE, propCommands, relCommands, relGroupCommands, nodeCommands);
    addFiltered(commands, Mode.UPDATE, propCommands, relCommands, relGroupCommands, nodeCommands);
    addFiltered(commands, Mode.DELETE, relCommands, relGroupCommands, nodeCommands);
    EnumMap<Mode, List<Command>> schemaChangeByMode = new EnumMap<>(Mode.class);
    var schemaRuleChange = recordChangeSet.getSchemaRuleChanges().changes();
    memoryTracker.allocateHeap(schemaRuleChange.size() * Command.SchemaRuleCommand.HEAP_SIZE);
    for (RecordProxy<SchemaRecord, SchemaRule> change : schemaRuleChange) {
        SchemaRecord schemaRecord = change.forReadingLinkage();
        SchemaRule rule = change.getAdditionalData();
        if (schemaRecord.inUse()) {
            integrityValidator.validateSchemaRule(rule);
        }
        Command.SchemaRuleCommand cmd = new Command.SchemaRuleCommand(commandSerialization, change.getBefore(), change.forChangingData(), rule);
        schemaChangeByMode.computeIfAbsent(cmd.getMode(), MODE_TO_ARRAY_LIST).add(cmd);
    }
    commands.addAll(schemaChangeByMode.getOrDefault(Mode.DELETE, Collections.emptyList()));
    commands.addAll(schemaChangeByMode.getOrDefault(Mode.CREATE, Collections.emptyList()));
    commands.addAll(schemaChangeByMode.getOrDefault(Mode.UPDATE, Collections.emptyList()));
    // Add deleted property commands last, so they happen after the schema record changes.
    // This extends the lifetime of property records just past the last moment of use,
    // and prevents reading and deleting of schema records from racing, and making the
    // schema records look malformed.
    addFiltered(commands, Mode.DELETE, propCommands);
    assert commands.size() == noOfCommands - skippedCommands : format("Expected %d final commands, got %d " + "instead, with %d skipped", noOfCommands, commands.size(), skippedCommands);
    if (groupDegreesUpdater.degrees != null) {
        memoryTracker.allocateHeap(groupDegreesUpdater.degrees.size() * Command.GroupDegreeCommand.SHALLOW_SIZE);
        groupDegreesUpdater.degrees.forEachKeyValue((key, delta) -> {
            if (delta.longValue() != 0) {
                long groupId = Command.GroupDegreeCommand.groupIdFromCombinedKey(key);
                RelationshipDirection direction = Command.GroupDegreeCommand.directionFromCombinedKey(key);
                commands.add(new Command.GroupDegreeCommand(groupId, direction, delta.longValue()));
            }
        });
    }
    prepared = true;
}

Example 17 with PrimitiveRecord

use of org.neo4j.kernel.impl.store.record.PrimitiveRecord in project neo4j by neo4j.

the class WriteTransactionCommandOrderingTest method injectAllPossibleCommands.

private static TransactionRecordState injectAllPossibleCommands() {
    RecordChangeSet recordChangeSet = mock(RecordChangeSet.class);
    RecordChanges<LabelTokenRecord, Void> labelTokenChanges = mock(RecordChanges.class);
    RecordChanges<RelationshipTypeTokenRecord, Void> relationshipTypeTokenChanges = mock(RecordChanges.class);
    RecordChanges<PropertyKeyTokenRecord, Void> propertyKeyTokenChanges = mock(RecordChanges.class);
    RecordChanges<NodeRecord, Void> nodeRecordChanges = mock(RecordChanges.class);
    RecordChanges<RelationshipRecord, Void> relationshipRecordChanges = mock(RecordChanges.class);
    RecordChanges<PropertyRecord, PrimitiveRecord> propertyRecordChanges = mock(RecordChanges.class);
    RecordChanges<RelationshipGroupRecord, Integer> relationshipGroupChanges = mock(RecordChanges.class);
    RecordChanges<SchemaRecord, SchemaRule> schemaRuleChanges = mock(RecordChanges.class);
    when(recordChangeSet.getLabelTokenChanges()).thenReturn(labelTokenChanges);
    when(recordChangeSet.getRelationshipTypeTokenChanges()).thenReturn(relationshipTypeTokenChanges);
    when(recordChangeSet.getPropertyKeyTokenChanges()).thenReturn(propertyKeyTokenChanges);
    when(recordChangeSet.getNodeRecords()).thenReturn(nodeRecordChanges);
    when(recordChangeSet.getRelRecords()).thenReturn(relationshipRecordChanges);
    when(recordChangeSet.getPropertyRecords()).thenReturn(propertyRecordChanges);
    when(recordChangeSet.getRelGroupRecords()).thenReturn(relationshipGroupChanges);
    when(recordChangeSet.getSchemaRuleChanges()).thenReturn(schemaRuleChanges);
    List<RecordProxy<NodeRecord, Void>> nodeChanges = new LinkedList<>();
    RecordChange<NodeRecord, Void> deletedNode = mock(RecordChange.class);
    when(deletedNode.getBefore()).thenReturn(inUseNode());
    when(deletedNode.forReadingLinkage()).thenReturn(missingNode());
    nodeChanges.add(deletedNode);
    RecordChange<NodeRecord, Void> createdNode = mock(RecordChange.class);
    when(createdNode.getBefore()).thenReturn(missingNode());
    when(createdNode.forReadingLinkage()).thenReturn(createdNode());
    nodeChanges.add(createdNode);
    RecordChange<NodeRecord, Void> updatedNode = mock(RecordChange.class);
    when(updatedNode.getBefore()).thenReturn(inUseNode());
    when(updatedNode.forReadingLinkage()).thenReturn(inUseNode());
    nodeChanges.add(updatedNode);
    when(nodeRecordChanges.changes()).thenReturn(nodeChanges);
    when(nodeRecordChanges.changeSize()).thenReturn(3);
    when(recordChangeSet.changeSize()).thenReturn(3);
    when(labelTokenChanges.changes()).thenReturn(Collections.emptyList());
    when(relationshipTypeTokenChanges.changes()).thenReturn(Collections.emptyList());
    when(propertyKeyTokenChanges.changes()).thenReturn(Collections.emptyList());
    when(relationshipRecordChanges.changes()).thenReturn(Collections.emptyList());
    when(propertyRecordChanges.changes()).thenReturn(Collections.emptyList());
    when(relationshipGroupChanges.changes()).thenReturn(Collections.emptyList());
    when(schemaRuleChanges.changes()).thenReturn(Collections.emptyList());
    NeoStores neoStores = mock(NeoStores.class);
    NodeStore store = mock(NodeStore.class);
    when(neoStores.getNodeStore()).thenReturn(store);
    RelationshipGroupStore relationshipGroupStore = mock(RelationshipGroupStore.class);
    when(neoStores.getRelationshipGroupStore()).thenReturn(relationshipGroupStore);
    RelationshipStore relationshipStore = mock(RelationshipStore.class);
    when(neoStores.getRelationshipStore()).thenReturn(relationshipStore);
    return new TransactionRecordState(neoStores, mock(IntegrityValidator.class), recordChangeSet, 0, null, LockTracer.NONE, null, null, null, NULL, INSTANCE, LATEST_LOG_SERIALIZATION);
}